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/i18n/rtl.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
+#include "base/location.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string16.h"
 #include "base/values.h"
 #include "chrome/common/localized_error.h"
 #include "grit/generated_resources.h"
 #include "net/base/escape.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_util.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "third_party/WebKit/public/platform/WebURLError.h"
@@ skipping 16 matching lines @@
   {IDS_ERRORPAGES_SUGGESTION_ALTERNATE_URL, "sitemap"},
   {IDS_ERRORPAGES_SUGGESTION_ALTERNATE_URL, "pathParentFolder"},
   // "siteSearchQuery" is not yet supported.
   // TODO(mmenke):  Figure out what format "siteSearchQuery" uses for its
   // suggestions.
   // "webSearchQuery" has special handling.
   {IDS_ERRORPAGES_SUGGESTION_ALTERNATE_URL, "contentOverlap"},
   {IDS_ERRORPAGES_SUGGESTION_CORRECTED_URL, "emphasizedUrlCorrection"},
 };
 
+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);
 }
 
 GURL SanitizeURL(const GURL& url) {
   GURL::Replacements remove_params;
@@ skipping 206 matching lines @@
   // Request body to use when requesting corrections from a web service.
   // TODO(mmenke):  Investigate loading the error page at the same time as
   //                the blank page is loading, to get rid of these.
   std::string navigation_correction_request_body;
 
   // True if a page has completed loading, at which point it can receive
   // updates.
   bool is_finished_loading;
 };
 
+bool NetErrorHelperCore::IsReloadableError(
+    const NetErrorHelperCore::ErrorPageInfo& info) {
+  return info.error.domain.utf8() == net::kErrorDomain &&
+         info.error.reason != net::ERR_ABORTED &&
+         !info.was_failed_post;
+}
+
 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),
+      auto_reload_timer_(new MockableOneShotTimer()),
+      online_(true),

[mmenke, 2014/03/13 14:39:13]

Don't suppose we can get the correct initial value for this?  Think it's fine to
save that for a followup CL, but should probably at least look into it before
enabling by default.

If we can't manage it, should probably at least set auto_reload_count_ on the
offline -> online transition, instead of / in addition to the online -> offline
one (That may make sense, anyways).

[Elly Fong-Jones, 2014/03/13 17:56:19]

NetworkChangeNotifier has this state, but it's only browser-side unfortunately.
A quick look did not reveal any IPCs that could convey this state to the
renderer or any places where it's kept renderer-side except for inside blink :(.
I'll add a TODO.
Actually, we currently set it at both transitions, I think.

[mmenke, 2014/03/13 19:18:12]

Ah, you're right...unless we're currently automatically reloading the page (As
opposed to just running the timer to do so)...

+      auto_reload_count_(0),
+      can_auto_reload_page_(false) {
 }
 
 NetErrorHelperCore::~NetErrorHelperCore() {
+  if (committed_error_page_info_ && can_auto_reload_page_) {
+    UMA_HISTOGRAM_CUSTOM_ENUMERATION("Net.AutoReload.ErrorAtStop",
+                                     -committed_error_page_info_->error.reason,
+                                     net::GetAllErrorCodesForUma());
+    UMA_HISTOGRAM_COUNTS("Net.AutoReload.CountAtStop", auto_reload_count_);
+  }
 }
 
-void NetErrorHelperCore::OnStop() {
-  // On stop, cancel loading navigation corrections, and prevent any
-  // pending error page load from starting to load corrections.  Swapping in an
-  // error page once corrections are received could interrupt a navigation,
-  // otherwise.
+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_ && can_auto_reload_page_) {
+    UMA_HISTOGRAM_CUSTOM_ENUMERATION("Net.AutoReload.ErrorAtStop",
+                                     -committed_error_page_info_->error.reason,
+                                     net::GetAllErrorCodesForUma());
+    UMA_HISTOGRAM_COUNTS("Net.AutoReload.CountAtStop", auto_reload_count_);
+  }
   if (committed_error_page_info_) {
     committed_error_page_info_->navigation_correction_url = GURL();
     committed_error_page_info_->navigation_correction_request_body.clear();
   }
   if (pending_error_page_info_) {
     pending_error_page_info_->navigation_correction_url = GURL();
     pending_error_page_info_->navigation_correction_request_body.clear();
   }
   delegate_->CancelFetchNavigationCorrections();
