Fix auto-reload histograms.

Two bugs, and general state-machine grotesqueness, prevented auto-reload
histograms from working properly in production:

1. Success could only be reported in OnCommitLoad() if can_auto_reload_page_ was
true, but can_auto_reload_page_ would be set to false in OnStartLoad(), since
OnStartLoad() had no way of knowing that the non-error page load it saw starting
was actually part of an attempt to auto-reload the page. This has been patched
around by tracking is_auto_reloading in committed_error_page_info_; when the
auto reload timer fires, it sets is_auto_reloading to indicate to OnCommitLoad
that auto-reload was running. OnCommitLoad can then use is_auto_reloading and
the loading URL to decide whether the committing load represents a success or
failure for auto-reload.

2. Whenever a non-error load started, OnStartLoad() would call
CancelPendingFetches(), intending to prevent auto-reload from replacing the
starting load with its own; as a side-effect, CancelPendingFetches() would
assume that if there was an existing error page which looked auto-reloadable
that the cancel represented a failure of auto-reload and log a histogram entry.
Unfortunately, this logic would trigger at each reload attempt by auto-reload,
inflating the failure count with nonexistent failures. To prevent this
misbehavior, CancelPendingFetches() is now no longer responsible for logging
auto-reload failures; instead, failures are detected and logged in
OnCommitLoad() (for "user navigated elsewhere" failures), OnStop (for "user
pressed Stop to abort auto-reload" failures), and the NetErrorHelperCore
destructor (for "user closed the tab" failures).

To help clean up the code, statistics are now reported through
ReportAutoReloadSuccess() and ReportAutoReloadFailure().

There are new unit tests covering these cases:
1. Auto-reload succeeding on the first attempt;
2. Auto-reload succeeding on the second attempt;
3. The user manually stopping an auto-reload;
4. The user manually stopping a non-auto-reload load;
5. The user navigating to a different URL;

As part of this cleanup, simplify the state machine; the ambiguous "can_auto_reload_page_" flag is gone, replaced by an implicit state bit in whether the timer is running (or paused) or not.

BUG=

Review URL: https://codereview.chromium.org/259613003

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@271007 0039d316-1c4b-4281-b951-d872f2087c98

chrome/renderer/net/net_error_helper.cc

@@ -116,7 +116,7 @@ void NetErrorHelper::DidStartProvisionalLoad() {
 
 void NetErrorHelper::DidCommitProvisionalLoad(bool is_new_navigation) {
   blink::WebFrame* frame = render_frame()->GetWebFrame();
-  core_.OnCommitLoad(GetFrameType(frame));
+  core_.OnCommitLoad(GetFrameType(frame), frame->document().url());
 }
 
 void NetErrorHelper::DidFinishLoad() {

chrome/renderer/net/net_error_helper_core.cc

@@ -22,6 +22,7 @@
 #include "base/strings/string_util.h"
 #include "base/values.h"
 #include "chrome/common/localized_error.h"
+#include "content/public/common/url_constants.h"
 #include "grit/generated_resources.h"
 #include "net/base/escape.h"
 #include "net/base/net_errors.h"
@@ -340,6 +341,29 @@ scoped_ptr<LocalizedError::ErrorPageParams> CreateErrorPageParams(
   return params.Pass();
 }
 
+void ReportAutoReloadSuccess(const blink::WebURLError& error, size_t count) {
+  if (error.domain.utf8() != net::kErrorDomain)
+    return;
+  UMA_HISTOGRAM_CUSTOM_ENUMERATION("Net.AutoReload.ErrorAtSuccess",
+                                   -error.reason,
+                                   net::GetAllErrorCodesForUma());
+  UMA_HISTOGRAM_COUNTS("Net.AutoReload.CountAtSuccess", count);
+  if (count == 1) {
+    UMA_HISTOGRAM_CUSTOM_ENUMERATION("Net.AutoReload.ErrorAtFirstSuccess",
+                                     -error.reason,
+                                     net::GetAllErrorCodesForUma());
+  }
+}
+
+void ReportAutoReloadFailure(const blink::WebURLError& error, size_t count) {
+  if (error.domain.utf8() != net::kErrorDomain)
+    return;
+  UMA_HISTOGRAM_CUSTOM_ENUMERATION("Net.AutoReload.ErrorAtStop",
+                                   -error.reason,
+                                   net::GetAllErrorCodesForUma());
+  UMA_HISTOGRAM_COUNTS("Net.AutoReload.CountAtStop", count);
+}
+
 }  // namespace
 
 struct NetErrorHelperCore::ErrorPageInfo {
@@ -350,7 +374,8 @@ struct NetErrorHelperCore::ErrorPageInfo {
         needs_load_navigation_corrections(false),
         reload_button_in_page(false),
         load_stale_button_in_page(false),
-        is_finished_loading(false) {
+        is_finished_loading(false),
+        auto_reload_triggered(false) {
   }
 
   // Information about the failed page load.
@@ -386,6 +411,10 @@ struct NetErrorHelperCore::ErrorPageInfo {
   // True if a page has completed loading, at which point it can receive
   // updates.
   bool is_finished_loading;
+
+  // True if the auto-reload timer has fired and a reload is or has been in
+  // flight.
+  bool auto_reload_triggered;
 };
 
 NetErrorHelperCore::NavigationCorrectionParams::NavigationCorrectionParams() {
@@ -406,19 +435,19 @@ NetErrorHelperCore::NetErrorHelperCore(Delegate* delegate)
       last_probe_status_(chrome_common_net::DNS_PROBE_POSSIBLE),
       auto_reload_enabled_(false),
       auto_reload_timer_(new base::Timer(false, false)),
+      auto_reload_paused_(false),
+      uncommitted_load_started_(false),
       // TODO(ellyjones): Make online_ accurate at object creation.
       online_(true),
       auto_reload_count_(0),
-      can_auto_reload_page_(false),
       navigation_from_button_(NO_BUTTON) {
 }
 
 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_);
+  if (committed_error_page_info_ &&
+      committed_error_page_info_->auto_reload_triggered) {
+    ReportAutoReloadFailure(committed_error_page_info_->error,
+                            auto_reload_count_);
   }
 }
 
@@ -426,23 +455,23 @@ 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_->needs_load_navigation_corrections = false;
   if (pending_error_page_info_)
     pending_error_page_info_->needs_load_navigation_corrections = false;
   delegate_->CancelFetchNavigationCorrections();
   auto_reload_timer_->Stop();
-  can_auto_reload_page_ = false;
+  auto_reload_paused_ = false;
 }
 
 void NetErrorHelperCore::OnStop() {
+  if (committed_error_page_info_ &&
+      committed_error_page_info_->auto_reload_triggered) {
+    ReportAutoReloadFailure(committed_error_page_info_->error,
+                            auto_reload_count_);
+  }
   CancelPendingFetches();
+  uncommitted_load_started_ = false;
   auto_reload_count_ = 0;
 }
 
@@ -450,20 +479,23 @@ void NetErrorHelperCore::OnStartLoad(FrameType frame_type, PageType page_type) {
   if (frame_type != MAIN_FRAME)
     return;
 
+  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_ || page_type != ERROR_PAGE) {
+  if (!pending_error_page_info_ || page_type != ERROR_PAGE)
     CancelPendingFetches();
-  } else if (auto_reload_enabled_) {
-    // 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) {
+void NetErrorHelperCore::OnCommitLoad(FrameType frame_type, const GURL& url) {
   if (frame_type != MAIN_FRAME)
     return;
 
+  // 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;
+
   // Track if an error occurred due to a page button press.
   // This isn't perfect; if (for instance), the server is slow responding
   // to a request generated from the page reload button, and the user hits
@@ -483,17 +515,13 @@ void NetErrorHelperCore::OnCommitLoad(FrameType frame_type) {
   navigation_from_button_ = NO_BUTTON;
 
   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_->auto_reload_triggered) {
+    const blink::WebURLError& error = committed_error_page_info_->error;
+    const GURL& error_url = error.unreachableURL;
+    if (url == error_url)
+      ReportAutoReloadSuccess(error, auto_reload_count_);
+    else if (url != GURL(content::kUnreachableWebDataURL))
+      ReportAutoReloadFailure(error, auto_reload_count_);
   }
 
   committed_error_page_info_.reset(pending_error_page_info_.release());
@@ -734,23 +762,27 @@ void NetErrorHelperCore::Reload() {
 bool NetErrorHelperCore::MaybeStartAutoReloadTimer() {
   if (!committed_error_page_info_ ||
       !committed_error_page_info_->is_finished_loading ||
-      !can_auto_reload_page_ ||
-      pending_error_page_info_) {
+      pending_error_page_info_ ||
+      uncommitted_load_started_) {
     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_);
+  DCHECK(IsReloadableError(*committed_error_page_info_));
+
+  committed_error_page_info_->auto_reload_triggered = true;
+
+  if (!online_) {
+    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,
@@ -764,17 +796,23 @@ void NetErrorHelperCore::AutoReloadTimerFired() {
 }
 
 void NetErrorHelperCore::NetworkStateChanged(bool online) {
+  bool was_online = 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 (!was_online && online) {
+    // Transitioning offline -> online
+    if (auto_reload_paused_)
+      MaybeStartAutoReloadTimer();
+  } else if (was_online && !online) {
+    // Transitioning online -> offline
+    if (auto_reload_timer_->IsRunning()) {
+      DCHECK(committed_error_page_info_);
+      DCHECK(!auto_reload_paused_);
+      DCHECK(committed_error_page_info_->auto_reload_triggered);
+      auto_reload_timer_->Stop();
+      auto_reload_count_ = 0;
+      auto_reload_paused_ = true;
+    }
   }
-
-  // If the network state changed to online, maybe start auto-reloading again.
-  if (online)
-    MaybeStartAutoReloadTimer();
 }
 
 bool NetErrorHelperCore::ShouldSuppressErrorPage(FrameType frame_type,
@@ -783,21 +821,36 @@ bool NetErrorHelperCore::ShouldSuppressErrorPage(FrameType frame_type,
   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())
+  if (!auto_reload_enabled_)
     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_)
+  if (!committed_error_page_info_)
+    return false;
+
+  // If the error page wasn't reloadable, display it.
+  if (!IsReloadableError(*committed_error_page_info_))
     return false;
 
+  // If |auto_reload_timer_| is still running or is paused, this error page
+  // isn't from an auto reload.
+  if (auto_reload_timer_->IsRunning() || auto_reload_paused_)
+    return false;
+
+  // If the error page was reloadable, and the timer isn't running or paused, an
+  // auto-reload has already been triggered.
+  DCHECK(committed_error_page_info_->auto_reload_triggered);
+
   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;
 
+  // Suppressed an error-page load; the previous uncommitted load was the error
+  // page load starting, so forget about it.
+  uncommitted_load_started_ = 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

chrome/renderer/net/net_error_helper_core.h

@@ -130,7 +130,7 @@ class NetErrorHelperCore {
 
   // These methods handle tracking the actual state of the page.
   void OnStartLoad(FrameType frame_type, PageType page_type);
-  void OnCommitLoad(FrameType frame_type);
+  void OnCommitLoad(FrameType frame_type, const GURL& url);
   void OnFinishLoad(FrameType frame_type);
   void OnStop();
 
@@ -225,14 +225,29 @@ class NetErrorHelperCore {
 
   NavigationCorrectionParams navigation_correction_params_;
 
+  // True if auto-reload is enabled at all.
   bool auto_reload_enabled_;
+
+  // Timer used to wait for auto-reload attempts.
   scoped_ptr<base::Timer> 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_;
+
+  // 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_;
+
   // Is the browser online?
   bool online_;
 
   int auto_reload_count_;
-  bool can_auto_reload_page_;
 
   // This value is set only when a navigation has been initiated from
   // the error page.  It is used to detect when such navigations result

chrome/renderer/net/net_error_helper_core_unittest.cc

@@ -4,17 +4,27 @@
 
 #include "chrome/renderer/net/net_error_helper_core.h"
 
+#include <map>
+#include <string>
+#include <vector>
+
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
+#include "base/metrics/statistics_recorder.h"
 #include "base/strings/stringprintf.h"
 #include "base/timer/mock_timer.h"
 #include "base/timer/timer.h"
 #include "base/values.h"
 #include "chrome/common/net/net_error_info.h"
+#include "chrome/test/base/uma_histogram_helper.h"
+#include "content/public/common/url_constants.h"
 #include "net/base/net_errors.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/WebKit/public/platform/WebURLError.h"
+#include "url/gurl.h"
+
+namespace {
 
 using blink::WebURLError;
 using chrome_common_net::DnsProbeStatus;
@@ -121,14 +131,6 @@ WebURLError NetError(net::Error net_error) {
   return error;
 }
 
-WebURLError HttpError(int status_code) {
-  WebURLError error;
-  error.unreachableURL = GURL(kFailedUrl);
-  error.domain = blink::WebString::fromUTF8("http");
-  error.reason = status_code;
-  return error;
-}
-
 // Convenience functions that create an error string for a non-POST request.
 
 std::string ProbeErrorString(DnsProbeStatus status) {
@@ -142,15 +144,16 @@ std::string NetErrorString(net::Error net_error) {
 class NetErrorHelperCoreTest : public testing::Test,
                                public NetErrorHelperCore::Delegate {
  public:
-  NetErrorHelperCoreTest()
-      : timer_(new base::MockTimer(false, false)),
-        core_(this),
-        update_count_(0),
-        error_html_update_count_(0),
-        reload_count_(0),
-        load_stale_count_(0),
-        enable_page_helper_functions_count_(0),
-        tracking_request_count_(0) {
+  NetErrorHelperCoreTest() : timer_(new base::MockTimer(false, false)),
+                             core_(this),
+                             update_count_(0),
+                             error_html_update_count_(0),
+                             reload_count_(0),
+                             load_stale_count_(0),
+                             enable_page_helper_functions_count_(0),
+                             default_url_(GURL(kFailedUrl)),
+                             error_url_(GURL(content::kUnreachableWebDataURL)),
+                             tracking_request_count_(0) {
     core_.set_auto_reload_enabled(false);
     core_.set_timer_for_testing(scoped_ptr<base::Timer>(timer_));
   }
@@ -160,6 +163,10 @@ class NetErrorHelperCoreTest : public testing::Test,
     EXPECT_FALSE(is_url_being_fetched());
   }
 
+  virtual void SetUp() OVERRIDE {
+    base::StatisticsRecorder::Initialize();
+  }
+
   NetErrorHelperCore& core() { return core_; }
 
   const GURL& url_being_fetched() const { return url_being_fetched_; }
@@ -177,6 +184,14 @@ class NetErrorHelperCoreTest : public testing::Test,
     return load_stale_url_;
   }
 
+  const GURL& default_url() const {
+    return default_url_;
+  }
+
+  const GURL& error_url() const {
+    return error_url_;
+  }
+
   int enable_page_helper_functions_count() const {
     return enable_page_helper_functions_count_;
   }
@@ -225,14 +240,15 @@ class NetErrorHelperCoreTest : public testing::Test,
 
     core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
                        NetErrorHelperCore::ERROR_PAGE);
-    core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
+    core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME,
+                        error_url());
     core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
   }
 
   void DoSuccessLoad() {
     core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
                        NetErrorHelperCore::NON_ERROR_PAGE);
-    core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
+    core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, default_url());
     core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
   }
 
@@ -384,6 +400,9 @@ class NetErrorHelperCoreTest : public testing::Test,
 
   int enable_page_helper_functions_count_;
 
+  const GURL default_url_;
+  const GURL error_url_;
+
   GURL last_tracking_url_;
   std::string last_tracking_request_body_;
   int tracking_request_count_;
@@ -400,7 +419,7 @@ TEST_F(NetErrorHelperCoreTest, Null) {
 TEST_F(NetErrorHelperCoreTest, SuccessfulPageLoad) {
   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
                      NetErrorHelperCore::NON_ERROR_PAGE);
-  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
+  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, default_url());
   core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
   EXPECT_EQ(0, update_count());
   EXPECT_EQ(0, error_html_update_count());
@@ -410,7 +429,7 @@ TEST_F(NetErrorHelperCoreTest, SuccessfulPageLoadWithNavigationCorrections) {
   EnableNavigationCorrections();
   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
                      NetErrorHelperCore::NON_ERROR_PAGE);
-  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
+  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, default_url());
   core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
   EXPECT_EQ(0, update_count());
   EXPECT_EQ(0, error_html_update_count());
@@ -433,7 +452,7 @@ TEST_F(NetErrorHelperCoreTest, MainFrameNonDnsError) {
   EXPECT_EQ(0, enable_page_helper_functions_count());
   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
                      NetErrorHelperCore::ERROR_PAGE);
-  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
+  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url());
   core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
   EXPECT_EQ(0, update_count());
   EXPECT_EQ(0, error_html_update_count());
@@ -458,7 +477,7 @@ TEST_F(NetErrorHelperCoreTest, MainFrameNonDnsErrorWithCorrections) {
   // Error page loads.
   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
                      NetErrorHelperCore::ERROR_PAGE);
-  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
+  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url());
   core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
   EXPECT_EQ(0, update_count());
   EXPECT_EQ(0, error_html_update_count());
@@ -489,7 +508,7 @@ TEST_F(NetErrorHelperCoreTest, MainFrameNonDnsErrorSpuriousStatus) {
                      NetErrorHelperCore::ERROR_PAGE);
   core().OnNetErrorInfo(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN);
 
-  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
+  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url());
   core().OnNetErrorInfo(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN);
 
   core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
@@ -515,7 +534,7 @@ TEST_F(NetErrorHelperCoreTest, SubFrameDnsError) {
   // Error page loads.
   core().OnStartLoad(NetErrorHelperCore::SUB_FRAME,
                      NetErrorHelperCore::ERROR_PAGE);
-  core().OnCommitLoad(NetErrorHelperCore::SUB_FRAME);
+  core().OnCommitLoad(NetErrorHelperCore::SUB_FRAME, error_url());
   core().OnFinishLoad(NetErrorHelperCore::SUB_FRAME);
   EXPECT_EQ(0, update_count());
   EXPECT_EQ(0, error_html_update_count());
@@ -539,7 +558,7 @@ TEST_F(NetErrorHelperCoreTest, SubFrameDnsErrorWithCorrections) {
   // Error page loads.
   core().OnStartLoad(NetErrorHelperCore::SUB_FRAME,
                      NetErrorHelperCore::ERROR_PAGE);
-  core().OnCommitLoad(NetErrorHelperCore::SUB_FRAME);
+  core().OnCommitLoad(NetErrorHelperCore::SUB_FRAME, error_url());
   core().OnFinishLoad(NetErrorHelperCore::SUB_FRAME);
   EXPECT_EQ(0, update_count());
   EXPECT_EQ(0, error_html_update_count());
@@ -569,7 +588,7 @@ TEST_F(NetErrorHelperCoreTest, SubFrameDnsErrorSpuriousStatus) {
                      NetErrorHelperCore::ERROR_PAGE);
   core().OnNetErrorInfo(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN);
 
-  core().OnCommitLoad(NetErrorHelperCore::SUB_FRAME);
+  core().OnCommitLoad(NetErrorHelperCore::SUB_FRAME, error_url());
   core().OnNetErrorInfo(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN);
 
   core().OnFinishLoad(NetErrorHelperCore::SUB_FRAME);
@@ -602,7 +621,7 @@ TEST_F(NetErrorHelperCoreTest, FinishedBeforeProbe) {
   // Error page loads.
   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
                      NetErrorHelperCore::ERROR_PAGE);
-  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
+  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url());
   core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
   EXPECT_EQ(0, update_count());
 
@@ -640,7 +659,7 @@ TEST_F(NetErrorHelperCoreTest, FinishedBeforeProbeNotRun) {
   // Error page loads.
   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
                      NetErrorHelperCore::ERROR_PAGE);
-  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
+  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url());
   core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
   EXPECT_EQ(0, update_count());
 
@@ -674,7 +693,7 @@ TEST_F(NetErrorHelperCoreTest, FinishedBeforeProbeInconclusive) {
   // Error page loads.
   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
                      NetErrorHelperCore::ERROR_PAGE);
-  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
+  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url());
   core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
   EXPECT_EQ(0, update_count());
 
@@ -712,7 +731,7 @@ TEST_F(NetErrorHelperCoreTest, FinishedBeforeProbeNoInternet) {
   // Error page loads.
   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
                      NetErrorHelperCore::ERROR_PAGE);
-  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
+  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url());
   core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
   EXPECT_EQ(0, update_count());
 
@@ -751,7 +770,7 @@ TEST_F(NetErrorHelperCoreTest, FinishedBeforeProbeBadConfig) {
   // Error page loads.
   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
                      NetErrorHelperCore::ERROR_PAGE);
-  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
+  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url());
   core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
   EXPECT_EQ(0, update_count());
 
@@ -791,7 +810,7 @@ TEST_F(NetErrorHelperCoreTest, FinishedAfterStartProbe) {
   // Error page loads.
   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
                      NetErrorHelperCore::ERROR_PAGE);
-  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
+  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url());
 
   // Nothing should be done when a probe status comes in before loading
   // finishes.
