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

chrome/browser/extensions/extension_messages_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 <stdint.h>
 
 #include <memory>
 #include <utility>
 
@@ skipping 106 matching lines @@
         GURL("http://b.com/")));
     event_router->BroadcastEvent(BuildEvent(
         BuildEventArguments(true, "last message"),
         content::Source<Profile>(source).ptr(),
         GURL()));
   }
 
   content::NotificationRegistrar registrar_;
 };
 
+class MessagingApiTest : public ExtensionApiTest {
+ public:
+  void SetUpOnMainThread() override {
+    ExtensionApiTest::SetUpOnMainThread();
+    host_resolver()->AddRule("*", "127.0.0.1");
+    ASSERT_TRUE(StartEmbeddedTestServer());
+  }
+};
+
 // Tests that message passing between extensions and content scripts works.
 #if defined(MEMORY_SANITIZER) || defined(OS_MACOSX)
 // https://crbug.com/582185 - flakily times out on Linux/CrOS MSAN
 // https://crbug.com/681705 - flakily times out on mac_chromium_rel_ng
 #define MAYBE_Messaging DISABLED_Messaging
 #else
 #define MAYBE_Messaging Messaging
 #endif
-IN_PROC_BROWSER_TEST_F(ExtensionApiTest, MAYBE_Messaging) {
-  ASSERT_TRUE(StartEmbeddedTestServer());
+IN_PROC_BROWSER_TEST_F(MessagingApiTest, MAYBE_Messaging) {
   ASSERT_TRUE(RunExtensionTest("messaging/connect")) << message_;
 }
 
-IN_PROC_BROWSER_TEST_F(ExtensionApiTest, MessagingCrash) {
-  ASSERT_TRUE(StartEmbeddedTestServer());
+IN_PROC_BROWSER_TEST_F(MessagingApiTest, MessagingCrash) {
   ExtensionTestMessageListener ready_to_crash("ready_to_crash", false);
   ASSERT_TRUE(LoadExtension(
           test_data_dir_.AppendASCII("messaging/connect_crash")));
   ui_test_utils::NavigateToURL(
       browser(), embedded_test_server()->GetURL("/extensions/test_file.html"));
   content::WebContents* tab =
       browser()->tab_strip_model()->GetActiveWebContents();
   EXPECT_TRUE(ready_to_crash.WaitUntilSatisfied());
 
   ResultCatcher catcher;
   CrashTab(tab);
   EXPECT_TRUE(catcher.GetNextResult());
 }
 
 // Tests that message passing from one extension to another works.
-IN_PROC_BROWSER_TEST_F(ExtensionApiTest, MessagingExternal) {
+IN_PROC_BROWSER_TEST_F(MessagingApiTest, MessagingExternal) {
   ASSERT_TRUE(LoadExtension(
       test_data_dir_.AppendASCII("..").AppendASCII("good")
                     .AppendASCII("Extensions")
                     .AppendASCII("bjafgdebaacbbbecmhlhpofkepfkgcpa")
                     .AppendASCII("1.0")));
 
   ASSERT_TRUE(RunExtensionTest("messaging/connect_external")) << message_;
 }
 
 // Tests that a content script can exchange messages with a tab even if there is
 // no background page.
-IN_PROC_BROWSER_TEST_F(ExtensionApiTest, MessagingNoBackground) {
-  ASSERT_TRUE(StartEmbeddedTestServer());
+IN_PROC_BROWSER_TEST_F(MessagingApiTest, MessagingNoBackground) {
   ASSERT_TRUE(RunExtensionSubtest("messaging/connect_nobackground",
                                   "page_in_main_frame.html")) << message_;
 }
 
 // Tests that messages with event_urls are only passed to extensions with
 // appropriate permissions.
-IN_PROC_BROWSER_TEST_F(ExtensionApiTest, MessagingEventURL) {
+IN_PROC_BROWSER_TEST_F(MessagingApiTest, MessagingEventURL) {
   MessageSender sender;
   ASSERT_TRUE(RunExtensionTest("messaging/event_url")) << message_;
 }
 
 // Tests that messages cannot be received from the same frame.
-IN_PROC_BROWSER_TEST_F(ExtensionApiTest, MessagingBackgroundOnly) {
+IN_PROC_BROWSER_TEST_F(MessagingApiTest, MessagingBackgroundOnly) {
   ASSERT_TRUE(RunExtensionTest("messaging/background_only")) << message_;
 }
 
 // Tests whether an extension in an interstitial page can send messages to the
 // background page.
-IN_PROC_BROWSER_TEST_F(ExtensionApiTest, MessagingInterstitial) {
+IN_PROC_BROWSER_TEST_F(MessagingApiTest, MessagingInterstitial) {
   net::EmbeddedTestServer https_server(net::EmbeddedTestServer::TYPE_HTTPS);
   https_server.SetSSLConfig(net::EmbeddedTestServer::CERT_MISMATCHED_NAME);
   ASSERT_TRUE(https_server.Start());
 
   ASSERT_TRUE(RunExtensionSubtest("messaging/interstitial_component",
                                   https_server.base_url().spec(),
                                   kFlagLoadAsComponent)) << message_;
 }
 
 // XXX(kalman): All web messaging tests disabled on windows due to extreme
 // flakiness. See http://crbug.com/350517.
 #if !defined(OS_WIN)
 
 // Tests externally_connectable between a web page and an extension.
 //
 // TODO(kalman): Test between extensions. This is already tested in this file,
 // but not with externally_connectable set in the manifest.
 //
 // TODO(kalman): Test with host permissions.
-class ExternallyConnectableMessagingTest : public ExtensionApiTest {
+class ExternallyConnectableMessagingTest : public MessagingApiTest {
  protected:
   // Result codes from the test. These must match up with |results| in
   // c/t/d/extensions/api_test/externally_connectable/assertions.json.
   enum Result {
     OK = 0,
     NAMESPACE_NOT_DEFINED = 1,
     FUNCTION_NOT_DEFINED = 2,
     COULD_NOT_ESTABLISH_CONNECTION_ERROR = 3,
     OTHER_ERROR = 4,
     INCORRECT_RESPONSE_SENDER = 5,
@@ skipping 201 matching lines @@
                                  "      \"web_url\": \"%s\""
                                  "    }\n"
                                  "  }\n"
                                  "}",
                                  chromium_org_url().spec().c_str(),
                                  chromium_org_url().spec().c_str()));
     CHECK(hosted_app.get());
     return hosted_app;
   }
 
-  void InitializeTestServer() {
+  void SetUpOnMainThread() override {
     base::FilePath test_data;
     EXPECT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &test_data));
     embedded_test_server()->ServeFilesFromDirectory(test_data.AppendASCII(
         "extensions/api_test/messaging/externally_connectable/sites"));
-    ASSERT_TRUE(embedded_test_server()->Start());
-    host_resolver()->AddRule("*", embedded_test_server()->base_url().host());
+    MessagingApiTest::SetUpOnMainThread();
   }
 
   const char* close_background_message() {
     return "closeBackgroundPage";
   }
 
  private:
   scoped_refptr<const Extension> LoadExtensionIntoDir(
       TestExtensionDir* dir,
       const std::string& manifest,
@@ skipping 65 matching lines @@
   }
 
   TestExtensionDir web_connectable_dir_extension_;
   TestExtensionDir web_connectable_dir_app_;
   TestExtensionDir not_connectable_dir_;
   TestExtensionDir tls_channel_id_connectable_dir_;
   TestExtensionDir hosted_app_dir_;
 };
 
 IN_PROC_BROWSER_TEST_F(ExternallyConnectableMessagingTest, NotInstalled) {
-  InitializeTestServer();
-
   scoped_refptr<const Extension> extension =
       ExtensionBuilder()
           .SetID("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")
           .SetManifest(DictionaryBuilder()
                            .Set("name", "Fake extension")
                            .Set("version", "1")
                            .Set("manifest_version", 2)
                            .Build())
           .Build();
 
   ui_test_utils::NavigateToURL(browser(), chromium_org_url());
   EXPECT_EQ(NAMESPACE_NOT_DEFINED,
             CanConnectAndSendMessagesToMainFrame(extension.get()));
   EXPECT_FALSE(AreAnyNonWebApisDefinedForMainFrame());
 
   ui_test_utils::NavigateToURL(browser(), google_com_url());
   EXPECT_EQ(NAMESPACE_NOT_DEFINED,
             CanConnectAndSendMessagesToMainFrame(extension.get()));
   EXPECT_FALSE(AreAnyNonWebApisDefinedForMainFrame());
 }
 
 // Tests two extensions on the same sites: one web connectable, one not.
 IN_PROC_BROWSER_TEST_F(ExternallyConnectableMessagingTest,
                        WebConnectableAndNotConnectable) {
-  InitializeTestServer();
-
   // Install the web connectable extension. chromium.org can connect to it,
   // google.com can't.
   scoped_refptr<const Extension> chromium_connectable =
       LoadChromiumConnectableExtension();
 
   ui_test_utils::NavigateToURL(browser(), chromium_org_url());
   EXPECT_EQ(OK,
             CanConnectAndSendMessagesToMainFrame(chromium_connectable.get()));
   EXPECT_FALSE(AreAnyNonWebApisDefinedForMainFrame());
 
@@ skipping 15 matching lines @@
 
   ui_test_utils::NavigateToURL(browser(), google_com_url());
   EXPECT_EQ(NAMESPACE_NOT_DEFINED,
             CanConnectAndSendMessagesToMainFrame(not_connectable.get()));
   EXPECT_FALSE(AreAnyNonWebApisDefinedForMainFrame());
 }
 
 // See http://crbug.com/297866
 IN_PROC_BROWSER_TEST_F(ExternallyConnectableMessagingTest,
                        DISABLED_BackgroundPageClosesOnMessageReceipt) {
-  InitializeTestServer();
-
   // Install the web connectable extension.
   scoped_refptr<const Extension> chromium_connectable =
       LoadChromiumConnectableExtension();
 
   ui_test_utils::NavigateToURL(browser(), chromium_org_url());
   // If the background page closes after receipt of the message, it will still
   // reply to this message...
   EXPECT_EQ(OK,
             CanConnectAndSendMessagesToMainFrame(chromium_connectable.get(),
                                                  close_background_message()));
   // and be re-opened by receipt of a subsequent message.
   EXPECT_EQ(OK,
             CanConnectAndSendMessagesToMainFrame(chromium_connectable.get()));
 }
 
 // Tests a web connectable extension that doesn't receive TLS channel id.
 IN_PROC_BROWSER_TEST_F(ExternallyConnectableMessagingTest,
                        WebConnectableWithoutTlsChannelId) {
-  InitializeTestServer();
-
   // Install the web connectable extension. chromium.org can connect to it,
   // google.com can't.
   scoped_refptr<const Extension> chromium_connectable =
       LoadChromiumConnectableExtension();
   ASSERT_TRUE(chromium_connectable.get());
 
   ui_test_utils::NavigateToURL(browser(), chromium_org_url());
   // The web connectable extension doesn't request the TLS channel ID, so it
   // doesn't get it, whether or not the page asks for it.
   EXPECT_EQ(std::string(),
             GetTlsChannelIdFromPortConnect(chromium_connectable.get(), false));
   EXPECT_EQ(std::string(),
             GetTlsChannelIdFromSendMessage(chromium_connectable.get(), true));
   EXPECT_EQ(std::string(),
             GetTlsChannelIdFromPortConnect(chromium_connectable.get(), false));
   EXPECT_EQ(std::string(),
             GetTlsChannelIdFromSendMessage(chromium_connectable.get(), true));
 }
 
 // Tests a web connectable extension that receives TLS channel id with a site
 // that can't connect to it.
 IN_PROC_BROWSER_TEST_F(ExternallyConnectableMessagingTest,
                        WebConnectableWithTlsChannelIdWithNonMatchingSite) {
-  InitializeTestServer();
-
   scoped_refptr<const Extension> chromium_connectable =
       LoadChromiumConnectableExtensionWithTlsChannelId();
   ASSERT_TRUE(chromium_connectable.get());
 
   ui_test_utils::NavigateToURL(browser(), google_com_url());
   // The extension requests the TLS channel ID, but it doesn't get it for a
   // site that can't connect to it, regardless of whether the page asks for it.
   EXPECT_EQ(base::IntToString(NAMESPACE_NOT_DEFINED),
             GetTlsChannelIdFromPortConnect(chromium_connectable.get(), false));
   EXPECT_EQ(base::IntToString(NAMESPACE_NOT_DEFINED),
             GetTlsChannelIdFromSendMessage(chromium_connectable.get(), true));
   EXPECT_EQ(base::IntToString(NAMESPACE_NOT_DEFINED),
             GetTlsChannelIdFromPortConnect(chromium_connectable.get(), false));
   EXPECT_EQ(base::IntToString(NAMESPACE_NOT_DEFINED),
             GetTlsChannelIdFromSendMessage(chromium_connectable.get(), true));
 }
 
 // Tests a web connectable extension that receives TLS channel id on a site
 // that can connect to it, but with no TLS channel ID having been generated.
 IN_PROC_BROWSER_TEST_F(ExternallyConnectableMessagingTest,
                        WebConnectableWithTlsChannelIdWithEmptyTlsChannelId) {
-  InitializeTestServer();
-
   scoped_refptr<const Extension> chromium_connectable =
       LoadChromiumConnectableExtensionWithTlsChannelId();
   ASSERT_TRUE(chromium_connectable.get());
 
   ui_test_utils::NavigateToURL(browser(), chromium_org_url());
 
   // Since the extension requests the TLS channel ID, it gets it for a site that
   // can connect to it, but only if the page also asks to include it.
   EXPECT_EQ(std::string(),
             GetTlsChannelIdFromPortConnect(chromium_connectable.get(), false));
   EXPECT_EQ(std::string(),
             GetTlsChannelIdFromSendMessage(chromium_connectable.get(), false));
   // If the page does ask for it, it isn't empty.
   std::string tls_channel_id =
       GetTlsChannelIdFromPortConnect(chromium_connectable.get(), true);
   // Because the TLS channel ID has never been generated for this domain,
   // no TLS channel ID is reported.
   EXPECT_EQ(std::string(), tls_channel_id);
 }
 
 // Flaky on Linux and Windows. http://crbug.com/315264
 // Tests a web connectable extension that receives TLS channel id, but
 // immediately closes its background page upon receipt of a message.
 IN_PROC_BROWSER_TEST_F(ExternallyConnectableMessagingTest,
     DISABLED_WebConnectableWithEmptyTlsChannelIdAndClosedBackgroundPage) {
-  InitializeTestServer();
-
   scoped_refptr<const Extension> chromium_connectable =
       LoadChromiumConnectableExtensionWithTlsChannelId();
 
   ui_test_utils::NavigateToURL(browser(), chromium_org_url());
   // If the page does ask for it, it isn't empty, even if the background page
   // closes upon receipt of the connect.
   std::string tls_channel_id = GetTlsChannelIdFromPortConnect(
       chromium_connectable.get(), true, close_background_message());
   // Because the TLS channel ID has never been generated for this domain,
   // no TLS channel ID is reported.
   EXPECT_EQ(std::string(), tls_channel_id);
   // A subsequent connect will still succeed, even if the background page was
   // previously closed.
   tls_channel_id =
       GetTlsChannelIdFromPortConnect(chromium_connectable.get(), true);
   // And the empty value is still retrieved.
   EXPECT_EQ(std::string(), tls_channel_id);
 }
 
 // Tests that enabling and disabling an extension makes the runtime bindings
 // appear and disappear.
 //
 // TODO(kalman): Test with multiple extensions that can be accessed by the same
 // host.
 IN_PROC_BROWSER_TEST_F(ExternallyConnectableMessagingTest,
                        EnablingAndDisabling) {
-  InitializeTestServer();
-
   scoped_refptr<const Extension> chromium_connectable =
       LoadChromiumConnectableExtension();
   scoped_refptr<const Extension> not_connectable =
       LoadNotConnectableExtension();
 
   ui_test_utils::NavigateToURL(browser(), chromium_org_url());
   EXPECT_EQ(OK,
             CanConnectAndSendMessagesToMainFrame(chromium_connectable.get()));
   EXPECT_EQ(COULD_NOT_ESTABLISH_CONNECTION_ERROR,
             CanConnectAndSendMessagesToMainFrame(not_connectable.get()));
@@ skipping 12 matching lines @@
 // Tests connection from incognito tabs when the user denies the connection
 // request. Spanning mode only. A separate test for apps and extensions.
 //
 // TODO(kalman): ensure that we exercise split vs spanning incognito logic
 // somewhere. This is a test that should be shared with the content script logic
 // so it's not really our specific concern for web connectable.
 //
 // TODO(kalman): test messages from incognito extensions too.
 IN_PROC_BROWSER_TEST_F(ExternallyConnectableMessagingTest,
                        FromIncognitoDenyApp) {
-  InitializeTestServer();
-
   scoped_refptr<const Extension> app = LoadChromiumConnectableApp();
   ASSERT_TRUE(app->is_platform_app());
 
   Browser* incognito_browser = OpenURLOffTheRecord(
       profile()->GetOffTheRecordProfile(), chromium_org_url());
   content::RenderFrameHost* incognito_frame = incognito_browser->
       tab_strip_model()->GetActiveWebContents()->GetMainFrame();
 
   {
     IncognitoConnectability::ScopedAlertTracker alert_tracker(
@@ skipping 14 matching lines @@
   }
 
   // It's not possible to allow an app in incognito.
   ExtensionPrefs::Get(profile())->SetIsIncognitoEnabled(app->id(), true);
   EXPECT_EQ(COULD_NOT_ESTABLISH_CONNECTION_ERROR,
             CanConnectAndSendMessagesToFrame(incognito_frame, app.get(), NULL));
 }
 
 IN_PROC_BROWSER_TEST_F(ExternallyConnectableMessagingTest,
                        FromIncognitoDenyExtensionAndApp) {
-  InitializeTestServer();
-
   scoped_refptr<const Extension> extension = LoadChromiumConnectableExtension();
   EXPECT_FALSE(util::IsIncognitoEnabled(extension->id(), profile()));
 
   Browser* incognito_browser = OpenURLOffTheRecord(
       profile()->GetOffTheRecordProfile(), chromium_org_url());
   content::RenderFrameHost* incognito_frame =
       incognito_browser->tab_strip_model()
           ->GetActiveWebContents()
           ->GetMainFrame();
 
@@ skipping 29 matching lines @@
 
   // No alert is shown for extensions since they support being enabled in
   // incognito mode.
   EXPECT_EQ(0, alert_tracker.GetAndResetAlertCount());
 }
 
 // Tests connection from incognito tabs when the extension doesn't have an event
 // handler for the connection event.
 IN_PROC_BROWSER_TEST_F(ExternallyConnectableMessagingTest,
                        FromIncognitoNoEventHandlerInApp) {
-  InitializeTestServer();
-
   scoped_refptr<const Extension> app = LoadChromiumConnectableApp(false);
   ASSERT_TRUE(app->is_platform_app());
 
   Browser* incognito_browser = OpenURLOffTheRecord(
       profile()->GetOffTheRecordProfile(), chromium_org_url());
   content::RenderFrameHost* incognito_frame =
       incognito_browser->tab_strip_model()
           ->GetActiveWebContents()
           ->GetMainFrame();
 
@@ skipping 10 matching lines @@
     EXPECT_EQ(0, alert_tracker.GetAndResetAlertCount());
   }
 }
 
 // Tests connection from incognito tabs when the user accepts the connection
 // request. Spanning mode only. Separate tests for apps and extensions.
 //
 // TODO(kalman): see comment above about split mode.
 IN_PROC_BROWSER_TEST_F(ExternallyConnectableMessagingTest,
                        FromIncognitoAllowApp) {
-  InitializeTestServer();
-
   scoped_refptr<const Extension> app = LoadChromiumConnectableApp();
   ASSERT_TRUE(app->is_platform_app());
 
   Browser* incognito_browser = OpenURLOffTheRecord(
       profile()->GetOffTheRecordProfile(), chromium_org_url());
   content::RenderFrameHost* incognito_frame = incognito_browser->
       tab_strip_model()->GetActiveWebContents()->GetMainFrame();
 
   {
     IncognitoConnectability::ScopedAlertTracker alert_tracker(
@@ skipping 15 matching lines @@
   // already allowed.
   ExtensionPrefs::Get(profile())->SetIsIncognitoEnabled(app->id(), true);
   EXPECT_EQ(OK,
             CanConnectAndSendMessagesToFrame(incognito_frame, app.get(), NULL));
 }
 
 // Tests connection from incognito tabs when there are multiple tabs open to the
 // same origin. The user should only need to accept the connection request once.
 IN_PROC_BROWSER_TEST_F(ExternallyConnectableMessagingTest,
                        FromIncognitoPromptApp) {
-  InitializeTestServer();
-
   scoped_refptr<const Extension> app = LoadChromiumConnectableApp();
   ASSERT_TRUE(app->is_platform_app());
 
   // Open an incognito browser with two tabs displaying "chromium.org".
   Browser* incognito_browser = OpenURLOffTheRecord(
       profile()->GetOffTheRecordProfile(), chromium_org_url());
   content::RenderFrameHost* incognito_frame1 =
       incognito_browser->tab_strip_model()
           ->GetActiveWebContents()
           ->GetMainFrame();
@@ skipping 39 matching lines @@
     EXPECT_EQ(OK, CanConnectAndSendMessagesToFrame(incognito_frame2, app.get(),
                                                    NULL));
     EXPECT_EQ(1, alert_tracker.GetAndResetAlertCount());
     EXPECT_EQ(0U, infobar_service1->infobar_count());
   }
 }
 
 IN_PROC_BROWSER_TEST_F(ExternallyConnectableMessagingTest, IllegalArguments) {
   // Tests that malformed arguments to connect() don't crash.
   // Regression test for crbug.com/472700.
-  InitializeTestServer();
   LoadChromiumConnectableExtension();
   ui_test_utils::NavigateToURL(browser(), chromium_org_url());
   bool result;
   CHECK(content::ExecuteScriptAndExtractBool(
       browser()->tab_strip_model()->GetActiveWebContents(),
       "assertions.tryIllegalArguments()", &result));
   EXPECT_TRUE(result);
 }
 
 IN_PROC_BROWSER_TEST_F(ExternallyConnectableMessagingTest,
                        FromIncognitoAllowExtension) {
-  InitializeTestServer();
-
   scoped_refptr<const Extension> extension = LoadChromiumConnectableExtension();
   EXPECT_FALSE(util::IsIncognitoEnabled(extension->id(), profile()));
 
   Browser* incognito_browser = OpenURLOffTheRecord(
       profile()->GetOffTheRecordProfile(), chromium_org_url());
   content::RenderFrameHost* incognito_frame =
       incognito_browser->tab_strip_model()
           ->GetActiveWebContents()
           ->GetMainFrame();
 
@@ skipping 22 matching lines @@
 
   // No alert is shown for extensions which support being enabled in incognito
   // mode.
   EXPECT_EQ(0, alert_tracker.GetAndResetAlertCount());
 }
 
 // Tests a connection from an iframe within a tab which doesn't have
 // permission. Iframe should work.
 IN_PROC_BROWSER_TEST_F(ExternallyConnectableMessagingTest,
                        FromIframeWithPermission) {
-  InitializeTestServer();
-
   scoped_refptr<const Extension> extension = LoadChromiumConnectableExtension();
 
   ui_test_utils::NavigateToURL(browser(), google_com_url());
   EXPECT_EQ(NAMESPACE_NOT_DEFINED,
             CanConnectAndSendMessagesToMainFrame(extension.get()));
   EXPECT_FALSE(AreAnyNonWebApisDefinedForMainFrame());
 
   ASSERT_TRUE(AppendIframe(chromium_org_url()));
 
   EXPECT_EQ(OK, CanConnectAndSendMessagesToIFrame(extension.get()));
   EXPECT_FALSE(AreAnyNonWebApisDefinedForIFrame());
 }
 
 // Tests connection from an iframe without permission within a tab that does.
 // Iframe shouldn't work.
 IN_PROC_BROWSER_TEST_F(ExternallyConnectableMessagingTest,
                        FromIframeWithoutPermission) {
-  InitializeTestServer();
-
   scoped_refptr<const Extension> extension = LoadChromiumConnectableExtension();
 
   ui_test_utils::NavigateToURL(browser(), chromium_org_url());
   EXPECT_EQ(OK, CanConnectAndSendMessagesToMainFrame(extension.get()));
   EXPECT_FALSE(AreAnyNonWebApisDefinedForMainFrame());
 
   ASSERT_TRUE(AppendIframe(google_com_url()));
 
   EXPECT_EQ(NAMESPACE_NOT_DEFINED,
             CanConnectAndSendMessagesToIFrame(extension.get()));
   EXPECT_FALSE(AreAnyNonWebApisDefinedForIFrame());
 }
 
 IN_PROC_BROWSER_TEST_F(ExternallyConnectableMessagingTest, FromPopup) {
   base::CommandLine::ForCurrentProcess()->AppendSwitch(
       switches::kDisablePopupBlocking);
 
-  InitializeTestServer();
   scoped_refptr<const Extension> extension = LoadChromiumConnectableExtension();
 
   // This will let us wait for the chromium.org.html page to load in a popup.
   ui_test_utils::UrlLoadObserver url_observer(
       chromium_org_url(), content::NotificationService::AllSources());
 
   // The page at popup_opener_url() should open chromium_org_url() as a popup.
   ui_test_utils::NavigateToURL(browser(), popup_opener_url());
   url_observer.Wait();
 
@@ skipping 80 matching lines @@
     tls_channel_id_created_.Signal();
   }
 
   base::WaitableEvent tls_channel_id_created_;
 };
 
 // Tests a web connectable extension that receives TLS channel id on a site
 // that can connect to it, with a TLS channel ID having been generated.
 IN_PROC_BROWSER_TEST_F(ExternallyConnectableMessagingWithTlsChannelIdTest,
                        WebConnectableWithNonEmptyTlsChannelId) {
-  InitializeTestServer();
   std::string expected_tls_channel_id_value = CreateTlsChannelId();
 
   scoped_refptr<const Extension> chromium_connectable =
       LoadChromiumConnectableExtensionWithTlsChannelId();
   ASSERT_TRUE(chromium_connectable.get());
 
   ui_test_utils::NavigateToURL(browser(), chromium_org_url());
 
   // Since the extension requests the TLS channel ID, it gets it for a site that
   // can connect to it, but only if the page also asks to send it.
@@ skipping 36 matching lines @@
   tls_channel_id2 =
       GetTlsChannelIdFromSendMessage(chromium_connectable.get(), true);
   EXPECT_EQ(tls_channel_id, tls_channel_id2);
 }
 
 // Tests a web connectable extension that receives TLS channel id, but
 // immediately closes its background page upon receipt of a message.
 // Same flakiness seen in http://crbug.com/297866
 IN_PROC_BROWSER_TEST_F(ExternallyConnectableMessagingWithTlsChannelIdTest,
     DISABLED_WebConnectableWithNonEmptyTlsChannelIdAndClosedBackgroundPage) {
-  InitializeTestServer();
   std::string expected_tls_channel_id_value = CreateTlsChannelId();
 
   scoped_refptr<const Extension> chromium_connectable =
       LoadChromiumConnectableExtensionWithTlsChannelId();
 
   ui_test_utils::NavigateToURL(browser(), chromium_org_url());
   // If the page does ask for it, it isn't empty, even if the background page
   // closes upon receipt of the connect.
   std::string tls_channel_id = GetTlsChannelIdFromPortConnect(
       chromium_connectable.get(), true, close_background_message());
@@ skipping 47 matching lines @@
           "chrome.test.runWithUserGesture(function() {\n"
           "  chrome.runtime.sendMessage('%s', {}, function(response)  {\n"
           "    window.domAutomationController.send('' + response.result);\n"
           "  });\n"
           "});", receiver->id().c_str())));
 }
 
 // Tests that a hosted app on a connectable site doesn't interfere with the
 // connectability of that site.
 IN_PROC_BROWSER_TEST_F(ExternallyConnectableMessagingTest, HostedAppOnWebsite) {
-  InitializeTestServer();
-
   scoped_refptr<const Extension> app = LoadChromiumHostedApp();
 
   // The presence of the hosted app shouldn't give the ability to send messages.
   ui_test_utils::NavigateToURL(browser(), chromium_org_url());
   EXPECT_EQ(NAMESPACE_NOT_DEFINED,
             CanConnectAndSendMessagesToMainFrame(app.get()));
   EXPECT_FALSE(AreAnyNonWebApisDefinedForMainFrame());
 
   // Once a connectable extension is installed, it should.
   scoped_refptr<const Extension> extension = LoadChromiumConnectableExtension();
   EXPECT_EQ(OK, CanConnectAndSendMessagesToMainFrame(extension.get()));
   EXPECT_FALSE(AreAnyNonWebApisDefinedForMainFrame());
 }
 
 // Tests that an invalid extension ID specified in a hosted app does not crash
 // the hosted app's renderer.
 //
 // This is a regression test for http://crbug.com/326250#c12.
 IN_PROC_BROWSER_TEST_F(ExternallyConnectableMessagingTest,
                        InvalidExtensionIDFromHostedApp) {
-  InitializeTestServer();
-
   // The presence of the chromium hosted app triggers this bug. The chromium
   // connectable extension needs to be installed to set up the runtime bindings.
   LoadChromiumHostedApp();
   LoadChromiumConnectableExtension();
 
   scoped_refptr<const Extension> invalid =
       ExtensionBuilder()
           // A bit scary that this works...
           .SetID("invalid")
           .SetManifest(DictionaryBuilder()
                            .Set("name", "Fake extension")
                            .Set("version", "1")
                            .Set("manifest_version", 2)
                            .Build())
           .Build();
 
   ui_test_utils::NavigateToURL(browser(), chromium_org_url());
   EXPECT_EQ(COULD_NOT_ESTABLISH_CONNECTION_ERROR,
             CanConnectAndSendMessagesToMainFrame(invalid.get()));
 }
 
 #endif  // !defined(OS_WIN) - http://crbug.com/350517.
 
 // Tests that messages sent in the unload handler of a window arrive.
-IN_PROC_BROWSER_TEST_F(ExtensionApiTest, MessagingOnUnload) {
-  host_resolver()->AddRule("*", "127.0.0.1");
-  ASSERT_TRUE(StartEmbeddedTestServer());
+IN_PROC_BROWSER_TEST_F(MessagingApiTest, MessagingOnUnload) {
   const Extension* extension =
       LoadExtension(test_data_dir_.AppendASCII("messaging/on_unload"));
   ExtensionTestMessageListener listener("listening", false);
   ASSERT_TRUE(extension);
   ui_test_utils::NavigateToURL(
       browser(), embedded_test_server()->GetURL("example.com", "/empty.html"));
   EXPECT_TRUE(listener.WaitUntilSatisfied());
   ExtensionHost* background_host =
       ProcessManager::Get(profile())->GetBackgroundHostForExtension(
           extension->id());
@@ skipping 17 matching lines @@
   ASSERT_TRUE(content::ExecuteScriptAndExtractInt(
       background_contents,
       "window.domAutomationController.send(window.messageCount);",
       &message_count));
   EXPECT_EQ(1, message_count);
 }
 
 }  // namespace
 
 };  // namespace extensions