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

chrome/browser/errorpage_browsertest.cc

 // Copyright (c) 2012 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 "base/bind.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/path_service.h"
@@ skipping 16 matching lines @@
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_observer.h"
 #include "content/public/test/browser_test_utils.h"
 #include "content/public/test/test_navigation_observer.h"
 #include "content/test/net/url_request_failed_job.h"
 #include "content/test/net/url_request_mock_http_job.h"
+#include "grit/generated_resources.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_util.h"
 #include "net/http/failing_http_transaction_factory.h"
 #include "net/http/http_cache.h"
 #include "net/test/spawned_test_server/spawned_test_server.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "net/url_request/url_request_filter.h"
 #include "net/url_request/url_request_job.h"
 #include "net/url_request/url_request_job_factory.h"
 #include "net/url_request/url_request_test_job.h"
 #include "net/url_request/url_request_test_util.h"
+#include "ui/base/l10n/l10n_util.h"
 
 using content::BrowserThread;
 using content::NavigationController;
 using content::URLRequestFailedJob;
 using net::URLRequestJobFactory;
 using net::URLRequestTestJob;
 
 namespace {
 
 // Returns true if |text| is displayed on the page |browser| is currently
@@ skipping 70 matching lines @@
   // Check that the search box is populated correctly.
   bool search_box_populated = false;
   ASSERT_TRUE(content::ExecuteScriptAndExtractBool(
       browser->tab_strip_model()->GetActiveWebContents(),
       "var searchText = document.getElementById('search-box').value;"
           "domAutomationController.send(searchText == 'search query');",
       &search_box_populated));
   EXPECT_TRUE(search_box_populated);
 }
 
+std::string GetLoadStaleButtonLabel() {
+  return l10n_util::GetStringUTF8(IDS_ERRORPAGES_BUTTON_LOAD_STALE);
+}
+
 // A protocol handler that fails a configurable number of requests, then
 // succeeds all requests after that, keeping count of failures and successes.
 class FailFirstNRequestsProtocolHandler
     : public URLRequestJobFactory::ProtocolHandler {
  public:
   FailFirstNRequestsProtocolHandler(const GURL& url, int requests_to_fail)
       : url_(url), requests_(0), failures_(0),
         requests_to_fail_(requests_to_fail) {}
   virtual ~FailFirstNRequestsProtocolHandler() {}
 
@@ skipping 93 matching lines @@
 
   void GoBackAndWaitForNavigations(int num_navigations) {
     NavigateHistory(num_navigations, HISTORY_NAVIGATE_BACK);
   }
 
   void GoForwardAndWaitForNavigations(int num_navigations) {
     NavigateHistory(num_navigations, HISTORY_NAVIGATE_FORWARD);
   }
 
   // Confirms that the javascript variable indicating whether or not we have
-  // a stale copy in the cache has been set to |expected|.
-  bool ProbeStaleCopyValue(bool expected) {
+  // a stale copy in the cache has been set to |expected|, and that the
+  // stale load button is or isn't there based on the same expectation.
+  testing::AssertionResult ProbeStaleCopyValue(bool expected) {
     const char* js_cache_probe =
         "try {\n"
         "    domAutomationController.send(\n"
-        "        templateData.staleCopyInCache ? 'yes' : 'no');\n"
+        "        'staleLoadButton' in templateData ? 'yes' : 'no');\n"
         "} catch (e) {\n"
         "    domAutomationController.send(e.message);\n"
         "}\n";
 
     std::string result;
     bool ret =
         content::ExecuteScriptAndExtractString(
             browser()->tab_strip_model()->GetActiveWebContents(),
             js_cache_probe,
             &result);
-    EXPECT_TRUE(ret);
-    if (!ret)
-      return false;
-    EXPECT_EQ(expected ? "yes" : "no", result);
-    return ((expected ? "yes" : "no") == result);
+    if (!ret) {
+      return testing::AssertionFailure()
+          << "Failing return from ExecuteScriptAndExtractString.";
+    }
+
+    if ((expected && "yes" == result) || (!expected && "no" == result))
+      return testing::AssertionSuccess();
+
+    return testing::AssertionFailure() << "Cache probe result is " << result;
   }
 
   testing::AssertionResult ReloadStaleCopyFromCache() {
     const char* js_reload_script =
         "try {\n"
-        "    errorCacheLoad.reloadStaleInstance();\n"
+        "    document.getElementById('stale-load-button').click();\n"
         "    domAutomationController.send('success');\n"
         "} catch (e) {\n"
         "    domAutomationController.send(e.message);\n"
         "}\n";
 
     std::string result;
     bool ret = content::ExecuteScriptAndExtractString(
         browser()->tab_strip_model()->GetActiveWebContents(),
         js_reload_script,
         &result);
@@ skipping 385 matching lines @@
       browser()->profile()->GetRequestContext();
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&InterceptNetworkTransactions, url_request_context_getter,
                  net::ERR_FAILED));
 
   ui_test_utils::NavigateToURLBlockUntilNavigationsComplete(
       // With no navigation corrections to load, there's only one navigation.
       browser(), test_url, 1);
   EXPECT_TRUE(ProbeStaleCopyValue(true));
+  EXPECT_TRUE(IsDisplayingText(browser(), GetLoadStaleButtonLabel()));
   EXPECT_NE(base::ASCIIToUTF16("Nocache Test Page"),
             browser()->tab_strip_model()->GetActiveWebContents()->GetTitle());
 
   // Confirm that loading the stale copy from the cache works.
   content::TestNavigationObserver same_tab_observer(
       browser()->tab_strip_model()->GetActiveWebContents(), 1);
   ASSERT_TRUE(ReloadStaleCopyFromCache());
   same_tab_observer.Wait();
   EXPECT_EQ(base::ASCIIToUTF16("Nocache Test Page"),
             browser()->tab_strip_model()->GetActiveWebContents()->GetTitle());
 
   // Clear the cache and reload the same URL; confirm the error page is told
   // that there is no cached copy.
   BrowsingDataRemover* remover =
       BrowsingDataRemover::CreateForUnboundedRange(browser()->profile());
   remover->Remove(BrowsingDataRemover::REMOVE_CACHE,
                   BrowsingDataHelper::UNPROTECTED_WEB);
   ui_test_utils::NavigateToURLBlockUntilNavigationsComplete(
       browser(), test_url, 1);
   EXPECT_TRUE(ProbeStaleCopyValue(false));
+  EXPECT_FALSE(IsDisplayingText(browser(), GetLoadStaleButtonLabel()));
 }
 
 class ErrorPageAutoReloadTest : public InProcessBrowserTest {
  public:
   virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
     command_line->AppendSwitch(switches::kEnableOfflineAutoReload);
   }
 
   void InstallProtocolHandler(const GURL& url, int requests_to_fail) {
     protocol_handler_ = new FailFirstNRequestsProtocolHandler(
@@ skipping 141 matching lines @@
   // confirm that the error page is told the cached copy exists.
   scoped_refptr<net::URLRequestContextGetter> url_request_context_getter =
       browser()->profile()->GetRequestContext();
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&InterceptNetworkTransactions, url_request_context_getter,
                  net::ERR_CONNECTION_FAILED));
 
   ui_test_utils::NavigateToURLBlockUntilNavigationsComplete(
       browser(), test_url, 2);