@@ -838,7 +857,7 @@ TEST_F(NetErrorHelperCoreTest, FinishedBeforeProbePost) {
   EXPECT_EQ(0, enable_page_helper_functions_count());
   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
                      NetErrorHelperCore::ERROR_PAGE);
-  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
+  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url());
   core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
   EXPECT_EQ(0, update_count());
   EXPECT_EQ(1, enable_page_helper_functions_count());
@@ -882,7 +901,7 @@ TEST_F(NetErrorHelperCoreTest, ProbeFinishesEarly) {
   core().OnNetErrorInfo(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN);
   EXPECT_EQ(0, update_count());
 
-  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
+  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url());
   EXPECT_EQ(0, update_count());
 
   // When loading finishes, however, the buffered probe status should be sent
@@ -916,7 +935,7 @@ TEST_F(NetErrorHelperCoreTest, TwoErrorsWithProbes) {
   // Error page loads.
   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
                      NetErrorHelperCore::ERROR_PAGE);
-  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
+  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url());
   core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
 
   // Probe results come in.
@@ -942,7 +961,7 @@ TEST_F(NetErrorHelperCoreTest, TwoErrorsWithProbes) {
   // Error page loads.
   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
                      NetErrorHelperCore::ERROR_PAGE);
-  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
+  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url());
   core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
   EXPECT_EQ(2, update_count());
 
