Revert "[WebLayer] Use NetErrorAutoReloader"

This reverts commit 596311e0.

Reason for revert: causes flakiness in
ErrorPageReloadBrowserTest.ReloadOnNetworkChanged test, 
https://crbug.com/1110192

Original change's description:
> [WebLayer] Use NetErrorAutoReloader
> 
> Navigations which fail with network errors may attempt to
> auto-reload in some cases, in order to more seamlessly recover
> from transient failures.
> 
> This behavior was previously implemented renderer-side and copied
> verbatim from Chrome. The Chrome implementation has been moved
> browser-side (see bug for why) and also made into a reusable
> component.
> 
> This changes WebLayer to use the same component implementation
> and deletes all the corresponding renderer logic.
> 
> Fixed: 1098578
> Change-Id: I10c337abcae36f64be47f31b89e36c7393989077
> Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2311371
> Commit-Queue: John Abd-El-Malek <jam@chromium.org>
> Reviewed-by: John Abd-El-Malek <jam@chromium.org>
> Reviewed-by: Clark DuVall <cduvall@chromium.org>
> Cr-Commit-Position: refs/heads/master@{#792028}

TBR=jam@chromium.org,rockot@google.com,cduvall@chromium.org

Bug: 1098578, 1110192
Change-Id: I7b05267e5bc9c13528607bebfa35beb485b0c965
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2323150Reviewed-by: Alex Ilin <alexilin@chromium.org>
Commit-Queue: Alex Ilin <alexilin@chromium.org>
Cr-Commit-Position: refs/heads/master@{#792215}

weblayer/BUILD.gn

@@ -337,7 +337,6 @@ source_set("weblayer_lib_base") {
     "//components/embedder_support",
     "//components/embedder_support/origin_trials",
     "//components/error_page/common",
-    "//components/error_page/content/browser",
     "//components/find_in_page",
     "//components/infobars/core",
     "//components/js_injection/browser",

weblayer/browser/DEPS

@@ -18,7 +18,6 @@ include_rules = [
   "+components/crash/core/common",
   "+components/download/public/common",
   "+components/embedder_support",
-  "+components/error_page/content/browser",
   "+components/find_in_page",
   "+components/infobars/android",
   "+components/infobars/content",

weblayer/browser/content_browser_client_impl.cc

@@ -20,7 +20,6 @@
 #include "components/blocked_content/popup_blocker.h"
 #include "components/captive_portal/core/buildflags.h"
 #include "components/embedder_support/switches.h"
-#include "components/error_page/content/browser/net_error_auto_reloader.h"
 #include "components/network_time/network_time_tracker.h"
 #include "components/page_load_metrics/browser/metrics_navigation_throttle.h"
 #include "components/page_load_metrics/browser/metrics_web_contents_observer.h"
@@ -559,11 +558,6 @@ ContentBrowserClientImpl::CreateThrottlesForNavigation(
   std::vector<std::unique_ptr<content::NavigationThrottle>> throttles;
 
   if (handle->IsInMainFrame()) {
-    auto auto_reload_throttle =
-        error_page::NetErrorAutoReloader::MaybeCreateThrottleFor(handle);
-    if (auto_reload_throttle)
-      throttles.push_back(std::move(auto_reload_throttle));
-
     // MetricsNavigationThrottle requires that it runs before
     // NavigationThrottles that may delay or cancel navigations, so only
     // NavigationThrottles that don't delay or cancel navigations (e.g.

weblayer/renderer/content_renderer_client_impl.cc

@@ -124,6 +124,16 @@ bool ContentRendererClientImpl::HasErrorPage(int http_status_code) {
   return http_status_code >= 400;
 }
 
+bool ContentRendererClientImpl::ShouldSuppressErrorPage(
+    content::RenderFrame* render_frame,
+    const GURL& url,
+    int error_code) {
+  auto* error_page_helper = ErrorPageHelper::GetForFrame(render_frame);
+  if (error_page_helper)
+    return error_page_helper->ShouldSuppressErrorPage(error_code);
+  return false;
+}
+
 void ContentRendererClientImpl::PrepareErrorPage(
     content::RenderFrame* render_frame,
     const blink::WebURLError& error,
@@ -131,9 +141,11 @@ void ContentRendererClientImpl::PrepareErrorPage(
     std::string* error_html) {
   auto* error_page_helper = ErrorPageHelper::GetForFrame(render_frame);
   if (error_page_helper) {
-    error_page_helper->PrepareErrorPage(error_page::Error::NetError(
-        error.url(), error.reason(), error.resolve_error_info(),
-        error.has_copy_in_cache()));
+    error_page_helper->PrepareErrorPage(
+        error_page::Error::NetError(error.url(), error.reason(),
+                                    error.resolve_error_info(),
+                                    error.has_copy_in_cache()),
+        http_method == "POST");
   }
 
 #if defined(OS_ANDROID)

weblayer/renderer/content_renderer_client_impl.h

@@ -30,6 +30,9 @@ class ContentRendererClientImpl : public content::ContentRendererClient {
   SkBitmap* GetSadPluginBitmap() override;
   SkBitmap* GetSadWebViewBitmap() override;
   bool HasErrorPage(int http_status_code) override;
+  bool ShouldSuppressErrorPage(content::RenderFrame* render_frame,
+                               const GURL& url,
+                               int error_code) override;
   void PrepareErrorPage(content::RenderFrame* render_frame,
                         const blink::WebURLError& error,
                         const std::string& http_method,

weblayer/renderer/error_page_helper.cc

@@ -15,12 +15,61 @@
 #include "weblayer/common/features.h"
 
 namespace weblayer {
+namespace {
+
+base::TimeDelta GetAutoReloadTime(size_t reload_count) {
+  static const int kDelaysMs[] = {0,      5000,   30000,  60000,
+                                  300000, 600000, 1800000};
+  if (reload_count >= base::size(kDelaysMs))
+    reload_count = base::size(kDelaysMs) - 1;
+  return base::TimeDelta::FromMilliseconds(kDelaysMs[reload_count]);
+}
+
+bool IsErrorPage(const GURL& url) {
+  return url.is_valid() && url.spec() == content::kUnreachableWebDataURL;
+}
+
+bool IsReloadableError(const error_page::Error& error, bool was_failed_post) {
+  const GURL& url = error.url();
+  return error.domain() == error_page::Error::kNetErrorDomain &&
+         error.reason() != net::ERR_ABORTED &&
+         // For now, net::ERR_UNKNOWN_URL_SCHEME is only being displayed on
+         // Chrome for Android.
+         error.reason() != net::ERR_UNKNOWN_URL_SCHEME &&
+         // Do not trigger if the server rejects a client certificate.
+         // https://crbug.com/431387
+         !net::IsClientCertificateError(error.reason()) &&
+         // Some servers reject client certificates with a generic
+         // handshake_failure alert.
+         // https://crbug.com/431387
+         error.reason() != net::ERR_SSL_PROTOCOL_ERROR &&
+         // Do not trigger for blacklisted URLs.
+         // https://crbug.com/803839
+         // Do not trigger for requests that were blocked by the browser itself.
+         !net::IsRequestBlockedError(error.reason()) && !was_failed_post &&
+         // Do not trigger for this error code because it is used by Chrome
+         // while an auth prompt is being displayed.
+         error.reason() != net::ERR_INVALID_AUTH_CREDENTIALS &&
+         // Don't auto-reload non-http/https schemas.
+         // https://crbug.com/471713
+         url.SchemeIsHTTPOrHTTPS() &&
+         // Don't auto reload if the error was a secure DNS network error, since
+         // the reload may interfere with the captive portal probe state.
+         // TODO(crbug.com/1016164): Explore how to allow reloads for secure DNS
+         // network errors without interfering with the captive portal probe
+         // state.
+         !error.resolve_error_info().is_secure_network_error;
+}
+
+}  // namespace
 
 struct ErrorPageHelper::ErrorPageInfo {
-  explicit ErrorPageInfo(const error_page::Error& error) : error(error) {}
+  ErrorPageInfo(const error_page::Error& error, bool was_failed_post)
+      : error(error), was_failed_post(was_failed_post) {}
 
   // Information about the failed page load.
   error_page::Error error;
+  bool was_failed_post = false;
 
   // True if a page has completed loading, at which point it can receive
   // updates.
@@ -39,23 +88,97 @@ ErrorPageHelper* ErrorPageHelper::GetForFrame(
   return render_frame->IsMainFrame() ? Get(render_frame) : nullptr;
 }
 
-void ErrorPageHelper::PrepareErrorPage(const error_page::Error& error) {
-  pending_error_page_info_ = std::make_unique<ErrorPageInfo>(error);
+void ErrorPageHelper::PrepareErrorPage(const error_page::Error& error,
+                                       bool was_failed_post) {
+  pending_error_page_info_ =
+      std::make_unique<ErrorPageInfo>(error, was_failed_post);
+}
+
+bool ErrorPageHelper::ShouldSuppressErrorPage(int error_code) {
+  // If there's no auto reload attempt in flight, this error page didn't come
+  // from auto reload, so don't suppress it.
+  if (!auto_reload_in_flight_)
+    return false;
+
+  // Even with auto_reload_in_flight_ error page may not come from
+  // the auto reload when proceeding from error CERT_AUTHORITY_INVALID
+  // to error INVALID_AUTH_CREDENTIALS, so do not suppress the error page
+  // for the new error code.
+  if (committed_error_page_info_ &&
+      committed_error_page_info_->error.reason() != error_code)
+    return false;
+
+  uncommitted_load_started_ = false;
+  // This serves to terminate the auto-reload in flight attempt. If
+  // ShouldSuppressErrorPage is called, the auto-reload yielded an error, which
+  // means the request was already sent.
+  auto_reload_in_flight_ = false;
+  MaybeStartAutoReloadTimer();
+  return true;
+}
+
+void ErrorPageHelper::DidStartNavigation(
+    const GURL& url,
+    base::Optional<blink::WebNavigationType> navigation_type) {
+  uncommitted_load_started_ = true;
+
+  // If there's no pending error page information associated with the page load,
+  // or the new page is not an error page, then reset pending error page state.
+  if (!pending_error_page_info_ || !IsErrorPage(url)) {
+    CancelPendingReload();
+  } else {
+    // Halt auto-reload if it's currently scheduled. OnFinishLoad will trigger
+    // auto-reload if appropriate.
+    PauseAutoReloadTimer();
+  }
 }
 
 void ErrorPageHelper::DidCommitProvisionalLoad(ui::PageTransition transition) {
+  // If a page is committing, either it's an error page and autoreload will be
+  // started again below, or it's a success page and we need to clear autoreload
+  // state.
+  auto_reload_in_flight_ = false;
+
+  // uncommitted_load_started_ could already be false, since RenderFrameImpl
+  // calls OnCommitLoad once for each in-page navigation (like a fragment
+  // change) with no corresponding OnStartLoad.
+  uncommitted_load_started_ = false;
+
   committed_error_page_info_ = std::move(pending_error_page_info_);
+
   weak_factory_.InvalidateWeakPtrs();
 }
 
 void ErrorPageHelper::DidFinishLoad() {
-  if (!committed_error_page_info_)
+  if (!committed_error_page_info_) {
+    auto_reload_count_ = 0;
     return;
+  }
 
   security_interstitials::SecurityInterstitialPageController::Install(
       render_frame(), weak_factory_.GetWeakPtr());
 
   committed_error_page_info_->is_finished_loading = true;
+  if (IsReloadableError(committed_error_page_info_->error,
+                        committed_error_page_info_->was_failed_post)) {
+    MaybeStartAutoReloadTimer();
+  }
+}
+
+void ErrorPageHelper::OnStop() {
+  CancelPendingReload();
+  uncommitted_load_started_ = false;
+  auto_reload_count_ = 0;
+  auto_reload_in_flight_ = false;
+}
+
+void ErrorPageHelper::WasShown() {
+  if (auto_reload_paused_)
+    MaybeStartAutoReloadTimer();
+}
+
+void ErrorPageHelper::WasHidden() {
+  PauseAutoReloadTimer();
 }
 
 void ErrorPageHelper::OnDestruct() {
@@ -128,9 +251,14 @@ ErrorPageHelper::GetInterface() {
 
 ErrorPageHelper::ErrorPageHelper(content::RenderFrame* render_frame)
     : RenderFrameObserver(render_frame),
-      RenderFrameObserverTracker<ErrorPageHelper>(render_frame) {}
+      RenderFrameObserverTracker<ErrorPageHelper>(render_frame),
+      online_(content::RenderThread::Get()->IsOnline()) {
+  content::RenderThread::Get()->AddObserver(this);
+}
 
-ErrorPageHelper::~ErrorPageHelper() = default;
+ErrorPageHelper::~ErrorPageHelper() {
+  content::RenderThread::Get()->RemoveObserver(this);
+}
 
 void ErrorPageHelper::Reload() {
   if (!committed_error_page_info_)
@@ -138,4 +266,82 @@ void ErrorPageHelper::Reload() {
   render_frame()->GetWebFrame()->StartReload(blink::WebFrameLoadType::kReload);
 }
 
+void ErrorPageHelper::MaybeStartAutoReloadTimer() {
+  // Automation tools expect to be in control of reloads.
+  if (base::CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kEnableAutomation) ||
+      !base::FeatureList::IsEnabled(features::kEnableAutoReload)) {
+    return;
+  }
+
+  if (!committed_error_page_info_ ||
+      !committed_error_page_info_->is_finished_loading ||
+      pending_error_page_info_ || uncommitted_load_started_) {
+    return;
+  }
+
+  StartAutoReloadTimer();
+}
+
+void ErrorPageHelper::StartAutoReloadTimer() {
+  DCHECK(committed_error_page_info_);
+  DCHECK(IsReloadableError(committed_error_page_info_->error,
+                           committed_error_page_info_->was_failed_post));
+
+  if (!online_ || render_frame()->IsHidden()) {
+    auto_reload_paused_ = true;
+    return;
+  }
+
+  auto_reload_paused_ = false;
+  base::TimeDelta delay = GetAutoReloadTime(auto_reload_count_);
+  auto_reload_timer_.Stop();
+  auto_reload_timer_.Start(
+      FROM_HERE, delay,
+      base::BindOnce(&ErrorPageHelper::AutoReloadTimerFired,
+                     base::Unretained(this)));
+}
+
+void ErrorPageHelper::AutoReloadTimerFired() {
+  // AutoReloadTimerFired only runs if:
+  // 1. StartAutoReloadTimer was previously called, which requires that
+  //    committed_error_page_info_ is populated;
+  // 2. No other page load has started since (1), since DidStartNavigation stops
+  //    the auto-reload timer.
+  DCHECK(committed_error_page_info_);
+
+  auto_reload_count_++;
+  auto_reload_in_flight_ = true;
+  Reload();
+}
+
+void ErrorPageHelper::PauseAutoReloadTimer() {
+  if (!auto_reload_timer_.IsRunning())
+    return;
+  DCHECK(committed_error_page_info_);
+  DCHECK(!auto_reload_paused_);
+  auto_reload_timer_.Stop();
+  auto_reload_paused_ = true;
+}
+
+void ErrorPageHelper::NetworkStateChanged(bool online) {
+  bool was_online = online_;
+  online_ = online;
+  if (!was_online && online) {
+    // Transitioning offline -> online
+    if (auto_reload_paused_)
+      MaybeStartAutoReloadTimer();
+  } else if (was_online && !online) {
+    // Transitioning online -> offline
+    if (auto_reload_timer_.IsRunning())
+      auto_reload_count_ = 0;
+    PauseAutoReloadTimer();
+  }
+}
+
+void ErrorPageHelper::CancelPendingReload() {
+  auto_reload_timer_.Stop();
+  auto_reload_paused_ = false;
+}
+
 }  // namespace weblayer

weblayer/renderer/error_page_helper.h

@@ -10,6 +10,7 @@
 #include "components/security_interstitials/core/common/mojom/interstitial_commands.mojom.h"
 #include "content/public/renderer/render_frame_observer.h"
 #include "content/public/renderer/render_frame_observer_tracker.h"
+#include "content/public/renderer/render_thread_observer.h"
 #include "third_party/blink/public/common/associated_interfaces/associated_interface_provider.h"
 
 namespace error_page {
@@ -26,6 +27,7 @@ namespace weblayer {
 class ErrorPageHelper
     : public content::RenderFrameObserver,
       public content::RenderFrameObserverTracker<ErrorPageHelper>,
+      public content::RenderThreadObserver,
       public security_interstitials::SecurityInterstitialPageController::
           Delegate {
  public:
@@ -38,13 +40,26 @@ class ErrorPageHelper
   static ErrorPageHelper* GetForFrame(content::RenderFrame* render_frame);
 
   // Called when the current navigation results in an error.
-  void PrepareErrorPage(const error_page::Error& error);
+  void PrepareErrorPage(const error_page::Error& error, bool was_failed_post);
+
+  // Returns whether a load for the frame the ErrorPageHelper is attached to
+  // should have its error page suppressed.
+  bool ShouldSuppressErrorPage(int error_code);
 
   // content::RenderFrameObserver:
+  void DidStartNavigation(
+      const GURL& url,
+      base::Optional<blink::WebNavigationType> navigation_type) override;
   void DidCommitProvisionalLoad(ui::PageTransition transition) override;
   void DidFinishLoad() override;
+  void OnStop() override;
+  void WasShown() override;
+  void WasHidden() override;
   void OnDestruct() override;
 
+  // content::RenderThreadObserver:
+  void NetworkStateChanged(bool online) override;
+
   // security_interstitials::SecurityInterstitialPageController::Delegate:
   void SendCommand(
       security_interstitials::SecurityInterstitialCommand command) override;
@@ -59,6 +74,11 @@ class ErrorPageHelper
   ~ErrorPageHelper() override;
 
   void Reload();
+  void MaybeStartAutoReloadTimer();
+  void StartAutoReloadTimer();
+  void AutoReloadTimerFired();
+  void PauseAutoReloadTimer();
+  void CancelPendingReload();
 
   // Information for the provisional / "pre-provisional" error page. Null when
   // there's no page pending, or the pending page is not an error page.
@@ -68,6 +88,30 @@ class ErrorPageHelper
   // not an error page.
   std::unique_ptr<ErrorPageInfo> committed_error_page_info_;
 
+  // Timer used to wait for auto-reload attempts.
+  base::OneShotTimer auto_reload_timer_;
+
+  // True if the auto-reload timer would be running but is waiting for an
+  // offline->online network transition.
+  bool auto_reload_paused_ = false;
+
+  // Whether an auto-reload-initiated Reload() attempt is in flight.
+  bool auto_reload_in_flight_ = false;
+
+  // True if there is an uncommitted-but-started load, error page or not. This
+  // is used to inhibit starting auto-reload when an error page finishes, in
+  // case this happens:
+  //   Error page starts
+  //   Error page commits
+  //   Non-error page starts
+  //   Error page finishes
+  bool uncommitted_load_started_ = false;
+
+  // Is the browser online?
+  bool online_ = false;
+
+  int auto_reload_count_ = 0;
+
   base::WeakPtrFactory<ErrorPageHelper> weak_factory_{this};
 
   DISALLOW_COPY_AND_ASSIGN(ErrorPageHelper);