Switch to using the new Link Doctor API.

chrome/browser/net/dns_probe_browsertest.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 <set>
 
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/path_service.h"
@@ skipping 92 matching lines @@
     return delayed_probes_.size();
   }
 
  private:
   std::vector<ProbeCallback> delayed_probes_;
 };
 
 FilePath GetMockLinkDoctorFilePath() {
   FilePath root_http;
   PathService::Get(chrome::DIR_TEST_DATA, &root_http);
-  return root_http.AppendASCII("mock-link-doctor.html");
+  return root_http.AppendASCII("mock-link-doctor.json");
 }
 
 // A request that can be delayed until Resume() is called.  Can also run a
 // callback if destroyed without being resumed.  Resume can be called either
 // before or after a the request is started.
 class DelayableRequest {
  public:
   // Called by a DelayableRequest if it was set to be delayed, and has been
   // destroyed without Undelay being called.
   typedef base::Callback<void(DelayableRequest* request)> DestructionCallback;
@@ skipping 330 matching lines @@
   void NavigateToDnsError(int num_navigations);
   void NavigateToOtherError(int num_navigations);
 
   void StartDelayedProbes(int expected_delayed_probe_count);
   DnsProbeStatus WaitForSentStatus();
   int pending_status_count() const { return dns_probe_status_queue_.size(); }
 
   std::string Title();
   bool PageContains(const std::string& expected);
 
+  // Checks that the local error page is being displayed, without Link Doctor
+  // suggestions, and with the specified status text.  The status text should be
+  // either a network error or DNS probe status.
+  void ExpectDisplayingLocalErrorPage(const std::string& status_text);
+
+  // Checks that an error page with suggestions retrieved from the mock Link
+  // Doctor result is being displayed, with the specified status text.
+  // The status text should be either a network error or DNS probe status.
+  void ExpectDisplayingLinkDoctor(const std::string& status_text);
+
  private:
   void OnDnsProbeStatusSent(DnsProbeStatus dns_probe_status);
 
   DnsProbeBrowserTestIOThreadHelper* helper_;
 
   // Browser that methods apply to.
   Browser* active_browser_;
   // Helper that current has its DnsProbeStatus messages monitored.
   NetErrorTabHelper* monitored_tab_helper_;
 
@@ skipping 157 matching lines @@
   bool rv = content::ExecuteScriptAndExtractString(
       active_browser_->tab_strip_model()->GetActiveWebContents(),
       "domAutomationController.send(document.body.textContent);",
       &text_content);
   if (!rv)
     return false;
 
   return text_content.find(expected) != std::string::npos;
 }
 
+void DnsProbeBrowserTest::ExpectDisplayingLocalErrorPage(
+    const std::string& status_text) {
+  EXPECT_FALSE(PageContains("http://correction1/"));
+  EXPECT_FALSE(PageContains("http://correction2/"));
+  EXPECT_TRUE(PageContains(status_text));
+}
+
+void DnsProbeBrowserTest::ExpectDisplayingLinkDoctor(
+    const std::string& status_text) {
+  EXPECT_TRUE(PageContains("http://correction1/"));
+  EXPECT_TRUE(PageContains("http://correction2/"));
+  EXPECT_TRUE(PageContains(status_text));
+}
+
 void DnsProbeBrowserTest::OnDnsProbeStatusSent(
     DnsProbeStatus dns_probe_status) {
   dns_probe_status_queue_.push_back(dns_probe_status);
   if (awaiting_dns_probe_status_)
     MessageLoop::current()->Quit();
 }
 
 // Make sure probes don't break non-DNS error pages when Link Doctor loads.
 IN_PROC_BROWSER_TEST_F(DnsProbeBrowserTest, OtherErrorWithWorkingLinkDoctor) {
   SetLinkDoctorBroken(false);
 
   NavigateToOtherError(2);
-  EXPECT_EQ("Mock Link Doctor", Title());
+  ExpectDisplayingLinkDoctor("ERR_CONNECTION_REFUSED");
 }
 
 // Make sure probes don't break non-DNS error pages when Link Doctor doesn't
 // load.
 IN_PROC_BROWSER_TEST_F(DnsProbeBrowserTest, OtherErrorWithBrokenLinkDoctor) {
   SetLinkDoctorBroken(true);
 
   NavigateToOtherError(2);
-  EXPECT_TRUE(PageContains("CONNECTION_REFUSED"));
+  ExpectDisplayingLocalErrorPage("ERR_CONNECTION_REFUSED");
 }
 
