Merge 262846 "Revert 255617, due to it not tracking use of the link doctor page."

chrome/browser/net/dns_probe_browsertest.cc

Index: chrome/browser/net/dns_probe_browsertest.cc
===================================================================
--- chrome/browser/net/dns_probe_browsertest.cc	(revision 263850)
+++ chrome/browser/net/dns_probe_browsertest.cc	(working copy)
@@ -110,7 +110,7 @@
 FilePath GetMockLinkDoctorFilePath() {
   FilePath root_http;
   PathService::Get(chrome::DIR_TEST_DATA, &root_http);
-  return root_http.AppendASCII("mock-link-doctor.json");
+  return root_http.AppendASCII("mock-link-doctor.html");
 }
 
 // A request that can be delayed until Resume() is called.  Can also run a
@@ -215,23 +215,23 @@
   const DestructionCallback destruction_callback_;
 };
 
-// ProtocolHandler for navigation correction requests.  Can cause requests to
-// fail with an error, and/or delay a request until a test allows to continue.
-// Also can run a callback when a delayed request is cancelled.
-class BreakableCorrectionProtocolHandler
+// ProtocolHandler for Link Doctor requests.  Can cause requests to fail with
+// an error, and/or delay a request until a test allows to continue.  Also can
+// run a callback when a delayed request is cancelled.
+class BreakableLinkDoctorProtocolHandler
     : public URLRequestJobFactory::ProtocolHandler {
  public:
-  explicit BreakableCorrectionProtocolHandler(
-      const FilePath& mock_corrections_file_path)
-      : mock_corrections_file_path_(mock_corrections_file_path),
+  explicit BreakableLinkDoctorProtocolHandler(
+      const FilePath& mock_link_doctor_file_path)
+      : mock_link_doctor_file_path_(mock_link_doctor_file_path),
         net_error_(net::OK),
         delay_requests_(false),
         on_request_destroyed_callback_(
-            base::Bind(&BreakableCorrectionProtocolHandler::OnRequestDestroyed,
+            base::Bind(&BreakableLinkDoctorProtocolHandler::OnRequestDestroyed,
                        base::Unretained(this))) {
   }
 
-  virtual ~BreakableCorrectionProtocolHandler() {
+  virtual ~BreakableLinkDoctorProtocolHandler() {
     // All delayed requests should have been resumed or cancelled by this point.
     EXPECT_TRUE(delayed_requests_.empty());
   }
@@ -250,7 +250,7 @@
     } else {
       DelayableURLRequestMockHTTPJob* job =
           new DelayableURLRequestMockHTTPJob(
-              request, network_delegate, mock_corrections_file_path_,
+              request, network_delegate, mock_link_doctor_file_path_,
               delay_requests_, on_request_destroyed_callback_);
       if (delay_requests_)
         delayed_requests_.insert(job);
@@ -295,7 +295,7 @@
   }
 
  private:
-  const FilePath mock_corrections_file_path_;
+  const FilePath mock_link_doctor_file_path_;
   int net_error_;
   bool delay_requests_;
 
@@ -319,8 +319,8 @@
 
   void SetMockDnsClientRules(MockDnsClientRule::Result system_good_result,
                              MockDnsClientRule::Result public_good_result);
-  void SetCorrectionServiceNetError(int net_error);
-  void SetCorrectionServiceDelayRequests(bool delay_requests);
+  void SetLinkDoctorNetError(int link_doctor_net_error);
+  void SetLinkDoctorDelayRequests(bool delay_requests);
   void SetRequestDestructionCallback(const base::Closure& callback);
   void StartDelayedProbes(int expected_delayed_probe_count);
 
@@ -328,8 +328,8 @@
   IOThread* io_thread_;
   DnsProbeService* original_dns_probe_service_;
   DelayingDnsProbeService* delaying_dns_probe_service_;
-  BreakableCorrectionProtocolHandler* protocol_handler_;
-  FilePath mock_corrections_file_path_;
+  BreakableLinkDoctorProtocolHandler* protocol_handler_;
+  FilePath mock_link_doctor_file_path_;
 };
 
 DnsProbeBrowserTestIOThreadHelper::DnsProbeBrowserTestIOThreadHelper()
@@ -337,7 +337,7 @@
       original_dns_probe_service_(NULL),
       delaying_dns_probe_service_(NULL),
       protocol_handler_(NULL),
-      mock_corrections_file_path_(GetMockLinkDoctorFilePath()) {}
+      mock_link_doctor_file_path_(GetMockLinkDoctorFilePath()) {}
 
 void DnsProbeBrowserTestIOThreadHelper::SetUpOnIOThread(IOThread* io_thread) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
@@ -358,11 +358,13 @@
   URLRequestFailedJob::AddUrlHandler();
 
   scoped_ptr<URLRequestJobFactory::ProtocolHandler> protocol_handler(
-      new BreakableCorrectionProtocolHandler(mock_corrections_file_path_));
+      new BreakableLinkDoctorProtocolHandler(mock_link_doctor_file_path_));
   protocol_handler_ =
