Migrating tests to use EmbeddedTestServer (/chrome/browser misc)

chrome/browser/prerender/prerender_browsertest.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 <deque>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted_memory.h"
 #include "base/memory/scoped_vector.h"
 #include "base/memory/weak_ptr.h"
 #include "base/path_service.h"
 #include "base/prefs/pref_service.h"
 #include "base/run_loop.h"
 #include "base/scoped_observer.h"
 #include "base/stl_util.h"
+#include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/test/histogram_tester.h"
 #include "base/test/test_timeouts.h"
 #include "base/values.h"
 #include "chrome/browser/browsing_data/browsing_data_helper.h"
 #include "chrome/browser/browsing_data/browsing_data_remover.h"
 #include "chrome/browser/browsing_data/browsing_data_remover_test_util.h"
 #include "chrome/browser/chrome_content_browser_client.h"
@@ skipping 66 matching lines @@
 #include "extensions/common/constants.h"
 #include "extensions/common/extension_urls.h"
 #include "extensions/common/manifest_handlers/mime_types_handler.h"
 #include "extensions/common/switches.h"
 #include "extensions/test/result_catcher.h"
 #include "net/base/escape.h"
 #include "net/cert/x509_certificate.h"
 #include "net/dns/mock_host_resolver.h"
 #include "net/ssl/client_cert_store.h"
 #include "net/ssl/ssl_cert_request_info.h"
+#include "net/ssl/ssl_server_config.h"
+#include "net/test/embedded_test_server/embedded_test_server.h"
+#include "net/test/embedded_test_server/request_handler_util.h"
 #include "net/test/url_request/url_request_mock_http_job.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "net/url_request/url_request_filter.h"
 #include "net/url_request/url_request_interceptor.h"
 #include "net/url_request/url_request_job.h"
 #include "ppapi/shared_impl/ppapi_switches.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "url/gurl.h"
 
@@ skipping 78 matching lines @@
   ConnectionType GetCurrentConnectionType() const override {
     return NetworkChangeNotifier::CONNECTION_4G;
   }
 };
 
 // Constants used in the test HTML files.
 const char* kReadyTitle = "READY";
 const char* kPassTitle = "PASS";
 
 std::string CreateClientRedirect(const std::string& dest_url) {
-  const char* const kClientRedirectBase = "client-redirect?";
+  const char* const kClientRedirectBase = "/client-redirect?";
   return kClientRedirectBase + net::EscapeQueryParamValue(dest_url, false);
 }
 
 std::string CreateServerRedirect(const std::string& dest_url) {
-  const char* const kServerRedirectBase = "server-redirect?";
+  const char* const kServerRedirectBase = "/server-redirect?";
   return kServerRedirectBase + net::EscapeQueryParamValue(dest_url, false);
 }
 
 // Clears the specified data using BrowsingDataRemover.
 void ClearBrowsingData(Browser* browser, int remove_mask) {
   BrowsingDataRemover* remover =
       BrowsingDataRemover::CreateForUnboundedRange(browser->profile());
   BrowsingDataRemoverCompletionObserver observer(remover);
   remover->Remove(remove_mask, BrowsingDataHelper::UNPROTECTED_WEB);
   observer.BlockUntilCompletion();
@@ skipping 874 matching lines @@
 class PrerenderBrowserTest : virtual public InProcessBrowserTest {
  public:
   PrerenderBrowserTest()
       : autostart_test_server_(true),
         prerender_contents_factory_(NULL),
 #if defined(FULL_SAFE_BROWSING)
         safe_browsing_factory_(new TestSafeBrowsingServiceFactory()),
 #endif
         call_javascript_(true),
         check_load_events_(true),
-        loader_path_("files/prerender/prerender_loader.html"),
-        explicitly_set_browser_(NULL) {}
+        loader_path_("/prerender/prerender_loader.html"),
+        explicitly_set_browser_(NULL) {
+  }
 
   ~PrerenderBrowserTest() override {}
 
   content::SessionStorageNamespace* GetSessionStorageNamespace() const {
     WebContents* web_contents = GetActiveWebContents();
     if (!web_contents)
       return NULL;
     return web_contents->GetController().GetDefaultSessionStorageNamespace();
   }
 
@@ skipping 17 matching lines @@
         switches::kOverridePluginPowerSaverForTesting, "ignore-list");
 
     ASSERT_TRUE(ppapi::RegisterPowerSaverTestPlugin(command_line));
   }
 
   void SetUpOnMainThread() override {
     current_browser()->profile()->GetPrefs()->SetBoolean(
         prefs::kPromptForDownload, false);
     IncreasePrerenderMemory();
     if (autostart_test_server_)
-      ASSERT_TRUE(test_server()->Start());
+      ASSERT_TRUE(embedded_test_server()->Start());
     ChromeResourceDispatcherHostDelegate::
         SetExternalProtocolHandlerDelegateForTesting(
             &external_protocol_handler_delegate_);
 
     PrerenderManager* prerender_manager = GetPrerenderManager();
     ASSERT_TRUE(prerender_manager);
     prerender_manager->mutable_config().rate_limit_enabled = false;
     ASSERT_TRUE(prerender_contents_factory_ == NULL);
     prerender_contents_factory_ = new TestPrerenderContentsFactory;
     prerender_manager->SetPrerenderContentsFactory(prerender_contents_factory_);
   }
 
   // Convenience function to get the currently active WebContents in
   // current_browser().
   WebContents* GetActiveWebContents() const {
     return current_browser()->tab_strip_model()->GetActiveWebContents();
   }
 
   // Overload for a single expected final status
   scoped_ptr<TestPrerender> PrerenderTestURL(
       const std::string& html_file,
       FinalStatus expected_final_status,
       int expected_number_of_loads) {
-    GURL url = test_server()->GetURL(html_file);
+    GURL url = embedded_test_server()->GetURL(html_file);
     return PrerenderTestURL(url,
                             expected_final_status,
                             expected_number_of_loads);
   }
 
   ScopedVector<TestPrerender> PrerenderTestURL(
       const std::string& html_file,
       const std::vector<FinalStatus>& expected_final_status_queue,
       int expected_number_of_loads) {
-    GURL url = test_server()->GetURL(html_file);
+    GURL url = embedded_test_server()->GetURL(html_file);
     return PrerenderTestURLImpl(url,
                                 expected_final_status_queue,
                                 expected_number_of_loads);
   }
 
   scoped_ptr<TestPrerender> PrerenderTestURL(
       const GURL& url,
       FinalStatus expected_final_status,
       int expected_number_of_loads) {
     std::vector<FinalStatus> expected_final_status_queue(
@@ skipping 20 matching lines @@
         expect_swap_to_succeed);
   }
 
   void NavigateToURL(const std::string& dest_html_file) const {
     NavigateToURLWithDisposition(dest_html_file, CURRENT_TAB, true);
   }
 
   void NavigateToURLWithDisposition(const std::string& dest_html_file,
                                     WindowOpenDisposition disposition,
                                     bool expect_swap_to_succeed) const {
-    GURL dest_url = test_server()->GetURL(dest_html_file);
+    GURL dest_url = embedded_test_server()->GetURL(dest_html_file);
     NavigateToURLWithDisposition(dest_url, disposition, expect_swap_to_succeed);
   }
 
   void NavigateToURLWithDisposition(const GURL& dest_url,
                                     WindowOpenDisposition disposition,
                                     bool expect_swap_to_succeed) const {
     NavigateToURLWithParams(
         content::OpenURLParams(dest_url, Referrer(), disposition,
                                ui::PAGE_TRANSITION_TYPED, false),
         expect_swap_to_succeed);
@@ skipping 49 matching lines @@
     TestNavigationObserver nav_observer(GetActiveWebContents());
     RenderFrameHost* render_frame_host = GetActiveWebContents()->GetMainFrame();
     render_frame_host->ExecuteJavaScriptForTests(
         base::ASCIIToUTF16("ClickOpenLink()"));
     nav_observer.Wait();
   }
 
   void NavigateToNextPageAfterPrerender() const {
     ui_test_utils::NavigateToURL(
         current_browser(),
-        test_server()->GetURL("files/prerender/prerender_page.html"));
+        embedded_test_server()->GetURL("/prerender/prerender_page.html"));
   }
 
   // Called after the prerendered page has been navigated to and then away from.
   // Navigates back through the history to the prerendered page.
   void GoBackToPrerender() {
     TestNavigationObserver back_nav_observer(GetActiveWebContents());
     chrome::GoBack(current_browser(), CURRENT_TAB);
     back_nav_observer.Wait();
     bool original_prerender_page = false;
     ASSERT_TRUE(content::ExecuteScriptAndExtractBool(
@@ skipping 15 matching lines @@
     back_nav_observer.Wait();
     bool js_result;
     ASSERT_TRUE(content::ExecuteScriptAndExtractBool(
         tab,
         "window.domAutomationController.send(DidBackToOriginalPagePass())",
         &js_result));
     EXPECT_TRUE(js_result);
   }
 
   bool UrlIsInPrerenderManager(const std::string& html_file) const {
-    return UrlIsInPrerenderManager(test_server()->GetURL(html_file));
+    return UrlIsInPrerenderManager(embedded_test_server()->GetURL(html_file));
   }
 
   bool UrlIsInPrerenderManager(const GURL& url) const {
     return GetPrerenderManager()->FindPrerenderData(
         url, GetSessionStorageNamespace()) != NULL;
   }
 
   void UseHttpsSrcServer() {
     if (https_src_server_)
       return;
     https_src_server_.reset(
-        new net::SpawnedTestServer(
-            net::SpawnedTestServer::TYPE_HTTPS,
-            net::SpawnedTestServer::kLocalhost,
-            base::FilePath(FILE_PATH_LITERAL("chrome/test/data"))));
+        new net::EmbeddedTestServer(net::EmbeddedTestServer::TYPE_HTTPS));
+    https_src_server_->ServeFilesFromSourceDirectory("chrome/test/data");
     CHECK(https_src_server_->Start());
   }
 
   void DisableJavascriptCalls() {
     call_javascript_ = false;
   }
 
   void DisableLoadEventCheck() {
     check_load_events_ = false;
   }
@@ skipping 123 matching lines @@
   }
 
   void set_loader_query(const std::string& query) {
     loader_query_ = query;
   }
 
   GURL GetCrossDomainTestUrl(const std::string& path) {
     static const std::string secondary_domain = "www.foo.com";
     host_resolver()->AddRule(secondary_domain, "127.0.0.1");
     std::string url_str(base::StringPrintf(
-        "http://%s:%d/%s",
-        secondary_domain.c_str(),
-        test_server()->host_port_pair().port(),
-        path.c_str()));
+        "http://%s:%d/%s", secondary_domain.c_str(),
+        embedded_test_server()->host_port_pair().port(), path.c_str()));
     return GURL(url_str);
   }
 
   void set_browser(Browser* browser) {
     explicitly_set_browser_ = browser;
   }
 
   Browser* current_browser() const {
     return explicitly_set_browser_ ? explicitly_set_browser_ : browser();
   }
@@ skipping 66 matching lines @@
   TestPrerenderContents* GetPrerenderContents() const {
     return GetPrerenderContentsFor(dest_url_);
   }
 
   ScopedVector<TestPrerender> PrerenderTestURLImpl(
       const GURL& prerender_url,
       const std::vector<FinalStatus>& expected_final_status_queue,
       int expected_number_of_loads) {
     dest_url_ = prerender_url;
 
-    std::vector<net::SpawnedTestServer::StringPair> replacement_text;
+    base::StringPairs replacement_text;
     replacement_text.push_back(
         make_pair("REPLACE_WITH_PRERENDER_URL", prerender_url.spec()));
     std::string replacement_path;
-    CHECK(net::SpawnedTestServer::GetFilePathWithReplacements(
-        loader_path_,
-        replacement_text,
-        &replacement_path));
+    net::test_server::GetFilePathWithReplacements(
+        loader_path_, replacement_text, &replacement_path);
 
-    const net::SpawnedTestServer* src_server = test_server();
+    const net::EmbeddedTestServer* src_server = embedded_test_server();
     if (https_src_server_)
       src_server = https_src_server_.get();
     GURL loader_url = src_server->GetURL(
         replacement_path + "&" + loader_query_);
 
     GURL::Replacements loader_replacements;
     if (!loader_host_override_.empty())
       loader_replacements.SetHostStr(loader_host_override_);
     loader_url = loader_url.ReplaceComponents(loader_replacements);
 
@@ skipping 99 matching lines @@
       observer.Wait();
     }
   }
 
   TestPrerenderContentsFactory* prerender_contents_factory_;
 #if defined(FULL_SAFE_BROWSING)
   scoped_ptr<TestSafeBrowsingServiceFactory> safe_browsing_factory_;
 #endif
   NeverRunsExternalProtocolHandlerDelegate external_protocol_handler_delegate_;
   GURL dest_url_;
-  scoped_ptr<net::SpawnedTestServer> https_src_server_;
+  scoped_ptr<net::EmbeddedTestServer> https_src_server_;
   bool call_javascript_;
   bool check_load_events_;
   std::string loader_host_override_;
   std::string loader_path_;
   std::string loader_query_;
   Browser* explicitly_set_browser_;
   base::HistogramTester histogram_tester_;
 };
 
 // Checks that a page is correctly prerendered in the case of a
 // <link rel=prerender> tag and then loaded into a tab in response to a
 // navigation.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderPage) {
-  PrerenderTestURL("files/prerender/prerender_page.html", FINAL_STATUS_USED, 1);
+  PrerenderTestURL("/prerender/prerender_page.html", FINAL_STATUS_USED, 1);
   EXPECT_EQ(1, GetPrerenderDomContentLoadedEventCountForLinkNumber(0));
   histogram_tester().ExpectTotalCount("Prerender.none_PerceivedPLT", 1);
   histogram_tester().ExpectTotalCount("Prerender.none_PerceivedPLTMatched", 0);
   histogram_tester().ExpectTotalCount(
       "Prerender.none_PerceivedPLTMatchedComplete", 0);
   histogram_tester().ExpectTotalCount(
       "Prerender.websame_PrerenderNotSwappedInPLT", 1);
 
   ChannelDestructionWatcher channel_close_watcher;
   channel_close_watcher.WatchChannel(
       GetActiveWebContents()->GetRenderProcessHost());
   NavigateToDestURL();
   channel_close_watcher.WaitForChannelClose();
 
   histogram_tester().ExpectTotalCount("Prerender.websame_PerceivedPLT", 1);
   histogram_tester().ExpectTotalCount("Prerender.websame_PerceivedPLTMatched",
                                       1);
   histogram_tester().ExpectTotalCount(
       "Prerender.websame_PerceivedPLTMatchedComplete", 1);
 
   ASSERT_TRUE(IsEmptyPrerenderLinkManager());
 }
 
 // Checks that cross-domain prerenders emit the correct histograms.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderPageCrossDomain) {
-  PrerenderTestURL(GetCrossDomainTestUrl("files/prerender/prerender_page.html"),
+  PrerenderTestURL(GetCrossDomainTestUrl("prerender/prerender_page.html"),
                    FINAL_STATUS_USED, 1);
   histogram_tester().ExpectTotalCount("Prerender.none_PerceivedPLT", 1);
   histogram_tester().ExpectTotalCount("Prerender.none_PerceivedPLTMatched", 0);
   histogram_tester().ExpectTotalCount(
       "Prerender.none_PerceivedPLTMatchedComplete", 0);
   histogram_tester().ExpectTotalCount(
       "Prerender.webcross_PrerenderNotSwappedInPLT", 1);
 
   NavigateToDestURL();
   histogram_tester().ExpectTotalCount("Prerender.webcross_PerceivedPLT", 1);
   histogram_tester().ExpectTotalCount("Prerender.webcross_PerceivedPLTMatched",
                                       1);
   histogram_tester().ExpectTotalCount(
       "Prerender.webcross_PerceivedPLTMatchedComplete", 1);
 }
 
 // Checks that pending prerenders launch and receive proper event treatment.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderPagePending) {
-  scoped_ptr<TestPrerender> prerender =
-      PrerenderTestURL("files/prerender/prerender_page_pending.html",
-                       FINAL_STATUS_USED, 1);
+  scoped_ptr<TestPrerender> prerender = PrerenderTestURL(
+      "/prerender/prerender_page_pending.html", FINAL_STATUS_USED, 1);
 
   // Navigate to the prerender.
   scoped_ptr<TestPrerender> prerender2 = ExpectPrerender(FINAL_STATUS_USED);
   NavigateToDestURL();
   // Abort early if the original prerender didn't swap, so as not to hang.
   ASSERT_FALSE(prerender->contents());
 
   // Wait for the new prerender to be ready.
   prerender2->WaitForStart();
   prerender2->WaitForLoads(1);
 
   const GURL prerender_page_url =