-// Make sure probes don't break DNS error pages when Link doctor loads.
+// Make sure probes don't break DNS error pages when Link Doctor loads.
 IN_PROC_BROWSER_TEST_F(DnsProbeBrowserTest,
                        NxdomainProbeResultWithWorkingLinkDoctor) {
   SetLinkDoctorBroken(false);
   SetMockDnsClientRules(MockDnsClientRule::OK, MockDnsClientRule::OK);
 
   NavigateToDnsError(2);
-  EXPECT_EQ("Mock Link Doctor", Title());
+  ExpectDisplayingLinkDoctor("ERR_NAME_NOT_RESOLVED");
 
   // One status for committing a blank page before the Link Doctor, and one for
   // when the Link Doctor is committed.
   EXPECT_EQ(chrome_common_net::DNS_PROBE_STARTED, WaitForSentStatus());
   EXPECT_EQ(chrome_common_net::DNS_PROBE_STARTED, WaitForSentStatus());
   EXPECT_EQ(0, pending_status_count());
-  EXPECT_EQ("Mock Link Doctor", Title());
+  ExpectDisplayingLinkDoctor("ERR_NAME_NOT_RESOLVED");
 
   StartDelayedProbes(1);
 
   EXPECT_EQ(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN,
             WaitForSentStatus());
   EXPECT_EQ(0, pending_status_count());
-  EXPECT_EQ("Mock Link Doctor", Title());
+  ExpectDisplayingLinkDoctor("ERR_NAME_NOT_RESOLVED");
 }
 
 // Make sure probes don't break Link Doctor when probes complete before the
 // Link Doctor loads.
 IN_PROC_BROWSER_TEST_F(DnsProbeBrowserTest,
                        NxdomainProbeResultWithWorkingSlowLinkDoctor) {
   SetLinkDoctorBroken(false);
   SetLinkDoctorDelayRequests(true);
   SetMockDnsClientRules(MockDnsClientRule::OK, MockDnsClientRule::OK);
 
@@ skipping 12 matching lines @@
             WaitForSentStatus());
   EXPECT_EQ(0, pending_status_count());
   EXPECT_EQ("", Title());
 
   content::TestNavigationObserver observer(
       browser()->tab_strip_model()->GetActiveWebContents(), 1);
   // The Link Doctor page finishes loading.
   SetLinkDoctorDelayRequests(false);
   // Wait for it to commit.
   observer.Wait();
-  EXPECT_EQ("Mock Link Doctor", Title());
+  ExpectDisplayingLinkDoctor("ERR_NAME_NOT_RESOLVED");
 
   // Committing the Link Doctor page should trigger sending the probe result
   // again.
   EXPECT_EQ(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN,
             WaitForSentStatus());
