GTTF: convert some tests in chrome to use EmbeddedTestServer patch nr 1

chrome/browser/extensions/lazy_background_page_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 "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/bookmarks/bookmark_model.h"
 #include "chrome/browser/bookmarks/bookmark_model_factory.h"
 #include "chrome/browser/bookmarks/bookmark_utils.h"
@@ skipping 12 matching lines @@
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/test/browser_test_utils.h"
 #include "googleurl/src/gurl.h"
 #include "net/dns/mock_host_resolver.h"
+#include "net/test/embedded_test_server/embedded_test_server.h"
 
 using extensions::Extension;
 
 namespace {
 
 // This unfortunate bit of silliness is necessary when loading an extension in
 // incognito. The goal is to load the extension, enable incognito, then wait
 // for both background pages to load and close. The problem is that enabling
 // incognito involves reloading the extension - and the background pages may
 // have already loaded once before then. So we wait until the extension is
@@ skipping 91 matching lines @@
   LazyBackgroundObserver page_complete;
   BrowserActionTestUtil(browser()).Press(0);
   page_complete.Wait();
 
   // Background page is closed after creating a new tab.
   EXPECT_FALSE(pm->GetBackgroundHostForExtension(last_loaded_extension_id_));
   EXPECT_EQ(num_tabs_before + 1, browser()->tab_strip_model()->count());
 }
 
 IN_PROC_BROWSER_TEST_F(LazyBackgroundPageApiTest, BroadcastEvent) {
-  ASSERT_TRUE(StartTestServer());
+  ASSERT_TRUE(StartEmbeddedTestServer());
 
   const Extension* extension = LoadExtensionAndWait("broadcast_event");
   ASSERT_TRUE(extension);
 
   // Lazy Background Page doesn't exist yet.
   ExtensionProcessManager* pm =
       extensions::ExtensionSystem::Get(browser()->profile())->process_manager();
   EXPECT_FALSE(pm->GetBackgroundHostForExtension(last_loaded_extension_id_));
   int num_page_actions = browser()->window()->GetLocationBar()->
       GetLocationBarForTesting()->PageActionVisibleCount();
 
   // Open a tab to a URL that will trigger the page action to show.
   LazyBackgroundObserver page_complete;
   content::WindowedNotificationObserver page_action_changed(
         chrome::NOTIFICATION_EXTENSION_PAGE_ACTION_VISIBILITY_CHANGED,
         content::NotificationService::AllSources());
   ui_test_utils::NavigateToURL(
-      browser(), test_server()->GetURL("files/extensions/test_file.html"));
+      browser(), embedded_test_server()->GetURL("/extensions/test_file.html"));
   page_complete.Wait();
 
   EXPECT_FALSE(pm->GetBackgroundHostForExtension(last_loaded_extension_id_));
 
   // Page action is shown.
   page_action_changed.Wait();
   EXPECT_EQ(num_page_actions + 1,
             browser()->window()->GetLocationBar()->
                 GetLocationBarForTesting()->PageActionVisibleCount());
 }
 
 IN_PROC_BROWSER_TEST_F(LazyBackgroundPageApiTest, Filters) {
   const Extension* extension = LoadExtensionAndWait("filters");
   ASSERT_TRUE(extension);
 
   // Lazy Background Page doesn't exist yet.
   ExtensionProcessManager* pm =
       extensions::ExtensionSystem::Get(browser()->profile())->process_manager();
   EXPECT_FALSE(pm->GetBackgroundHostForExtension(last_loaded_extension_id_));
 
   // Open a tab to a URL that will fire a webNavigation event.
   LazyBackgroundObserver page_complete;
   ui_test_utils::NavigateToURL(
-      browser(), test_server()->GetURL("files/extensions/test_file.html"));
+      browser(), embedded_test_server()->GetURL("/extensions/test_file.html"));
   page_complete.Wait();
 }
 
 // Tests that the lazy background page receives the onInstalled event and shuts
 // down.
 IN_PROC_BROWSER_TEST_F(LazyBackgroundPageApiTest, OnInstalled) {
   ResultCatcher catcher;
   ASSERT_TRUE(LoadExtensionAndWait("on_installed"));
   EXPECT_TRUE(catcher.GetNextResult()) << catcher.message();
 
@@ skipping 31 matching lines @@
   page_complete.Wait();
 
   // Lazy Background Page has been shut down.
   EXPECT_FALSE(pm->GetBackgroundHostForExtension(last_loaded_extension_id_));
 }
 
 // Tests that the lazy background page stays alive until all network requests
 // are complete.
 IN_PROC_BROWSER_TEST_F(LazyBackgroundPageApiTest, WaitForRequest) {
   host_resolver()->AddRule("*", "127.0.0.1");
-  ASSERT_TRUE(StartTestServer());
+  ASSERT_TRUE(StartEmbeddedTestServer());
 
   LazyBackgroundObserver page_complete;
   ResultCatcher catcher;
   base::FilePath extdir = test_data_dir_.AppendASCII("lazy_background_page").
       AppendASCII("wait_for_request");
   const Extension* extension = LoadExtension(extdir);
   ASSERT_TRUE(extension);
   EXPECT_TRUE(catcher.GetNextResult()) << catcher.message();
 
   // Lazy Background Page still exists, because the extension started a request.
@@ skipping 120 matching lines @@
     EXPECT_FALSE(pm->GetBackgroundHostForExtension(last_loaded_extension_id_));
     EXPECT_FALSE(pmi->GetBackgroundHostForExtension(last_loaded_extension_id_));
     EXPECT_TRUE(listener.was_satisfied());
     EXPECT_TRUE(listener_incognito.was_satisfied());
   }
 }
 
 // Tests that messages from the content script activate the lazy background
 // page, and keep it alive until all channels are closed.
 IN_PROC_BROWSER_TEST_F(LazyBackgroundPageApiTest, Messaging) {
-  ASSERT_TRUE(StartTestServer());
+  ASSERT_TRUE(StartEmbeddedTestServer());
   ASSERT_TRUE(LoadExtensionAndWait("messaging"));
 
   // Lazy Background Page doesn't exist yet.
   ExtensionProcessManager* pm =
       extensions::ExtensionSystem::Get(browser()->profile())->process_manager();
   EXPECT_FALSE(pm->GetBackgroundHostForExtension(last_loaded_extension_id_));
   EXPECT_EQ(1, browser()->tab_strip_model()->count());
 
   // Navigate to a page that opens a message channel to the background page.
   ResultCatcher catcher;
   LazyBackgroundObserver lazybg;
   ui_test_utils::NavigateToURL(
-      browser(), test_server()->GetURL("files/extensions/test_file.html"));
+      browser(), embedded_test_server()->GetURL("/extensions/test_file.html"));
   lazybg.WaitUntilLoaded();
 
   // Background page got the content script's message and is still loaded
   // until we close the channel.
   EXPECT_TRUE(catcher.GetNextResult()) << catcher.message();
   EXPECT_TRUE(pm->GetBackgroundHostForExtension(last_loaded_extension_id_));
 
   // Navigate away, closing the message channel and therefore the background
   // page.
   ui_test_utils::NavigateToURL(browser(), GURL("about:blank"));
@@ skipping 50 matching lines @@
 
   EXPECT_TRUE(event_page_ready.WaitUntilSatisfied());
 
   page_ready.Reply("go");
 
   EXPECT_TRUE(catcher.GetNextResult()) << catcher.message();
 }
 
 // TODO: background page with timer.
 // TODO: background page that interacts with popup.