@@ -978,7 +997,7 @@ TEST_F(NetErrorHelperCoreTest, TwoErrorsWithProbesAfterSecondStarts) {
   // Error page loads.
   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
                      NetErrorHelperCore::ERROR_PAGE);
-  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
+  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url());
   core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
 
   // The process starts again.
@@ -1006,7 +1025,7 @@ TEST_F(NetErrorHelperCoreTest, TwoErrorsWithProbesAfterSecondStarts) {
             last_error_html());
 
   // Second page finishes loading, and is updated using the same probe result.
-  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
+  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url());
   core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
   EXPECT_EQ(3, update_count());
   EXPECT_EQ(ProbeErrorString(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN),
@@ -1052,7 +1071,7 @@ TEST_F(NetErrorHelperCoreTest, ErrorPageLoadInterrupted) {
   EXPECT_EQ(ProbeErrorString(chrome_common_net::DNS_PROBE_POSSIBLE), html);
 
   // Error page finishes loading.
-  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
+  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url());
   core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
 
   // Probe results come in.
@@ -1095,7 +1114,7 @@ TEST_F(NetErrorHelperCoreTest, NoCorrectionsForHttps) {
   // The blank page loads, no error page is loaded.
   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
                      NetErrorHelperCore::ERROR_PAGE);
-  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
+  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url());
   core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
   EXPECT_FALSE(is_url_being_fetched());
   EXPECT_FALSE(last_error_page_params());
