Support auto-reload on errors.

chrome/renderer/net/net_error_helper_core.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/renderer/net/net_error_helper_core.h"
 
 #include <string>
 
+#include "base/bind.h"
+#include "base/callback.h"
+#include "base/location.h"
 #include "base/metrics/histogram.h"
 #include "chrome/common/localized_error.h"
 #include "net/base/escape.h"
 #include "net/base/net_errors.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "third_party/WebKit/public/platform/WebURLError.h"
 #include "url/gurl.h"
 
 namespace {
 
+base::TimeDelta GetAutoReloadTime(size_t reload_count) {
+  static const int kDelaysMs[] = {
+    0, 5000, 30000, 60000, 300000, 600000, 1800000
+  };
+  if (reload_count >= arraysize(kDelaysMs))
+    reload_count = arraysize(kDelaysMs) - 1;
+  return base::TimeDelta::FromMilliseconds(kDelaysMs[reload_count]);
+}
+
 // Returns whether |net_error| is a DNS-related error (and therefore whether
 // the tab helper should start a DNS probe after receiving it.)
 bool IsDnsError(const blink::WebURLError& error) {
   return error.domain.utf8() == net::kErrorDomain &&
          (error.reason == net::ERR_NAME_NOT_RESOLVED ||
           error.reason == net::ERR_NAME_RESOLUTION_FAILED);
 }
 
+bool IsReloadableError(const blink::WebURLError& error) {
+  return error.domain.utf8() == net::kErrorDomain &&
+         error.reason != net::ERR_ABORTED;
+}
+
 // If an alternate error page should be retrieved remotely for a main frame load
 // that failed with |error|, returns true and sets |error_page_url| to the URL
 // of the remote error page.
 bool GetErrorPageURL(const blink::WebURLError& error,
                      const GURL& alt_error_page_url,
                      GURL* error_page_url) {
   if (!alt_error_page_url.is_valid())
     return false;
 
   // Parameter to send to the error page indicating the error type.
@@ skipping 72 matching lines @@
   // valid URL.  Request will be issued when the error page finishes loading.
   // This is done on load complete to ensure that there are two complete loads
   // for tests to wait for.
   GURL alternate_error_page_url;
 
   // True if a page has completed loading, at which point it can receive
   // updates.
   bool is_finished_loading;
 };
 
-NetErrorHelperCore::NetErrorHelperCore(Delegate* delegate)
+NetErrorHelperCore::NetErrorHelperCore(Delegate* delegate,
+  scoped_ptr<MockableOneShotTimer> reload_timer)
     : delegate_(delegate),
-      last_probe_status_(chrome_common_net::DNS_PROBE_POSSIBLE) {
+      last_probe_status_(chrome_common_net::DNS_PROBE_POSSIBLE),
+      auto_reload_enabled_(false),
+      auto_reload_timer_(reload_timer.Pass()),
+      auto_reload_count_(0),
+      auto_reload_pending_(false),
+      online_(true) {
+  LOG(ERROR) << "NetErrorHelperCore: allocated";
 }
 
 NetErrorHelperCore::~NetErrorHelperCore() {
 }
 
-void NetErrorHelperCore::OnStop() {
-  // On stop, cancel loading the alternate error page, and prevent any pending
-  // error page load from starting a new error page load.  Swapping in the error
-  // page when it's finished loading could abort the navigation, otherwise.
-  if (committed_error_page_info_)
+void NetErrorHelperCore::CancelPendingFetches() {
+  // Cancel loading the alternate error page, and prevent any pending error page
+  // load from starting a new error page load.  Swapping in the error page when
+  // it's finished loading could abort the navigation, otherwise.
+  if (committed_error_page_info_) {
     committed_error_page_info_->alternate_error_page_url = GURL();
+  }
   if (pending_error_page_info_)
     pending_error_page_info_->alternate_error_page_url = GURL();
   delegate_->CancelFetchErrorPage();
+  auto_reload_timer_->Stop();
+}
+
+void NetErrorHelperCore::OnStop() {
+  CancelPendingFetches();
+  if (auto_reload_pending_) {
+    HISTOGRAM_CUSTOM_ENUMERATION("Net.AutoReload.ErrorAtStop",
+                                 committed_error_page_info_->error.reason,
+                                 net::GetAllErrorCodesForUma());
+    HISTOGRAM_COUNTS("Net.AutoReload.CountAtStop",
+                     auto_reload_count_);
+  }
+  auto_reload_count_ = 0;
+  auto_reload_pending_ = false;
 }
 
 void NetErrorHelperCore::OnStartLoad(FrameType frame_type, PageType page_type) {
   if (frame_type != MAIN_FRAME)
     return;
 
   // 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_ || page_type != ERROR_PAGE) {
-    OnStop();
+    CancelPendingFetches();
   }
 }
 
 void NetErrorHelperCore::OnCommitLoad(FrameType frame_type) {
   if (frame_type != MAIN_FRAME)
     return;
 
+  if (committed_error_page_info_ && !pending_error_page_info_ &&
+          auto_reload_pending_) {
+    int reason = committed_error_page_info_->error.reason;
+    HISTOGRAM_CUSTOM_ENUMERATION("Net.AutoReload.ErrorAtSuccess",
+                                 reason,
+                                 net::GetAllErrorCodesForUma());
+    if (auto_reload_count_ == 1)
+      HISTOGRAM_CUSTOM_ENUMERATION("Net.AutoReload.ErrorAtFirstSuccess",
+                                   reason,
+                                   net::GetAllErrorCodesForUma());
+  }
+
   committed_error_page_info_.reset(pending_error_page_info_.release());
 }
 
 void NetErrorHelperCore::OnFinishLoad(FrameType frame_type) {
-  if (frame_type != MAIN_FRAME || !committed_error_page_info_)
+  if (frame_type != MAIN_FRAME)
     return;
 
+  if (!committed_error_page_info_) {
+    if (auto_reload_pending_)
+      HISTOGRAM_COUNTS("Net.AutoReload.CountAtSuccess", auto_reload_count_);

[Randy Smith (Not in Mondays), 2014/02/26 00:07:38]

Suggestion: I'd be inclined to move this histogram up to be with the other ones
so that we can reason about them together.  My belief is that we'll usually
succeed after commit, if the original error resulted in a pre-commit failure,
and that for both code simplicity and histogram consistency reasons we're better
off taking the small inaccuracy of moving the histogram above.  You could put
another one in to detect the Commit/Finish distinction if you'd like.

[Elly Fong-Jones, 2014/03/03 19:31:07]

Done.

+    auto_reload_count_ = 0;
+    auto_reload_pending_ = false;
+    return;
+  }
+
   committed_error_page_info_->is_finished_loading = true;
 
   if (committed_error_page_info_->alternate_error_page_url.is_valid()) {
     // If there is another pending error page load,
     // |replace_with_alternate_error_page| should have been set to false.
     DCHECK(!pending_error_page_info_);
     DCHECK(!committed_error_page_info_->needs_dns_updates);
     GURL error_page_url;
     delegate_->FetchErrorPage(
         committed_error_page_info_->alternate_error_page_url);
+  } else if (auto_reload_enabled_) {
+    auto_reload_pending_ = true;
+    MaybeStartAutoReloadTimer();
   }
 
   if (!committed_error_page_info_->needs_dns_updates ||
       last_probe_status_ == chrome_common_net::DNS_PROBE_POSSIBLE) {
     return;
   }
   DVLOG(1) << "Error page finished loading; sending saved status.";
   UpdateErrorPage();
 }
 
@@ skipping 129 matching lines @@
   }
 
   blink::WebURLError updated_error;
   updated_error.domain = blink::WebString::fromUTF8(
       chrome_common_net::kDnsProbeErrorDomain);
   updated_error.reason = last_probe_status_;
   updated_error.unreachableURL = error.unreachableURL;
 
   return updated_error;
 }