-      test_server()->GetURL("files/prerender/prerender_page.html");
+      embedded_test_server()->GetURL("/prerender/prerender_page.html");
   EXPECT_FALSE(IsEmptyPrerenderLinkManager());
   EXPECT_NE(static_cast<TestPrerenderContents*>(NULL),
             GetPrerenderContentsFor(prerender_page_url));
 
   // Now navigate to our target page.
   NavigationOrSwapObserver swap_observer(current_browser()->tab_strip_model(),
                                          GetActiveWebContents());
   ui_test_utils::NavigateToURLWithDisposition(
       current_browser(), prerender_page_url, CURRENT_TAB,
       ui_test_utils::BROWSER_TEST_NONE);
   swap_observer.Wait();
 
   EXPECT_TRUE(IsEmptyPrerenderLinkManager());
 }
 
 // Checks that pending prerenders which are canceled before they are launched
 // never get started.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderPageRemovesPending) {
-  PrerenderTestURL("files/prerender/prerender_page_removes_pending.html",
+  PrerenderTestURL("/prerender/prerender_page_removes_pending.html",
                    FINAL_STATUS_USED, 1);
 
   ChannelDestructionWatcher channel_close_watcher;
   channel_close_watcher.WatchChannel(
       GetActiveWebContents()->GetRenderProcessHost());
   NavigateToDestURL();
   channel_close_watcher.WaitForChannelClose();
 
   EXPECT_FALSE(DidReceivePrerenderStartEventForLinkNumber(1));
   EXPECT_FALSE(DidReceivePrerenderStopEventForLinkNumber(1));
   EXPECT_FALSE(HadPrerenderEventErrors());
   // IsEmptyPrerenderLinkManager() is not racy because the earlier DidReceive*
   // calls did a thread/process hop to the renderer which insured pending
   // renderer events have arrived.
   ASSERT_TRUE(IsEmptyPrerenderLinkManager());
 }
 
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderPageRemovingLink) {
-  scoped_ptr<TestPrerender> prerender =
-      PrerenderTestURL("files/prerender/prerender_page.html",
-                       FINAL_STATUS_CANCELLED, 1);
+  scoped_ptr<TestPrerender> prerender = PrerenderTestURL(
+      "/prerender/prerender_page.html", FINAL_STATUS_CANCELLED, 1);
 
   // No ChannelDestructionWatcher is needed here, since prerenders in the
   // PrerenderLinkManager should be deleted by removing the links, rather than
   // shutting down the renderer process.
   RemoveLinkElement(0);
   prerender->WaitForStop();
 
   EXPECT_TRUE(DidReceivePrerenderStartEventForLinkNumber(0));
   EXPECT_FALSE(DidReceivePrerenderStopEventForLinkNumber(0));
   EXPECT_FALSE(HadPrerenderEventErrors());
   // IsEmptyPrerenderLinkManager() is not racy because the earlier DidReceive*
   // calls did a thread/process hop to the renderer which insured pending
   // renderer events have arrived.
   EXPECT_TRUE(IsEmptyPrerenderLinkManager());
 }
 
 IN_PROC_BROWSER_TEST_F(
     PrerenderBrowserTest, PrerenderPageRemovingLinkWithTwoLinks) {
   GetPrerenderManager()->mutable_config().max_link_concurrency = 2;
   GetPrerenderManager()->mutable_config().max_link_concurrency_per_launcher = 2;
 
   set_loader_query("links_to_insert=2");
-  scoped_ptr<TestPrerender> prerender =
-      PrerenderTestURL("files/prerender/prerender_page.html",
-                       FINAL_STATUS_CANCELLED, 1);
+  scoped_ptr<TestPrerender> prerender = PrerenderTestURL(
+      "/prerender/prerender_page.html", FINAL_STATUS_CANCELLED, 1);
   EXPECT_TRUE(DidReceivePrerenderStartEventForLinkNumber(0));
   EXPECT_FALSE(DidReceivePrerenderStopEventForLinkNumber(0));
   EXPECT_TRUE(DidReceivePrerenderStartEventForLinkNumber(1));
   EXPECT_FALSE(DidReceivePrerenderStopEventForLinkNumber(1));
 
   RemoveLinkElement(0);
   RemoveLinkElement(1);
   prerender->WaitForStop();
 
   EXPECT_TRUE(DidReceivePrerenderStartEventForLinkNumber(0));
   EXPECT_FALSE(DidReceivePrerenderStopEventForLinkNumber(0));
   EXPECT_TRUE(DidReceivePrerenderStartEventForLinkNumber(1));
   EXPECT_FALSE(DidReceivePrerenderStopEventForLinkNumber(1));
   EXPECT_FALSE(HadPrerenderEventErrors());
   // IsEmptyPrerenderLinkManager() is not racy because the earlier DidReceive*
   // calls did a thread/process hop to the renderer which insured pending
   // renderer events have arrived.
   EXPECT_TRUE(IsEmptyPrerenderLinkManager());
 }
 
 IN_PROC_BROWSER_TEST_F(
     PrerenderBrowserTest, PrerenderPageRemovingLinkWithTwoLinksOneLate) {
   GetPrerenderManager()->mutable_config().max_link_concurrency = 2;
   GetPrerenderManager()->mutable_config().max_link_concurrency_per_launcher = 2;
 
-  GURL url = test_server()->GetURL("files/prerender/prerender_page.html");
+  GURL url = embedded_test_server()->GetURL("/prerender/prerender_page.html");
   scoped_ptr<TestPrerender> prerender =
       PrerenderTestURL(url, FINAL_STATUS_CANCELLED, 1);
 
   // Add a second prerender for the same link. It reuses the prerender, so only
   // the start event fires here.
   AddPrerender(url, 1);
   WaitForPrerenderEventCount(1, "webkitprerenderstart", 1);
   EXPECT_TRUE(DidReceivePrerenderStartEventForLinkNumber(1));
   EXPECT_EQ(0, GetPrerenderLoadEventCountForLinkNumber(1));
   EXPECT_FALSE(DidReceivePrerenderStopEventForLinkNumber(1));
@@ skipping 12 matching lines @@
   // renderer events have arrived.
   EXPECT_TRUE(IsEmptyPrerenderLinkManager());
 }
 
 IN_PROC_BROWSER_TEST_F(
     PrerenderBrowserTest,
     PrerenderPageRemovingLinkWithTwoLinksRemovingOne) {
   GetPrerenderManager()->mutable_config().max_link_concurrency = 2;
   GetPrerenderManager()->mutable_config().max_link_concurrency_per_launcher = 2;
   set_loader_query("links_to_insert=2");
-  PrerenderTestURL("files/prerender/prerender_page.html",
-                   FINAL_STATUS_USED, 1);
+  PrerenderTestURL("/prerender/prerender_page.html", FINAL_STATUS_USED, 1);
   EXPECT_TRUE(DidReceivePrerenderStartEventForLinkNumber(0));
   EXPECT_FALSE(DidReceivePrerenderStopEventForLinkNumber(0));
   EXPECT_TRUE(DidReceivePrerenderStartEventForLinkNumber(1));
   EXPECT_FALSE(DidReceivePrerenderStopEventForLinkNumber(1));
 
   RemoveLinkElement(0);
   EXPECT_TRUE(DidReceivePrerenderStartEventForLinkNumber(0));
   EXPECT_FALSE(DidReceivePrerenderStopEventForLinkNumber(0));
   EXPECT_TRUE(DidReceivePrerenderStartEventForLinkNumber(1));
   EXPECT_FALSE(DidReceivePrerenderStopEventForLinkNumber(1));
   EXPECT_FALSE(HadPrerenderEventErrors());
   // IsEmptyPrerenderLinkManager() is not racy because the earlier DidReceive*
   // calls did a thread/process hop to the renderer which insured pending
   // renderer events have arrived.
   EXPECT_FALSE(IsEmptyPrerenderLinkManager());
 
   ChannelDestructionWatcher channel_close_watcher;
   channel_close_watcher.WatchChannel(
       GetActiveWebContents()->GetRenderProcessHost());
   NavigateToDestURL();
   channel_close_watcher.WaitForChannelClose();
 
   EXPECT_TRUE(IsEmptyPrerenderLinkManager());
 }
 
 // Checks that the visibility API works.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderVisibility) {
-  PrerenderTestURL("files/prerender/prerender_visibility.html",
-                   FINAL_STATUS_USED,
+  PrerenderTestURL("/prerender/prerender_visibility.html", FINAL_STATUS_USED,
                    1);
   NavigateToDestURL();
 }
 
 // Checks that the prerendering of a page is canceled correctly if we try to
 // swap it in before it commits.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderNoCommitNoSwap) {
   // Navigate to a page that triggers a prerender for a URL that never commits.
   const GURL kNoCommitUrl("http://never-respond.example.com");
   base::FilePath file(GetTestPath("prerender_page.html"));
@@ skipping 31 matching lines @@
   // Wait for the hanging request to be scheduled.
   prerender_start_loop.Run();
 
   // Navigating to the second URL should not swap.
   NavigateToURLWithDisposition(kNoCommitUrl, CURRENT_TAB, false);
 }
 
 // Checks that the prerendering of a page is canceled correctly when a
 // Javascript alert is called.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderAlertBeforeOnload) {
-  PrerenderTestURL("files/prerender/prerender_alert_before_onload.html",
-                   FINAL_STATUS_JAVASCRIPT_ALERT,
-                   0);
+  PrerenderTestURL("/prerender/prerender_alert_before_onload.html",
+                   FINAL_STATUS_JAVASCRIPT_ALERT, 0);
 }
 
 // Checks that the prerendering of a page is canceled correctly when a
 // Javascript alert is called.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderAlertAfterOnload) {
-  PrerenderTestURL("files/prerender/prerender_alert_after_onload.html",
-                   FINAL_STATUS_JAVASCRIPT_ALERT,
-                   1);
+  PrerenderTestURL("/prerender/prerender_alert_after_onload.html",
+                   FINAL_STATUS_JAVASCRIPT_ALERT, 1);
 }
 
 // Checks that plugins are not loaded while a page is being preloaded, but
 // are loaded when the page is displayed.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderDelayLoadPlugin) {
-  PrerenderTestURL("files/prerender/prerender_plugin_delay_load.html",
+  PrerenderTestURL("/prerender/prerender_plugin_delay_load.html",
                    FINAL_STATUS_USED, 1);
   NavigateToDestURL();
 }
 
 // For Content Setting DETECT, checks that plugins are not loaded while
 // a page is being preloaded, but are loaded when the page is displayed.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderContentSettingDetect) {
   HostContentSettingsMap* content_settings_map =
       HostContentSettingsMapFactory::GetForProfile(
           current_browser()->profile());
   content_settings_map->SetDefaultContentSetting(
       CONTENT_SETTINGS_TYPE_PLUGINS, CONTENT_SETTING_DETECT_IMPORTANT_CONTENT);
 
-  PrerenderTestURL("files/prerender/prerender_plugin_power_saver.html",
+  PrerenderTestURL("/prerender/prerender_plugin_power_saver.html",
                    FINAL_STATUS_USED, 1);
 
   DisableJavascriptCalls();
   NavigateToDestURL();
   bool second_placeholder_present = false;
   ASSERT_TRUE(content::ExecuteScriptAndExtractBool(
       GetActiveWebContents(), "AwaitPluginPrerollAndPlaceholder();",
       &second_placeholder_present));
   EXPECT_TRUE(second_placeholder_present);
 }
 
 // For Content Setting BLOCK, checks that plugins are never loaded.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderContentSettingBlock) {
   HostContentSettingsMap* content_settings_map =
       HostContentSettingsMapFactory::GetForProfile(
           current_browser()->profile());
   content_settings_map->SetDefaultContentSetting(CONTENT_SETTINGS_TYPE_PLUGINS,
                                                  CONTENT_SETTING_BLOCK);
 
-  PrerenderTestURL("files/prerender/prerender_plugin_never_load.html",
+  PrerenderTestURL("/prerender/prerender_plugin_never_load.html",
                    FINAL_STATUS_USED, 1);
   NavigateToDestURL();
 }
 
 // Checks that we don't load a NaCl plugin when NaCl is disabled.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderNaClPluginDisabled) {
-  PrerenderTestURL("files/prerender/prerender_plugin_nacl_disabled.html",
-                   FINAL_STATUS_USED,
-                   1);
+  PrerenderTestURL("/prerender/prerender_plugin_nacl_disabled.html",
+                   FINAL_STATUS_USED, 1);
   NavigateToDestURL();
 
 
   // Run this check again.  When we try to load aa ppapi plugin, the
   // "loadstart" event is asynchronously posted to a message loop.
   // It's possible that earlier call could have been run before the
   // the "loadstart" event was posted.
   // TODO(mmenke):  While this should reliably fail on regressions, the
   //                reliability depends on the specifics of ppapi plugin
   //                loading.  It would be great if we could avoid that.
@@ skipping 12 matching lines @@
         DISABLED_PrerenderIframeDelayLoadPlugin
 #elif defined(OS_WIN) && defined(ARCH_CPU_X86_64)
 // TODO(jschuh): Failing plugin tests. crbug.com/244653
 #define MAYBE_PrerenderIframeDelayLoadPlugin \
         DISABLED_PrerenderIframeDelayLoadPlugin
 #else
 #define MAYBE_PrerenderIframeDelayLoadPlugin PrerenderIframeDelayLoadPlugin
 #endif
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
                        MAYBE_PrerenderIframeDelayLoadPlugin) {
-  PrerenderTestURL("files/prerender/prerender_iframe_plugin_delay_load.html",
-                   FINAL_STATUS_USED,
-                   1);
+  PrerenderTestURL("/prerender/prerender_iframe_plugin_delay_load.html",
+                   FINAL_STATUS_USED, 1);
   NavigateToDestURL();
 }
 
 // Renders a page that contains a prerender link to a page that contains an
 // iframe with a source that requires http authentication. This should not
 // prerender successfully.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderHttpAuthentication) {
