Surface button for loading stale cache copy on net error page.

chrome/renderer/net/net_error_helper_core_unittest.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 "base/json/json_writer.h"
 #include "base/logging.h"
 #include "base/strings/stringprintf.h"
 #include "base/timer/mock_timer.h"
@@ skipping 96 matching lines @@
   return ErrorToString(ProbeError(status), false);
 }
 
 std::string NetErrorString(net::Error net_error) {
   return ErrorToString(NetError(net_error), false);
 }
 
 class NetErrorHelperCoreTest : public testing::Test,
                                public NetErrorHelperCore::Delegate {
  public:
   NetErrorHelperCoreTest() : timer_(new base::MockTimer(false, false)),

[jar (doing other things), 2014/04/21 23:48:19]

nit: When we have to put initializers on multiple lines, put them all on
following lines, with the ":" indented 4 spaces, and then align initializers
under the first one.

[Randy Smith (Not in Mondays), 2014/04/22 20:40:02]

I'm a little reluctant, since this wasn't code I originally wrote or that I
changed in this CL.  Matt, do you have an opinion?  I think of this as your
code.

[mmenke, 2014/04/22 21:03:27]

I'm fine with either style.  Looking at the C++ style guide, it looks like jar's
unambiguously right on this one.

[Randy Smith (Not in Mondays), 2014/04/22 21:09:42]

Done.

                              core_(this),
                              update_count_(0),
                              error_html_update_count_(0),
                              reload_count_(0),
-                             enable_stale_load_bindings_count_(0) {
+                             load_stale_count_(0),
+                             enable_page_helper_functions_count_(0) {
     core_.set_auto_reload_enabled(false);
     core_.set_timer_for_testing(scoped_ptr<base::Timer>(timer_));
   }
 
   virtual ~NetErrorHelperCoreTest() {
     // No test finishes while an error page is being fetched.
     EXPECT_FALSE(is_url_being_fetched());
   }
 
   NetErrorHelperCore& core() { return core_; }
 
   const GURL& url_being_fetched() const { return url_being_fetched_; }
   bool is_url_being_fetched() const { return !url_being_fetched_.is_empty(); }
 
   int reload_count() const {
     return reload_count_;
   }
 
-  int enable_stale_load_bindings_count() const {
-    return enable_stale_load_bindings_count_;
+  int load_stale_count() const {
+    return load_stale_count_;
+  }
+
+  const GURL& load_stale_url() const {
+    return load_stale_url_;
+  }
+
+  int enable_page_helper_functions_count() const {
+    return enable_page_helper_functions_count_;
   }
 
   const std::string& last_update_string() const { return last_update_string_; }
   int update_count() const { return update_count_;  }
 
   const std::string& last_error_html() const { return last_error_html_; }
   int error_html_update_count() const { return error_html_update_count_; }
 
   const LocalizedError::ErrorPageParams* last_error_page_params() const {
     return last_error_page_params_.get();
@@ skipping 65 matching lines @@
     core().OnSetNavigationCorrectionInfo(navigation_correction_url,
                                          "en", "us", "api_key",
                                          GURL(kSearchUrl));
   }
 
   // NetErrorHelperCore::Delegate implementation:
   virtual void GenerateLocalizedErrorPage(
       const WebURLError& error,
       bool is_failed_post,
       scoped_ptr<LocalizedError::ErrorPageParams> params,
+      bool* reload_button_shown,
+      bool* load_stale_button_shown,
       std::string* html) const OVERRIDE {
     last_error_page_params_.reset(params.release());
+    *reload_button_shown = false;
+    *load_stale_button_shown = false;
     *html = ErrorToString(error, is_failed_post);
   }
 
   virtual void LoadErrorPageInMainFrame(const std::string& html,
                                         const GURL& failed_url) OVERRIDE {
     error_html_update_count_++;
     last_error_html_ = html;
   }
 
-  virtual void EnableStaleLoadBindings(const GURL& page_url) OVERRIDE {
-    enable_stale_load_bindings_count_++;
+  virtual void EnablePageHelperFunctions() OVERRIDE {
+    enable_page_helper_functions_count_++;
   }
 
   virtual void UpdateErrorPage(const WebURLError& error,
                                bool is_failed_post) OVERRIDE {
     update_count_++;
     last_error_page_params_.reset(NULL);
     last_error_html_ = ErrorToString(error, is_failed_post);
   }
 
   virtual void FetchNavigationCorrections(
       const GURL& navigation_correction_url,
       const std::string& navigation_correction_request_body) OVERRIDE {
     EXPECT_TRUE(url_being_fetched_.is_empty());
     EXPECT_TRUE(request_body_.empty());
     EXPECT_EQ(GURL(kNavigationCorrectionUrl), navigation_correction_url);
 
     url_being_fetched_ = navigation_correction_url;
     request_body_ = navigation_correction_request_body;
   }
 
   virtual void CancelFetchNavigationCorrections() OVERRIDE {
     url_being_fetched_ = GURL();
     request_body_.clear();
   }
 
   virtual void ReloadPage() OVERRIDE {
     reload_count_++;
   }
 
+  virtual void LoadPageFromCache(const GURL& error_url) OVERRIDE {
+    load_stale_count_++;
+    load_stale_url_ = error_url;
+  }
+
   base::MockTimer* timer_;
 
   NetErrorHelperCore core_;
 
   GURL url_being_fetched_;
   std::string request_body_;
 
   // Contains the information passed to the last call to UpdateErrorPage, as a
   // string.
   std::string last_update_string_;
   // Number of times |last_update_string_| has been changed.
   int update_count_;
 
   // Contains the HTML set by the last call to LoadErrorPageInMainFrame.
   std::string last_error_html_;
   // Number of times |last_error_html_| has been changed.
   int error_html_update_count_;
 
   // Mutable because GenerateLocalizedErrorPage is const.
   mutable scoped_ptr<LocalizedError::ErrorPageParams> last_error_page_params_;
 
   int reload_count_;
+  int load_stale_count_;
+  GURL load_stale_url_;
 
-  int enable_stale_load_bindings_count_;
+  int enable_page_helper_functions_count_;
 };
 
 //------------------------------------------------------------------------------
 // Basic tests that don't update the error page for probes or load navigation
 // corrections.
 //------------------------------------------------------------------------------
 
 TEST_F(NetErrorHelperCoreTest, Null) {
 }
 
@@ skipping 23 matching lines @@
 
   // It fails, and an error page is requested.
   std::string html;
   core().GetErrorHTML(NetErrorHelperCore::MAIN_FRAME,
                       NetError(net::ERR_CONNECTION_RESET), false, &html);
   // Should have returned a local error page.
   EXPECT_FALSE(html.empty());
   EXPECT_EQ(NetErrorString(net::ERR_CONNECTION_RESET), html);
 
   // Error page loads.
-  EXPECT_EQ(0, enable_stale_load_bindings_count());
+  EXPECT_EQ(0, enable_page_helper_functions_count());
   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
                      NetErrorHelperCore::ERROR_PAGE);
   core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
   core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
   EXPECT_EQ(0, update_count());
   EXPECT_EQ(0, error_html_update_count());
-  EXPECT_EQ(1, enable_stale_load_bindings_count());
+  EXPECT_EQ(1, enable_page_helper_functions_count());
 }
 
 TEST_F(NetErrorHelperCoreTest, MainFrameNonDnsErrorWithCorrections) {
   EnableNavigationCorrections();
 
   // Original page starts loading.
   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
                      NetErrorHelperCore::NON_ERROR_PAGE);
 
   // It fails, and an error page is requested.
@@ skipping 377 matching lines @@
   core().GetErrorHTML(NetErrorHelperCore::MAIN_FRAME,
                       NetError(net::ERR_NAME_NOT_RESOLVED),
                       true, &html);
   // Should have returned a local error page indicating a probe may run.
   EXPECT_EQ(ErrorToString(
                 ProbeError(chrome_common_net::DNS_PROBE_POSSIBLE),
                            true),
             html);
 
   // Error page loads.
-  EXPECT_EQ(0, enable_stale_load_bindings_count());
+  EXPECT_EQ(0, enable_page_helper_functions_count());
   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
                      NetErrorHelperCore::ERROR_PAGE);
   core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
   core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
   EXPECT_EQ(0, update_count());
