Update some host_resolver()->AddRules in chrome/browser.

chrome/browser/ssl/ssl_browser_tests.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 <utility>
 
 #include "base/base_switches.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
@@ skipping 342 matching lines @@
   }
 
   void SetUpCommandLine(base::CommandLine* command_line) override {
     // Browser will both run and display insecure content.
     command_line->AppendSwitch(switches::kAllowRunningInsecureContent);
     // Use process-per-site so that navigating to a same-site page in a
     // new tab will use the same process.
     command_line->AppendSwitch(switches::kProcessPerSite);
   }
 
+  void SetUpOnMainThread() override {
+    host_resolver()->AddRule("*", "127.0.0.1");
+  }
+
   void CheckAuthenticatedState(WebContents* tab,
                                int expected_authentication_state) {
     CheckSecurityState(tab, CertError::NONE, security_state::SECURE,
                        expected_authentication_state);
   }
 
   void CheckUnauthenticatedState(WebContents* tab,
                                  int expected_authentication_state) {
     CheckSecurityState(tab, CertError::NONE, security_state::NONE,
                        expected_authentication_state);
@@ skipping 1369 matching lines @@
     DISABLED_TestDisplaysInsecureContentLoadedFromJS
 #else
 #define MAYBE_TestDisplaysInsecureContentLoadedFromJS \
     TestDisplaysInsecureContentLoadedFromJS
 #endif
 IN_PROC_BROWSER_TEST_F(SSLUITest,
                        MAYBE_TestDisplaysInsecureContentLoadedFromJS) {
   ASSERT_TRUE(embedded_test_server()->Start());
   ASSERT_TRUE(https_server_.Start());
 
-  host_resolver()->AddRule("example.test",
-                           https_server_.GetURL("/title1.html").host());
-
   net::HostPortPair replacement_pair = embedded_test_server()->host_port_pair();
   replacement_pair.set_host("example.test");
 
   std::string replacement_path;
   GetFilePathWithHostAndPortReplacement(
       "/ssl/page_with_dynamic_insecure_content.html",
       replacement_pair, &replacement_path);
   ui_test_utils::NavigateToURL(browser(), https_server_.GetURL(
       replacement_path));
 
@@ skipping 379 matching lines @@
 
 class SSLUITestWaitForDOMNotification : public SSLUITestIgnoreCertErrors,
                                         public content::NotificationObserver {
  public:
   SSLUITestWaitForDOMNotification()
       : SSLUITestIgnoreCertErrors(), run_loop_(nullptr) {}
 
   ~SSLUITestWaitForDOMNotification() override { registrar_.RemoveAll(); };
 
   void SetUpOnMainThread() override {
+    SSLUITestIgnoreCertErrors::SetUpOnMainThread();
     registrar_.Add(this, content::NOTIFICATION_DOM_OPERATION_RESPONSE,
                    content::NotificationService::AllSources());
   }
 
   void set_expected_notification(const std::string& expected_notification) {
     expected_notification_ = expected_notification;
   }
 
   void set_run_loop(base::RunLoop* run_loop) { run_loop_ = run_loop; }
 
@@ skipping 18 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(SSLUITestWaitForDOMNotification);
 };
 
 // Tests that a mixed resource which includes HTTP in the redirect chain
 // is marked as mixed content, even if the end result is HTTPS.
 IN_PROC_BROWSER_TEST_F(SSLUITestWaitForDOMNotification,
                        TestMixedContentWithHTTPInRedirectChain) {
   ASSERT_TRUE(embedded_test_server()->Start());
   ASSERT_TRUE(https_server_.Start());
 
-  host_resolver()->AddRule("*", embedded_test_server()->GetURL("/").host());
-
   ui_test_utils::NavigateToURL(browser(),
                                https_server_.GetURL("/ssl/blank_page.html"));
   WebContents* tab = browser()->tab_strip_model()->GetActiveWebContents();
   CheckAuthenticatedState(tab, AuthState::NONE);
 
   // Construct a URL which will be dynamically added to the page as an
   // image. The URL redirects through HTTP, though it ends up at an
   // HTTPS resource.
   GURL http_url = embedded_test_server()->GetURL("/server-redirect?");
   GURL::Replacements http_url_replacements;
@@ skipping 59 matching lines @@
 // From a good HTTPS top frame:
 // - navigate to an OK HTTPS frame
 // - navigate to a bad HTTPS (expect unsafe content and filtered frame), then
 //   back
 // - navigate to HTTP (expect insecure content), then back
 IN_PROC_BROWSER_TEST_F(SSLUITest, TestGoodFrameNavigation) {
   ASSERT_TRUE(embedded_test_server()->Start());
   ASSERT_TRUE(https_server_.Start());
   ASSERT_TRUE(https_server_expired_.Start());
 
-  // Make sure to add this hostname to the resolver so that it's not blocked
-  // (browser_test_base.cc has a resolver that blocks all non-local hostnames
-  // by default to ensure tests don't hit the network). This is critical to do
-  // because for PlzNavigate the request would otherwise get cancelled in the
-  // browser before the renderer sees it.
-  host_resolver()->AddRule(
-      "example.test",
-      embedded_test_server()->GetURL("/title1.html").host());
+  // SetUpOnMainThread adds this hostname to the resolver so that it's not
+  // blocked (browser_test_base.cc has a resolver that blocks all non-local
+  // hostnames by default to ensure tests don't hit the network). This is
+  // critical to do because for PlzNavigate the request would otherwise get
+  // cancelled in the browser before the renderer sees it.
 
   std::string top_frame_path;
   GetTopFramePath(*embedded_test_server(), https_server_, https_server_expired_,
                   &top_frame_path);
 
   WebContents* tab = browser()->tab_strip_model()->GetActiveWebContents();
   ui_test_utils::NavigateToURL(browser(),
                                https_server_.GetURL(top_frame_path));
 
   CheckAuthenticatedState(tab, AuthState::NONE);
@@ skipping 789 matching lines @@
             "<SSLNetworkTimeBrowserTestFieldTrial");
     command_line->AppendSwitchASCII(
         switches::kForceFieldTrials,
         "SSLNetworkTimeBrowserTestFieldTrial/Enabled/");
     command_line->AppendSwitchASCII(
         variations::switches::kForceFieldTrialParams,
         "SSLNetworkTimeBrowserTestFieldTrial.Enabled:FetchBehavior/"
         "on-demand-only");
   }
 
-  void SetUpOnMainThread() override { SetUpNetworkTimeServer(); }
+  void SetUpOnMainThread() override {
+    SSLUITest::SetUpOnMainThread();
+    SetUpNetworkTimeServer();
+  }
 
   void TearDownOnMainThread() override {
     content::BrowserThread::PostTask(content::BrowserThread::IO, FROM_HERE,
                                      base::Bind(&CleanUpOnIOThread));
   }
 
  protected:
   void SetUpNetworkTimeServer() {
     // Install the URL interceptor that serves delayed network time responses.
     interceptor_ = new DelayedNetworkTimeInterceptor();
@@ skipping 297 matching lines @@
 class CommonNameMismatchBrowserTest : public CertVerifierBrowserTest {
  public:
   CommonNameMismatchBrowserTest() : CertVerifierBrowserTest() {}
   ~CommonNameMismatchBrowserTest() override {}
 
   void SetUpCommandLine(base::CommandLine* command_line) override {
     // Enable finch experiment for SSL common name mismatch handling.
     command_line->AppendSwitchASCII(switches::kForceFieldTrials,
                                     "SSLCommonNameMismatchHandling/Enabled/");
   }
+
+  void SetUpOnMainThread() override {
+    CertVerifierBrowserTest::SetUpOnMainThread();
+    host_resolver()->AddRule("*", "127.0.0.1");
+  }
 };
 
 // Visit the URL www.mail.example.com on a server that presents a valid
 // certificate for mail.example.com. Verify that the page navigates to
 // mail.example.com.
 IN_PROC_BROWSER_TEST_F(CommonNameMismatchBrowserTest,
                        ShouldShowWWWSubdomainMismatchInterstitial) {
   net::EmbeddedTestServer https_server_example_domain_(
       net::EmbeddedTestServer::TYPE_HTTPS);
   https_server_example_domain_.ServeFilesFromSourceDirectory(
       base::FilePath(kDocRoot));
   ASSERT_TRUE(https_server_example_domain_.Start());
 
-  host_resolver()->AddRule(
-      "mail.example.com", https_server_example_domain_.host_port_pair().host());
-  host_resolver()->AddRule(
-      "www.mail.example.com",
-      https_server_example_domain_.host_port_pair().host());
-
   scoped_refptr<net::X509Certificate> cert =
       https_server_example_domain_.GetCertificate();
 
   // Use the "spdy_pooling.pem" cert which has "mail.example.com"
   // as one of its SANs.
   net::CertVerifyResult verify_result;
   verify_result.verified_cert =
       net::ImportCertFromFile(net::GetTestCertsDirectory(), "spdy_pooling.pem");
   verify_result.cert_status = net::CERT_STATUS_COMMON_NAME_INVALID;
 
@@ skipping 40 matching lines @@
 // Visit the URL example.org on a server that presents a valid certificate
 // for www.example.org. Verify that the page redirects to www.example.org.
 IN_PROC_BROWSER_TEST_F(CommonNameMismatchBrowserTest,
                        CheckWWWSubdomainMismatchInverse) {
   net::EmbeddedTestServer https_server_example_domain_(
       net::EmbeddedTestServer::TYPE_HTTPS);
   https_server_example_domain_.ServeFilesFromSourceDirectory(
       base::FilePath(kDocRoot));
   ASSERT_TRUE(https_server_example_domain_.Start());
 
-  host_resolver()->AddRule(
-      "www.example.org", https_server_example_domain_.host_port_pair().host());
-  host_resolver()->AddRule(
-      "example.org", https_server_example_domain_.host_port_pair().host());
-
   scoped_refptr<net::X509Certificate> cert =
       https_server_example_domain_.GetCertificate();
 
   net::CertVerifyResult verify_result;
   verify_result.verified_cert =
       net::ImportCertFromFile(net::GetTestCertsDirectory(), "spdy_pooling.pem");
   verify_result.cert_status = net::CERT_STATUS_COMMON_NAME_INVALID;
 
   mock_cert_verifier()->AddResultForCertAndHost(
       cert.get(), "example.org", verify_result,
@@ skipping 34 matching lines @@
 //   indefinitely (also because the timer has a long timeout).
 // - Stopping the page load shouldn't result in any interstitials.
 IN_PROC_BROWSER_TEST_F(CommonNameMismatchBrowserTest,
                        InterstitialStopNavigationWhileLoading) {
   net::EmbeddedTestServer https_server_example_domain_(
       net::EmbeddedTestServer::TYPE_HTTPS);
   https_server_example_domain_.ServeFilesFromSourceDirectory(
       base::FilePath(kDocRoot));
   ASSERT_TRUE(https_server_example_domain_.Start());
 
-  host_resolver()->AddRule(
-      "mail.example.com", https_server_example_domain_.host_port_pair().host());
-  host_resolver()->AddRule(
-      "www.mail.example.com",
-      https_server_example_domain_.host_port_pair().host());
-
   scoped_refptr<net::X509Certificate> cert =
       https_server_example_domain_.GetCertificate();
 
   net::CertVerifyResult verify_result;
   verify_result.verified_cert =
       net::ImportCertFromFile(net::GetTestCertsDirectory(), "spdy_pooling.pem");
   verify_result.cert_status = net::CERT_STATUS_COMMON_NAME_INVALID;
 
   mock_cert_verifier()->AddResultForCertAndHost(
       cert.get(), "www.mail.example.com", verify_result,
@@ skipping 43 matching lines @@
 // Same as above, but instead of stopping, the loading page is reloaded. The end
 // result is the same. (i.e. page load stops, no interstitials shown)
 IN_PROC_BROWSER_TEST_F(CommonNameMismatchBrowserTest,
                        InterstitialReloadNavigationWhileLoading) {
   net::EmbeddedTestServer https_server_example_domain_(
       net::EmbeddedTestServer::TYPE_HTTPS);
   https_server_example_domain_.ServeFilesFromSourceDirectory(
       base::FilePath(kDocRoot));
   ASSERT_TRUE(https_server_example_domain_.Start());
 
-  host_resolver()->AddRule(
-      "mail.example.com", https_server_example_domain_.host_port_pair().host());
-  host_resolver()->AddRule(
-      "www.mail.example.com",
-      https_server_example_domain_.host_port_pair().host());
-
   scoped_refptr<net::X509Certificate> cert =
       https_server_example_domain_.GetCertificate();
 
   net::CertVerifyResult verify_result;
   verify_result.verified_cert =
       net::ImportCertFromFile(net::GetTestCertsDirectory(), "spdy_pooling.pem");
   verify_result.cert_status = net::CERT_STATUS_COMMON_NAME_INVALID;
 
   mock_cert_verifier()->AddResultForCertAndHost(
       cert.get(), "www.mail.example.com", verify_result,
@@ skipping 41 matching lines @@
 // Same as above, but instead of reloading, the page is navigated away. The
 // new page should load, and no interstitials should be shown.
 IN_PROC_BROWSER_TEST_F(CommonNameMismatchBrowserTest,
                        InterstitialNavigateAwayWhileLoading) {
   net::EmbeddedTestServer https_server_example_domain_(
       net::EmbeddedTestServer::TYPE_HTTPS);
   https_server_example_domain_.ServeFilesFromSourceDirectory(
       base::FilePath(kDocRoot));
   ASSERT_TRUE(https_server_example_domain_.Start());
 
-  host_resolver()->AddRule(
-      "mail.example.com", https_server_example_domain_.host_port_pair().host());
-  host_resolver()->AddRule(
-      "www.mail.example.com",
-      https_server_example_domain_.host_port_pair().host());
-
   scoped_refptr<net::X509Certificate> cert =
       https_server_example_domain_.GetCertificate();
 
   net::CertVerifyResult verify_result;
   verify_result.verified_cert =
       net::ImportCertFromFile(net::GetTestCertsDirectory(), "spdy_pooling.pem");
   verify_result.cert_status = net::CERT_STATUS_COMMON_NAME_INVALID;
 
   mock_cert_verifier()->AddResultForCertAndHost(
       cert.get(), "www.mail.example.com", verify_result,
@@ skipping 753 matching lines @@
 
 // Visit a page over https that contains a frame with a redirect.
 
 // XMLHttpRequest insecure content in synchronous mode.
 
 // XMLHttpRequest insecure content in asynchronous mode.
 
 // XMLHttpRequest over bad ssl in synchronous mode.
 
 // XMLHttpRequest over OK ssl in synchronous mode.