-  PrerenderTestURL("files/prerender/prerender_http_auth_container.html",
-                   FINAL_STATUS_AUTH_NEEDED,
-                   0);
+  PrerenderTestURL("/prerender/prerender_http_auth_container.html",
+                   FINAL_STATUS_AUTH_NEEDED, 0);
 }
 
 // Checks that client-issued redirects work with prerendering.
 // This version navigates to the page which issues the redirection, rather
 // than the final destination page.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
                        PrerenderClientRedirectNavigateToFirst) {
-  PrerenderTestURL(CreateClientRedirect("files/prerender/prerender_page.html"),
-                   FINAL_STATUS_USED,
-                   2);
+  PrerenderTestURL(CreateClientRedirect("/prerender/prerender_page.html"),
+                   FINAL_STATUS_USED, 2);
   NavigateToDestURL();
 }
 
 // Checks that client-issued redirects work with prerendering.
 // This version navigates to the final destination page, rather than the
 // page which does the redirection.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
                        PrerenderClientRedirectNavigateToSecond) {
-  PrerenderTestURL(CreateClientRedirect("files/prerender/prerender_page.html"),
-                   FINAL_STATUS_USED,
-                   2);
-  NavigateToURL("files/prerender/prerender_page.html");
+  PrerenderTestURL(CreateClientRedirect("/prerender/prerender_page.html"),
+                   FINAL_STATUS_USED, 2);
+  NavigateToURL("/prerender/prerender_page.html");
 }
 
 // Checks that redirects with location.replace do not cancel a prerender and
 // and swap when navigating to the first page.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
                        PrerenderLocationReplaceNavigateToFirst) {
-  PrerenderTestURL("files/prerender/prerender_location_replace.html",
-                   FINAL_STATUS_USED,
-                   2);
+  PrerenderTestURL("/prerender/prerender_location_replace.html",
+                   FINAL_STATUS_USED, 2);
   NavigateToDestURL();
 }
 
 // Checks that redirects with location.replace do not cancel a prerender and
 // and swap when navigating to the second.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
                        PrerenderLocationReplaceNavigateToSecond) {
-  PrerenderTestURL("files/prerender/prerender_location_replace.html",
-                   FINAL_STATUS_USED,
-                   2);
-  NavigateToURL("files/prerender/prerender_page.html");
+  PrerenderTestURL("/prerender/prerender_location_replace.html",
+                   FINAL_STATUS_USED, 2);
+  NavigateToURL("/prerender/prerender_page.html");
 }
 
 // Checks that we get the right PPLT histograms for client redirect prerenders
 // and navigations when the referring page is Google.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
                        PrerenderLocationReplaceGWSHistograms) {
   DisableJavascriptCalls();
 
   // The loader page should look like Google.
   static const char kGoogleDotCom[] = "www.google.com";
   SetLoaderHostOverride(kGoogleDotCom);
-  set_loader_path("files/prerender/prerender_loader_with_replace_state.html");
+  set_loader_path("/prerender/prerender_loader_with_replace_state.html");
 
-  GURL dest_url = GetCrossDomainTestUrl(
-      "files/prerender/prerender_deferred_image.html");
+  GURL dest_url =
+      GetCrossDomainTestUrl("prerender/prerender_deferred_image.html");
 
-  GURL prerender_url = test_server()->GetURL(
-      "files/prerender/prerender_location_replace.html?" +
-      net::EscapeQueryParamValue(dest_url.spec(), false) +
-      "#prerender");
+  GURL prerender_url = embedded_test_server()->GetURL(
+      "/prerender/prerender_location_replace.html?" +
+      net::EscapeQueryParamValue(dest_url.spec(), false) + "#prerender");
   GURL::Replacements replacements;
   replacements.SetHostStr(kGoogleDotCom);
   prerender_url = prerender_url.ReplaceComponents(replacements);
 
   // The prerender will not completely load until after the swap, so wait for a
   // title change before calling DidPrerenderPass.
   scoped_ptr<TestPrerender> prerender =
       PrerenderTestURL(prerender_url, FINAL_STATUS_USED, 1);
   WaitForASCIITitle(prerender->contents()->prerender_contents(), kReadyTitle);
   EXPECT_TRUE(DidPrerenderPass(prerender->contents()->prerender_contents()));
   EXPECT_EQ(1, prerender->number_of_loads());
 
   histogram_tester().ExpectTotalCount("Prerender.none_PerceivedPLT", 1);
   histogram_tester().ExpectTotalCount("Prerender.none_PerceivedPLTMatched", 0);
   histogram_tester().ExpectTotalCount(
       "Prerender.none_PerceivedPLTMatchedComplete", 0);
   // Although there is a client redirect, it is dropped from histograms because
   // it is a Google URL. The target page itself does not load until after the
   // swap.
   histogram_tester().ExpectTotalCount("Prerender.gws_PrerenderNotSwappedInPLT",
                                       0);
 
-  GURL navigate_url = test_server()->GetURL(
-      "files/prerender/prerender_location_replace.html?" +
-      net::EscapeQueryParamValue(dest_url.spec(), false) +
-      "#navigate");
+  GURL navigate_url = embedded_test_server()->GetURL(
+      "/prerender/prerender_location_replace.html?" +
+      net::EscapeQueryParamValue(dest_url.spec(), false) + "#navigate");
   navigate_url = navigate_url.ReplaceComponents(replacements);
 
   NavigationOrSwapObserver swap_observer(
       current_browser()->tab_strip_model(),
       GetActiveWebContents(), 2);
   current_browser()->OpenURL(OpenURLParams(
       navigate_url, Referrer(), CURRENT_TAB,
       ui::PAGE_TRANSITION_TYPED, false));
   swap_observer.Wait();
 
   EXPECT_TRUE(DidDisplayPass(GetActiveWebContents()));
 
   histogram_tester().ExpectTotalCount("Prerender.gws_PrerenderNotSwappedInPLT",
                                       0);
   histogram_tester().ExpectTotalCount("Prerender.gws_PerceivedPLT", 1);
   histogram_tester().ExpectTotalCount("Prerender.gws_PerceivedPLTMatched", 1);
   histogram_tester().ExpectTotalCount(
       "Prerender.gws_PerceivedPLTMatchedComplete", 1);
 
   // The client redirect does /not/ count as a miss because it's a Google URL.
   histogram_tester().ExpectTotalCount("Prerender.PerceivedPLTFirstAfterMiss",
                                       0);
 }
 
 // Checks that client-issued redirects work with prerendering.
 // This version navigates to the final destination page, rather than the
 // page which does the redirection via a mouse click.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
                        PrerenderClientRedirectNavigateToSecondViaClick) {
-  GURL prerender_url = test_server()->GetURL(
-      CreateClientRedirect("files/prerender/prerender_page.html"));
-  GURL destination_url = test_server()->GetURL(
-      "files/prerender/prerender_page.html");
+  GURL prerender_url = embedded_test_server()->GetURL(
+      CreateClientRedirect("/prerender/prerender_page.html"));
+  GURL destination_url =
+      embedded_test_server()->GetURL("/prerender/prerender_page.html");
   PrerenderTestURL(prerender_url, FINAL_STATUS_USED, 2);
   OpenURLViaClick(destination_url);
 }
 
 // Checks that a page served over HTTPS is correctly prerendered.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderHttps) {
-  net::SpawnedTestServer https_server(
-      net::SpawnedTestServer::TYPE_HTTPS, net::SpawnedTestServer::kLocalhost,
-      base::FilePath(FILE_PATH_LITERAL("chrome/test/data")));
+  net::EmbeddedTestServer https_server(net::EmbeddedTestServer::TYPE_HTTPS);
+  https_server.ServeFilesFromSourceDirectory("chrome/test/data");
   ASSERT_TRUE(https_server.Start());
-  GURL https_url = https_server.GetURL("files/prerender/prerender_page.html");
+  GURL https_url = https_server.GetURL("/prerender/prerender_page.html");
   PrerenderTestURL(https_url,
                    FINAL_STATUS_USED,
                    1);
   NavigateToDestURL();
 }
 
 // Checks that client-issued redirects within an iframe in a prerendered
 // page will not count as an "alias" for the prerendered page.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
                        PrerenderClientRedirectInIframe) {
-  std::string redirect_path = CreateClientRedirect(
-      "/files/prerender/prerender_embedded_content.html");
-  std::vector<net::SpawnedTestServer::StringPair> replacement_text;
-  replacement_text.push_back(
-      std::make_pair("REPLACE_WITH_URL", "/" + redirect_path));
+  std::string redirect_path =
+      CreateClientRedirect("/prerender/prerender_embedded_content.html");
+  base::StringPairs replacement_text;
+  replacement_text.push_back(std::make_pair("REPLACE_WITH_URL", redirect_path));
   std::string replacement_path;
-  ASSERT_TRUE(net::SpawnedTestServer::GetFilePathWithReplacements(
-      "files/prerender/prerender_with_iframe.html",
-      replacement_text,
-      &replacement_path));
+  net::test_server::GetFilePathWithReplacements(
+      "/prerender/prerender_with_iframe.html", replacement_text,
+      &replacement_path);
   PrerenderTestURL(replacement_path, FINAL_STATUS_USED, 2);
-  EXPECT_FALSE(UrlIsInPrerenderManager(
-      "files/prerender/prerender_embedded_content.html"));
+  EXPECT_FALSE(
+      UrlIsInPrerenderManager("/prerender/prerender_embedded_content.html"));
   NavigateToDestURL();
 }
 
 // Checks that server-issued redirects work with prerendering.
 // This version navigates to the page which issues the redirection, rather
 // than the final destination page.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
                        PrerenderServerRedirectNavigateToFirst) {
-  PrerenderTestURL(CreateServerRedirect("files/prerender/prerender_page.html"),
-                   FINAL_STATUS_USED,
-                   1);
+  PrerenderTestURL(CreateServerRedirect("/prerender/prerender_page.html"),
+                   FINAL_STATUS_USED, 1);
   NavigateToDestURL();
 }
 
 // Checks that server-issued redirects work with prerendering.
 // This version navigates to the final destination page, rather than the
 // page which does the redirection.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
                        PrerenderServerRedirectNavigateToSecond) {
-  PrerenderTestURL(CreateServerRedirect("files/prerender/prerender_page.html"),
-                   FINAL_STATUS_USED,
-                   1);
-  NavigateToURL("files/prerender/prerender_page.html");
+  PrerenderTestURL(CreateServerRedirect("/prerender/prerender_page.html"),
+                   FINAL_STATUS_USED, 1);
+  NavigateToURL("/prerender/prerender_page.html");
 }
 
 // Checks that server-issued redirects work with prerendering.
 // This version navigates to the final destination page, rather than the
 // page which does the redirection via a mouse click.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
                        PrerenderServerRedirectNavigateToSecondViaClick) {
-  GURL prerender_url = test_server()->GetURL(
-      CreateServerRedirect("files/prerender/prerender_page.html"));
-  GURL destination_url = test_server()->GetURL(
-      "files/prerender/prerender_page.html");
+  GURL prerender_url = embedded_test_server()->GetURL(
+      CreateServerRedirect("/prerender/prerender_page.html"));
+  GURL destination_url =
+      embedded_test_server()->GetURL("/prerender/prerender_page.html");
   PrerenderTestURL(prerender_url, FINAL_STATUS_USED, 1);
   OpenURLViaClick(destination_url);
 }
 
 // Checks that server-issued redirects within an iframe in a prerendered
 // page will not count as an "alias" for the prerendered page.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderServerRedirectInIframe) {
-  std::string redirect_path = CreateServerRedirect(
-      "/files/prerender/prerender_embedded_content.html");
-  std::vector<net::SpawnedTestServer::StringPair> replacement_text;
-  replacement_text.push_back(
-      std::make_pair("REPLACE_WITH_URL", "/" + redirect_path));
+  std::string redirect_path =
+      CreateServerRedirect("//prerender/prerender_embedded_content.html");
+  base::StringPairs replacement_text;
+  replacement_text.push_back(std::make_pair("REPLACE_WITH_URL", redirect_path));
   std::string replacement_path;
-  ASSERT_TRUE(net::SpawnedTestServer::GetFilePathWithReplacements(
-      "files/prerender/prerender_with_iframe.html",
-      replacement_text,
-      &replacement_path));
+  net::test_server::GetFilePathWithReplacements(
+      "/prerender/prerender_with_iframe.html", replacement_text,
+      &replacement_path);
   PrerenderTestURL(replacement_path, FINAL_STATUS_USED, 1);
-  EXPECT_FALSE(UrlIsInPrerenderManager(
-      "files/prerender/prerender_embedded_content.html"));
+  EXPECT_FALSE(
+      UrlIsInPrerenderManager("/prerender/prerender_embedded_content.html"));
   NavigateToDestURL();
 }
 
 // Prerenders a page that contains an automatic download triggered through an
 // iframe. This should not prerender successfully.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderDownloadIframe) {
-  PrerenderTestURL("files/prerender/prerender_download_iframe.html",
-                   FINAL_STATUS_DOWNLOAD,
-                   0);
+  PrerenderTestURL("/prerender/prerender_download_iframe.html",
+                   FINAL_STATUS_DOWNLOAD, 0);
 }
 
 // Prerenders a page that contains an automatic download triggered through
 // Javascript changing the window.location. This should not prerender
 // successfully
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderDownloadLocation) {
-  PrerenderTestURL(CreateClientRedirect("files/download-test1.lib"),
-                   FINAL_STATUS_DOWNLOAD,
-                   1);
+  PrerenderTestURL(CreateClientRedirect("/download-test1.lib"),
+                   FINAL_STATUS_DOWNLOAD, 1);
 }
 
 // Prerenders a page that contains an automatic download triggered through a
 // client-issued redirect. This should not prerender successfully.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderDownloadClientRedirect) {
-  PrerenderTestURL("files/prerender/prerender_download_refresh.html",
-                   FINAL_STATUS_DOWNLOAD,
-                   1);
+  PrerenderTestURL("/prerender/prerender_download_refresh.html",
+                   FINAL_STATUS_DOWNLOAD, 1);
 }
 
 // Checks that the referrer is set when prerendering.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderReferrer) {
-  PrerenderTestURL("files/prerender/prerender_referrer.html",
-                   FINAL_STATUS_USED,
-                   1);
+  PrerenderTestURL("/prerender/prerender_referrer.html", FINAL_STATUS_USED, 1);
   NavigateToDestURL();
 }
 
 // Checks that the referrer is not set when prerendering and the source page is
 // HTTPS.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
                        PrerenderNoSSLReferrer) {
   UseHttpsSrcServer();
-  PrerenderTestURL("files/prerender/prerender_no_referrer.html",
-                   FINAL_STATUS_USED,
+  PrerenderTestURL("/prerender/prerender_no_referrer.html", FINAL_STATUS_USED,
                    1);
   NavigateToDestURL();
 }
 
 // Checks that the referrer is set when prerendering is cancelled.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderCancelReferrer) {
   scoped_ptr<TestContentBrowserClient> test_content_browser_client(
       new TestContentBrowserClient);
   content::ContentBrowserClient* original_browser_client =
       content::SetBrowserClientForTesting(test_content_browser_client.get());
 
-  PrerenderTestURL("files/prerender/prerender_referrer.html",
-                   FINAL_STATUS_CANCELLED,
+  PrerenderTestURL("/prerender/prerender_referrer.html", FINAL_STATUS_CANCELLED,
                    1);
   OpenDestURLViaClick();
 
   EXPECT_TRUE(DidDisplayPass(GetActiveWebContents()));
 
   content::SetBrowserClientForTesting(original_browser_client);
 }
 
 // Checks that popups on a prerendered page cause cancellation.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderPopup) {
-  PrerenderTestURL("files/prerender/prerender_popup.html",
-                   FINAL_STATUS_CREATE_NEW_WINDOW,
-                   0);
+  PrerenderTestURL("/prerender/prerender_popup.html",
+                   FINAL_STATUS_CREATE_NEW_WINDOW, 0);
 }
 
 // Checks that registering a protocol handler causes cancellation.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderRegisterProtocolHandler) {
-  PrerenderTestURL("files/prerender/prerender_register_protocol_handler.html",
-                   FINAL_STATUS_REGISTER_PROTOCOL_HANDLER,
-                   0);
+  PrerenderTestURL("/prerender/prerender_register_protocol_handler.html",
+                   FINAL_STATUS_REGISTER_PROTOCOL_HANDLER, 0);
 }
 
 // Checks that renderers using excessive memory will be terminated.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderExcessiveMemory) {
   ASSERT_TRUE(GetPrerenderManager());
   GetPrerenderManager()->mutable_config().max_bytes = 30 * 1024 * 1024;
   // The excessive memory kill may happen before or after the load event as it
   // happens asynchronously with IPC calls. Even if the test does not start
   // allocating until after load, the browser process might notice before the
   // message gets through. This happens on XP debug bots because they're so
   // slow. Instead, don't bother checking the load event count.
   DisableLoadEventCheck();
-  PrerenderTestURL("files/prerender/prerender_excessive_memory.html",
+  PrerenderTestURL("/prerender/prerender_excessive_memory.html",
                    FINAL_STATUS_MEMORY_LIMIT_EXCEEDED, 0);
 }
 
 // Checks shutdown code while a prerender is active.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderQuickQuit) {
   DisableJavascriptCalls();
   DisableLoadEventCheck();
-  PrerenderTestURL("files/prerender/prerender_page.html",
-                   FINAL_STATUS_APP_TERMINATING,
-                   0);
+  PrerenderTestURL("/prerender/prerender_page.html",
+                   FINAL_STATUS_APP_TERMINATING, 0);
 }
 
 // Checks that we don't prerender in an infinite loop.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderInfiniteLoop) {
-  const char* const kHtmlFileA = "files/prerender/prerender_infinite_a.html";
-  const char* const kHtmlFileB = "files/prerender/prerender_infinite_b.html";
+  const char* const kHtmlFileA = "/prerender/prerender_infinite_a.html";
+  const char* const kHtmlFileB = "/prerender/prerender_infinite_b.html";
 
   std::vector<FinalStatus> expected_final_status_queue;
   expected_final_status_queue.push_back(FINAL_STATUS_USED);
   expected_final_status_queue.push_back(FINAL_STATUS_APP_TERMINATING);
 
   ScopedVector<TestPrerender> prerenders =
       PrerenderTestURL(kHtmlFileA, expected_final_status_queue, 1);
   ASSERT_TRUE(prerenders[0]->contents());
   // Assert that the pending prerender is in there already. This relies on the
   // fact that the renderer sends out the AddLinkRelPrerender IPC before sending
