Switch to using the new Link Doctor API.

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/compiler_specific.h"
+#include "base/path_service.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/browsing_data/browsing_data_helper.h"
 #include "chrome/browser/browsing_data/browsing_data_remover.h"
 #include "chrome/browser/google/google_util.h"
 #include "chrome/browser/net/url_request_mock_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_commands.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
+#include "chrome/common/chrome_paths.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "content/public/browser/notification_service.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 "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_factory.h"
 
 using content::BrowserThread;
 using content::NavigationController;
 using content::URLRequestFailedJob;
 
 namespace {
 
+// Returns true if |text| is displayed on the page |browser| is currently
+// displaying.  Uses "innerText", so will miss hidden text, and whitespace
+// space handling may be weird.
+bool WARN_UNUSED_RESULT IsDisplayingText(Browser* browser,
+                                         const std::string& text) {
+  std::string command = base::StringPrintf(
+      "var textContent = document.body.innerText;"
+      "var hasText = textContent.indexOf('%s') >= 0;"
+      "domAutomationController.send(hasText);",
+      text.c_str());
+  bool result = false;
+  EXPECT_TRUE(content::ExecuteScriptAndExtractBool(
+      browser->tab_strip_model()->GetActiveWebContents(), command, &result));
+  return result;
+}
+
+// Expands the more box on the currently displayed error page.
+void ToggleHelpBox(Browser* browser) {
+  EXPECT_TRUE(content::ExecuteScript(
+      browser->tab_strip_model()->GetActiveWebContents(),
+      "document.getElementById('more-less-button').click();"));
+}
+
+// Returns true if |browser| is displaying the text representation of
+// |error_code| on the current page.
+bool WARN_UNUSED_RESULT IsDisplayingNetError(Browser* browser,
+                                             net::Error error_code) {
+  // Get the error as a string, and remove the leading "net::", which is not
+  // included on error pages.
+  std::string error_string = net::ErrorToString(error_code);
+  base::RemoveChars(error_string, "net:", &error_string);
+
+  return IsDisplayingText(browser, error_string);
+}
+
+// Checks that the local error page is being displayed, without remotely
+// retrieved Link Doctor information, and with the specified error code.
+void ExpectDisplayingLocalErrorPage(Browser* browser, net::Error error_code) {
+  // Expand the help box so innerText will include text below the fold.
+  ToggleHelpBox(browser);
+
+  EXPECT_TRUE(IsDisplayingNetError(browser, error_code));
+
+  // Locally generated error pages should not have Link Doctor suggestions.
+  EXPECT_FALSE(IsDisplayingText(browser, "http://correction1/"));
+  EXPECT_FALSE(IsDisplayingText(browser, "http://correction2/"));
+
+  // Locally generated error pages should not have a populated search box.
+  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_FALSE(search_box_populated);
+}
+
+// Checks that an error page with information retrieved from the Link Doctor
+// is being displayed, with the specified specified error code.
+void ExpectDisplayingLinkDoctor(Browser* browser, net::Error error_code) {
+  // Expand the help box so innerText will include text below the fold.
+  ToggleHelpBox(browser);
+
+  EXPECT_TRUE(IsDisplayingNetError(browser, error_code));
+
+  // Check that suggestions from the mock Link Doctor results are displayed.
+  EXPECT_TRUE(IsDisplayingText(browser, "http://correction1/"));
+  EXPECT_TRUE(IsDisplayingText(browser, "http://correction2/"));
+
+  // 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);
+}
+
 class ErrorPageTest : public InProcessBrowserTest {
  public:
   enum HistoryNavigationDirection {
     HISTORY_NAVIGATE_BACK,
     HISTORY_NAVIGATE_FORWARD,
   };
 
   // Navigates the active tab to a mock url created for the file at |file_path|.
   void NavigateToFileURL(const base::FilePath::StringType& file_path) {
     ui_test_utils::NavigateToURL(
@@ skipping 28 matching lines @@
 
   // Navigates forward in the history and waits for |num_navigations| to occur,
   // and the title to change to |expected_title|.
   void GoForwardAndWaitForTitle(const std::string& expected_title,
                                 int num_navigations) {
     NavigateHistoryAndWaitForTitle(expected_title,
                                    num_navigations,
                                    HISTORY_NAVIGATE_FORWARD);
   }
 
+  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) {
     const char* js_cache_probe =
         "(function () {\n"
         "  if ('staleCopyInCache' in templateData) {\n"
         "    domAutomationController.send(\n"
         "      templateData.staleCopyInCache ? 'yes' : 'no');\n"
         "  } else {\n"
         "    domAutomationController.send('absent');\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);
   }
 
  protected:
+  static void EnableMocks(const GURL& search_url) {
+    chrome_browser_net::SetUrlRequestMocksEnabled(true);
+
+    // Add a mock for the search engine the error page will use.
+    base::FilePath root_http;
+    PathService::Get(chrome::DIR_TEST_DATA, &root_http);
+    content::URLRequestMockHTTPJob::AddHostnameToFileHandler(
+        search_url.host(), root_http.AppendASCII("title3.html"));
+  }
+
   virtual void SetUpOnMainThread() OVERRIDE {
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
-        base::Bind(&chrome_browser_net::SetUrlRequestMocksEnabled, true));
+        base::Bind(&ErrorPageTest::EnableMocks,
+                   google_util::GetGoogleSearchURL(browser()->profile())));
   }
 
   // Returns a GURL that results in a DNS error.
   GURL GetDnsErrorURL() const {
     return URLRequestFailedJob::GetMockHttpUrl(net::ERR_NAME_NOT_RESOLVED);
   }
 
  private:
   // Navigates the browser the indicated direction in the history and waits for
   // |num_navigations| to occur and the title to change to |expected_title|.
   void NavigateHistoryAndWaitForTitle(const std::string& expected_title,
                                       int num_navigations,
                                       HistoryNavigationDirection direction) {
     content::TitleWatcher title_watcher(
         browser()->tab_strip_model()->GetActiveWebContents(),
         base::ASCIIToUTF16(expected_title));
 
+    NavigateHistory(num_navigations, direction);
+
+    EXPECT_EQ(title_watcher.WaitAndGetTitle(),
+              base::ASCIIToUTF16(expected_title));
+  }
+
+  void NavigateHistory(int num_navigations,
+                       HistoryNavigationDirection direction) {
     content::TestNavigationObserver test_navigation_observer(
         browser()->tab_strip_model()->GetActiveWebContents(),
         num_navigations);
     if (direction == HISTORY_NAVIGATE_BACK) {
       chrome::GoBack(browser(), CURRENT_TAB);
     } else if (direction == HISTORY_NAVIGATE_FORWARD) {
       chrome::GoForward(browser(), CURRENT_TAB);
     } else {
       FAIL();
     }
     test_navigation_observer.Wait();
-
-    EXPECT_EQ(title_watcher.WaitAndGetTitle(),
-              base::ASCIIToUTF16(expected_title));
   }
 };
 
 class TestFailProvisionalLoadObserver : public content::WebContentsObserver {
  public:
   explicit TestFailProvisionalLoadObserver(content::WebContents* contents)
       : content::WebContentsObserver(contents) {}
   virtual ~TestFailProvisionalLoadObserver() {}
 
   // This method is invoked when the provisional load failed.
@@ skipping 32 matching lines @@
 // See crbug.com/109669
 #if defined(USE_AURA) || defined(OS_WIN)
 #define MAYBE_DNSError_Basic DISABLED_DNSError_Basic
 #else
 #define MAYBE_DNSError_Basic DNSError_Basic
 #endif
 // Test that a DNS error occuring in the main frame redirects to an error page.
 IN_PROC_BROWSER_TEST_F(ErrorPageTest, MAYBE_DNSError_Basic) {
   // The first navigation should fail, and the second one should be the error
   // page.
-  NavigateToURLAndWaitForTitle(GetDnsErrorURL(), "Mock Link Doctor", 2);
+  ui_test_utils::NavigateToURLBlockUntilNavigationsComplete(
+       browser(), GetDnsErrorURL(), 2);
+  ExpectDisplayingLinkDoctor(browser(), net::ERR_NAME_NOT_RESOLVED);
 }
 
 // See crbug.com/109669
 #if defined(USE_AURA)
 #define MAYBE_DNSError_GoBack1 DISABLED_DNSError_GoBack1
 #else
 #define MAYBE_DNSError_GoBack1 DNSError_GoBack1
 #endif
 
 // Test that a DNS error occuring in the main frame does not result in an
 // additional session history entry.
 IN_PROC_BROWSER_TEST_F(ErrorPageTest, MAYBE_DNSError_GoBack1) {
   NavigateToFileURL(FILE_PATH_LITERAL("title2.html"));
-  NavigateToURLAndWaitForTitle(GetDnsErrorURL(), "Mock Link Doctor", 2);
+  ui_test_utils::NavigateToURLBlockUntilNavigationsComplete(
+       browser(), GetDnsErrorURL(), 2);
+  ExpectDisplayingLinkDoctor(browser(), net::ERR_NAME_NOT_RESOLVED);
   GoBackAndWaitForTitle("Title Of Awesomeness", 1);
 }
 
 // See crbug.com/109669
 #if defined(USE_AURA)
 #define MAYBE_DNSError_GoBack2 DISABLED_DNSError_GoBack2
 #else
 #define MAYBE_DNSError_GoBack2 DNSError_GoBack2
 #endif
 // Test that a DNS error occuring in the main frame does not result in an
 // additional session history entry.
 IN_PROC_BROWSER_TEST_F(ErrorPageTest, DNSError_GoBack2) {
   NavigateToFileURL(FILE_PATH_LITERAL("title2.html"));
 
-  NavigateToURLAndWaitForTitle(GetDnsErrorURL(), "Mock Link Doctor", 2);
+  ui_test_utils::NavigateToURLBlockUntilNavigationsComplete(
+       browser(), GetDnsErrorURL(), 2);
+  ExpectDisplayingLinkDoctor(browser(), net::ERR_NAME_NOT_RESOLVED);
+
   NavigateToFileURL(FILE_PATH_LITERAL("title3.html"));
 
-  GoBackAndWaitForTitle("Mock Link Doctor", 2);
+  GoBackAndWaitForNavigations(2);
+  ExpectDisplayingLinkDoctor(browser(), net::ERR_NAME_NOT_RESOLVED);
+
   GoBackAndWaitForTitle("Title Of Awesomeness", 1);
 }
 
 // See crbug.com/109669
 #if defined(USE_AURA)
 #define MAYBE_DNSError_GoBack2AndForward DISABLED_DNSError_GoBack2AndForward
 #else
 #define MAYBE_DNSError_GoBack2AndForward DNSError_GoBack2AndForward
 #endif
 // Test that a DNS error occuring in the main frame does not result in an
 // additional session history entry.
 IN_PROC_BROWSER_TEST_F(ErrorPageTest, DNSError_GoBack2AndForward) {
   NavigateToFileURL(FILE_PATH_LITERAL("title2.html"));
 
-  NavigateToURLAndWaitForTitle(GetDnsErrorURL(), "Mock Link Doctor", 2);
+  ui_test_utils::NavigateToURLBlockUntilNavigationsComplete(
+       browser(), GetDnsErrorURL(), 2);
+  ExpectDisplayingLinkDoctor(browser(), net::ERR_NAME_NOT_RESOLVED);
+
   NavigateToFileURL(FILE_PATH_LITERAL("title3.html"));
 
-  GoBackAndWaitForTitle("Mock Link Doctor", 2);
+  GoBackAndWaitForNavigations(2);
+  ExpectDisplayingLinkDoctor(browser(), net::ERR_NAME_NOT_RESOLVED);
+
   GoBackAndWaitForTitle("Title Of Awesomeness", 1);
 
-  GoForwardAndWaitForTitle("Mock Link Doctor", 2);
+  GoForwardAndWaitForNavigations(2);
+  ExpectDisplayingLinkDoctor(browser(), net::ERR_NAME_NOT_RESOLVED);
 }
 
 // See crbug.com/109669
 #if defined(USE_AURA)
 #define MAYBE_DNSError_GoBack2Forward2 DISABLED_DNSError_GoBack2Forward2
 #else
 #define MAYBE_DNSError_GoBack2Forward2 DNSError_GoBack2Forward2
 #endif
 // Test that a DNS error occuring in the main frame does not result in an
 // additional session history entry.
 IN_PROC_BROWSER_TEST_F(ErrorPageTest, DNSError_GoBack2Forward2) {
   NavigateToFileURL(FILE_PATH_LITERAL("title3.html"));
 
-  NavigateToURLAndWaitForTitle(GetDnsErrorURL(), "Mock Link Doctor", 2);
+  ui_test_utils::NavigateToURLBlockUntilNavigationsComplete(
+       browser(), GetDnsErrorURL(), 2);
+  ExpectDisplayingLinkDoctor(browser(), net::ERR_NAME_NOT_RESOLVED);
+
   NavigateToFileURL(FILE_PATH_LITERAL("title2.html"));
 
-  GoBackAndWaitForTitle("Mock Link Doctor", 2);
+  GoBackAndWaitForNavigations(2);
+  ExpectDisplayingLinkDoctor(browser(), net::ERR_NAME_NOT_RESOLVED);
+
   GoBackAndWaitForTitle("Title Of More Awesomeness", 1);
 
-  GoForwardAndWaitForTitle("Mock Link Doctor", 2);
+  GoForwardAndWaitForNavigations(2);
+  ExpectDisplayingLinkDoctor(browser(), net::ERR_NAME_NOT_RESOLVED);
+
   GoForwardAndWaitForTitle("Title Of Awesomeness", 1);
 }
 
-// Test that a DNS error occuring in an iframe.
+// See crbug.com/109669
+#if defined(USE_AURA)
+#define MAYBE_DNSError_DoSearch DNSError_DoSearch
+#else
+#define MAYBE_DNSError_DoSearch DNSError_DoSearch
+#endif
+// Test that the search button on a DNS error page works.
+IN_PROC_BROWSER_TEST_F(ErrorPageTest, MAYBE_DNSError_DoSearch) {
+  // The first navigation should fail, and the second one should be the error
+  // page.
+  ui_test_utils::NavigateToURLBlockUntilNavigationsComplete(
+       browser(), GetDnsErrorURL(), 2);
+  ExpectDisplayingLinkDoctor(browser(), net::ERR_NAME_NOT_RESOLVED);
+
+  // Do a search and make sure the browser ends up at the right page.
+  content::TestNavigationObserver nav_observer(
+      browser()->tab_strip_model()->GetActiveWebContents(),
+      1);
+  content::TitleWatcher title_watcher(
+      browser()->tab_strip_model()->GetActiveWebContents(),
+      base::ASCIIToUTF16("Title Of More Awesomeness"));
+  ASSERT_TRUE(content::ExecuteScript(
+                  browser()->tab_strip_model()->GetActiveWebContents(),
+                  "document.getElementById('search-button').click();"));
+  nav_observer.Wait();
+  EXPECT_EQ(base::ASCIIToUTF16("Title Of More Awesomeness"),
+            title_watcher.WaitAndGetTitle());
+
+  // Check the path and query string.
+  std::string url;
+  ASSERT_TRUE(content::ExecuteScriptAndExtractString(
+                  browser()->tab_strip_model()->GetActiveWebContents(),
+                  "domAutomationController.send(window.location.href);",
+                  &url));
+  EXPECT_EQ("/search", GURL(url).path());
+  EXPECT_EQ("q=search%20query", GURL(url).query());
+
+  // Go back to the error page, to make sure the history is correct.
+  GoBackAndWaitForNavigations(2);
+  ExpectDisplayingLinkDoctor(browser(), net::ERR_NAME_NOT_RESOLVED);
+}
+
+// Test that a DNS error occuring in an iframe does not result in showing the
+// Link Doctor.
 IN_PROC_BROWSER_TEST_F(ErrorPageTest, IFrameDNSError_Basic) {
   NavigateToURLAndWaitForTitle(
       content::URLRequestMockHTTPJob::GetMockUrl(
           base::FilePath(FILE_PATH_LITERAL("iframe_dns_error.html"))),
       "Blah",
       1);
   // We expect to have two history entries, since we started off with navigation
   // to "about:blank" and then navigated to "iframe_dns_error.html".
   EXPECT_EQ(2,
       browser()->tab_strip_model()->GetActiveWebContents()->
@@ skipping 141 matching lines @@
   // 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));
 }
 
-// Returns Javascript code that executes plain text search for the page.
-// Pass into content::ExecuteScriptAndExtractBool as |script| parameter.
-std::string GetTextContentContainsStringScript(
-    const std::string& value_to_search) {
-  return base::StringPrintf(
-      "var textContent = document.body.textContent;"
-      "var hasError = textContent.indexOf('%s') >= 0;"
-      "domAutomationController.send(hasError);",
-      value_to_search.c_str());
-}
-
 // Protocol handler that fails all requests with net::ERR_ADDRESS_UNREACHABLE.
 class AddressUnreachableProtocolHandler
     : public net::URLRequestJobFactory::ProtocolHandler {
  public:
   AddressUnreachableProtocolHandler() {}
   virtual ~AddressUnreachableProtocolHandler() {}
 
   // net::URLRequestJobFactory::ProtocolHandler:
   virtual net::URLRequestJob* MaybeCreateJob(
       net::URLRequest* request,
@@ skipping 50 matching lines @@
 };
 
 // Make sure that when the Link Doctor fails to load, the network error page is
 // successfully loaded.
 IN_PROC_BROWSER_TEST_F(ErrorPageLinkDoctorFailTest, LinkDoctorFail) {
   ui_test_utils::NavigateToURLBlockUntilNavigationsComplete(
       browser(),
       URLRequestFailedJob::GetMockHttpUrl(net::ERR_NAME_NOT_RESOLVED),
       2);
 
-  // Verify that the expected error page is being displayed.  Do this by making
-  // sure the original error code (ERR_NAME_NOT_RESOLVED) is displayed.
-  bool result = false;
-  EXPECT_TRUE(content::ExecuteScriptAndExtractBool(
-      browser()->tab_strip_model()->GetActiveWebContents(),
-      GetTextContentContainsStringScript("ERR_NAME_NOT_RESOLVED"),
-      &result));
-  EXPECT_TRUE(result);
+  // Verify that the expected error page is being displayed.
+  ExpectDisplayingLocalErrorPage(browser(), net::ERR_NAME_NOT_RESOLVED);
 }
 
 // Checks that when an error occurs and a link doctor load fails, the stale
 // cache status of the page is correctly transferred.  Most logic copied
 // from StaleCacheStatus above.
 IN_PROC_BROWSER_TEST_F(ErrorPageLinkDoctorFailTest,
                        StaleCacheStatusFailedLinkDoctor) {
   ASSERT_TRUE(test_server()->Start());
   // Load cache with entry with "nocache" set, to create stale
   // cache.
@@ skipping 67 matching lines @@
 
 // Make sure error page shows correct unicode for IDN.
 IN_PROC_BROWSER_TEST_F(ErrorPageForIDNTest, IDN) {
   // ERR_UNSAFE_PORT will not trigger the link doctor.
   ui_test_utils::NavigateToURLBlockUntilNavigationsComplete(
       browser(),
       URLRequestFailedJob::GetMockHttpUrlForHostname(net::ERR_UNSAFE_PORT,
                                                      kHostname),
       1);
 
-  bool result = false;
-  EXPECT_TRUE(content::ExecuteScriptAndExtractBool(
-      browser()->tab_strip_model()->GetActiveWebContents(),
-      GetTextContentContainsStringScript(kHostnameJSUnicode),
-      &result));
-  EXPECT_TRUE(result);
+  ToggleHelpBox(browser());
+  EXPECT_TRUE(IsDisplayingText(browser(), kHostnameJSUnicode));
 }
 
 }  // namespace