-      static_cast<BreakableCorrectionProtocolHandler*>(protocol_handler.get());
-  URLRequestFilter::GetInstance()->AddUrlProtocolHandler(
-      LinkDoctorBaseURL(), protocol_handler.Pass());
+      static_cast<BreakableLinkDoctorProtocolHandler*>(protocol_handler.get());
+  const GURL link_doctor_base_url = LinkDoctorBaseURL();
+  const std::string link_doctor_host = link_doctor_base_url.host();
+  URLRequestFilter::GetInstance()->AddHostnameProtocolHandler(
+      "http", link_doctor_host, protocol_handler.Pass());
 }
 
 void DnsProbeBrowserTestIOThreadHelper::CleanUpOnIOThreadAndDeleteHelper() {
@@ -392,14 +394,14 @@
       CreateMockDnsClientForProbes(public_result));
 }
 
-void DnsProbeBrowserTestIOThreadHelper::SetCorrectionServiceNetError(
-    int net_error) {
+void DnsProbeBrowserTestIOThreadHelper::SetLinkDoctorNetError(
+    int link_doctor_net_error) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
-  protocol_handler_->set_net_error(net_error);
+  protocol_handler_->set_net_error(link_doctor_net_error);
 }
 
-void DnsProbeBrowserTestIOThreadHelper::SetCorrectionServiceDelayRequests(
+void DnsProbeBrowserTestIOThreadHelper::SetLinkDoctorDelayRequests(
     bool delay_requests) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
@@ -439,16 +441,16 @@
   // DnsProbeStatus messages of its currently active tab monitored.
   void SetActiveBrowser(Browser* browser);
 
-  void SetCorrectionServiceBroken(bool broken);
-  void SetCorrectionServiceDelayRequests(bool delay_requests);
+  void SetLinkDoctorBroken(bool broken);
+  void SetLinkDoctorDelayRequests(bool delay_requests);
   void WaitForDelayedRequestDestruction();
   void SetMockDnsClientRules(MockDnsClientRule::Result system_result,
                              MockDnsClientRule::Result public_result);
 
-  // These functions are often used to wait for two navigations because two
-  // pages are loaded when navigation corrections are enabled: a blank page, so
-  // the user stops seeing the previous page, and then the error page, either
-  // with navigation corrections or without them (If the request failed).
+  // These functions are often used to wait for two navigations because the Link
+  // Doctor loads two pages: a blank page, so the user stops seeing the previous
+  // page, and then either the Link Doctor page or a regular error page.  Often
+  // need to wait for both to finish in a row.
   void NavigateToDnsError(int num_navigations);
   void NavigateToOtherError(int num_navigations);
 
@@ -459,16 +461,6 @@
   std::string Title();
   bool PageContains(const std::string& expected);
 
-  // Checks that the local error page is being displayed, without navigation
-  // corrections, 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 mock navigation corrections is being
-  // displayed, with the specified status text. The status text should be either
-  // a network error or DNS probe status.
-  void ExpectDisplayingCorrections(const std::string& status_text);
-
  private:
   void OnDnsProbeStatusSent(DnsProbeStatus dns_probe_status);
 
@@ -536,22 +528,20 @@
       Bind(&DnsProbeBrowserTest::OnDnsProbeStatusSent, Unretained(this)));
 }
 