@@ skipping 12 matching lines @@
   EXPECT_TRUE(UrlIsInPrerenderManager(kHtmlFileB));
   EXPECT_EQ(1U, GetLinkPrerenderCount());
   EXPECT_EQ(1U, GetRunningLinkPrerenderCount());
 }
 
 // Checks that we don't prerender in an infinite loop and multiple links are
 // handled correctly.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
                        PrerenderInfiniteLoopMultiple) {
   const char* const kHtmlFileA =
-      "files/prerender/prerender_infinite_a_multiple.html";
+      "/prerender/prerender_infinite_a_multiple.html";
   const char* const kHtmlFileB =
-      "files/prerender/prerender_infinite_b_multiple.html";
+      "/prerender/prerender_infinite_b_multiple.html";
   const char* const kHtmlFileC =
-      "files/prerender/prerender_infinite_c_multiple.html";
+      "/prerender/prerender_infinite_c_multiple.html";
 
   // This test is conceptually simplest if concurrency is at two, since we
   // don't have to worry about which of kHtmlFileB or kHtmlFileC gets evicted.
   GetPrerenderManager()->mutable_config().max_link_concurrency = 2;
   GetPrerenderManager()->mutable_config().max_link_concurrency_per_launcher = 2;
 
   std::vector<FinalStatus> expected_final_status_queue;
   expected_final_status_queue.push_back(FINAL_STATUS_USED);
   expected_final_status_queue.push_back(FINAL_STATUS_APP_TERMINATING);
   expected_final_status_queue.push_back(FINAL_STATUS_APP_TERMINATING);
@@ skipping 19 matching lines @@
   bool url_b_is_active_prerender = UrlIsInPrerenderManager(kHtmlFileB);
   bool url_c_is_active_prerender = UrlIsInPrerenderManager(kHtmlFileC);
   EXPECT_TRUE(url_b_is_active_prerender && url_c_is_active_prerender);
   EXPECT_EQ(2U, GetLinkPrerenderCount());
   EXPECT_EQ(2U, GetRunningLinkPrerenderCount());
 }
 
 // Checks that pending prerenders are aborted (and never launched) when launched
 // by a prerender that itself gets aborted.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderAbortPendingOnCancel) {
-  const char* const kHtmlFileA = "files/prerender/prerender_infinite_a.html";
-  const char* const kHtmlFileB = "files/prerender/prerender_infinite_b.html";
+  const char* const kHtmlFileA = "/prerender/prerender_infinite_a.html";
+  const char* const kHtmlFileB = "/prerender/prerender_infinite_b.html";
 
   scoped_ptr<TestPrerender> prerender =
       PrerenderTestURL(kHtmlFileA, FINAL_STATUS_CANCELLED, 1);
   ASSERT_TRUE(prerender->contents());
   // Assert that the pending prerender is in there already. This relies on the
   // fact that the renderer sends out the AddLinkRelPrerender IPC before sending
   // the page load one.
   EXPECT_EQ(2U, GetLinkPrerenderCount());
   EXPECT_EQ(1U, GetRunningLinkPrerenderCount());
 
@@ skipping 18 matching lines @@
   const base::string16 original = MatchTaskManagerTab("Preloader");
   const base::string16 prerender = MatchTaskManagerPrerender("Prerender Page");
   const base::string16 final = MatchTaskManagerTab("Prerender Page");
 
   // Show the task manager. This populates the model.
   chrome::OpenTaskManager(current_browser());
   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, any_tab));
   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(0, any_prerender));
 
   // Prerender a page in addition to the original tab.
-  PrerenderTestURL("files/prerender/prerender_page.html", FINAL_STATUS_USED, 1);
+  PrerenderTestURL("/prerender/prerender_page.html", FINAL_STATUS_USED, 1);
 
   // A TaskManager entry should appear like "Prerender: Prerender Page"
   // alongside the original tab entry. There should be just these two entries.
   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, prerender));
   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, original));
   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(0, final));
   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, any_prerender));
   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, any_tab));
 
   // Swap in the prerendered content.
@@ skipping 13 matching lines @@
   // explicitly disable the new one.
   task_manager::browsertest_util::EnableOldTaskManager();
 
   const base::string16 any_prerender = MatchTaskManagerPrerender("*");
   const base::string16 any_tab = MatchTaskManagerTab("*");
   const base::string16 original = MatchTaskManagerTab("Preloader");
   const base::string16 prerender = MatchTaskManagerPrerender("Prerender Page");
   const base::string16 final = MatchTaskManagerTab("Prerender Page");
 
   // Start with two resources.
-  PrerenderTestURL("files/prerender/prerender_page.html", FINAL_STATUS_USED, 1);
+  PrerenderTestURL("/prerender/prerender_page.html", FINAL_STATUS_USED, 1);
 
   // Show the task manager. This populates the model. Importantly, we're doing
   // this after the prerender WebContents already exists - the task manager
   // needs to find it, it can't just listen for creation.
   chrome::OpenTaskManager(current_browser());
 
   // A TaskManager entry should appear like "Prerender: Prerender Page"
   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, prerender));
   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, original));
   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(0, final));
@@ skipping 15 matching lines @@
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, OpenTaskManagerAfterSwapIn) {
   // This test is for the old implementation of the task manager. We must
   // explicitly disable the new one.
   task_manager::browsertest_util::EnableOldTaskManager();
 
   const base::string16 any_prerender = MatchTaskManagerPrerender("*");
   const base::string16 any_tab = MatchTaskManagerTab("*");
   const base::string16 final = MatchTaskManagerTab("Prerender Page");
 
   // Prerender, and swap it in.
-  PrerenderTestURL("files/prerender/prerender_page.html", FINAL_STATUS_USED, 1);
+  PrerenderTestURL("/prerender/prerender_page.html", FINAL_STATUS_USED, 1);
   NavigateToDestURL();
 
   // Show the task manager. This populates the model. Importantly, we're doing
   // this after the prerender has been swapped in.
   chrome::OpenTaskManager(current_browser());
 
   // We should not see a prerender resource in the task manager, just a normal
   // page.
   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, final));
   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, any_tab));
   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(0, any_prerender));
 }
 
 // Checks that audio loads are deferred on prerendering.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderHTML5Audio) {
-  PrerenderTestURL("files/prerender/prerender_html5_audio.html",
-                   FINAL_STATUS_USED,
+  PrerenderTestURL("/prerender/prerender_html5_audio.html", FINAL_STATUS_USED,
                    1);
   NavigateToDestURL();
   WaitForASCIITitle(GetActiveWebContents(), kPassTitle);
 }
 
 // Checks that audio loads are deferred on prerendering and played back when
 // the prerender is swapped in if autoplay is set.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderHTML5AudioAutoplay) {
-  PrerenderTestURL("files/prerender/prerender_html5_audio_autoplay.html",
-                   FINAL_STATUS_USED,
-                   1);
+  PrerenderTestURL("/prerender/prerender_html5_audio_autoplay.html",
+                   FINAL_STATUS_USED, 1);
   NavigateToDestURL();
   WaitForASCIITitle(GetActiveWebContents(), kPassTitle);
 }
 
 // Checks that audio loads are deferred on prerendering and played back when
 // the prerender is swapped in if js starts playing.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderHTML5AudioJsplay) {
-  PrerenderTestURL("files/prerender/prerender_html5_audio_jsplay.html",
-                   FINAL_STATUS_USED,
-                   1);
+  PrerenderTestURL("/prerender/prerender_html5_audio_jsplay.html",
+                   FINAL_STATUS_USED, 1);
   NavigateToDestURL();
   WaitForASCIITitle(GetActiveWebContents(), kPassTitle);
 }
 
 // Checks that video loads are deferred on prerendering.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderHTML5Video) {
-  PrerenderTestURL("files/prerender/prerender_html5_video.html",
-                   FINAL_STATUS_USED,
+  PrerenderTestURL("/prerender/prerender_html5_video.html", FINAL_STATUS_USED,
                    1);
   NavigateToDestURL();
   WaitForASCIITitle(GetActiveWebContents(), kPassTitle);
 }
 
 // Checks that video tags inserted by javascript are deferred and played
 // correctly on swap in.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderHTML5VideoJs) {
-  PrerenderTestURL("files/prerender/prerender_html5_video_script.html",
-                   FINAL_STATUS_USED,
-                   1);
+  PrerenderTestURL("/prerender/prerender_html5_video_script.html",
+                   FINAL_STATUS_USED, 1);
   NavigateToDestURL();
   WaitForASCIITitle(GetActiveWebContents(), kPassTitle);
 }
 
 // Checks for correct network events by using a busy sleep the javascript.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderHTML5VideoNetwork) {
   DisableJavascriptCalls();
-  scoped_ptr<TestPrerender> prerender =
-      PrerenderTestURL("files/prerender/prerender_html5_video_network.html",
-                       FINAL_STATUS_USED,
-                       1);
+  scoped_ptr<TestPrerender> prerender = PrerenderTestURL(
+      "/prerender/prerender_html5_video_network.html", FINAL_STATUS_USED, 1);
   WaitForASCIITitle(prerender->contents()->prerender_contents(), kReadyTitle);
   EXPECT_TRUE(DidPrerenderPass(prerender->contents()->prerender_contents()));
   NavigateToDestURL();
   WaitForASCIITitle(GetActiveWebContents(), kPassTitle);
 }
 
 // Checks that scripts can retrieve the correct window size while prerendering.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderWindowSize) {
-  PrerenderTestURL("files/prerender/prerender_size.html",
-                   FINAL_STATUS_USED,
-                   1);
+  PrerenderTestURL("/prerender/prerender_size.html", FINAL_STATUS_USED, 1);
   NavigateToDestURL();
 }
 
 // TODO(jam): http://crbug.com/350550
 #if !(defined(OS_CHROMEOS) && defined(ADDRESS_SANITIZER))
 
 // Checks that prerenderers will terminate when the RenderView crashes.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderRendererCrash) {
-  scoped_ptr<TestPrerender> prerender =
-      PrerenderTestURL("files/prerender/prerender_page.html",
-                       FINAL_STATUS_RENDERER_CRASHED,
-                       1);
+  scoped_ptr<TestPrerender> prerender = PrerenderTestURL(
+      "/prerender/prerender_page.html", FINAL_STATUS_RENDERER_CRASHED, 1);
 
   // Navigate to about:crash and then wait for the renderer to crash.
   ASSERT_TRUE(prerender->contents());
   ASSERT_TRUE(prerender->contents()->prerender_contents());
   prerender->contents()->prerender_contents()->GetController().
       LoadURL(
           GURL(content::kChromeUICrashURL),
           content::Referrer(),
           ui::PAGE_TRANSITION_TYPED,
           std::string());
   prerender->WaitForStop();
 }
 #endif
 
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
                        PrerenderPageWithFragment) {
-  PrerenderTestURL("files/prerender/prerender_page.html#fragment",
-                   FINAL_STATUS_USED,
+  PrerenderTestURL("/prerender/prerender_page.html#fragment", FINAL_STATUS_USED,
                    1);
 
   ChannelDestructionWatcher channel_close_watcher;
   channel_close_watcher.WatchChannel(browser()->tab_strip_model()->
       GetActiveWebContents()->GetRenderProcessHost());
   NavigateToDestURL();
   channel_close_watcher.WaitForChannelClose();
 
   ASSERT_TRUE(IsEmptyPrerenderLinkManager());
 }
 
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
                        PrerenderPageWithRedirectedFragment) {
   PrerenderTestURL(
-      CreateClientRedirect("files/prerender/prerender_page.html#fragment"),
-      FINAL_STATUS_USED,
-      2);
+      CreateClientRedirect("/prerender/prerender_page.html#fragment"),
+      FINAL_STATUS_USED, 2);
 
   ChannelDestructionWatcher channel_close_watcher;
   channel_close_watcher.WatchChannel(browser()->tab_strip_model()->
       GetActiveWebContents()->GetRenderProcessHost());
   NavigateToDestURL();
   channel_close_watcher.WaitForChannelClose();
 
   ASSERT_TRUE(IsEmptyPrerenderLinkManager());
 }
 
 // Checks that we do not use a prerendered page when navigating from
 // the main page to a fragment.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
                        PrerenderPageNavigateFragment) {
-  PrerenderTestURL("files/prerender/no_prerender_page.html",
-                   FINAL_STATUS_APP_TERMINATING,
-                   1);
-  NavigateToURLWithDisposition(
-      "files/prerender/no_prerender_page.html#fragment",
-      CURRENT_TAB, false);
+  PrerenderTestURL("/prerender/no_prerender_page.html",
+                   FINAL_STATUS_APP_TERMINATING, 1);
+  NavigateToURLWithDisposition("/prerender/no_prerender_page.html#fragment",
+                               CURRENT_TAB, false);
 }
 
 // Checks that we do not use a prerendered page when we prerender a fragment
 // but navigate to the main page.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
                        PrerenderFragmentNavigatePage) {
-  PrerenderTestURL("files/prerender/no_prerender_page.html#fragment",
-                   FINAL_STATUS_APP_TERMINATING,
-                   1);
-  NavigateToURLWithDisposition(
-      "files/prerender/no_prerender_page.html",
-      CURRENT_TAB, false);
+  PrerenderTestURL("/prerender/no_prerender_page.html#fragment",
+                   FINAL_STATUS_APP_TERMINATING, 1);
+  NavigateToURLWithDisposition("/prerender/no_prerender_page.html", CURRENT_TAB,
+                               false);
 }
 
 // Checks that we do not use a prerendered page when we prerender a fragment
 // but navigate to a different fragment on the same page.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
                        PrerenderFragmentNavigateFragment) {
-  PrerenderTestURL("files/prerender/no_prerender_page.html#other_fragment",
-                   FINAL_STATUS_APP_TERMINATING,
-                   1);
-  NavigateToURLWithDisposition(
-      "files/prerender/no_prerender_page.html#fragment",
-      CURRENT_TAB, false);
+  PrerenderTestURL("/prerender/no_prerender_page.html#other_fragment",
+                   FINAL_STATUS_APP_TERMINATING, 1);
+  NavigateToURLWithDisposition("/prerender/no_prerender_page.html#fragment",
+                               CURRENT_TAB, false);
 }
 
 // Checks that we do not use a prerendered page when the page uses a client
 // redirect to refresh from a fragment on the same page.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
                        PrerenderClientRedirectFromFragment) {
   PrerenderTestURL(
-      CreateClientRedirect("files/prerender/no_prerender_page.html#fragment"),
-      FINAL_STATUS_APP_TERMINATING,
-      2);
-  NavigateToURLWithDisposition(
-      "files/prerender/no_prerender_page.html",
-      CURRENT_TAB, false);
+      CreateClientRedirect("/prerender/no_prerender_page.html#fragment"),
+      FINAL_STATUS_APP_TERMINATING, 2);
+  NavigateToURLWithDisposition("/prerender/no_prerender_page.html", CURRENT_TAB,
+                               false);
 }
 
 // Checks that we do not use a prerendered page when the page uses a client
 // redirect to refresh to a fragment on the same page.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
                        PrerenderClientRedirectToFragment) {
-  PrerenderTestURL(
-      CreateClientRedirect("files/prerender/no_prerender_page.html"),
-      FINAL_STATUS_APP_TERMINATING,
-      2);
-  NavigateToURLWithDisposition(
-      "files/prerender/no_prerender_page.html#fragment",
-      CURRENT_TAB, false);
+  PrerenderTestURL(CreateClientRedirect("/prerender/no_prerender_page.html"),
+                   FINAL_STATUS_APP_TERMINATING, 2);
+  NavigateToURLWithDisposition("/prerender/no_prerender_page.html#fragment",
+                               CURRENT_TAB, false);
 }
 
 // Checks that we correctly use a prerendered page when the page uses JS to set
 // the window.location.hash to a fragment on the same page.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
                        PrerenderPageChangeFragmentLocationHash) {
-  PrerenderTestURL("files/prerender/prerender_fragment_location_hash.html",
-                   FINAL_STATUS_USED,
-                   1);
-  NavigateToURL("files/prerender/prerender_fragment_location_hash.html");
+  PrerenderTestURL("/prerender/prerender_fragment_location_hash.html",
+                   FINAL_STATUS_USED, 1);
+  NavigateToURL("/prerender/prerender_fragment_location_hash.html");
 }
 
 // Checks that prerendering a PNG works correctly.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderImagePng) {
   DisableJavascriptCalls();
-  PrerenderTestURL("files/prerender/image.png", FINAL_STATUS_USED, 1);
+  PrerenderTestURL("/prerender/image.png", FINAL_STATUS_USED, 1);
   NavigateToDestURL();
 }
 
 // Checks that prerendering a JPG works correctly.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderImageJpeg) {
   DisableJavascriptCalls();
-  PrerenderTestURL("files/prerender/image.jpeg", FINAL_STATUS_USED, 1);
+  PrerenderTestURL("/prerender/image.jpeg", FINAL_STATUS_USED, 1);
   NavigateToDestURL();
 }
 
 // Checks that a prerender of a CRX will result in a cancellation due to
 // download.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderCrx) {