-  EXPECT_EQ(0, enable_stale_load_bindings_count());
+  EXPECT_EQ(1, enable_page_helper_functions_count());
 
   core().OnNetErrorInfo(chrome_common_net::DNS_PROBE_STARTED);
   EXPECT_EQ(1, update_count());
   EXPECT_EQ(ErrorToString(
                 ProbeError(chrome_common_net::DNS_PROBE_STARTED), true),
             last_error_html());
 
   core().OnNetErrorInfo(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN);
   EXPECT_EQ(2, update_count());
   EXPECT_EQ(ErrorToString(
@@ skipping 1218 matching lines @@
   DoErrorLoad(net::ERR_CONNECTION_RESET);
   timer()->Fire();
 
   EXPECT_FALSE(core().ShouldSuppressErrorPage(NetErrorHelperCore::SUB_FRAME,
                                               GURL(kFailedUrl)));
   EXPECT_FALSE(core().ShouldSuppressErrorPage(NetErrorHelperCore::MAIN_FRAME,
                                               GURL("http://some.other.url")));
   EXPECT_TRUE(core().ShouldSuppressErrorPage(NetErrorHelperCore::MAIN_FRAME,
                                              GURL(kFailedUrl)));
 }
+
+TEST_F(NetErrorHelperCoreTest, ExplicitReloadSucceeds) {
+  DoErrorLoad(net::ERR_CONNECTION_RESET);
+  EXPECT_EQ(0, reload_count());
+  core().ExecuteButtonPress(NetErrorHelperCore::RELOAD_BUTTON);
+  EXPECT_EQ(1, reload_count());
+}
+
+TEST_F(NetErrorHelperCoreTest, ExplicitLoadStaleSucceeds) {
+  DoErrorLoad(net::ERR_CONNECTION_RESET);
+  EXPECT_EQ(0, load_stale_count());
+  core().ExecuteButtonPress(NetErrorHelperCore::LOAD_STALE_BUTTON);
+  EXPECT_EQ(1, load_stale_count());
+  EXPECT_EQ(GURL(kFailedUrl), load_stale_url());
+}
+
+