@@ -1132,7 +1151,7 @@ TEST_F(NetErrorHelperCoreTest, CorrectionsReceivedBeforeProbe) {
   // The blank page loads.
   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
                       NetErrorHelperCore::ERROR_PAGE);
-  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
+  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url());
 
   // Corrections retrieval starts when the error page finishes loading.
   EXPECT_FALSE(is_url_being_fetched());
@@ -1152,7 +1171,7 @@ TEST_F(NetErrorHelperCoreTest, CorrectionsReceivedBeforeProbe) {
   // Corrections load.
   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
                       NetErrorHelperCore::ERROR_PAGE);
-  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
+  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url());
   core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
 
   // Any probe statuses should be ignored.
@@ -1181,7 +1200,7 @@ TEST_F(NetErrorHelperCoreTest, CorrectionsRetrievedAfterProbes) {
   // The blank page loads.
   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
                      NetErrorHelperCore::ERROR_PAGE);
-  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
+  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url());
   core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
   EXPECT_TRUE(is_url_being_fetched());
   EXPECT_FALSE(last_error_page_params());
@@ -1205,7 +1224,7 @@ TEST_F(NetErrorHelperCoreTest, CorrectionsRetrievedAfterProbes) {
   // Corrections load.
   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
                      NetErrorHelperCore::ERROR_PAGE);