-  PrerenderTestURL("files/prerender/extension.crx", FINAL_STATUS_DOWNLOAD, 0);
+  PrerenderTestURL("/prerender/extension.crx", FINAL_STATUS_DOWNLOAD, 0);
 }
 
 // Checks that xhr GET requests allow prerenders.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderXhrGet) {
-  PrerenderTestURL("files/prerender/prerender_xhr_get.html",
-                   FINAL_STATUS_USED,
-                   1);
+  PrerenderTestURL("/prerender/prerender_xhr_get.html", FINAL_STATUS_USED, 1);
   NavigateToDestURL();
 }
 
 // Checks that xhr HEAD requests allow prerenders.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderXhrHead) {
-  PrerenderTestURL("files/prerender/prerender_xhr_head.html",
-                   FINAL_STATUS_USED,
-                   1);
+  PrerenderTestURL("/prerender/prerender_xhr_head.html", FINAL_STATUS_USED, 1);
   NavigateToDestURL();
 }
 
 // Checks that xhr OPTIONS requests allow prerenders.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderXhrOptions) {
-  PrerenderTestURL("files/prerender/prerender_xhr_options.html",
-                   FINAL_STATUS_USED,
+  PrerenderTestURL("/prerender/prerender_xhr_options.html", FINAL_STATUS_USED,
                    1);
   NavigateToDestURL();
 }
 
 // Checks that xhr TRACE requests allow prerenders.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderXhrTrace) {
-  PrerenderTestURL("files/prerender/prerender_xhr_trace.html",
-                   FINAL_STATUS_USED,
-                   1);
+  PrerenderTestURL("/prerender/prerender_xhr_trace.html", FINAL_STATUS_USED, 1);
   NavigateToDestURL();
 }
 
 // Checks that xhr POST requests allow prerenders.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderXhrPost) {
-  PrerenderTestURL("files/prerender/prerender_xhr_post.html",
-                   FINAL_STATUS_USED,
-                   1);
+  PrerenderTestURL("/prerender/prerender_xhr_post.html", FINAL_STATUS_USED, 1);
   NavigateToDestURL();
 }
 
 // Checks that xhr PUT cancels prerenders.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderXhrPut) {
-  PrerenderTestURL("files/prerender/prerender_xhr_put.html",
-                   FINAL_STATUS_INVALID_HTTP_METHOD,
-                   1);
+  PrerenderTestURL("/prerender/prerender_xhr_put.html",
+                   FINAL_STATUS_INVALID_HTTP_METHOD, 1);
 }
 
 // Checks that xhr DELETE cancels prerenders.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderXhrDelete) {
-  PrerenderTestURL("files/prerender/prerender_xhr_delete.html",
-                   FINAL_STATUS_INVALID_HTTP_METHOD,
-                   1);
+  PrerenderTestURL("/prerender/prerender_xhr_delete.html",
+                   FINAL_STATUS_INVALID_HTTP_METHOD, 1);
 }
 
 // Checks that a top-level page which would trigger an SSL error is canceled.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderSSLErrorTopLevel) {
-  net::SpawnedTestServer::SSLOptions ssl_options;
-  ssl_options.server_certificate =
-      net::SpawnedTestServer::SSLOptions::CERT_MISMATCHED_NAME;
-  net::SpawnedTestServer https_server(
-      net::SpawnedTestServer::TYPE_HTTPS, ssl_options,
-      base::FilePath(FILE_PATH_LITERAL("chrome/test/data")));
+  net::EmbeddedTestServer https_server(net::EmbeddedTestServer::TYPE_HTTPS);
+  https_server.SetSSLConfig(net::EmbeddedTestServer::CERT_MISMATCHED_NAME);
+  https_server.ServeFilesFromSourceDirectory("chrome/test/data");
   ASSERT_TRUE(https_server.Start());
-  GURL https_url = https_server.GetURL("files/prerender/prerender_page.html");
+  GURL https_url = https_server.GetURL("/prerender/prerender_page.html");
   PrerenderTestURL(https_url,
                    FINAL_STATUS_SSL_ERROR,
                    0);
 }
 
 // Checks that an SSL error that comes from a subresource does not cancel
 // the page. Non-main-frame requests are simply cancelled if they run into
 // an SSL problem.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderSSLErrorSubresource) {
-  net::SpawnedTestServer::SSLOptions ssl_options;
-  ssl_options.server_certificate =
-      net::SpawnedTestServer::SSLOptions::CERT_MISMATCHED_NAME;
-  net::SpawnedTestServer https_server(
-      net::SpawnedTestServer::TYPE_HTTPS, ssl_options,
-      base::FilePath(FILE_PATH_LITERAL("chrome/test/data")));
+  net::EmbeddedTestServer https_server(net::EmbeddedTestServer::TYPE_HTTPS);
+  https_server.SetSSLConfig(net::EmbeddedTestServer::CERT_MISMATCHED_NAME);
+  https_server.ServeFilesFromSourceDirectory("chrome/test/data");
   ASSERT_TRUE(https_server.Start());
-  GURL https_url = https_server.GetURL("files/prerender/image.jpeg");
-  std::vector<net::SpawnedTestServer::StringPair> replacement_text;
+  GURL https_url = https_server.GetURL("/prerender/image.jpeg");
+  base::StringPairs replacement_text;
   replacement_text.push_back(
       std::make_pair("REPLACE_WITH_IMAGE_URL", https_url.spec()));
   std::string replacement_path;
-  ASSERT_TRUE(net::SpawnedTestServer::GetFilePathWithReplacements(
-      "files/prerender/prerender_with_image.html",
-      replacement_text,
-      &replacement_path));
+  net::test_server::GetFilePathWithReplacements(
+      "/prerender/prerender_with_image.html", replacement_text,
+      &replacement_path);
   PrerenderTestURL(replacement_path, FINAL_STATUS_USED, 1);
   NavigateToDestURL();
 }
 
 // Checks that an SSL error that comes from an iframe does not cancel
 // the page. Non-main-frame requests are simply cancelled if they run into
 // an SSL problem.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderSSLErrorIframe) {
-  net::SpawnedTestServer::SSLOptions ssl_options;
-  ssl_options.server_certificate =
-      net::SpawnedTestServer::SSLOptions::CERT_MISMATCHED_NAME;
-  net::SpawnedTestServer https_server(
-      net::SpawnedTestServer::TYPE_HTTPS, ssl_options,
-      base::FilePath(FILE_PATH_LITERAL("chrome/test/data")));
+  net::EmbeddedTestServer https_server(net::EmbeddedTestServer::TYPE_HTTPS);
+  https_server.SetSSLConfig(net::EmbeddedTestServer::CERT_MISMATCHED_NAME);
+  https_server.ServeFilesFromSourceDirectory("chrome/test/data");
   ASSERT_TRUE(https_server.Start());
-  GURL https_url = https_server.GetURL(
-      "files/prerender/prerender_embedded_content.html");
-  std::vector<net::SpawnedTestServer::StringPair> replacement_text;
+  GURL https_url =
+      https_server.GetURL("/prerender/prerender_embedded_content.html");
+  base::StringPairs replacement_text;
   replacement_text.push_back(
       std::make_pair("REPLACE_WITH_URL", https_url.spec()));
   std::string replacement_path;
-  ASSERT_TRUE(net::SpawnedTestServer::GetFilePathWithReplacements(
-      "files/prerender/prerender_with_iframe.html",
-      replacement_text,
-      &replacement_path));
+  net::test_server::GetFilePathWithReplacements(
+      "/prerender/prerender_with_iframe.html", replacement_text,
+      &replacement_path);
   PrerenderTestURL(replacement_path, FINAL_STATUS_USED, 1);
   NavigateToDestURL();
 }
 
 // Checks that we cancel correctly when window.print() is called.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderPrint) {
   DisableLoadEventCheck();
-  PrerenderTestURL("files/prerender/prerender_print.html",
-                   FINAL_STATUS_WINDOW_PRINT,
+  PrerenderTestURL("/prerender/prerender_print.html", FINAL_STATUS_WINDOW_PRINT,
                    0);
 }
 
 // Checks that prerenders do not get swapped into target pages that have opened
 // popups; the BrowsingInstance is not empty.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderTargetHasPopup) {
-  PrerenderTestURL("files/prerender/prerender_page.html",
-                   FINAL_STATUS_NON_EMPTY_BROWSING_INSTANCE,
-                   1);
+  PrerenderTestURL("/prerender/prerender_page.html",
+                   FINAL_STATUS_NON_EMPTY_BROWSING_INSTANCE, 1);
   OpenURLViaWindowOpen(GURL(url::kAboutBlankURL));
 
   // Switch back to the current tab and attempt to swap it in.
   current_browser()->tab_strip_model()->ActivateTabAt(0, true);
   NavigateToDestURLWithDisposition(CURRENT_TAB, false);
 }
 
 class TestClientCertStore : public net::ClientCertStore {
  public:
   TestClientCertStore() {}
@@ skipping 15 matching lines @@
 }
 
 // Checks that a top-level page which would normally request an SSL client
 // certificate will never be seen since it's an https top-level resource.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
                        PrerenderSSLClientCertTopLevel) {
   ProfileIOData::FromResourceContext(
       current_browser()->profile()->GetResourceContext())->
           set_client_cert_store_factory_for_testing(
               base::Bind(&CreateCertStore));
-  net::SpawnedTestServer::SSLOptions ssl_options;
-  ssl_options.request_client_certificate = true;
-  net::SpawnedTestServer https_server(
-      net::SpawnedTestServer::TYPE_HTTPS, ssl_options,
-      base::FilePath(FILE_PATH_LITERAL("chrome/test/data")));
+  net::EmbeddedTestServer https_server(net::EmbeddedTestServer::TYPE_HTTPS);
+  net::SSLServerConfig ssl_config;
+  ssl_config.require_client_cert = true;
+  https_server.SetSSLConfig(net::EmbeddedTestServer::CERT_OK, ssl_config);
+  https_server.ServeFilesFromSourceDirectory("chrome/test/data");
   ASSERT_TRUE(https_server.Start());
-  GURL https_url = https_server.GetURL("files/prerender/prerender_page.html");
+  GURL https_url = https_server.GetURL("/prerender/prerender_page.html");
   PrerenderTestURL(https_url, FINAL_STATUS_SSL_CLIENT_CERTIFICATE_REQUESTED, 0);
 }
 
 // Checks that an SSL Client Certificate request that originates from a
 // subresource will cancel the prerendered page.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
                        PrerenderSSLClientCertSubresource) {
   ProfileIOData::FromResourceContext(
       current_browser()->profile()->GetResourceContext())->
           set_client_cert_store_factory_for_testing(
               base::Bind(&CreateCertStore));
-  net::SpawnedTestServer::SSLOptions ssl_options;
-  ssl_options.request_client_certificate = true;
-  net::SpawnedTestServer https_server(
-      net::SpawnedTestServer::TYPE_HTTPS, ssl_options,
-      base::FilePath(FILE_PATH_LITERAL("chrome/test/data")));
+  net::EmbeddedTestServer https_server(net::EmbeddedTestServer::TYPE_HTTPS);
+  net::SSLServerConfig ssl_config;
+  ssl_config.require_client_cert = true;
+  https_server.SetSSLConfig(net::EmbeddedTestServer::CERT_OK, ssl_config);
+  https_server.ServeFilesFromSourceDirectory("chrome/test/data");
   ASSERT_TRUE(https_server.Start());
-  GURL https_url = https_server.GetURL("files/prerender/image.jpeg");
-  std::vector<net::SpawnedTestServer::StringPair> replacement_text;
+  GURL https_url = https_server.GetURL("/prerender/image.jpeg");
+  base::StringPairs replacement_text;
   replacement_text.push_back(
       std::make_pair("REPLACE_WITH_IMAGE_URL", https_url.spec()));
   std::string replacement_path;
-  ASSERT_TRUE(net::SpawnedTestServer::GetFilePathWithReplacements(
-      "files/prerender/prerender_with_image.html",
-      replacement_text,
-      &replacement_path));
+  net::test_server::GetFilePathWithReplacements(
+      "/prerender/prerender_with_image.html", replacement_text,
+      &replacement_path);
   PrerenderTestURL(replacement_path,
                    FINAL_STATUS_SSL_CLIENT_CERTIFICATE_REQUESTED,
                    0);
 }
 
 // Checks that an SSL Client Certificate request that originates from an
 // iframe will cancel the prerendered page.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderSSLClientCertIframe) {
   ProfileIOData::FromResourceContext(
       current_browser()->profile()->GetResourceContext())->
           set_client_cert_store_factory_for_testing(
               base::Bind(&CreateCertStore));
-  net::SpawnedTestServer::SSLOptions ssl_options;
-  ssl_options.request_client_certificate = true;
-  net::SpawnedTestServer https_server(
-      net::SpawnedTestServer::TYPE_HTTPS, ssl_options,
-      base::FilePath(FILE_PATH_LITERAL("chrome/test/data")));
+  net::EmbeddedTestServer https_server(net::EmbeddedTestServer::TYPE_HTTPS);
+  net::SSLServerConfig ssl_config;
+  ssl_config.require_client_cert = true;
+  https_server.SetSSLConfig(net::EmbeddedTestServer::CERT_OK, ssl_config);
+  https_server.ServeFilesFromSourceDirectory("chrome/test/data");
   ASSERT_TRUE(https_server.Start());
-  GURL https_url = https_server.GetURL(
-      "files/prerender/prerender_embedded_content.html");
-  std::vector<net::SpawnedTestServer::StringPair> replacement_text;
+  GURL https_url =
+      https_server.GetURL("/prerender/prerender_embedded_content.html");
+  base::StringPairs replacement_text;
   replacement_text.push_back(
       std::make_pair("REPLACE_WITH_URL", https_url.spec()));
   std::string replacement_path;
-  ASSERT_TRUE(net::SpawnedTestServer::GetFilePathWithReplacements(
-      "files/prerender/prerender_with_iframe.html",
-      replacement_text,
-      &replacement_path));
+  net::test_server::GetFilePathWithReplacements(
+      "/prerender/prerender_with_iframe.html", replacement_text,
+      &replacement_path);
   PrerenderTestURL(replacement_path,
                    FINAL_STATUS_SSL_CLIENT_CERTIFICATE_REQUESTED,
                    0);
 }
 
 #if defined(FULL_SAFE_BROWSING)
 // Ensures that we do not prerender pages with a safe browsing
 // interstitial.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderSafeBrowsingTopLevel) {
-  GURL url = test_server()->GetURL("files/prerender/prerender_page.html");
+  GURL url = embedded_test_server()->GetURL("/prerender/prerender_page.html");
   GetFakeSafeBrowsingDatabaseManager()->SetThreatTypeForUrl(
       url, safe_browsing::SB_THREAT_TYPE_URL_MALWARE);
-  PrerenderTestURL("files/prerender/prerender_page.html",
-                   FINAL_STATUS_SAFE_BROWSING, 0);
+  PrerenderTestURL("/prerender/prerender_page.html", FINAL_STATUS_SAFE_BROWSING,
+                   0);
 }
 
 // Ensures that server redirects to a malware page will cancel prerenders.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
                        PrerenderSafeBrowsingServerRedirect) {
-  GURL url = test_server()->GetURL("files/prerender/prerender_page.html");
+  GURL url = embedded_test_server()->GetURL("/prerender/prerender_page.html");
   GetFakeSafeBrowsingDatabaseManager()->SetThreatTypeForUrl(
       url, safe_browsing::SB_THREAT_TYPE_URL_MALWARE);
-  PrerenderTestURL(CreateServerRedirect("files/prerender/prerender_page.html"),
-                   FINAL_STATUS_SAFE_BROWSING,
-                   0);
+  PrerenderTestURL(CreateServerRedirect("/prerender/prerender_page.html"),
+                   FINAL_STATUS_SAFE_BROWSING, 0);
 }
 
 // Ensures that client redirects to a malware page will cancel prerenders.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
                        PrerenderSafeBrowsingClientRedirect) {
-  GURL url = test_server()->GetURL("files/prerender/prerender_page.html");
+  GURL url = embedded_test_server()->GetURL("/prerender/prerender_page.html");
   GetFakeSafeBrowsingDatabaseManager()->SetThreatTypeForUrl(
       url, safe_browsing::SB_THREAT_TYPE_URL_MALWARE);
-  PrerenderTestURL(CreateClientRedirect("files/prerender/prerender_page.html"),
-                   FINAL_STATUS_SAFE_BROWSING,
-                   1);
+  PrerenderTestURL(CreateClientRedirect("/prerender/prerender_page.html"),
+                   FINAL_STATUS_SAFE_BROWSING, 1);
 }
 
 // Ensures that we do not prerender pages which have a malware subresource.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderSafeBrowsingSubresource) {
-  GURL image_url = test_server()->GetURL("files/prerender/image.jpeg");
+  GURL image_url = embedded_test_server()->GetURL("/prerender/image.jpeg");
   GetFakeSafeBrowsingDatabaseManager()->SetThreatTypeForUrl(
       image_url, safe_browsing::SB_THREAT_TYPE_URL_MALWARE);
-  std::vector<net::SpawnedTestServer::StringPair> replacement_text;
+  base::StringPairs replacement_text;
   replacement_text.push_back(
       std::make_pair("REPLACE_WITH_IMAGE_URL", image_url.spec()));
   std::string replacement_path;
-  ASSERT_TRUE(net::SpawnedTestServer::GetFilePathWithReplacements(
-      "files/prerender/prerender_with_image.html",
-      replacement_text,
-      &replacement_path));
+  net::test_server::GetFilePathWithReplacements(
+      "/prerender/prerender_with_image.html", replacement_text,
+      &replacement_path);
   PrerenderTestURL(replacement_path,
                    FINAL_STATUS_SAFE_BROWSING,
                    0);
 }
 
 // Ensures that we do not prerender pages which have a malware iframe.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderSafeBrowsingIframe) {
-  GURL iframe_url = test_server()->GetURL(
-      "files/prerender/prerender_embedded_content.html");
+  GURL iframe_url = embedded_test_server()->GetURL(
+      "/prerender/prerender_embedded_content.html");
   GetFakeSafeBrowsingDatabaseManager()->SetThreatTypeForUrl(
       iframe_url, safe_browsing::SB_THREAT_TYPE_URL_MALWARE);
-  std::vector<net::SpawnedTestServer::StringPair> replacement_text;
+  base::StringPairs replacement_text;
   replacement_text.push_back(
       std::make_pair("REPLACE_WITH_URL", iframe_url.spec()));
   std::string replacement_path;
-  ASSERT_TRUE(net::SpawnedTestServer::GetFilePathWithReplacements(
-      "files/prerender/prerender_with_iframe.html",
-      replacement_text,
-      &replacement_path));
+  net::test_server::GetFilePathWithReplacements(
+      "/prerender/prerender_with_iframe.html", replacement_text,
+      &replacement_path);
   PrerenderTestURL(replacement_path,
                    FINAL_STATUS_SAFE_BROWSING,
                    0);
 }
 
 #endif
 
 // Checks that a local storage read will not cause prerender to fail.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderLocalStorageRead) {
-  PrerenderTestURL("files/prerender/prerender_localstorage_read.html",
-                   FINAL_STATUS_USED,
-                   1);
+  PrerenderTestURL("/prerender/prerender_localstorage_read.html",
+                   FINAL_STATUS_USED, 1);
   NavigateToDestURL();
 }
 
 // Checks that a local storage write will not cause prerender to fail.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderLocalStorageWrite) {
-  PrerenderTestURL("files/prerender/prerender_localstorage_write.html",
-                   FINAL_STATUS_USED,
-                   1);
+  PrerenderTestURL("/prerender/prerender_localstorage_write.html",
+                   FINAL_STATUS_USED, 1);
   NavigateToDestURL();
 }
 
 // Checks that the favicon is properly loaded on prerender.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderFavicon) {
-  scoped_ptr<TestPrerender> prerender =
-      PrerenderTestURL("files/prerender/prerender_favicon.html",
-                       FINAL_STATUS_USED,
-                       1);
+  scoped_ptr<TestPrerender> prerender = PrerenderTestURL(
+      "/prerender/prerender_favicon.html", FINAL_STATUS_USED, 1);
   NavigateToDestURL();
 
   favicon::FaviconDriver* favicon_driver =
       favicon::ContentFaviconDriver::FromWebContents(GetActiveWebContents());
   if (!favicon_driver->FaviconIsValid()) {
     // If the favicon has not been set yet, wait for it to be.
     FaviconUpdateWatcher favicon_update_watcher(GetActiveWebContents());
     favicon_update_watcher.Wait();
   }
   EXPECT_TRUE(favicon_driver->FaviconIsValid());
 }
 
 // Checks that when a prerendered page is swapped in to a referring page, the
 // unload handlers on the referring page are executed.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderUnload) {
   // Matches URL in prerender_loader_with_unload.html.
   const GURL unload_url("http://unload-url.test");
   base::FilePath empty_file = ui_test_utils::GetTestFilePath(
       base::FilePath(), base::FilePath(FILE_PATH_LITERAL("empty.html")));
   RequestCounter unload_counter;
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&CreateCountingInterceptorOnIO,
                  unload_url, empty_file, unload_counter.AsWeakPtr()));
 
-  set_loader_path("files/prerender/prerender_loader_with_unload.html");
-  PrerenderTestURL("files/prerender/prerender_page.html", FINAL_STATUS_USED, 1);
+  set_loader_path("/prerender/prerender_loader_with_unload.html");
+  PrerenderTestURL("/prerender/prerender_page.html", FINAL_STATUS_USED, 1);
   NavigateToDestURL();
   unload_counter.WaitForCount(1);
 }
 
 // Checks that a hanging unload on the referring page of a prerender swap does
 // not crash the browser on exit.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderHangingUnload) {
   // Matches URL in prerender_loader_with_unload.html.
   const GURL hang_url("http://unload-url.test");
   base::FilePath empty_file = ui_test_utils::GetTestFilePath(
       base::FilePath(), base::FilePath(FILE_PATH_LITERAL("empty.html")));
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&CreateHangingFirstRequestInterceptorOnIO,
                  hang_url, empty_file,
                  base::Closure()));
 
-  set_loader_path("files/prerender/prerender_loader_with_unload.html");
-  PrerenderTestURL("files/prerender/prerender_page.html", FINAL_STATUS_USED, 1);
+  set_loader_path("/prerender/prerender_loader_with_unload.html");
+  PrerenderTestURL("/prerender/prerender_page.html", FINAL_STATUS_USED, 1);
   NavigateToDestURL();
 }
 
 
 // Checks that when the history is cleared, prerendering is cancelled and
 // prerendering history is cleared.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderClearHistory) {
   scoped_ptr<TestPrerender> prerender =
-      PrerenderTestURL("files/prerender/prerender_page.html",
-                       FINAL_STATUS_CACHE_OR_HISTORY_CLEARED,
-                       1);
+      PrerenderTestURL("/prerender/prerender_page.html",
+                       FINAL_STATUS_CACHE_OR_HISTORY_CLEARED, 1);
 
   ClearBrowsingData(current_browser(), BrowsingDataRemover::REMOVE_HISTORY);
   prerender->WaitForStop();
 
   // Make sure prerender history was cleared.
   EXPECT_EQ(0, GetHistoryLength());
 }
 
 // Checks that when the cache is cleared, prerenders are cancelled but
 // prerendering history is not cleared.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderClearCache) {
   scoped_ptr<TestPrerender> prerender =
-      PrerenderTestURL("files/prerender/prerender_page.html",
-                       FINAL_STATUS_CACHE_OR_HISTORY_CLEARED,
-                       1);
+      PrerenderTestURL("/prerender/prerender_page.html",
+                       FINAL_STATUS_CACHE_OR_HISTORY_CLEARED, 1);
 
   ClearBrowsingData(current_browser(), BrowsingDataRemover::REMOVE_CACHE);
   prerender->WaitForStop();
 
   // Make sure prerender history was not cleared.  Not a vital behavior, but
   // used to compare with PrerenderClearHistory test.
   EXPECT_EQ(1, GetHistoryLength());
 }
 
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderCancelAll) {
-  scoped_ptr<TestPrerender> prerender =
-      PrerenderTestURL("files/prerender/prerender_page.html",
-                       FINAL_STATUS_CANCELLED,
-                       1);
+  scoped_ptr<TestPrerender> prerender = PrerenderTestURL(
+      "/prerender/prerender_page.html", FINAL_STATUS_CANCELLED, 1);
 
   GetPrerenderManager()->CancelAllPrerenders();
   prerender->WaitForStop();
 
   EXPECT_FALSE(prerender->contents());
 }
 
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderEvents) {
-  scoped_ptr<TestPrerender> prerender =
-      PrerenderTestURL("files/prerender/prerender_page.html",
-                       FINAL_STATUS_CANCELLED, 1);
+  scoped_ptr<TestPrerender> prerender = PrerenderTestURL(
+      "/prerender/prerender_page.html", FINAL_STATUS_CANCELLED, 1);
 
   GetPrerenderManager()->CancelAllPrerenders();
   prerender->WaitForStop();
 
   EXPECT_TRUE(DidReceivePrerenderStartEventForLinkNumber(0));
   EXPECT_TRUE(DidReceivePrerenderStopEventForLinkNumber(0));
   EXPECT_FALSE(HadPrerenderEventErrors());
 }
 
 // Cancels the prerender of a page with its own prerender.  The second prerender
 // should never be started.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
                        PrerenderCancelPrerenderWithPrerender) {
-  scoped_ptr<TestPrerender> prerender =
-      PrerenderTestURL("files/prerender/prerender_infinite_a.html",
-                       FINAL_STATUS_CANCELLED,
-                       1);
+  scoped_ptr<TestPrerender> prerender = PrerenderTestURL(
+      "/prerender/prerender_infinite_a.html", FINAL_STATUS_CANCELLED, 1);
 
   GetPrerenderManager()->CancelAllPrerenders();
   prerender->WaitForStop();
 
   EXPECT_FALSE(prerender->contents());
 }
 
 // Prerendering and history tests.
 // The prerendered page is navigated to in several ways [navigate via
 // omnibox, click on link, key-modified click to open in background tab, etc],
 // followed by a navigation to another page from the prerendered page, followed
 // by a back navigation.
 
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderNavigateClickGoBack) {
-  PrerenderTestURL("files/prerender/prerender_page_with_link.html",
-                   FINAL_STATUS_USED,
-                   1);
+  PrerenderTestURL("/prerender/prerender_page_with_link.html",
+                   FINAL_STATUS_USED, 1);
   NavigateToDestURL();
   ClickToNextPageAfterPrerender();
   GoBackToPrerender();
 }
 
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderNavigateNavigateGoBack) {
-  PrerenderTestURL("files/prerender/prerender_page_with_link.html",
-                   FINAL_STATUS_USED,
-                   1);
+  PrerenderTestURL("/prerender/prerender_page_with_link.html",
+                   FINAL_STATUS_USED, 1);
   NavigateToDestURL();
   NavigateToNextPageAfterPrerender();
   GoBackToPrerender();
 }
 
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderClickClickGoBack) {
-  PrerenderTestURL("files/prerender/prerender_page_with_link.html",
-                   FINAL_STATUS_USED,
-                   1);
+  PrerenderTestURL("/prerender/prerender_page_with_link.html",
+                   FINAL_STATUS_USED, 1);
   OpenDestURLViaClick();
   ClickToNextPageAfterPrerender();
   GoBackToPrerender();
 }
 
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderClickNavigateGoBack) {
-  PrerenderTestURL("files/prerender/prerender_page_with_link.html",
-                   FINAL_STATUS_USED,
-                   1);
+  PrerenderTestURL("/prerender/prerender_page_with_link.html",
+                   FINAL_STATUS_USED, 1);
   OpenDestURLViaClick();
   NavigateToNextPageAfterPrerender();
   GoBackToPrerender();
 }
 
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderClickNewWindow) {
-  PrerenderTestURL("files/prerender/prerender_page_with_link.html",
+  PrerenderTestURL("/prerender/prerender_page_with_link.html",
                    FINAL_STATUS_APP_TERMINATING, 1);
   OpenDestURLViaClickNewWindow();
 }
 
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderClickNewForegroundTab) {
-  PrerenderTestURL("files/prerender/prerender_page_with_link.html",
+  PrerenderTestURL("/prerender/prerender_page_with_link.html",
                    FINAL_STATUS_APP_TERMINATING, 1);
   OpenDestURLViaClickNewForegroundTab();
 }
 
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
                        NavigateToPrerenderedPageWhenDevToolsAttached) {
   DisableJavascriptCalls();
   WebContents* web_contents =
       current_browser()->tab_strip_model()->GetActiveWebContents();
   scoped_refptr<DevToolsAgentHost> agent(
       DevToolsAgentHost::GetOrCreateFor(web_contents));
   FakeDevToolsClient client;
   agent->AttachClient(&client);
-  const char* url = "files/prerender/prerender_page.html";
+  const char* url = "/prerender/prerender_page.html";
   PrerenderTestURL(url, FINAL_STATUS_DEVTOOLS_ATTACHED, 1);
   NavigateToURLWithDisposition(url, CURRENT_TAB, false);
   agent->DetachClient();
 }
 
 // Validate that the sessionStorage namespace remains the same when swapping
 // in a prerendered page.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderSessionStorage) {
-  set_loader_path("files/prerender/prerender_loader_with_session_storage.html");
-  PrerenderTestURL(GetCrossDomainTestUrl("files/prerender/prerender_page.html"),
-                   FINAL_STATUS_USED,
-                   1);
+  set_loader_path("/prerender/prerender_loader_with_session_storage.html");
+  PrerenderTestURL(GetCrossDomainTestUrl("prerender/prerender_page.html"),
+                   FINAL_STATUS_USED, 1);
   NavigateToDestURL();
   GoBackToPageBeforePrerender();
 }
 
 // Checks that the control group works.  An XHR PUT cannot be detected in the
 // control group.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, ControlGroup) {
   RestorePrerenderMode restore_prerender_mode;
   PrerenderManager::SetMode(
       PrerenderManager::PRERENDER_MODE_EXPERIMENT_CONTROL_GROUP);
   DisableJavascriptCalls();
-  PrerenderTestURL("files/prerender/prerender_xhr_put.html",
+  PrerenderTestURL("/prerender/prerender_xhr_put.html",
                    FINAL_STATUS_WOULD_HAVE_BEEN_USED, 0);
   NavigateToDestURL();
 }
 
 // Checks that the control group correctly hits WOULD_HAVE_BEEN_USED
 // renderer-initiated navigations. (This verifies that the ShouldFork logic
 // behaves correctly.)
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, ControlGroupRendererInitiated) {
   RestorePrerenderMode restore_prerender_mode;
   PrerenderManager::SetMode(
       PrerenderManager::PRERENDER_MODE_EXPERIMENT_CONTROL_GROUP);
   DisableJavascriptCalls();
-  PrerenderTestURL("files/prerender/prerender_xhr_put.html",
+  PrerenderTestURL("/prerender/prerender_xhr_put.html",
                    FINAL_STATUS_WOULD_HAVE_BEEN_USED, 0);
   OpenDestURLViaClick();
 }
 
 // Make sure that the MatchComplete dummy works in the normal case.  Once
 // a prerender is cancelled because of a script, a dummy must be created to
 // account for the MatchComplete case, and it must have a final status of
 // FINAL_STATUS_WOULD_HAVE_BEEN_USED.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, MatchCompleteDummy) {
   RestorePrerenderMode restore_prerender_mode;
   PrerenderManager::SetMode(
       PrerenderManager::PRERENDER_MODE_EXPERIMENT_MATCH_COMPLETE_GROUP);
 
   std::vector<FinalStatus> expected_final_status_queue;
   expected_final_status_queue.push_back(FINAL_STATUS_INVALID_HTTP_METHOD);
   expected_final_status_queue.push_back(FINAL_STATUS_WOULD_HAVE_BEEN_USED);
-  PrerenderTestURL("files/prerender/prerender_xhr_put.html",
+  PrerenderTestURL("/prerender/prerender_xhr_put.html",
                    expected_final_status_queue, 1);
   histogram_tester().ExpectTotalCount("Prerender.none_PerceivedPLT", 1);
   histogram_tester().ExpectTotalCount("Prerender.none_PerceivedPLTMatched", 0);
   histogram_tester().ExpectTotalCount(
       "Prerender.none_PerceivedPLTMatchedComplete", 0);
   histogram_tester().ExpectTotalCount(
       "Prerender.websame_PrerenderNotSwappedInPLT", 1);
 
   NavigateToDestURL();
   histogram_tester().ExpectTotalCount("Prerender.websame_PerceivedPLT", 1);
   histogram_tester().ExpectTotalCount("Prerender.websame_PerceivedPLTMatched",
                                       0);
   histogram_tester().ExpectTotalCount(
       "Prerender.websame_PerceivedPLTMatchedComplete", 1);
 }
 
 // Checks that the referrer policy is used when prerendering.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderReferrerPolicy) {
-  set_loader_path("files/prerender/prerender_loader_with_referrer_policy.html");
-  PrerenderTestURL("files/prerender/prerender_referrer_policy.html",
-                   FINAL_STATUS_USED,
-                   1);
+  set_loader_path("/prerender/prerender_loader_with_referrer_policy.html");
+  PrerenderTestURL("/prerender/prerender_referrer_policy.html",
+                   FINAL_STATUS_USED, 1);
   NavigateToDestURL();
 }
 
 // Checks that the referrer policy is used when prerendering on HTTPS.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
                        PrerenderSSLReferrerPolicy) {
   UseHttpsSrcServer();
-  set_loader_path("files/prerender/prerender_loader_with_referrer_policy.html");
-  PrerenderTestURL("files/prerender/prerender_referrer_policy.html",
-                   FINAL_STATUS_USED,
-                   1);
+  set_loader_path("/prerender/prerender_loader_with_referrer_policy.html");
+  PrerenderTestURL("/prerender/prerender_referrer_policy.html",
+                   FINAL_STATUS_USED, 1);
   NavigateToDestURL();
 }
 
 // Checks that the referrer policy is used when prerendering is cancelled.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderCancelReferrerPolicy) {
   scoped_ptr<TestContentBrowserClient> test_content_browser_client(
       new TestContentBrowserClient);
   content::ContentBrowserClient* original_browser_client =
       content::SetBrowserClientForTesting(test_content_browser_client.get());
 