+
+void NetErrorHelperCore::Reload() {
+  if (!committed_error_page_info_) {
+    return;
+  }
+  delegate_->ReloadPage();
+}
+
+bool NetErrorHelperCore::MaybeStartAutoReloadTimer() {
+  if (!committed_error_page_info_)
+    return false;
+
+  if (!IsReloadableError(committed_error_page_info_->error))
+    return false;
+
+  if (committed_error_page_info_->was_failed_post)
+    return false;
+
+  if (!online_)
+    return false;
+
+  if (!auto_reload_pending_)
+    return false;
+
+  StartAutoReloadTimer();
+  return true;
+}
+
+void NetErrorHelperCore::StartAutoReloadTimer() {
+  base::TimeDelta delay = GetAutoReloadTime(auto_reload_count_);
+  auto_reload_count_++;
+  auto_reload_timer_->Stop();
+  auto_reload_timer_->Start(FROM_HERE, delay,
+      base::Bind(&NetErrorHelperCore::Reload,
+          base::Unretained(this)));
+}
+
+// Handler for NetworkStateChanged notification from the browser process. If the
+// network state changes to online, this method is responsible for starting the
+// auto-reload process.
+//
+// Warning: if there are many tabs sitting at an error page, this handler will
+// be run at the same time for each of their top-level renderframes, which can
+// cause many requests to be started at the same time. There's no current
+// protection against this kind of "reload storm".
+//
+// TODO(rdsmith): prevent the reload storm.
+void NetErrorHelperCore::NetworkStateChanged(bool online) {
+  online_ = online;
+  if (auto_reload_timer_->IsRunning()) {
+    // If there's an existing timer running, stop it and reset the retry count.
+    auto_reload_timer_->Stop();
+    auto_reload_count_ = 0;
+  }
+
+  if (online)
+    // If we just got online, maybe start auto-reloading again.
+    MaybeStartAutoReloadTimer();

[mmenke, 2014/02/25 22:09:52]

Use braces for multi-line if blocks, or put the comment before the if, like you
do in ShouldSuppressErrorPage (May want to go the latter route, here and above,
just to be consistent, but I don't have strong feelings on it).

[Elly Fong-Jones, 2014/03/03 19:31:07]

Done.

+}
+
+bool NetErrorHelperCore::ShouldSuppressErrorPage(const GURL& url) {
+  // Don't suppress errors if not auto-reloading.
+  if (!auto_reload_pending_)
+    return false;
+
+  // If auto_reload_timer_ is still running, this error page isn't from an auto
+  // reload.
+  if (auto_reload_timer_->IsRunning())
+    return false;
+
+  // If there's no committed error page, this error page wasn't from an auto
+  // reload.
+  if (!committed_error_page_info_)
+    return false;
+
+  GURL error_url = committed_error_page_info_->error.unreachableURL;
+  if (error_url != url)
+    return false;
+
+  MaybeStartAutoReloadTimer();
+  return true;
+}