-  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
+  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url());
   core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
   EXPECT_EQ(1, error_html_update_count());
   EXPECT_EQ(0, update_count());
@@ -1229,7 +1248,7 @@ TEST_F(NetErrorHelperCoreTest, CorrectionsFailLoadNoProbes) {
   // The blank page loads.
   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
                      NetErrorHelperCore::ERROR_PAGE);
-  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
+  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url());
   core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
 
   // Corrections request fails, final error page is shown.
@@ -1244,7 +1263,7 @@ TEST_F(NetErrorHelperCoreTest, CorrectionsFailLoadNoProbes) {
   // Error page loads.
   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
                      NetErrorHelperCore::ERROR_PAGE);
-  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
+  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url());
   core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
 
   // If probe statuses come in last from another page load, they should be
@@ -1273,7 +1292,7 @@ TEST_F(NetErrorHelperCoreTest, CorrectionsFailLoadBeforeProbe) {
   // The blank page loads.
   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
                      NetErrorHelperCore::ERROR_PAGE);
-  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
+  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url());
   core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
 
   // Corrections request fails, probe pending page shown.
@@ -1288,7 +1307,7 @@ TEST_F(NetErrorHelperCoreTest, CorrectionsFailLoadBeforeProbe) {
   // Probe page loads.
   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
                      NetErrorHelperCore::ERROR_PAGE);
-  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
+  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url());
   core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
 
   // Probe statuses comes in, and page is updated.
@@ -1325,7 +1344,7 @@ TEST_F(NetErrorHelperCoreTest, CorrectionsFailAfterProbe) {
   // The blank page loads.
   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
                      NetErrorHelperCore::ERROR_PAGE);
-  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
+  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url());
   core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
 
   // Results come in, but end up being ignored.
@@ -1345,7 +1364,7 @@ TEST_F(NetErrorHelperCoreTest, CorrectionsFailAfterProbe) {
   // Probe page loads.
   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
                      NetErrorHelperCore::ERROR_PAGE);
-  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
+  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url());
   core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
 
   // Probe statuses comes in, and page is updated.
@@ -1385,7 +1404,7 @@ TEST_F(NetErrorHelperCoreTest, CorrectionsInterruptedBeforeCommit) {
   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
                      NetErrorHelperCore::NON_ERROR_PAGE);
   EXPECT_FALSE(is_url_being_fetched());
-  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
+  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, default_url());
   EXPECT_FALSE(is_url_being_fetched());
   core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
 
@@ -1412,14 +1431,14 @@ TEST_F(NetErrorHelperCoreTest, CorrectionsInterruptedBeforeLoad) {
   // The blank page starts loading and is committed.
   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
                      NetErrorHelperCore::ERROR_PAGE);
-  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
+  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url());
 
   // A new page load interrupts the original load.
   EXPECT_FALSE(is_url_being_fetched());
   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
                      NetErrorHelperCore::NON_ERROR_PAGE);
   EXPECT_FALSE(is_url_being_fetched());
-  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
+  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, default_url());
   EXPECT_FALSE(is_url_being_fetched());
   core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
 
@@ -1446,7 +1465,7 @@ TEST_F(NetErrorHelperCoreTest, CorrectionsInterrupted) {
   // The blank page loads.
   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
                      NetErrorHelperCore::ERROR_PAGE);
-  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
+  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url());
   core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
   EXPECT_TRUE(is_url_being_fetched());
 
@@ -1467,7 +1486,7 @@ TEST_F(NetErrorHelperCoreTest, CorrectionsInterrupted) {
   EXPECT_TRUE(html.empty());
   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
                      NetErrorHelperCore::ERROR_PAGE);
-  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
+  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url());
   EXPECT_FALSE(is_url_being_fetched());
   core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
   EXPECT_TRUE(is_url_being_fetched());
@@ -1505,7 +1524,7 @@ TEST_F(NetErrorHelperCoreTest, CorrectionsStopped) {
   // The blank page loads.
   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
                      NetErrorHelperCore::ERROR_PAGE);
-  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
+  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url());
   core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
 
   EXPECT_TRUE(is_url_being_fetched());
@@ -1530,7 +1549,7 @@ TEST_F(NetErrorHelperCoreTest, CorrectionsStopped) {
   // The blank page loads again.
   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
                      NetErrorHelperCore::ERROR_PAGE);
-  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
+  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url());
   core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
   EXPECT_TRUE(is_url_being_fetched());
 
@@ -1544,7 +1563,7 @@ TEST_F(NetErrorHelperCoreTest, CorrectionsStopped) {
   // Probe page loads.
   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
                      NetErrorHelperCore::ERROR_PAGE);
-  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
+  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url());
   core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
 
   // Probe statuses comes in, and page is updated.
@@ -1580,7 +1599,7 @@ TEST_F(NetErrorHelperCoreTest, CorrectionsDisabledBeforeFetch) {
                      NetErrorHelperCore::ERROR_PAGE);
   // Corrections is disabled.
   DisableNavigationCorrections();
-  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
+  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url());
   core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
   EXPECT_TRUE(is_url_being_fetched());
   EXPECT_FALSE(last_error_page_params());
@@ -1596,7 +1615,7 @@ TEST_F(NetErrorHelperCoreTest, CorrectionsDisabledBeforeFetch) {
   // Corrections load.
   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
                      NetErrorHelperCore::ERROR_PAGE);
-  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
+  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url());
   core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
   EXPECT_EQ(1, error_html_update_count());
   EXPECT_EQ(0, update_count());
@@ -1620,7 +1639,7 @@ TEST_F(NetErrorHelperCoreTest, CorrectionsDisabledDuringFetch) {
   // The blank page loads.
   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
                      NetErrorHelperCore::ERROR_PAGE);
-  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
+  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url());
   core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
   EXPECT_TRUE(is_url_being_fetched());
   EXPECT_FALSE(last_error_page_params());
@@ -1639,7 +1658,7 @@ TEST_F(NetErrorHelperCoreTest, CorrectionsDisabledDuringFetch) {
   // Corrections load.
   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
                      NetErrorHelperCore::ERROR_PAGE);