-  set_loader_path("files/prerender/prerender_loader_with_referrer_policy.html");
-  PrerenderTestURL("files/prerender/prerender_referrer_policy.html",
-                   FINAL_STATUS_CANCELLED,
-                   1);
+  set_loader_path("/prerender/prerender_loader_with_referrer_policy.html");
+  PrerenderTestURL("/prerender/prerender_referrer_policy.html",
+                   FINAL_STATUS_CANCELLED, 1);
   OpenDestURLViaClick();
 
   bool display_test_result = false;
   WebContents* web_contents =
       browser()->tab_strip_model()->GetActiveWebContents();
   ASSERT_TRUE(content::ExecuteScriptAndExtractBool(
       web_contents,
       "window.domAutomationController.send(DidDisplayPass())",
       &display_test_result));
   EXPECT_TRUE(display_test_result);
@@ skipping 32 matching lines @@
     PrerenderBrowserTest::TearDownOnMainThread();
     ExtensionApiTest::TearDownOnMainThread();
   }
 
   void SetUpOnMainThread() override {
     PrerenderBrowserTest::SetUpOnMainThread();
   }
 };
 
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTestWithExtensions, WebNavigation) {
-  ASSERT_TRUE(StartSpawnedTestServer());
+  ASSERT_TRUE(StartEmbeddedTestServer());
   extensions::FrameNavigationState::set_allow_extension_scheme(true);
 
   // Wait for the extension to set itself up and return control to us.
   ASSERT_TRUE(RunExtensionTest("webnavigation/prerender")) << message_;
 
   extensions::ResultCatcher catcher;
 
-  PrerenderTestURL("files/prerender/prerender_page.html", FINAL_STATUS_USED, 1);
+  PrerenderTestURL("/prerender/prerender_page.html", FINAL_STATUS_USED, 1);
 
   ChannelDestructionWatcher channel_close_watcher;
   channel_close_watcher.WatchChannel(browser()->tab_strip_model()->
       GetActiveWebContents()->GetRenderProcessHost());
   NavigateToDestURL();
   channel_close_watcher.WaitForChannelClose();
 
   ASSERT_TRUE(IsEmptyPrerenderLinkManager());
   ASSERT_TRUE(catcher.GetNextResult()) << catcher.message();
 }
 
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTestWithExtensions, TabsApi) {
-  ASSERT_TRUE(StartSpawnedTestServer());
+  ASSERT_TRUE(StartEmbeddedTestServer());
   extensions::FrameNavigationState::set_allow_extension_scheme(true);
 
   // Wait for the extension to set itself up and return control to us.
   ASSERT_TRUE(RunExtensionTest("tabs/on_replaced")) << message_;
 
   extensions::ResultCatcher catcher;
 
-  PrerenderTestURL("files/prerender/prerender_page.html", FINAL_STATUS_USED, 1);
+  PrerenderTestURL("/prerender/prerender_page.html", FINAL_STATUS_USED, 1);
 
   ChannelDestructionWatcher channel_close_watcher;
   channel_close_watcher.WatchChannel(browser()->tab_strip_model()->
       GetActiveWebContents()->GetRenderProcessHost());
   NavigateToDestURL();
   channel_close_watcher.WaitForChannelClose();
 
   ASSERT_TRUE(IsEmptyPrerenderLinkManager());
   ASSERT_TRUE(catcher.GetNextResult()) << catcher.message();
 }
 
 // Test that prerenders abort when navigating to a stream.
 // See chrome/browser/extensions/api/streams_private/streams_private_apitest.cc
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTestWithExtensions, StreamsTest) {
   RestorePrerenderMode restore_prerender_mode;
   PrerenderManager::SetMode(
       PrerenderManager::PRERENDER_MODE_EXPERIMENT_MATCH_COMPLETE_GROUP);
 
-  ASSERT_TRUE(StartSpawnedTestServer());
+  ASSERT_TRUE(StartEmbeddedTestServer());
 
   const extensions::Extension* extension = LoadExtension(
       test_data_dir_.AppendASCII("streams_private/handle_mime_type"));
   ASSERT_TRUE(extension);
   EXPECT_EQ(std::string(extension_misc::kMimeHandlerPrivateTestExtensionId),
             extension->id());
   MimeTypesHandler* handler = MimeTypesHandler::GetHandler(extension);
   ASSERT_TRUE(handler);
   EXPECT_TRUE(handler->CanHandleMIMEType("application/msword"));
 
-  PrerenderTestURL("files/prerender/document.doc", FINAL_STATUS_DOWNLOAD, 0);
+  PrerenderTestURL("/prerender/document.doc", FINAL_STATUS_DOWNLOAD, 0);
 
   // Sanity-check that the extension would have picked up the stream in a normal
   // navigation had prerender not intercepted it.
   // streams_private/handle_mime_type reports success if it has handled the
   // application/msword type.
   extensions::ResultCatcher catcher;
   NavigateToDestURL();
   EXPECT_TRUE(catcher.GetNextResult());
 }
 
 // Checks that non-http/https/chrome-extension subresource cancels the
 // prerender.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
                        PrerenderCancelSubresourceUnsupportedScheme) {
   GURL image_url = GURL("invalidscheme://www.google.com/test.jpg");
-  std::vector<net::SpawnedTestServer::StringPair> replacement_text;
+  base::StringPairs replacement_text;
   replacement_text.push_back(
       std::make_pair("REPLACE_WITH_IMAGE_URL", image_url.spec()));
   std::string replacement_path;
-  ASSERT_TRUE(net::SpawnedTestServer::GetFilePathWithReplacements(
-      "files/prerender/prerender_with_image.html",
-      replacement_text,
-      &replacement_path));
+  net::test_server::GetFilePathWithReplacements(
+      "/prerender/prerender_with_image.html", replacement_text,
+      &replacement_path);
   PrerenderTestURL(replacement_path, FINAL_STATUS_UNSUPPORTED_SCHEME, 0);
 }
 
 // Ensure that about:blank is permitted for any subresource.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
                        PrerenderAllowAboutBlankSubresource) {
   GURL image_url = GURL("about:blank");
-  std::vector<net::SpawnedTestServer::StringPair> replacement_text;
+  base::StringPairs replacement_text;
   replacement_text.push_back(
       std::make_pair("REPLACE_WITH_IMAGE_URL", image_url.spec()));
   std::string replacement_path;
-  ASSERT_TRUE(net::SpawnedTestServer::GetFilePathWithReplacements(
-      "files/prerender/prerender_with_image.html",
-      replacement_text,
-      &replacement_path));
+  net::test_server::GetFilePathWithReplacements(
+      "/prerender/prerender_with_image.html", replacement_text,
+      &replacement_path);
   PrerenderTestURL(replacement_path, FINAL_STATUS_USED, 1);
   NavigateToDestURL();
 }
 
 // Checks that non-http/https/chrome-extension subresource cancels the prerender
 // on redirect.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
                        PrerenderCancelSubresourceRedirectUnsupportedScheme) {
-  GURL image_url = test_server()->GetURL(
+  GURL image_url = embedded_test_server()->GetURL(
       CreateServerRedirect("invalidscheme://www.google.com/test.jpg"));
-  std::vector<net::SpawnedTestServer::StringPair> replacement_text;
+  base::StringPairs replacement_text;
   replacement_text.push_back(
       std::make_pair("REPLACE_WITH_IMAGE_URL", image_url.spec()));
   std::string replacement_path;
-  ASSERT_TRUE(net::SpawnedTestServer::GetFilePathWithReplacements(
-      "files/prerender/prerender_with_image.html",
-      replacement_text,
-      &replacement_path));
+  net::test_server::GetFilePathWithReplacements(
+      "/prerender/prerender_with_image.html", replacement_text,
+      &replacement_path);
   PrerenderTestURL(replacement_path, FINAL_STATUS_UNSUPPORTED_SCHEME, 0);
 }
 
 // Checks that chrome-extension subresource does not cancel the prerender.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
                        PrerenderKeepSubresourceExtensionScheme) {
   GURL image_url = GURL("chrome-extension://abcdefg/test.jpg");
-  std::vector<net::SpawnedTestServer::StringPair> replacement_text;
+  base::StringPairs replacement_text;
   replacement_text.push_back(
       std::make_pair("REPLACE_WITH_IMAGE_URL", image_url.spec()));
   std::string replacement_path;
-  ASSERT_TRUE(net::SpawnedTestServer::GetFilePathWithReplacements(
-      "files/prerender/prerender_with_image.html",
-      replacement_text,
-      &replacement_path));
+  net::test_server::GetFilePathWithReplacements(
+      "/prerender/prerender_with_image.html", replacement_text,
+      &replacement_path);
   PrerenderTestURL(replacement_path, FINAL_STATUS_USED, 1);
   NavigateToDestURL();
 }
 
 // Checks that redirect to chrome-extension subresource does not cancel the
 // prerender.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
                        PrerenderKeepSubresourceRedirectExtensionScheme) {
-  GURL image_url = test_server()->GetURL(
+  GURL image_url = embedded_test_server()->GetURL(
       CreateServerRedirect("chrome-extension://abcdefg/test.jpg"));
-  std::vector<net::SpawnedTestServer::StringPair> replacement_text;
+  base::StringPairs replacement_text;
   replacement_text.push_back(
       std::make_pair("REPLACE_WITH_IMAGE_URL", image_url.spec()));
   std::string replacement_path;
-  ASSERT_TRUE(net::SpawnedTestServer::GetFilePathWithReplacements(
-      "files/prerender/prerender_with_image.html",
-      replacement_text,
-      &replacement_path));
+  net::test_server::GetFilePathWithReplacements(
+      "/prerender/prerender_with_image.html", replacement_text,
+      &replacement_path);
   PrerenderTestURL(replacement_path, FINAL_STATUS_USED, 1);
   NavigateToDestURL();
 }
 
 // Checks that non-http/https main page redirects cancel the prerender.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
                        PrerenderCancelMainFrameRedirectUnsupportedScheme) {
-  GURL url = test_server()->GetURL(
+  GURL url = embedded_test_server()->GetURL(
       CreateServerRedirect("invalidscheme://www.google.com/test.html"));
   PrerenderTestURL(url, FINAL_STATUS_UNSUPPORTED_SCHEME, 0);
 }
 
 // Checks that media source video loads are deferred on prerendering.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderHTML5MediaSourceVideo) {
-  PrerenderTestURL("files/prerender/prerender_html5_video_media_source.html",
-                   FINAL_STATUS_USED,
-                   1);
+  PrerenderTestURL("/prerender/prerender_html5_video_media_source.html",
+                   FINAL_STATUS_USED, 1);
   NavigateToDestURL();
   WaitForASCIITitle(GetActiveWebContents(), kPassTitle);
 }
 
 // Checks that a prerender that creates an audio stream (via a WebAudioDevice)
 // is cancelled.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderWebAudioDevice) {
   DisableLoadEventCheck();
-  PrerenderTestURL("files/prerender/prerender_web_audio_device.html",
+  PrerenderTestURL("/prerender/prerender_web_audio_device.html",
                    FINAL_STATUS_CREATING_AUDIO_STREAM, 0);
 }
 
 // Checks that prerenders do not swap in to WebContents being captured.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderCapturedWebContents) {
-  PrerenderTestURL("files/prerender/prerender_page.html",
+  PrerenderTestURL("/prerender/prerender_page.html",
                    FINAL_STATUS_PAGE_BEING_CAPTURED, 1);
   WebContents* web_contents = GetActiveWebContents();
   web_contents->IncrementCapturerCount(gfx::Size());
   NavigateToDestURLWithDisposition(CURRENT_TAB, false);
   web_contents->DecrementCapturerCount();
 }
 
 // Checks that prerenders are aborted on cross-process navigation from
 // a server redirect.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
                        PrerenderCrossProcessServerRedirect) {
   // Force everything to be a process swap.
   SwapProcessesContentBrowserClient test_browser_client;
   content::ContentBrowserClient* original_browser_client =
       content::SetBrowserClientForTesting(&test_browser_client);
 
-  PrerenderTestURL(
-      CreateServerRedirect("files/prerender/prerender_page.html"),
-      FINAL_STATUS_OPEN_URL, 0);
+  PrerenderTestURL(CreateServerRedirect("/prerender/prerender_page.html"),
+                   FINAL_STATUS_OPEN_URL, 0);
 
   content::SetBrowserClientForTesting(original_browser_client);
 }
 
 // Checks that URLRequests for prerenders being aborted on cross-process
 // navigation from a server redirect are cleaned up, so they don't keep cache
 // entries locked.
 // See http://crbug.com/341134
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
                        PrerenderCrossProcessServerRedirectNoHang) {
-  const char kDestPath[] = "files/prerender/prerender_page.html";
+  const char kDestPath[] = "/prerender/prerender_page.html";
   // Force everything to be a process swap.
   SwapProcessesContentBrowserClient test_browser_client;
   content::ContentBrowserClient* original_browser_client =
       content::SetBrowserClientForTesting(&test_browser_client);
 
   PrerenderTestURL(CreateServerRedirect(kDestPath), FINAL_STATUS_OPEN_URL, 0);
 
-  ui_test_utils::NavigateToURL(
-      browser(),
-      test_server()->GetURL(kDestPath));
+  ui_test_utils::NavigateToURL(browser(),
+                               embedded_test_server()->GetURL(kDestPath));
 
   content::SetBrowserClientForTesting(original_browser_client);
 }
 
 // Checks that prerenders are aborted on cross-process navigation from
 // a client redirect.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
                        PrerenderCrossProcessClientRedirect) {
   // Cross-process navigation logic for renderer-initiated navigations
   // is partially controlled by the renderer, namely
@@ skipping 15 matching lines @@
 // stop events.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, CancelMatchCompleteDummy) {
   RestorePrerenderMode restore_prerender_mode;
   PrerenderManager::SetMode(
       PrerenderManager::PRERENDER_MODE_EXPERIMENT_MATCH_COMPLETE_GROUP);
 
   std::vector<FinalStatus> expected_final_status_queue;
   expected_final_status_queue.push_back(FINAL_STATUS_JAVASCRIPT_ALERT);
   expected_final_status_queue.push_back(FINAL_STATUS_CANCELLED);
   ScopedVector<TestPrerender> prerenders =
-      PrerenderTestURL("files/prerender/prerender_alert_before_onload.html",
+      PrerenderTestURL("/prerender/prerender_alert_before_onload.html",
                        expected_final_status_queue, 0);
 
   // Cancel the MatchComplete dummy.
   GetPrerenderManager()->CancelAllPrerenders();
   prerenders[1]->WaitForStop();
 
   // Check the referring page only got one copy of the event.
   EXPECT_FALSE(HadPrerenderEventErrors());
 }
 
 // Checks that a deferred redirect to an image is not loaded until the page is
 // visible. Also test the right histogram events are emitted in this case.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderDeferredImage) {
   DisableJavascriptCalls();
 
   // The prerender will not completely load until after the swap, so wait for a
   // title change before calling DidPrerenderPass.
-  scoped_ptr<TestPrerender> prerender =
-      PrerenderTestURL(
-          "files/prerender/prerender_deferred_image.html",
-          FINAL_STATUS_USED, 0);
+  scoped_ptr<TestPrerender> prerender = PrerenderTestURL(
+      "/prerender/prerender_deferred_image.html", FINAL_STATUS_USED, 0);
   WaitForASCIITitle(prerender->contents()->prerender_contents(), kReadyTitle);
   EXPECT_EQ(1, GetPrerenderDomContentLoadedEventCountForLinkNumber(0));
   EXPECT_TRUE(DidPrerenderPass(prerender->contents()->prerender_contents()));
   EXPECT_EQ(0, prerender->number_of_loads());
   histogram_tester().ExpectTotalCount("Prerender.none_PerceivedPLT", 1);
   histogram_tester().ExpectTotalCount("Prerender.none_PerceivedPLTMatched", 0);
   histogram_tester().ExpectTotalCount(
       "Prerender.none_PerceivedPLTMatchedComplete", 0);
   histogram_tester().ExpectTotalCount(
       "Prerender.websame_PrerenderNotSwappedInPLT", 0);
@@ skipping 22 matching lines @@
 }
 
 // Checks that a deferred redirect to an image is not loaded until the
 // page is visible, even after another redirect.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
                        PrerenderDeferredImageAfterRedirect) {
   DisableJavascriptCalls();
 
   // The prerender will not completely load until after the swap, so wait for a
   // title change before calling DidPrerenderPass.
-  scoped_ptr<TestPrerender> prerender =
-      PrerenderTestURL(
-          "files/prerender/prerender_deferred_image.html",
-          FINAL_STATUS_USED, 0);
+  scoped_ptr<TestPrerender> prerender = PrerenderTestURL(
+      "/prerender/prerender_deferred_image.html", FINAL_STATUS_USED, 0);
   WaitForASCIITitle(prerender->contents()->prerender_contents(), kReadyTitle);
   EXPECT_TRUE(DidPrerenderPass(prerender->contents()->prerender_contents()));
   EXPECT_EQ(0, prerender->number_of_loads());
 
   // Swap.
   NavigationOrSwapObserver swap_observer(current_browser()->tab_strip_model(),
                                          GetActiveWebContents());
   ui_test_utils::NavigateToURLWithDisposition(
       current_browser(), dest_url(), CURRENT_TAB,
       ui_test_utils::BROWSER_TEST_NONE);
   swap_observer.Wait();
 
   // The prerender never observes the final load.
   EXPECT_EQ(0, prerender->number_of_loads());
 
   // Now check DidDisplayPass.
   EXPECT_TRUE(DidDisplayPass(GetActiveWebContents()));
 }
 
 // Checks that deferred redirects in the main frame are followed.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderDeferredMainFrame) {
   DisableJavascriptCalls();