-void DnsProbeBrowserTest::SetCorrectionServiceBroken(bool broken) {
+void DnsProbeBrowserTest::SetLinkDoctorBroken(bool broken) {
   int net_error = broken ? net::ERR_NAME_NOT_RESOLVED : net::OK;
 
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      Bind(&DnsProbeBrowserTestIOThreadHelper::SetCorrectionServiceNetError,
+      Bind(&DnsProbeBrowserTestIOThreadHelper::SetLinkDoctorNetError,
            Unretained(helper_),
            net_error));
 }
 
-void DnsProbeBrowserTest::SetCorrectionServiceDelayRequests(
-    bool delay_requests) {
+void DnsProbeBrowserTest::SetLinkDoctorDelayRequests(bool delay_requests) {
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      Bind(&DnsProbeBrowserTestIOThreadHelper::
-               SetCorrectionServiceDelayRequests,
+      Bind(&DnsProbeBrowserTestIOThreadHelper::SetLinkDoctorDelayRequests,
            Unretained(helper_),
            delay_requests));
 }
@@ -648,20 +638,6 @@
   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::ExpectDisplayingCorrections(
-    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);
@@ -669,57 +645,57 @@
     MessageLoop::current()->Quit();
 }
 
-// Make sure probes don't break non-DNS error pages when corrections load.
-IN_PROC_BROWSER_TEST_F(DnsProbeBrowserTest, OtherErrorWithCorrectionsSuccess) {
-  SetCorrectionServiceBroken(false);
+// 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);
-  ExpectDisplayingCorrections("ERR_CONNECTION_REFUSED");
+  EXPECT_EQ("Mock Link Doctor", Title());
 }
 
-// Make sure probes don't break non-DNS error pages when corrections failed to
+// Make sure probes don't break non-DNS error pages when Link Doctor doesn't
 // load.
-IN_PROC_BROWSER_TEST_F(DnsProbeBrowserTest, OtherErrorWithCorrectionsFailure) {
-  SetCorrectionServiceBroken(true);
+IN_PROC_BROWSER_TEST_F(DnsProbeBrowserTest, OtherErrorWithBrokenLinkDoctor) {
+  SetLinkDoctorBroken(true);
 
   NavigateToOtherError(2);
-  ExpectDisplayingLocalErrorPage("ERR_CONNECTION_REFUSED");
+  EXPECT_TRUE(PageContains("CONNECTION_REFUSED"));
 }
 
-// Make sure probes don't break DNS error pages when corrections load.
+// Make sure probes don't break DNS error pages when Link doctor loads.
 IN_PROC_BROWSER_TEST_F(DnsProbeBrowserTest,
-                       NxdomainProbeResultWithWorkingCorrections) {
-  SetCorrectionServiceBroken(false);
+                       NxdomainProbeResultWithWorkingLinkDoctor) {
+  SetLinkDoctorBroken(false);
   SetMockDnsClientRules(MockDnsClientRule::OK, MockDnsClientRule::OK);
 
   NavigateToDnsError(2);
-  ExpectDisplayingCorrections("ERR_NAME_NOT_RESOLVED");
+  EXPECT_EQ("Mock Link Doctor", Title());
 
-  // One status for committing a blank page before the corrections, and one for
-  // when the error page with corrections is committed.
+  // 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());
-  ExpectDisplayingCorrections("ERR_NAME_NOT_RESOLVED");
+  EXPECT_EQ("Mock Link Doctor", Title());
 
   StartDelayedProbes(1);
 
   EXPECT_EQ(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN,
             WaitForSentStatus());
   EXPECT_EQ(0, pending_status_count());
-  ExpectDisplayingCorrections("ERR_NAME_NOT_RESOLVED");
+  EXPECT_EQ("Mock Link Doctor", Title());
 }
 
-// Make sure probes don't break corrections when probes complete before the
-// corrections load.
+// Make sure probes don't break Link Doctor when probes complete before the
+// Link Doctor loads.
 IN_PROC_BROWSER_TEST_F(DnsProbeBrowserTest,
-                       NxdomainProbeResultWithWorkingSlowCorrections) {
-  SetCorrectionServiceBroken(false);
-  SetCorrectionServiceDelayRequests(true);
+                       NxdomainProbeResultWithWorkingSlowLinkDoctor) {
+  SetLinkDoctorBroken(false);
+  SetLinkDoctorDelayRequests(true);
   SetMockDnsClientRules(MockDnsClientRule::OK, MockDnsClientRule::OK);
 
   NavigateToDnsError(1);
-  // A blank page should be displayed while the corrections are loaded.
+  // A blank page should be displayed while the Link Doctor page loads.
   EXPECT_EQ("", Title());
 
   // A single probe should be triggered by the error page load, and it should
@@ -736,23 +712,23 @@
 
   content::TestNavigationObserver observer(
       browser()->tab_strip_model()->GetActiveWebContents(), 1);
-  // The corrections finish loading.
-  SetCorrectionServiceDelayRequests(false);
+  // The Link Doctor page finishes loading.
+  SetLinkDoctorDelayRequests(false);
   // Wait for it to commit.
   observer.Wait();
-  ExpectDisplayingCorrections("ERR_NAME_NOT_RESOLVED");
+  EXPECT_EQ("Mock Link Doctor", Title());
 
-  // Committing the corections page should trigger sending the probe result
+  // Committing the Link Doctor page should trigger sending the probe result
   // again.
   EXPECT_EQ(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN,
             WaitForSentStatus());
-  ExpectDisplayingCorrections("ERR_NAME_NOT_RESOLVED");
+  EXPECT_EQ("Mock Link Doctor", Title());
 }
 
 // Make sure probes update DNS error page properly when they're supposed to.
 IN_PROC_BROWSER_TEST_F(DnsProbeBrowserTest,
-                       NoInternetProbeResultWithBrokenCorrections) {
-  SetCorrectionServiceBroken(true);
+                       NoInternetProbeResultWithBrokenLinkDoctor) {
+  SetLinkDoctorBroken(true);
   SetMockDnsClientRules(MockDnsClientRule::TIMEOUT,
                         MockDnsClientRule::TIMEOUT);
 
@@ -761,9 +737,9 @@
   EXPECT_EQ(chrome_common_net::DNS_PROBE_STARTED, WaitForSentStatus());
   EXPECT_EQ(chrome_common_net::DNS_PROBE_STARTED, WaitForSentStatus());
 
-  // Checking the page runs the RunLoop, so make sure nothing hairy happens.
+  // PageContains runs the RunLoop, so make sure nothing hairy happens.
   EXPECT_EQ(0, pending_status_count());
-  ExpectDisplayingLocalErrorPage("DNS_PROBE_STARTED");
+  EXPECT_TRUE(PageContains("DNS_PROBE_STARTED"));
   EXPECT_EQ(0, pending_status_count());
 
   StartDelayedProbes(1);
@@ -771,22 +747,22 @@
   EXPECT_EQ(chrome_common_net::DNS_PROBE_FINISHED_NO_INTERNET,
             WaitForSentStatus());
 
-  // Checking the page runs the RunLoop, so make sure nothing hairy happens.
+  // PageContains runs the RunLoop, so make sure nothing hairy happens.
   EXPECT_EQ(0, pending_status_count());
-  ExpectDisplayingLocalErrorPage("DNS_PROBE_FINISHED_NO_INTERNET");
+  EXPECT_TRUE(PageContains("DNS_PROBE_FINISHED_NO_INTERNET"));
 }
 
-// Make sure probes don't break corrections when probes complete before the
-// corrections request returns an error.
+// 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,
-                       NoInternetProbeResultWithSlowBrokenCorrections) {
-  SetCorrectionServiceBroken(true);
-  SetCorrectionServiceDelayRequests(true);
+                       NoInternetProbeResultWithSlowBrokenLinkDoctor) {
+  SetLinkDoctorBroken(true);
+  SetLinkDoctorDelayRequests(true);
   SetMockDnsClientRules(MockDnsClientRule::TIMEOUT,
                         MockDnsClientRule::TIMEOUT);
 
   NavigateToDnsError(1);
-  // A blank page should be displayed while the corrections load.
+  // A blank page should be displayed while the Link Doctor page loads.
   EXPECT_EQ("", Title());
 
   // A single probe should be triggered by the error page load, and it should
@@ -803,8 +779,8 @@
 
   content::TestNavigationObserver observer(
       browser()->tab_strip_model()->GetActiveWebContents(), 1);
-  // The corrections request fails.
-  SetCorrectionServiceDelayRequests(false);
+  // 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.
@@ -812,12 +788,12 @@
             WaitForSentStatus());
 
   EXPECT_EQ(0, pending_status_count());
-  ExpectDisplayingLocalErrorPage("DNS_PROBE_FINISHED_NO_INTERNET");
+  EXPECT_TRUE(PageContains("DNS_PROBE_FINISHED_NO_INTERNET"));
 }
 
 // Double-check to make sure sync failures don't explode.