-  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
+  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url());
   core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
   EXPECT_EQ(1, error_html_update_count());
   EXPECT_EQ(0, update_count());
@@ -1666,7 +1685,7 @@ TEST_F(NetErrorHelperCoreTest, CorrectionsWithoutSearch) {
   // The blank page loads.
   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
                      NetErrorHelperCore::ERROR_PAGE);
-  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
+  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url());
   core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
   EXPECT_TRUE(is_url_being_fetched());
   EXPECT_FALSE(last_error_page_params());
@@ -1687,7 +1706,7 @@ TEST_F(NetErrorHelperCoreTest, CorrectionsWithoutSearch) {
   // Corrections load.
   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
                      NetErrorHelperCore::ERROR_PAGE);
-  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
+  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url());
   core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
   EXPECT_EQ(1, error_html_update_count());
   EXPECT_EQ(0, update_count());
@@ -1714,7 +1733,7 @@ TEST_F(NetErrorHelperCoreTest, CorrectionsOnlySearchSuggestion) {
   // The blank page loads.
   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
                      NetErrorHelperCore::ERROR_PAGE);
-  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
+  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url());
   core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
   EXPECT_TRUE(is_url_being_fetched());
   EXPECT_FALSE(last_error_page_params());
@@ -1735,7 +1754,7 @@ TEST_F(NetErrorHelperCoreTest, CorrectionsOnlySearchSuggestion) {
   // Corrections load.
   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
                      NetErrorHelperCore::ERROR_PAGE);
-  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
+  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url());
   core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
   EXPECT_EQ(1, error_html_update_count());
   EXPECT_EQ(0, update_count());
@@ -1758,7 +1777,7 @@ TEST_F(NetErrorHelperCoreTest, CorrectionServiceReturnsNonJsonResult) {
   // The blank page loads.
   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
                      NetErrorHelperCore::ERROR_PAGE);
-  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
+  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url());
   core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
 
   // Corrections request fails, final error page is shown.
@@ -1773,7 +1792,7 @@ TEST_F(NetErrorHelperCoreTest, CorrectionServiceReturnsNonJsonResult) {
   // Error page loads.
   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
                      NetErrorHelperCore::ERROR_PAGE);
-  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
+  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url());
   core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
 }
 
@@ -1795,7 +1814,7 @@ TEST_F(NetErrorHelperCoreTest, CorrectionServiceReturnsInvalidJsonResult) {
   // The blank page loads.
   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
                      NetErrorHelperCore::ERROR_PAGE);
-  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
+  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url());
   core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
 
   // Corrections request fails, final error page is shown.
@@ -1810,7 +1829,7 @@ TEST_F(NetErrorHelperCoreTest, CorrectionServiceReturnsInvalidJsonResult) {
   // Error page loads.
   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
                      NetErrorHelperCore::ERROR_PAGE);
-  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
+  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url());
   core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
 }
 
@@ -1834,7 +1853,7 @@ TEST_F(NetErrorHelperCoreTest, CorrectionClickTracking) {
   // The blank page loads.
   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
                       NetErrorHelperCore::ERROR_PAGE);
-  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
+  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url());
 
   // Corrections retrieval starts when the error page finishes loading.
   EXPECT_FALSE(is_url_being_fetched());
@@ -1854,7 +1873,7 @@ TEST_F(NetErrorHelperCoreTest, CorrectionClickTracking) {
   // Corrections load.
   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
                       NetErrorHelperCore::ERROR_PAGE);
-  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
+  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url());
   core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
 
   EXPECT_EQ(0, tracking_request_count());
@@ -2000,6 +2019,8 @@ TEST_F(NetErrorHelperCoreTest, AutoReloadRestartsOnOnline) {
   DoErrorLoad(net::ERR_CONNECTION_RESET);
   EXPECT_TRUE(timer()->IsRunning());
   EXPECT_NE(delay, timer()->GetCurrentDelay());
+  core().NetworkStateChanged(false);
+  EXPECT_FALSE(timer()->IsRunning());
   core().NetworkStateChanged(true);
   EXPECT_TRUE(timer()->IsRunning());
   EXPECT_EQ(delay, timer()->GetCurrentDelay());
@@ -2015,24 +2036,13 @@ TEST_F(NetErrorHelperCoreTest, AutoReloadDoesNotStartOnOnline) {
   EXPECT_FALSE(timer()->IsRunning());
 }
 
-TEST_F(NetErrorHelperCoreTest, AutoReloadStopsOnOffline) {
+TEST_F(NetErrorHelperCoreTest, AutoReloadDoesNotStartOffline) {
   core().set_auto_reload_enabled(true);
-  DoErrorLoad(net::ERR_CONNECTION_RESET);
-  EXPECT_TRUE(timer()->IsRunning());
   core().NetworkStateChanged(false);
-  EXPECT_FALSE(timer()->IsRunning());
-  EXPECT_EQ(0, core().auto_reload_count());
-}
-
-TEST_F(NetErrorHelperCoreTest, AutoReloadStopsOnOfflineThenRestartsOnOnline) {
-  core().set_auto_reload_enabled(true);
   DoErrorLoad(net::ERR_CONNECTION_RESET);
-  EXPECT_TRUE(timer()->IsRunning());
-  core().NetworkStateChanged(false);
   EXPECT_FALSE(timer()->IsRunning());
   core().NetworkStateChanged(true);
   EXPECT_TRUE(timer()->IsRunning());
-  EXPECT_EQ(0, core().auto_reload_count());
 }
 
 TEST_F(NetErrorHelperCoreTest, AutoReloadDoesNotRestartOnOnlineAfterStop) {
@@ -2078,7 +2088,7 @@ TEST_F(NetErrorHelperCoreTest, AutoReloadSlowError) {
                       NetError(net::ERR_CONNECTION_RESET), false, &html);
   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
                      NetErrorHelperCore::ERROR_PAGE);
-  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
+  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url());
   EXPECT_FALSE(timer()->IsRunning());
   // Start a new non-error page load.
   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
@@ -2087,7 +2097,7 @@ TEST_F(NetErrorHelperCoreTest, AutoReloadSlowError) {
   // Finish the error page load.
   core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
   EXPECT_FALSE(timer()->IsRunning());
-  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
+  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url());
   core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
   EXPECT_FALSE(timer()->IsRunning());
 }
