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

chrome/browser/extensions/content_script_apitest.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 <stddef.h>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
@@ skipping 233 matching lines @@
                              public testing::WithParamInterface<TestConfig> {
  public:
   void SetUpCommandLine(base::CommandLine* command_line) override {
     ExtensionApiTest::SetUpCommandLine(command_line);
     command_line->AppendSwitchASCII(
         switches::kYieldBetweenContentScriptRuns,
         (GetParam() == TestConfig::kYieldBetweenContentScriptRunsEnabled)
             ? "1"
             : "0");
   }
+
+  void SetUpOnMainThread() override {
+    ExtensionApiTest::SetUpOnMainThread();
+    host_resolver()->AddRule("*", "127.0.0.1");
+  }
 };
 
 IN_PROC_BROWSER_TEST_P(ContentScriptApiTest, ContentScriptAllFrames) {
   ASSERT_TRUE(StartEmbeddedTestServer());
   ASSERT_TRUE(RunExtensionTest("content_scripts/all_frames")) << message_;
 }
 
 IN_PROC_BROWSER_TEST_P(ContentScriptApiTest, ContentScriptAboutBlankIframes) {
   const char* testArg =
       GetParam() == TestConfig::kYieldBetweenContentScriptRunsEnabled
@@ skipping 48 matching lines @@
   ASSERT_TRUE(StartEmbeddedTestServer());
   ASSERT_TRUE(RunExtensionTest("content_scripts/isolated_world1")) << message_;
 
   // Now load a different extension, inject into same page, verify worlds aren't
   // shared.
   ASSERT_TRUE(RunExtensionTest("content_scripts/isolated_world2")) << message_;
 }
 
 IN_PROC_BROWSER_TEST_P(ContentScriptApiTest,
                        ContentScriptIgnoreHostPermissions) {
-  host_resolver()->AddRule("a.com", "127.0.0.1");
-  host_resolver()->AddRule("b.com", "127.0.0.1");
   ASSERT_TRUE(StartEmbeddedTestServer());
   ASSERT_TRUE(RunExtensionTest(
       "content_scripts/dont_match_host_permissions")) << message_;
 }
 
 // crbug.com/39249 -- content scripts js should not run on view source.
 IN_PROC_BROWSER_TEST_P(ContentScriptApiTest, ContentScriptViewSource) {
   ASSERT_TRUE(StartEmbeddedTestServer());
   ASSERT_TRUE(RunExtensionTest("content_scripts/view_source")) << message_;
 }
 
 // crbug.com/126257 -- content scripts should not get injected into other
 // extensions.
 IN_PROC_BROWSER_TEST_P(ContentScriptApiTest, ContentScriptOtherExtensions) {
-  host_resolver()->AddRule("a.com", "127.0.0.1");
   ASSERT_TRUE(StartEmbeddedTestServer());
   // First, load extension that sets up content script.
   ASSERT_TRUE(RunExtensionTest("content_scripts/other_extensions/injector"))
       << message_;
   // Then load targeted extension to make sure its content isn't changed.
   ASSERT_TRUE(RunExtensionTest("content_scripts/other_extensions/victim"))
       << message_;
 }
 
 class ContentScriptCssInjectionTest : public ExtensionApiTest {
  protected:
   // TODO(rdevlin.cronin): Make a testing switch that looks like FeatureSwitch,
   // but takes in an optional value so that we don't have to do this.
   void SetUpCommandLine(base::CommandLine* command_line) override {
     ExtensionApiTest::SetUpCommandLine(command_line);
     // We change the Webstore URL to be http://cws.com. We need to do this so
     // we can check that css injection is not allowed on the webstore (which
     // could lead to spoofing). Unfortunately, host_resolver seems to have
     // problems with redirecting "chrome.google.com" to the test server, so we
     // can't use the real Webstore's URL. If this changes, we could clean this
     // up.
     command_line->AppendSwitchASCII(
         ::switches::kAppsGalleryURL,
         base::StringPrintf("http://%s", kWebstoreDomain));
   }
+
+  void SetUpOnMainThread() override {
+    ExtensionApiTest::SetUpOnMainThread();
+    host_resolver()->AddRule("*", "127.0.0.1");
+  }
 };
 
 IN_PROC_BROWSER_TEST_P(ContentScriptApiTest,
                        ContentScriptDuplicateScriptInjection) {
-  host_resolver()->AddRule("maps.google.com", "127.0.0.1");
   ASSERT_TRUE(StartEmbeddedTestServer());
 
   GURL url(
       base::StringPrintf("http://maps.google.com:%i/extensions/test_file.html",
                          embedded_test_server()->port()));
 
   ASSERT_TRUE(LoadExtension(test_data_dir_.AppendASCII(
       "content_scripts/duplicate_script_injection")));
 
   ui_test_utils::NavigateToURL(browser(), url);
@@ skipping 17 matching lines @@
       "window.domAutomationController.send("
       "document.getElementsByClassName('injected-twice')"
       ".length == 2)",
       &scripts_injected_twice));
   ASSERT_TRUE(scripts_injected_twice);
 }
 
 IN_PROC_BROWSER_TEST_F(ContentScriptCssInjectionTest,
                        ContentScriptInjectsStyles) {
   ASSERT_TRUE(StartEmbeddedTestServer());
-  host_resolver()->AddRule(kWebstoreDomain, "127.0.0.1");
 
   ASSERT_TRUE(LoadExtension(test_data_dir_.AppendASCII("content_scripts")
                                           .AppendASCII("css_injection")));
 
   // CSS injection should be allowed on an aribitrary web page.
   GURL url =
       embedded_test_server()->GetURL("/extensions/test_file_with_body.html");
   EXPECT_TRUE(CheckStyleInjection(browser(), url, true));
 
   // The loaded extension has an exclude match for "extensions/test_file.html",
@@ skipping 76 matching lines @@
 // Flaky on Windows. http://crbug.com/248418
 #if defined(OS_WIN)
 #define MAYBE_ContentScriptPermissionsApi DISABLED_ContentScriptPermissionsApi
 #else
 #define MAYBE_ContentScriptPermissionsApi ContentScriptPermissionsApi
 #endif
 IN_PROC_BROWSER_TEST_P(ContentScriptApiTest,
                        MAYBE_ContentScriptPermissionsApi) {
   extensions::PermissionsRequestFunction::SetIgnoreUserGestureForTests(true);
   extensions::PermissionsRequestFunction::SetAutoConfirmForTests(true);
-  host_resolver()->AddRule("*.com", "127.0.0.1");
   ASSERT_TRUE(StartEmbeddedTestServer());
   ASSERT_TRUE(RunExtensionTest("content_scripts/permissions")) << message_;
 }
 
 IN_PROC_BROWSER_TEST_F(ExtensionApiTestWithManagementPolicy,
                        ContentScriptPolicy) {
   // Set enterprise policy to block injection to policy specified host.
   {
     ExtensionManagementPolicyUpdater pref(&policy_provider_);
     pref.AddRuntimeBlockedHost("*", "*://example.com/*");
   }
-  host_resolver()->AddRule("*.com", "127.0.0.1");
   ASSERT_TRUE(StartEmbeddedTestServer());
   ASSERT_TRUE(RunExtensionTest("content_scripts/policy")) << message_;
 }
 
 IN_PROC_BROWSER_TEST_P(ContentScriptApiTest, ContentScriptBypassPageCSP) {
   ASSERT_TRUE(StartEmbeddedTestServer());
   ASSERT_TRUE(RunExtensionTest("content_scripts/bypass_page_csp")) << message_;
 }
 
 // Test that when injecting a blocking content script, other scripts don't run
@@ skipping 159 matching lines @@
   ui_test_utils::NavigateToURLWithDisposition(
       browser(), embedded_test_server()->GetURL("/empty.html"),
       WindowOpenDisposition::CURRENT_TAB,
       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(listener.was_satisfied());
 }
 
 IN_PROC_BROWSER_TEST_P(ContentScriptApiTest,
                        DontInjectContentScriptsInBackgroundPages) {
-  host_resolver()->AddRule("a.com", "127.0.0.1");
   ASSERT_TRUE(StartEmbeddedTestServer());
   // Load two extensions, one with an iframe to a.com in its background page,
   // the other, a content script for a.com. The latter should never be able to
   // inject the script, because scripts aren't allowed to run on foreign
   // extensions' pages.
   base::FilePath data_dir = test_data_dir_.AppendASCII("content_scripts");
   ExtensionTestMessageListener iframe_loaded_listener("iframe loaded", false);
   ExtensionTestMessageListener content_script_listener("script injected",
                                                        false);
   LoadExtension(data_dir.AppendASCII("script_a_com"));
   LoadExtension(data_dir.AppendASCII("background_page_iframe"));
   iframe_loaded_listener.WaitUntilSatisfied();
   EXPECT_FALSE(content_script_listener.was_satisfied());
 }
 
 INSTANTIATE_TEST_CASE_P(
     ContentScriptApiTests,
     ContentScriptApiTest,
     testing::Values(TestConfig::kDefault,
                     TestConfig::kYieldBetweenContentScriptRunsEnabled));
 
 }  // namespace extensions