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) {
 }
 
 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_) {

[mmenke, 2014/03/04 17:26:25]

Think this should be lined up with committed

[Elly Fong-Jones, 2014/03/06 21:48:37]

Done.

+    int reason = committed_error_page_info_->error.reason;
+    HISTOGRAM_CUSTOM_ENUMERATION("Net.AutoReload.ErrorAtSuccess",

[mmenke, 2014/03/04 17:26:25]

To upload the histograms, you need to use the UMA_blah macros.  These just
update about:histograms (Why anyone would want that, I'm not sure).

[Elly Fong-Jones, 2014/03/06 21:48:37]

Done.

+                                 reason,
+                                 net::GetAllErrorCodesForUma());
+    HISTOGRAM_COUNTS("Net.AutoReload.CountAtSuccess", auto_reload_count_);
+    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_) {
+    auto_reload_count_ = 0;
+    auto_reload_pending_ = false;

[mmenke, 2014/03/04 17:26:25]

Hmm...Would it make sense to move these to ErrorPageInfo?  Seems like they're
associated with a particular error page, much like everything else.

[Elly Fong-Jones, 2014/03/06 21:48:37]

Done.

+    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_) {

[mmenke, 2014/03/04 17:26:25]

We don't want to do this if there's a pending load, right?  Should also test
this.

The simplest solution would be to move these into ErrorPageInfo, and then set
auto_reload_enabled_ to false for the committed load, if it's not finished
loading (This is, admittedly, a little weird and not a perfect solution).

[Elly Fong-Jones, 2014/03/06 21:48:37]

Done.

+    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 130 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;
   updated_error.staleCopyInCache = error.staleCopyInCache;
 
   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;

[mmenke, 2014/03/04 17:26:25]

I think having auto_reload_pending_ for a non-reloadable error code, or a failed
post, is very misleading.

[Elly Fong-Jones, 2014/03/06 21:48:37]

Done.

+
+  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)));

[mmenke, 2014/03/04 17:26:25]

Believe this should be lined up with the &.  Or on the previous line, if it
fits.

[Elly Fong-Jones, 2014/03/06 21:48:37]

Done.

+}
+
+// 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.

[mmenke, 2014/03/04 17:26:25]

Method level comments generally go with declarations, not definitions.

[Elly Fong-Jones, 2014/03/06 21:48:37]

Done.

+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 we just got online, maybe start auto-reloading again.

[mmenke, 2014/03/04 17:26:25]

nit:  --we

[Elly Fong-Jones, 2014/03/06 21:48:37]

Done.

+  if (online)
+    MaybeStartAutoReloadTimer();
+}
+
+bool NetErrorHelperCore::ShouldSuppressErrorPage(const GURL& url) {
+  // Don't suppress errors if not auto-reloading.
+  if (!auto_reload_pending_)
+    return false;

[mmenke, 2014/03/04 17:26:25]

May want to merged this check with the next...Think it's easier to mentally
process related checks together.

[Elly Fong-Jones, 2014/03/06 21:48:37]

They are now sadly more separate.

+
+  // If auto_reload_timer_ is still running, this error page isn't from an auto

[mmenke, 2014/03/04 17:26:25]

nit:  |auto_reload_timer_|  (Not required by Google style, but it's used
elsewhere in this file, and should be consistent within a file)

[Elly Fong-Jones, 2014/03/06 21:48:37]

Done.

+  // 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;

[mmenke, 2014/03/04 17:26:25]

The logic here seems correct in most cases (Except, perhaps, when we autoreload
and get an exciting new error, which I don't think is an issue), but all these
checks make me worry about fragility.  May want to think about making it more
robust, but fine for now.

[Elly Fong-Jones, 2014/03/06 21:48:37]

Done.

+
+  MaybeStartAutoReloadTimer();
+  return true;
+}