-  ProbeStaleCopyValue(true);
+  EXPECT_TRUE(IsDisplayingText(browser(), GetLoadStaleButtonLabel()));
+  EXPECT_TRUE(ProbeStaleCopyValue(true));
 
   // Confirm that loading the stale copy from the cache works.
   content::TestNavigationObserver same_tab_observer(
       browser()->tab_strip_model()->GetActiveWebContents(), 1);
   ASSERT_TRUE(ReloadStaleCopyFromCache());
   same_tab_observer.Wait();
   EXPECT_EQ(base::ASCIIToUTF16("Nocache Test Page"),
             browser()->tab_strip_model()->GetActiveWebContents()->GetTitle());
 
   // Clear the cache and reload the same URL; confirm the error page is told
   // that there is no cached copy.
   BrowsingDataRemover* remover =
       BrowsingDataRemover::CreateForUnboundedRange(browser()->profile());
   remover->Remove(BrowsingDataRemover::REMOVE_CACHE,
                   BrowsingDataHelper::UNPROTECTED_WEB);
   ui_test_utils::NavigateToURLBlockUntilNavigationsComplete(
       browser(), test_url, 2);
-  ProbeStaleCopyValue(false);
+  EXPECT_TRUE(ProbeStaleCopyValue(false));
+  EXPECT_FALSE(IsDisplayingText(browser(), GetLoadStaleButtonLabel()));
 }
 
 // A test fixture that simulates failing requests for an IDN domain name.
 class ErrorPageForIDNTest : public InProcessBrowserTest {
  public:
   // Target hostname in different forms.
   static const char kHostname[];
   static const char kHostnameJSUnicode[];
 
   // InProcessBrowserTest:
@@ skipping 37 matching lines @@
       browser(),
       URLRequestFailedJob::GetMockHttpUrlForHostname(net::ERR_UNSAFE_PORT,
                                                      kHostname),
       1);
 
   ToggleHelpBox(browser());
   EXPECT_TRUE(IsDisplayingText(browser(), kHostnameJSUnicode));
 }
 
 }  // namespace