-IN_PROC_BROWSER_TEST_F(DnsProbeBrowserTest, SyncFailureWithBrokenCorrections) {
-  SetCorrectionServiceBroken(true);
+IN_PROC_BROWSER_TEST_F(DnsProbeBrowserTest, SyncFailureWithBrokenLinkDoctor) {
+  SetLinkDoctorBroken(true);
   SetMockDnsClientRules(MockDnsClientRule::FAIL, MockDnsClientRule::FAIL);
 
   NavigateToDnsError(2);
@@ -825,9 +801,9 @@
   EXPECT_EQ(chrome_common_net::DNS_PROBE_STARTED, WaitForSentStatus());
   EXPECT_EQ(chrome_common_net::DNS_PROBE_STARTED, WaitForSentStatus());
 
-  // Checking the page runs the RunLoop, so make sure nothing hairy happens.
+  // PageContains runs the RunLoop, so make sure nothing hairy happens.
   EXPECT_EQ(0, pending_status_count());
-  ExpectDisplayingLocalErrorPage("DNS_PROBE_STARTED");
+  EXPECT_TRUE(PageContains("DNS_PROBE_STARTED"));
   EXPECT_EQ(0, pending_status_count());
 
   StartDelayedProbes(1);
@@ -835,19 +811,19 @@
   EXPECT_EQ(chrome_common_net::DNS_PROBE_FINISHED_INCONCLUSIVE,
             WaitForSentStatus());
 
-  // Checking the page runs the RunLoop, so make sure nothing hairy happens.
+  // PageContains runs the RunLoop, so make sure nothing hairy happens.
   EXPECT_EQ(0, pending_status_count());
-  ExpectDisplayingLocalErrorPage("ERR_NAME_NOT_RESOLVED");
+  EXPECT_TRUE(PageContains("NAME_NOT_RESOLVED"));
   EXPECT_EQ(0, pending_status_count());
 }
 
-// Test that pressing the stop button cancels loading corrections.
+// 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 corrections.  Disable that timeout for browser tests.
-IN_PROC_BROWSER_TEST_F(DnsProbeBrowserTest, CorrectionsLoadStopped) {
-  SetCorrectionServiceDelayRequests(true);
-  SetCorrectionServiceBroken(true);
+//                the Link Doctor page.  Disable that timeout for browser tests.
+IN_PROC_BROWSER_TEST_F(DnsProbeBrowserTest, LinkDoctorLoadStopped) {
+  SetLinkDoctorDelayRequests(true);
+  SetLinkDoctorBroken(true);
   SetMockDnsClientRules(MockDnsClientRule::TIMEOUT, MockDnsClientRule::TIMEOUT);
 
   NavigateToDnsError(1);
@@ -867,11 +843,12 @@
   EXPECT_EQ("", Title());
 }
 
-// Test that pressing the stop button cancels the load of corrections, and
-// receiving a probe result afterwards does not swap in a DNS error page.
-IN_PROC_BROWSER_TEST_F(DnsProbeBrowserTest, CorrectionsLoadStoppedSlowProbe) {
-  SetCorrectionServiceDelayRequests(true);
-  SetCorrectionServiceBroken(true);
+// Test that pressing the stop button cancels the load of the Link Doctor error
+// page, and receiving a probe result afterwards does not swap in a DNS error
+// page.
+IN_PROC_BROWSER_TEST_F(DnsProbeBrowserTest, LinkDoctorLoadStoppedSlowProbe) {
+  SetLinkDoctorDelayRequests(true);
+  SetLinkDoctorBroken(true);
   SetMockDnsClientRules(MockDnsClientRule::TIMEOUT, MockDnsClientRule::TIMEOUT);
 
   NavigateToDnsError(1);
@@ -896,7 +873,7 @@
 
 // Make sure probes don't run for subframe DNS errors.
 IN_PROC_BROWSER_TEST_F(DnsProbeBrowserTest, NoProbeInSubframe) {
-  SetCorrectionServiceBroken(false);
+  SetLinkDoctorBroken(false);
 
   const FilePath::CharType kIframeDnsErrorHtmlName[] =
       FILE_PATH_LITERAL("iframe_dns_error.html");
@@ -915,45 +892,45 @@
 
 // Make sure browser sends NOT_RUN properly when probes are disabled.
 IN_PROC_BROWSER_TEST_F(DnsProbeBrowserTest, ProbesDisabled) {
-  // Disable probes (And corrections).
+  // Disable probes (And Link Doctor).
   browser()->profile()->GetPrefs()->SetBoolean(
       prefs::kAlternateErrorPagesEnabled, false);
 
-  SetCorrectionServiceBroken(true);
+  SetLinkDoctorBroken(true);
   SetMockDnsClientRules(MockDnsClientRule::TIMEOUT, MockDnsClientRule::TIMEOUT);
 
   NavigateToDnsError(1);
 
   EXPECT_EQ(chrome_common_net::DNS_PROBE_NOT_RUN, WaitForSentStatus());
 
-  // Checking the page runs the RunLoop, so make sure nothing hairy happens.
+  // PageContains runs the RunLoop, so make sure nothing hairy happens.
   EXPECT_EQ(0, pending_status_count());
-  ExpectDisplayingLocalErrorPage("ERR_NAME_NOT_RESOLVED");
+  EXPECT_TRUE(PageContains("NAME_NOT_RESOLVED"));
 }
 
-// Test the case that corrections are disabled, but DNS probes are enabled.
-// This is the case with Chromium builds.
-IN_PROC_BROWSER_TEST_F(DnsProbeBrowserTest, CorrectionsDisabled) {
-  // Disable corrections.
+// 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 correction service should work if any are made, so the test
-  // fails if that happens unexpectedly.
-  SetCorrectionServiceBroken(false);
-  // Normally disabling corrections disables DNS probes, so force DNS probes
+  // 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 corrections are disabled.
+  // Just one commit and one sent status, since the Link Doctor is disabled.
   NavigateToDnsError(1);
   EXPECT_EQ(chrome_common_net::DNS_PROBE_STARTED, WaitForSentStatus());
 
-  // Checking the page runs the RunLoop, so make sure nothing hairy happens.
+  // PageContains runs the RunLoop, so make sure nothing hairy happens.
   EXPECT_EQ(0, pending_status_count());
-  ExpectDisplayingLocalErrorPage("DNS_PROBE_STARTED");
+  EXPECT_TRUE(PageContains("DNS_PROBE_STARTED"));
   EXPECT_EQ(0, pending_status_count());
 
   StartDelayedProbes(1);
@@ -961,28 +938,28 @@
   EXPECT_EQ(chrome_common_net::DNS_PROBE_FINISHED_INCONCLUSIVE,
             WaitForSentStatus());
   EXPECT_EQ(0, pending_status_count());
-  ExpectDisplayingLocalErrorPage("ERR_NAME_NOT_RESOLVED");
+  EXPECT_TRUE(PageContains("NAME_NOT_RESOLVED"));
 }
 
-// Test incognito mode.  Corrections should be disabled, but DNS probes are
+// Test incognito mode.  Link Doctor should be disabled, but DNS probes are
 // still enabled.
 IN_PROC_BROWSER_TEST_F(DnsProbeBrowserTest, Incognito) {
-  // Requests to the correction service should work if any are made, so the test
-  // will fail if one is requested unexpectedly.
-  SetCorrectionServiceBroken(false);
+  // 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 corrections are disabled.
+  // Just one commit and one sent status, since the Link Doctor is disabled.
   NavigateToDnsError(1);
   EXPECT_EQ(chrome_common_net::DNS_PROBE_STARTED, WaitForSentStatus());
 
-  // Checking the page runs the RunLoop, so make sure nothing hairy happens.
+  // PageContains runs the RunLoop, so make sure nothing hairy happens.
   EXPECT_EQ(0, pending_status_count());
-  ExpectDisplayingLocalErrorPage("DNS_PROBE_STARTED");
+  EXPECT_TRUE(PageContains("DNS_PROBE_STARTED"));
   EXPECT_EQ(0, pending_status_count());
 
   StartDelayedProbes(1);
@@ -990,7 +967,7 @@
   EXPECT_EQ(chrome_common_net::DNS_PROBE_FINISHED_INCONCLUSIVE,
             WaitForSentStatus());
   EXPECT_EQ(0, pending_status_count());
-  ExpectDisplayingLocalErrorPage("ERR_NAME_NOT_RESOLVED");
+  EXPECT_TRUE(PageContains("NAME_NOT_RESOLVED"));
 }
 
 }  // namespace