-  EXPECT_EQ("Mock Link Doctor", Title());
+  ExpectDisplayingLinkDoctor("ERR_NAME_NOT_RESOLVED");
 }
 
 // Make sure probes update DNS error page properly when they're supposed to.
 IN_PROC_BROWSER_TEST_F(DnsProbeBrowserTest,
                        NoInternetProbeResultWithBrokenLinkDoctor) {
   SetLinkDoctorBroken(true);
   SetMockDnsClientRules(MockDnsClientRule::TIMEOUT,
                         MockDnsClientRule::TIMEOUT);
 
   NavigateToDnsError(2);
 
   EXPECT_EQ(chrome_common_net::DNS_PROBE_STARTED, WaitForSentStatus());
   EXPECT_EQ(chrome_common_net::DNS_PROBE_STARTED, WaitForSentStatus());
 
-  // PageContains runs the RunLoop, so make sure nothing hairy happens.
+  // Checking the page runs the RunLoop, so make sure nothing hairy happens.
   EXPECT_EQ(0, pending_status_count());
-  EXPECT_TRUE(PageContains("DNS_PROBE_STARTED"));
+  ExpectDisplayingLocalErrorPage("DNS_PROBE_STARTED");
   EXPECT_EQ(0, pending_status_count());
 
   StartDelayedProbes(1);
 
   EXPECT_EQ(chrome_common_net::DNS_PROBE_FINISHED_NO_INTERNET,
             WaitForSentStatus());
 
-  // PageContains runs the RunLoop, so make sure nothing hairy happens.
+  // Checking the page runs the RunLoop, so make sure nothing hairy happens.
   EXPECT_EQ(0, pending_status_count());
-  EXPECT_TRUE(PageContains("DNS_PROBE_FINISHED_NO_INTERNET"));
+  ExpectDisplayingLocalErrorPage("DNS_PROBE_FINISHED_NO_INTERNET");
 }
 
 // Make sure probes don't break Link Doctor when probes complete before the
 // Link Doctor request returns an error.
 IN_PROC_BROWSER_TEST_F(DnsProbeBrowserTest,
                        NoInternetProbeResultWithSlowBrokenLinkDoctor) {
   SetLinkDoctorBroken(true);
   SetLinkDoctorDelayRequests(true);
   SetMockDnsClientRules(MockDnsClientRule::TIMEOUT,
                         MockDnsClientRule::TIMEOUT);
@@ skipping 18 matching lines @@
       browser()->tab_strip_model()->GetActiveWebContents(), 1);
   // The Link Doctor request fails.
   SetLinkDoctorDelayRequests(false);
   // Wait for the DNS error page to load instead.
   observer.Wait();
   // The page committing should result in sending the probe results again.
   EXPECT_EQ(chrome_common_net::DNS_PROBE_FINISHED_NO_INTERNET,
             WaitForSentStatus());
 
   EXPECT_EQ(0, pending_status_count());