-  PrerenderTestURL(
-      "files/prerender/image-deferred.png",
-      FINAL_STATUS_USED, 1);
+  PrerenderTestURL("/prerender/image-deferred.png", FINAL_STATUS_USED, 1);
   NavigateToDestURL();
 }
 
 // Checks that deferred redirects in the main frame are followed, even
 // with a double-redirect.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
                        PrerenderDeferredMainFrameAfterRedirect) {
   DisableJavascriptCalls();
-  PrerenderTestURL(
-      CreateServerRedirect("files/prerender/image-deferred.png"),
-      FINAL_STATUS_USED, 1);
+  PrerenderTestURL(CreateServerRedirect("/prerender/image-deferred.png"),
+                   FINAL_STATUS_USED, 1);
   NavigateToDestURL();
 }
 
 // Checks that deferred redirects in a synchronous XHR abort the
 // prerender.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderDeferredSynchronousXHR) {
   RestorePrerenderMode restore_prerender_mode;
   PrerenderManager::SetMode(
       PrerenderManager::PRERENDER_MODE_EXPERIMENT_MATCH_COMPLETE_GROUP);
-  PrerenderTestURL("files/prerender/prerender_deferred_sync_xhr.html",
+  PrerenderTestURL("/prerender/prerender_deferred_sync_xhr.html",
                    FINAL_STATUS_BAD_DEFERRED_REDIRECT, 0);
   NavigateToDestURL();
 }
 
 // Checks that prerenders are not swapped for navigations with extra headers.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderExtraHeadersNoSwap) {
-  PrerenderTestURL("files/prerender/prerender_page.html",
+  PrerenderTestURL("/prerender/prerender_page.html",
                    FINAL_STATUS_APP_TERMINATING, 1);
 
   content::OpenURLParams params(dest_url(), Referrer(), CURRENT_TAB,
                                 ui::PAGE_TRANSITION_TYPED, false);
   params.extra_headers = "X-Custom-Header: 42\r\n";
   NavigateToURLWithParams(params, false);
 }
 
 // Checks that prerenders are not swapped for navigations with browser-initiated
 // POST data.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
                        PrerenderBrowserInitiatedPostNoSwap) {
-  PrerenderTestURL("files/prerender/prerender_page.html",
+  PrerenderTestURL("/prerender/prerender_page.html",
                    FINAL_STATUS_APP_TERMINATING, 1);
 
   std::string post_data = "DATA";
   content::OpenURLParams params(dest_url(), Referrer(), CURRENT_TAB,
                                 ui::PAGE_TRANSITION_TYPED, false);
   params.uses_post = true;
   params.browser_initiated_post_data =
       base::RefCountedString::TakeString(&post_data);
   NavigateToURLWithParams(params, false);
 }
 
 // Checks that the prerendering of a page is canceled correctly when the
 // prerendered page tries to make a second navigation entry.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderNewNavigationEntry) {
-  PrerenderTestURL("files/prerender/prerender_new_entry.html",
-                   FINAL_STATUS_NEW_NAVIGATION_ENTRY,
-                   1);
+  PrerenderTestURL("/prerender/prerender_new_entry.html",
+                   FINAL_STATUS_NEW_NAVIGATION_ENTRY, 1);
 }
 
 // Attempt a swap-in in a new tab. The session storage doesn't match, so it
 // should not swap.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderPageNewTab) {
-  PrerenderTestURL("files/prerender/prerender_page.html",
+  PrerenderTestURL("/prerender/prerender_page.html",
                    FINAL_STATUS_APP_TERMINATING, 1);
 
   // Open a new tab to navigate in.
   ui_test_utils::NavigateToURLWithDisposition(
       current_browser(), GURL(url::kAboutBlankURL), NEW_FOREGROUND_TAB,
       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
 
   // Now navigate in the new tab.
   NavigateToDestURLWithDisposition(CURRENT_TAB, false);
 }
 
 // Checks that prerenders honor |should_replace_current_entry|.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderReplaceCurrentEntry) {
-  PrerenderTestURL("files/prerender/prerender_page.html", FINAL_STATUS_USED, 1);
+  PrerenderTestURL("/prerender/prerender_page.html", FINAL_STATUS_USED, 1);
 
   content::OpenURLParams params(dest_url(), Referrer(), CURRENT_TAB,
                                 ui::PAGE_TRANSITION_TYPED, false);
   params.should_replace_current_entry = true;
   NavigateToURLWithParams(params, false);
 
   const NavigationController& controller =
       GetActiveWebContents()->GetController();
   // First entry is about:blank, second is prerender_page.html.
   EXPECT_TRUE(controller.GetPendingEntry() == NULL);
   EXPECT_EQ(2, controller.GetEntryCount());
   EXPECT_EQ(GURL(url::kAboutBlankURL), controller.GetEntryAtIndex(0)->GetURL());
   EXPECT_EQ(dest_url(), controller.GetEntryAtIndex(1)->GetURL());
 }
 
 // Checks that <a ping> requests are not dropped in prerender.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderPing) {
   // Count hits to a certain URL.
   const GURL kPingURL("http://prerender.test/ping");
   base::FilePath empty_file = ui_test_utils::GetTestFilePath(
       base::FilePath(), base::FilePath(FILE_PATH_LITERAL("empty.html")));
   RequestCounter ping_counter;
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&CreateCountingInterceptorOnIO,
                  kPingURL, empty_file, ping_counter.AsWeakPtr()));
 
-  PrerenderTestURL("files/prerender/prerender_page.html", FINAL_STATUS_USED, 1);
+  PrerenderTestURL("/prerender/prerender_page.html", FINAL_STATUS_USED, 1);
   OpenDestURLViaClickPing(kPingURL);
 
   ping_counter.WaitForCount(1);
 }
 
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderPPLTNormalNavigation) {
-  GURL url = test_server()->GetURL("files/prerender/prerender_page.html");
+  GURL url = embedded_test_server()->GetURL("/prerender/prerender_page.html");
   ui_test_utils::NavigateToURL(current_browser(), url);
   histogram_tester().ExpectTotalCount("Prerender.none_PerceivedPLT", 1);
   histogram_tester().ExpectTotalCount("Prerender.none_PerceivedPLTMatched", 0);
   histogram_tester().ExpectTotalCount(
       "Prerender.none_PerceivedPLTMatchedComplete", 0);
 }
 
 // Checks that a prerender which calls window.close() on itself is aborted.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderWindowClose) {
   DisableLoadEventCheck();
-  PrerenderTestURL("files/prerender/prerender_window_close.html",
+  PrerenderTestURL("/prerender/prerender_window_close.html",
                    FINAL_STATUS_CLOSED, 0);
 }
 
 class PrerenderIncognitoBrowserTest : public PrerenderBrowserTest {
  public:
   void SetUpOnMainThread() override {
     Profile* normal_profile = current_browser()->profile();
     set_browser(OpenURLOffTheRecord(normal_profile, GURL("about:blank")));
     PrerenderBrowserTest::SetUpOnMainThread();
   }
 };
 
 // Checks that prerendering works in incognito mode.
 IN_PROC_BROWSER_TEST_F(PrerenderIncognitoBrowserTest, PrerenderIncognito) {
-  PrerenderTestURL("files/prerender/prerender_page.html", FINAL_STATUS_USED, 1);
+  PrerenderTestURL("/prerender/prerender_page.html", FINAL_STATUS_USED, 1);
   NavigateToDestURL();
 }
 
 // Checks that prerenders are aborted when an incognito profile is closed.
 IN_PROC_BROWSER_TEST_F(PrerenderIncognitoBrowserTest,
                        PrerenderIncognitoClosed) {
-  scoped_ptr<TestPrerender> prerender =
-      PrerenderTestURL("files/prerender/prerender_page.html",
-                       FINAL_STATUS_PROFILE_DESTROYED, 1);
+  scoped_ptr<TestPrerender> prerender = PrerenderTestURL(
+      "/prerender/prerender_page.html", FINAL_STATUS_PROFILE_DESTROYED, 1);
   current_browser()->window()->Close();
   prerender->WaitForStop();
 }
 
 class PrerenderOmniboxBrowserTest : public PrerenderBrowserTest {
  public:
   LocationBar* GetLocationBar() {
     return current_browser()->window()->GetLocationBar();
   }
 
@@ skipping 32 matching lines @@
     return prerender.Pass();
   }
 };
 
 // Checks that closing the omnibox popup cancels an omnibox prerender.
 // http://crbug.com/395152
 IN_PROC_BROWSER_TEST_F(PrerenderOmniboxBrowserTest,
                        DISABLED_PrerenderOmniboxCancel) {
   // Fake an omnibox prerender.
   scoped_ptr<TestPrerender> prerender = StartOmniboxPrerender(
-      test_server()->GetURL("files/empty.html"),
-      FINAL_STATUS_CANCELLED);
+      embedded_test_server()->GetURL("/empty.html"), FINAL_STATUS_CANCELLED);
 
   // Revert the location bar. This should cancel the prerender.
   GetLocationBar()->Revert();
   prerender->WaitForStop();
 }
 
 // Checks that accepting omnibox input abandons an omnibox prerender.
 // http://crbug.com/394592
 IN_PROC_BROWSER_TEST_F(PrerenderOmniboxBrowserTest,
                        DISABLED_PrerenderOmniboxAbandon) {
   // Set the abandon timeout to something high so it does not introduce
   // flakiness if the prerender times out before the test completes.
   GetPrerenderManager()->mutable_config().abandon_time_to_live =
       base::TimeDelta::FromDays(999);
 
   // Enter a URL into the Omnibox.
   OmniboxView* omnibox_view = GetOmniboxView();
   omnibox_view->OnBeforePossibleChange();
-  omnibox_view->SetUserText(
-      base::UTF8ToUTF16(test_server()->GetURL("files/empty.html?1").spec()));
+  omnibox_view->SetUserText(base::UTF8ToUTF16(
+      embedded_test_server()->GetURL("/empty.html?1").spec()));
   omnibox_view->OnAfterPossibleChange();
   WaitForAutocompleteDone(omnibox_view);
 
   // Fake an omnibox prerender for a different URL.
-  scoped_ptr<TestPrerender> prerender = StartOmniboxPrerender(
-      test_server()->GetURL("files/empty.html?2"),
-      FINAL_STATUS_APP_TERMINATING);
+  scoped_ptr<TestPrerender> prerender =
+      StartOmniboxPrerender(embedded_test_server()->GetURL("/empty.html?2"),
+                            FINAL_STATUS_APP_TERMINATING);
 
   // The final status may be either FINAL_STATUS_APP_TERMINATING or
   // FINAL_STATUS_CANCELLED. Although closing the omnibox will not cancel an
   // abandoned prerender, the AutocompleteActionPredictor will cancel the
   // predictor on destruction.
   prerender->contents()->set_skip_final_checks(true);
 
   // Navigate to the URL entered.
   omnibox_view->model()->AcceptInput(CURRENT_TAB, false);
 
@@ skipping 18 matching lines @@
 // Check that NaCl plugins work when enabled, with prerendering.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTestWithNaCl,
                        PrerenderNaClPluginEnabled) {
 #if defined(OS_WIN) && defined(USE_ASH)
   // Disable this test in Metro+Ash for now (http://crbug.com/262796).
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kAshBrowserTests))
     return;
 #endif
 
-  PrerenderTestURL("files/prerender/prerender_plugin_nacl_enabled.html",
-                   FINAL_STATUS_USED,
-                   1);
+  PrerenderTestURL("/prerender/prerender_plugin_nacl_enabled.html",
+                   FINAL_STATUS_USED, 1);
   NavigateToDestURL();
 
   // To avoid any chance of a race, we have to let the script send its response
   // asynchronously.
   WebContents* web_contents =
       browser()->tab_strip_model()->GetActiveWebContents();
   bool display_test_result = false;
   ASSERT_TRUE(content::ExecuteScriptAndExtractBool(web_contents,
                                                    "DidDisplayReallyPass()",
                                                    &display_test_result));
@@ skipping 14 matching lines @@
   return task_management::WebContentsTagsManager::GetInstance()->
       tracked_tags();
 }
 
 // Tests the correct recording of tags for the prerender WebContents.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, TaskManagementTagsBasic) {
   // Browser tests start with a single tab.
   EXPECT_EQ(1U, GetTrackedTags().size());
 
   // Start prerendering a page and make sure it's correctly tagged.
-  PrerenderTestURL("files/prerender/prerender_page.html", FINAL_STATUS_USED, 1);
+  PrerenderTestURL("/prerender/prerender_page.html", FINAL_STATUS_USED, 1);
   EXPECT_EQ(2U, GetTrackedTags().size());
 
   // Swap in the prerendered content and make sure its tag is removed.
   NavigateToDestURL();
   EXPECT_EQ(1U, GetTrackedTags().size());
 }
 
 // Tests that the task manager will be provided by tasks that correspond to
 // prerendered WebContents.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, TaskManagementTasksProvided) {
   task_management::MockWebContentsTaskManager task_manager;
   // Browser tests start with a single tab.
   EXPECT_EQ(1U, GetTrackedTags().size());
 
   task_manager.StartObserving();
 
   // The pre-existing tab is provided.
   EXPECT_EQ(1U, task_manager.tasks().size());
 
   // Start prerendering a page.
-  PrerenderTestURL("files/prerender/prerender_page.html", FINAL_STATUS_USED, 1);
+  PrerenderTestURL("/prerender/prerender_page.html", FINAL_STATUS_USED, 1);
 
   EXPECT_EQ(2U, GetTrackedTags().size());
   ASSERT_EQ(2U, task_manager.tasks().size());
 
   const task_management::Task* task = task_manager.tasks().back();
   EXPECT_EQ(task_management::Task::RENDERER, task->GetType());
   const base::string16 title = task->title();
   const base::string16 expected_prefix = GetPrerenderTitlePrefix();
   EXPECT_TRUE(base::StartsWith(title,
                                expected_prefix,
                                base::CompareCase::INSENSITIVE_ASCII));
 
   NavigateToDestURL();
   EXPECT_EQ(1U, task_manager.tasks().size());
 }
 
 }  // namespace
 
 #endif  // defined(ENABLE_TASK_MANAGER)
 
 }  // namespace prerender