@@ -2102,7 +2112,7 @@ TEST_F(NetErrorHelperCoreTest, AutoReloadOnlineSlowError) {
                       NetError(net::ERR_CONNECTION_RESET), false, &html);
   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
                      NetErrorHelperCore::ERROR_PAGE);
-  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
+  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url());
   EXPECT_FALSE(timer()->IsRunning());
   core().NetworkStateChanged(true);
   EXPECT_FALSE(timer()->IsRunning());
@@ -2127,7 +2137,7 @@ TEST_F(NetErrorHelperCoreTest, AutoReloadOnlinePendingError) {
   core().NetworkStateChanged(true);
   EXPECT_FALSE(timer()->IsRunning());
   core().NetworkStateChanged(false);
-  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
+  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url());
   core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
   EXPECT_FALSE(timer()->IsRunning());
   core().NetworkStateChanged(true);
@@ -2144,7 +2154,7 @@ TEST_F(NetErrorHelperCoreTest, AutoReloadOnlinePartialErrorReplacement) {
                       NetError(net::ERR_CONNECTION_RESET), false, &html);
   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
                      NetErrorHelperCore::ERROR_PAGE);
-  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
+  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url());
   core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
                      NetErrorHelperCore::NON_ERROR_PAGE);
@@ -2157,6 +2167,238 @@ TEST_F(NetErrorHelperCoreTest, AutoReloadOnlinePartialErrorReplacement) {
   EXPECT_FALSE(timer()->IsRunning());
 }
 
