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 {
 
 // 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.reason != net::ERR_ABORTED;

[Randy Smith (Not in Mondays), 2014/01/30 20:14:47]

I believe we just want to reload on "offline like" errors, which I currently
believe are:

  return (error == net::ERR_NAME_NOT_RESOLVED ||
          error == net::ERR_INTERNET_DISCONNECTED ||
          error == net::ERR_ADDRESS_UNREACHABLE ||
          error == net::ERR_CONNECTION_TIMED_OUT);

and based on the discussion with Paul J, I think we should add
ERR_NETWORK_CHANGED.

[mmenke, 2014/01/30 20:47:31]

I'm not sure about those...  ERR_CONNECTION_TIMED_OUT and
ERR_ADDRESS_UNREACHABLE in particular.  The latter you often see when upstream
network devices are down, like your cable modem rebooting.  Timed out you often
see on random connection hiccups, or site hiccups.  Also, if things are timing
out, at least you're not really hammering the network trying to reload.

[Randy Smith (Not in Mondays), 2014/01/30 20:57:30]

I'm confused; isn't modem rebooting and random connection hiccups exactly the
situations in which we want to auto-reload with an exponential backoff?

+}
+
 // 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 74 matching lines @@
   // 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)
     : delegate_(delegate),
-      last_probe_status_(chrome_common_net::DNS_PROBE_POSSIBLE) {
+      last_probe_status_(chrome_common_net::DNS_PROBE_POSSIBLE),
+      auto_reload_enabled_(false),

[Randy Smith (Not in Mondays), 2014/01/30 20:14:47]

Why not attach this to the flag setup for this work in
https://codereview.chromium.org/113133004/?

[Elly Fong-Jones, 2014/02/05 21:12:37]

Done.

+      auto_reload_count_(0) {
 }
 
 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_)
     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();
+  if (auto_reload_timer_.get())
+    auto_reload_timer_->Stop();
+  delegate_->CancelFetchAutoReloadPage();
 }
 
 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();
   }
 }
 
 void NetErrorHelperCore::OnCommitLoad(FrameType frame_type) {
   if (frame_type != MAIN_FRAME)
     return;
 
   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 || !committed_error_page_info_) {
+    if (frame_type == MAIN_FRAME && !committed_error_page_info_) {
+      // Just finished a non-error page load. Clear the auto-reload backoff
+      // count.
+      auto_reload_count_ = 0;
+    }
     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(
@@ skipping 26 matching lines @@
     // will just get the results for the next page load.
     if (IsDnsError(error))
       last_probe_status_ = chrome_common_net::DNS_PROBE_POSSIBLE;
 
     GURL error_page_url;
     if (GetErrorPageURL(error, alt_error_page_url_, &error_page_url)) {
       pending_error_page_info_.reset(new ErrorPageInfo(error, is_failed_post));
       pending_error_page_info_->alternate_error_page_url = error_page_url;
       return;
     }
+
+    if (auto_reload_enabled_) {
+      if (IsReloadableError(error))

[mmenke, 2014/01/30 20:45:07]

Don't want to auto reload POSTs.

[mmenke, 2014/01/30 20:45:07]

May make more sense to trigger this when the error page finishes loading (That
is, OnDidFinishLoading, when there's a committed_error_page_info_, no link
doctor load to start, and no pending_error_page_info_).

[mmenke, 2014/01/30 20:45:07]

We just try reloading eternally?

Suppose shouldn't be too bad, but I wonder about the 1, 2, 4, 8, and 16 seconds
reloads...Seems a bit too many.

[Elly Fong-Jones, 2014/02/05 21:12:37]

Done.

[Elly Fong-Jones, 2014/02/05 21:12:37]

Done.

+        StartAutoReload();
+      else
+        auto_reload_count_ = 0;
+    }
   }
 
   GenerateLocalErrorPage(frame_type, error, is_failed_post, error_html);
 }
 
 void NetErrorHelperCore::GenerateLocalErrorPage(
     FrameType frame_type,
     const blink::WebURLError& error,
     bool is_failed_post,
     std::string* error_html) {
@@ skipping 94 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::AutoReload() {
+  if (!committed_error_page_info_) {

[mmenke, 2014/01/30 20:45:07]

Is it possible for this to trigger because it's taking the first error page too
long to load?

[Elly Fong-Jones, 2014/02/05 21:12:37]

No. The timer is only restarted in GetErrorHTML.

+    return;
+  }
+  GURL url = committed_error_page_info_->error.unreachableURL;
+  delegate_->FetchAutoReloadPage(url);
+}
+
+void NetErrorHelperCore::StartAutoReload() {

[Randy Smith (Not in Mondays), 2014/01/30 20:14:47]

We want the NCN indicating we're offline to override this; we should only do
exponential backoff when the NCN says we're online.

[mmenke, 2014/01/30 20:45:07]

StartAutoReloadTimer?

[Elly Fong-Jones, 2014/02/05 21:12:37]

Done.

+  int delay = 1 << auto_reload_count_;

[mmenke, 2014/01/30 20:45:07]

I suggest making the 1 a constant at the top of the file, and make make it in
milliseconds.

[Elly Fong-Jones, 2014/02/05 21:12:37]

Moved it into a helper.

+  auto_reload_count_++;
+  auto_reload_timer_.reset(delegate_->NewMockableOneShotTimer());
+  auto_reload_timer_->Start(FROM_HERE, base::TimeDelta::FromSeconds(delay),
+      base::Bind(&NetErrorHelperCore::AutoReload,
+          base::Unretained(this)));
+}
+
+bool NetErrorHelperCore::IsAutoReloading() const {
+  return auto_reload_count_ != 0;

[mmenke, 2014/01/30 20:45:07]

This isn't correct in the OnStop() case.

[Elly Fong-Jones, 2014/02/05 21:12:37]

Yeah. Hm.

+}