+  auto_reload_timer_->Stop();
+  can_auto_reload_page_ = false;
+}
+
+void NetErrorHelperCore::OnStop() {
+  CancelPendingFetches();
+  auto_reload_count_ = 0;
 }
 
 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();
+  } else {
+    // If an error load is starting, the resulting error page is autoreloadable.
+    can_auto_reload_page_ = IsReloadableError(*pending_error_page_info_);
   }
 }
 
 void NetErrorHelperCore::OnCommitLoad(FrameType frame_type) {
   if (frame_type != MAIN_FRAME)
     return;
 
+  if (committed_error_page_info_ && !pending_error_page_info_ &&
+      can_auto_reload_page_) {
+    int reason = committed_error_page_info_->error.reason;
+    UMA_HISTOGRAM_CUSTOM_ENUMERATION("Net.AutoReload.ErrorAtSuccess",
+                                     -reason,
+                                     net::GetAllErrorCodesForUma());
+    UMA_HISTOGRAM_COUNTS("Net.AutoReload.CountAtSuccess", auto_reload_count_);
+    if (auto_reload_count_ == 1) {
+      UMA_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;
+    return;
+  }
+
   committed_error_page_info_->is_finished_loading = true;
 
   if (committed_error_page_info_->navigation_correction_url.is_valid()) {
     // If there is another pending error page load, |fix_url| should have been
     // cleared.
     DCHECK(!pending_error_page_info_);
     DCHECK(!committed_error_page_info_->needs_dns_updates);
     delegate_->FetchNavigationCorrections(
         committed_error_page_info_->navigation_correction_url,
         committed_error_page_info_->navigation_correction_request_body);
+  } else if (auto_reload_enabled_ &&
+             IsReloadableError(*committed_error_page_info_)) {
+    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 151 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_ ||
+      !committed_error_page_info_->is_finished_loading ||
+      !can_auto_reload_page_ ||
+      pending_error_page_info_) {

[mmenke, 2014/03/13 14:39:13]

Can any of these not be true, except in the offline to online case?  If not, may
want to move the checks down there, and turn them into DCHECKs here.

[Elly Fong-Jones, 2014/03/13 17:56:19]

Yes: as called in ShouldSuppressErrorPage(), is_finished_loading can be false,
and pending_error_page_info_ can be true. As called in OnFinish,
pending_error_page_info_ can be true. In general, I want this function to
contain its own checks for whether it should call StartAutoReloadTimer and not
push those into the callees.

+    return false;
+  }
+
+  DCHECK(IsReloadableError(*committed_error_page_info_));
+
+  if (!online_)
+    return false;
+
+  StartAutoReloadTimer();
+  return true;
+}
+
+void NetErrorHelperCore::StartAutoReloadTimer() {
+  DCHECK(committed_error_page_info_);
+  DCHECK(can_auto_reload_page_);
+  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)));
+}
+
+void NetErrorHelperCore::NetworkStateChanged(bool online) {
+  online_ = online;
+  if (auto_reload_timer_->IsRunning()) {
+    DCHECK(committed_error_page_info_);
+    // If there's an existing timer running, stop it and reset the retry count.
+    auto_reload_timer_->Stop();
+    auto_reload_count_ = 0;
+  }
+
+  // If the network state changed to online, maybe start auto-reloading again.
+  if (online)
+    MaybeStartAutoReloadTimer();
+}
+
+bool NetErrorHelperCore::ShouldSuppressErrorPage(FrameType frame_type,
+                                                 const GURL& url) {
+  // Don't suppress child frame errors.
+  if (frame_type != MAIN_FRAME)
+    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_ || !can_auto_reload_page_)
+    return false;
+
+  GURL error_url = committed_error_page_info_->error.unreachableURL;
+  // TODO(ellyjones): also plumb the error code down to CCRC and check that
+  if (error_url != url)
+    return false;
+
+  // The first iteration of the timer is started by OnFinishLoad calling
+  // MaybeStartAutoReloadTimer, but since error pages for subsequent loads are
+  // suppressed in this function, subsequent iterations of the timer have to be
+  // started here.
+  MaybeStartAutoReloadTimer();
+  return true;
+}