+// Return the count for the named histogram, or 0 if there is no histogram by
+// that name. This function is error-tolerant because histograms that have no
+// data points may not be registered, and the unit tests below still need to be
+// able to check that they haven't changed.
+int GetHistogramCount(const char *name) {
+  base::HistogramBase* histogram =
+      base::StatisticsRecorder::FindHistogram(name);
+  if (!histogram)
+    return 0;
+  scoped_ptr<base::HistogramSamples> samples = histogram->SnapshotSamples();
+  if (!samples)
+    return 0;
+  return samples->TotalCount();
+}
+
+void ExpectHistogramDelta(const char *name, int old_count, int delta) {
+  int new_count = GetHistogramCount(name);
+  EXPECT_EQ(old_count + delta, new_count) << "For histogram " << name;
+}
+
+class NetErrorHelperCoreHistogramTest : public NetErrorHelperCoreTest {
+ public:
+  virtual void SetUp() OVERRIDE {
+    NetErrorHelperCoreTest::SetUp();
+    StoreOldCounts();
+    core().set_auto_reload_enabled(true);
+  }
+
+  void ExpectDelta(const char *name, int delta) {
+    DCHECK(old_counts_.count(name) == 1);
+    ExpectHistogramDelta(name, old_counts_[name], delta);
+  }
+
+  static const char kCountAtStop[];
+  static const char kErrorAtStop[];
+  static const char kCountAtSuccess[];
+  static const char kErrorAtSuccess[];
+  static const char kErrorAtFirstSuccess[];
+
+ private:
+  void StoreOldCounts() {
+    for (size_t i = 0; kHistogramNames[i]; i++)
+      old_counts_[kHistogramNames[i]] = GetHistogramCount(kHistogramNames[i]);
+  }
+
+  static const char *kHistogramNames[];
+
+  std::map<std::string, int> old_counts_;
+};
+
+const char NetErrorHelperCoreHistogramTest::kCountAtStop[] =
+    "Net.AutoReload.CountAtStop";
+const char NetErrorHelperCoreHistogramTest::kErrorAtStop[] =
+    "Net.AutoReload.ErrorAtStop";
+const char NetErrorHelperCoreHistogramTest::kCountAtSuccess[] =
+    "Net.AutoReload.CountAtSuccess";
+const char NetErrorHelperCoreHistogramTest::kErrorAtSuccess[] =
+    "Net.AutoReload.ErrorAtSuccess";
+const char NetErrorHelperCoreHistogramTest::kErrorAtFirstSuccess[] =
+    "Net.AutoReload.ErrorAtFirstSuccess";
+const char *NetErrorHelperCoreHistogramTest::kHistogramNames[] = {
+  kCountAtStop,
+  kErrorAtStop,
+  kCountAtSuccess,
+  kErrorAtSuccess,
+  kErrorAtFirstSuccess,
+  NULL
+};
+
+// Test that the success histograms are updated when auto-reload succeeds at the
+// first attempt, and that the failure histograms are not updated.
+TEST_F(NetErrorHelperCoreHistogramTest, SuccessAtFirstAttempt) {
+  DoErrorLoad(net::ERR_CONNECTION_RESET);
+  timer()->Fire();
+  DoSuccessLoad();
+
+  // All of CountAtSuccess, ErrorAtSuccess, and ErrorAtFirstSuccess should
+  // reflect this successful load. The failure histograms should be unchanged.
+  ExpectDelta(kCountAtSuccess, 1);
+  ExpectDelta(kErrorAtSuccess, 1);
+  ExpectDelta(kErrorAtFirstSuccess, 1);
+  ExpectDelta(kCountAtStop, 0);
+  ExpectDelta(kErrorAtStop, 0);
+}
+
+// Test that the success histograms are updated when auto-reload succeeds but
+// not on the first attempt, and that the first-success histogram is not
+// updated.
+TEST_F(NetErrorHelperCoreHistogramTest, SuccessAtSecondAttempt) {
+  DoErrorLoad(net::ERR_CONNECTION_RESET);
+  timer()->Fire();
+  EXPECT_TRUE(core().ShouldSuppressErrorPage(NetErrorHelperCore::MAIN_FRAME,
+                                             default_url()));
+//  DoErrorLoad(net::ERR_CONNECTION_RESET);
+  timer()->Fire();
+  DoSuccessLoad();
+
+  // CountAtSuccess and ErrorAtSuccess should reflect this successful load, but
+  // not ErrorAtFirstSuccess since it wasn't a first success.
+  ExpectDelta(kCountAtSuccess, 1);
+  ExpectDelta(kErrorAtSuccess, 1);
+  ExpectDelta(kErrorAtFirstSuccess, 0);
+  ExpectDelta(kCountAtStop, 0);
+  ExpectDelta(kErrorAtStop, 0);
+}
+
+// Test that a user stop (caused by the user pressing the 'Stop' button)
+// registers as an auto-reload failure if an auto-reload attempt is in flight.
+// Note that "user stop" is also caused by a cross-process navigation, for which
+// the browser process will send an OnStop to the old process.
+TEST_F(NetErrorHelperCoreHistogramTest, UserStop) {
+  DoErrorLoad(net::ERR_CONNECTION_RESET);
+  timer()->Fire();
+  core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
+                     NetErrorHelperCore::NON_ERROR_PAGE);
+  core().OnStop();
+
+  // CountAtStop and ErrorAtStop should reflect the failure.
+  ExpectDelta(kCountAtSuccess, 0);
+  ExpectDelta(kErrorAtSuccess, 0);
+  ExpectDelta(kErrorAtFirstSuccess, 0);
+  ExpectDelta(kCountAtStop, 1);
+  ExpectDelta(kErrorAtStop, 1);
+}
+
+// Test that a user stop (caused by the user pressing the 'Stop' button)
+// registers as an auto-reload failure even if an auto-reload attempt has not
+// been launched yet (i.e., if the timer is running, but no reload is in
+// flight), because this means auto-reload didn't successfully replace the error
+// page.
+TEST_F(NetErrorHelperCoreHistogramTest, OtherPageLoaded) {
+  DoErrorLoad(net::ERR_CONNECTION_RESET);
+  core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
+                     NetErrorHelperCore::NON_ERROR_PAGE);
+  core().OnStop();
+
+  ExpectDelta(kCountAtSuccess, 0);
+  ExpectDelta(kErrorAtSuccess, 0);
+  ExpectDelta(kErrorAtFirstSuccess, 0);
+  ExpectDelta(kCountAtStop, 1);
+  ExpectDelta(kErrorAtStop, 1);
+}
+
+// Test that a commit of a different URL (caused by the user navigating to a
+// different page) with an auto-reload attempt in flight registers as an
+// auto-reload failure.
+TEST_F(NetErrorHelperCoreHistogramTest, OtherPageLoadedAfterTimerFires) {
+  const GURL kTestUrl("https://anotherurl");
+  DoErrorLoad(net::ERR_CONNECTION_RESET);
+  timer()->Fire();
+  core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
+                     NetErrorHelperCore::NON_ERROR_PAGE);
+  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME,
+                      kTestUrl);
+  core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
+
+  ExpectDelta(kCountAtSuccess, 0);
+  ExpectDelta(kErrorAtSuccess, 0);
+  ExpectDelta(kErrorAtFirstSuccess, 0);
+  ExpectDelta(kCountAtStop, 1);
+  ExpectDelta(kErrorAtStop, 1);
+}
+
+// Test that a commit of the same URL with an auto-reload attempt in flight
+// registers as an auto-reload success.
+TEST_F(NetErrorHelperCoreHistogramTest, SamePageLoadedAfterTimerFires) {
+  DoErrorLoad(net::ERR_CONNECTION_RESET);
+  timer()->Fire();
+  DoSuccessLoad();
+
+  ExpectDelta(kCountAtSuccess, 1);
+  ExpectDelta(kErrorAtSuccess, 1);
+  ExpectDelta(kErrorAtFirstSuccess, 1);
+  ExpectDelta(kCountAtStop, 0);
+  ExpectDelta(kErrorAtStop, 0);
+}
+
+TEST_F(NetErrorHelperCoreHistogramTest, SamePageLoadedAfterLoadStarts) {
+  DoErrorLoad(net::ERR_CONNECTION_RESET);
+  timer()->Fire();
+  // Autoreload attempt starts
+  core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
+                     NetErrorHelperCore::NON_ERROR_PAGE);
+  // User does a manual reload
+  DoSuccessLoad();
+
+  ExpectDelta(kCountAtSuccess, 1);
+  ExpectDelta(kErrorAtSuccess, 1);
+  ExpectDelta(kErrorAtFirstSuccess, 1);
+  ExpectDelta(kCountAtStop, 0);
+  ExpectDelta(kErrorAtStop, 0);
+}
+
+// In this test case, the user presses the reload button manually after an
+// auto-reload fails and the error page is suppressed.
+TEST_F(NetErrorHelperCoreHistogramTest, ErrorPageLoadedAfterTimerFires) {
+  DoErrorLoad(net::ERR_CONNECTION_RESET);
+  timer()->Fire();
+  core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
+                     NetErrorHelperCore::NON_ERROR_PAGE);
+  EXPECT_TRUE(core().ShouldSuppressErrorPage(NetErrorHelperCore::MAIN_FRAME,
+                                             default_url()));
+  DoErrorLoad(net::ERR_CONNECTION_RESET);
+
+  ExpectDelta(kCountAtSuccess, 0);
+  ExpectDelta(kErrorAtSuccess, 0);
+  ExpectDelta(kErrorAtFirstSuccess, 0);
+  ExpectDelta(kCountAtStop, 0);
+  ExpectDelta(kErrorAtStop, 0);
+}
+
+TEST_F(NetErrorHelperCoreHistogramTest, SuccessPageLoadedBeforeTimerFires) {
+  DoErrorLoad(net::ERR_CONNECTION_RESET);
+  core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
+                     NetErrorHelperCore::NON_ERROR_PAGE);
+  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME,
+                      GURL(kFailedHttpsUrl));
+
+  ExpectDelta(kCountAtSuccess, 0);
+  ExpectDelta(kErrorAtSuccess, 0);
+  ExpectDelta(kErrorAtFirstSuccess, 0);
+  ExpectDelta(kCountAtStop, 1);
+  ExpectDelta(kErrorAtStop, 1);
+}
+
+TEST_F(NetErrorHelperCoreTest, ShouldSuppressNonReloadableErrorPage) {
+  core().set_auto_reload_enabled(true);
+  DoErrorLoad(net::ERR_ABORTED);
+  EXPECT_FALSE(core().ShouldSuppressErrorPage(NetErrorHelperCore::MAIN_FRAME,
+                                              GURL(kFailedUrl)));
+}
+
 TEST_F(NetErrorHelperCoreTest, ShouldSuppressErrorPage) {
   // Set up the environment to test ShouldSuppressErrorPage: auto-reload is
   // enabled, an error page is loaded, and the auto-reload callback is running.
@@ -2186,3 +2428,5 @@ TEST_F(NetErrorHelperCoreTest, ExplicitLoadStaleSucceeds) {
   EXPECT_EQ(1, load_stale_count());
   EXPECT_EQ(GURL(kFailedUrl), load_stale_url());
 }
+
+} // namespace