-  EXPECT_TRUE(PageContains("DNS_PROBE_FINISHED_NO_INTERNET"));
+  ExpectDisplayingLocalErrorPage("DNS_PROBE_FINISHED_NO_INTERNET");
 }
 
 // Double-check to make sure sync failures don't explode.
 IN_PROC_BROWSER_TEST_F(DnsProbeBrowserTest, SyncFailureWithBrokenLinkDoctor) {
   SetLinkDoctorBroken(true);
   SetMockDnsClientRules(MockDnsClientRule::FAIL, MockDnsClientRule::FAIL);
 
   NavigateToDnsError(2);
 
   EXPECT_EQ(chrome_common_net::DNS_PROBE_STARTED, WaitForSentStatus());
   EXPECT_EQ(chrome_common_net::DNS_PROBE_STARTED, WaitForSentStatus());
 
-  // PageContains runs the RunLoop, so make sure nothing hairy happens.
+  // Checking the page runs the RunLoop, so make sure nothing hairy happens.
   EXPECT_EQ(0, pending_status_count());
-  EXPECT_TRUE(PageContains("DNS_PROBE_STARTED"));
+  ExpectDisplayingLocalErrorPage("DNS_PROBE_STARTED");
   EXPECT_EQ(0, pending_status_count());
 
   StartDelayedProbes(1);
 
   EXPECT_EQ(chrome_common_net::DNS_PROBE_FINISHED_INCONCLUSIVE,
             WaitForSentStatus());
 
-  // PageContains runs the RunLoop, so make sure nothing hairy happens.
+  // Checking the page runs the RunLoop, so make sure nothing hairy happens.
   EXPECT_EQ(0, pending_status_count());
-  EXPECT_TRUE(PageContains("NAME_NOT_RESOLVED"));
+  ExpectDisplayingLocalErrorPage("ERR_NAME_NOT_RESOLVED");
   EXPECT_EQ(0, pending_status_count());
 }
 
 // Test that pressing the stop button cancels loading the Link Doctor page.
 // TODO(mmenke):  Add a test for the cross process navigation case.
 // TODO(mmenke):  This test could flakily pass due to the timeout on downloading
 //                the Link Doctor page.  Disable that timeout for browser tests.
 IN_PROC_BROWSER_TEST_F(DnsProbeBrowserTest, LinkDoctorLoadStopped) {
   SetLinkDoctorDelayRequests(true);
   SetLinkDoctorBroken(true);
@@ skipping 69 matching lines @@
   browser()->profile()->GetPrefs()->SetBoolean(
       prefs::kAlternateErrorPagesEnabled, false);
 
   SetLinkDoctorBroken(true);
   SetMockDnsClientRules(MockDnsClientRule::TIMEOUT, MockDnsClientRule::TIMEOUT);
 
   NavigateToDnsError(1);
 
   EXPECT_EQ(chrome_common_net::DNS_PROBE_NOT_RUN, WaitForSentStatus());
 
-  // PageContains runs the RunLoop, so make sure nothing hairy happens.
+  // Checking the page runs the RunLoop, so make sure nothing hairy happens.
   EXPECT_EQ(0, pending_status_count());
-  EXPECT_TRUE(PageContains("NAME_NOT_RESOLVED"));
+  ExpectDisplayingLocalErrorPage("ERR_NAME_NOT_RESOLVED");
 }
 
 // Test the case that Link Doctor is disabled, but DNS probes are enabled.  This
 // is the case with Chromium builds.
 IN_PROC_BROWSER_TEST_F(DnsProbeBrowserTest, LinkDoctorDisabled) {
   // Disable Link Doctor.
   browser()->profile()->GetPrefs()->SetBoolean(
       prefs::kAlternateErrorPagesEnabled, false);
   // Requests to the Link Doctor should work if any are made, so the test fails
   // if that happens unexpectedly.
   SetLinkDoctorBroken(false);
   // Normally disabling the LinkDoctor disables DNS probes, so force DNS probes
   // to be enabled.
   NetErrorTabHelper::set_state_for_testing(
       NetErrorTabHelper::TESTING_FORCE_ENABLED);
 
   SetMockDnsClientRules(MockDnsClientRule::FAIL, MockDnsClientRule::FAIL);
 
   // Just one commit and one sent status, since the Link Doctor is disabled.
   NavigateToDnsError(1);
   EXPECT_EQ(chrome_common_net::DNS_PROBE_STARTED, WaitForSentStatus());
 
-  // PageContains runs the RunLoop, so make sure nothing hairy happens.
+  // Checking the page runs the RunLoop, so make sure nothing hairy happens.
   EXPECT_EQ(0, pending_status_count());
-  EXPECT_TRUE(PageContains("DNS_PROBE_STARTED"));
+  ExpectDisplayingLocalErrorPage("DNS_PROBE_STARTED");
   EXPECT_EQ(0, pending_status_count());
 
   StartDelayedProbes(1);
 
   EXPECT_EQ(chrome_common_net::DNS_PROBE_FINISHED_INCONCLUSIVE,
             WaitForSentStatus());
   EXPECT_EQ(0, pending_status_count());
-  EXPECT_TRUE(PageContains("NAME_NOT_RESOLVED"));
+  ExpectDisplayingLocalErrorPage("ERR_NAME_NOT_RESOLVED");
 }
 
 // Test incognito mode.  Link Doctor should be disabled, but DNS probes are
 // still enabled.
 IN_PROC_BROWSER_TEST_F(DnsProbeBrowserTest, Incognito) {
   // Requests to the Link Doctor should work if any are made, so the test will
   // fail if one is requested unexpectedly.
   SetLinkDoctorBroken(false);
 
   Browser* incognito = CreateIncognitoBrowser();
   SetActiveBrowser(incognito);
 
   SetMockDnsClientRules(MockDnsClientRule::FAIL, MockDnsClientRule::FAIL);
 
   // Just one commit and one sent status, since the Link Doctor is disabled.
   NavigateToDnsError(1);
   EXPECT_EQ(chrome_common_net::DNS_PROBE_STARTED, WaitForSentStatus());
 
-  // PageContains runs the RunLoop, so make sure nothing hairy happens.
+  // Checking the page runs the RunLoop, so make sure nothing hairy happens.
   EXPECT_EQ(0, pending_status_count());
-  EXPECT_TRUE(PageContains("DNS_PROBE_STARTED"));
+  ExpectDisplayingLocalErrorPage("DNS_PROBE_STARTED");
   EXPECT_EQ(0, pending_status_count());
 
   StartDelayedProbes(1);
 
   EXPECT_EQ(chrome_common_net::DNS_PROBE_FINISHED_INCONCLUSIVE,
             WaitForSentStatus());
   EXPECT_EQ(0, pending_status_count());
-  EXPECT_TRUE(PageContains("NAME_NOT_RESOLVED"));
+  ExpectDisplayingLocalErrorPage("ERR_NAME_NOT_RESOLVED");
 }
 
 }  // namespace
 
 }  // namespace chrome_browser_net