Make the TestServer use an absolute document root path.

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/command_line.h"
 #include "base/path_service.h"
 #include "base/string_util.h"
@@ skipping 992 matching lines @@
         loader_path_,
         replacement_text,
         &replacement_path));
 
     const net::TestServer* src_server = test_server();
     scoped_ptr<net::TestServer> https_src_server;
     if (use_https_src_server_) {
       https_src_server.reset(
           new net::TestServer(
                   net::TestServer::TYPE_HTTPS, net::TestServer::kLocalhost,
-                  base::FilePath(FILE_PATH_LITERAL("chrome/test/data"))));
+                  net::TestServer::GetTestDataPath()));
       ASSERT_TRUE(https_src_server->Start());
       src_server = https_src_server.get();
     }
     GURL loader_url = src_server->GetURL(replacement_path +
                                          loader_query_and_fragment_);
 
     PrerenderManager* prerender_manager = GetPrerenderManager();
     ASSERT_TRUE(prerender_manager);
     prerender_manager->mutable_config().rate_limit_enabled = false;
     prerender_manager->mutable_config().https_allowed = true;
@@ skipping 484 matching lines @@
   GURL destination_url = test_server()->GetURL(
       "files/prerender/prerender_page.html");
   PrerenderTestURL(prerender_url, destination_url, FINAL_STATUS_USED, 2);
   OpenDestURLViaClick();
 }
 
 // Checks that a prerender for an https will prevent a prerender from happening.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderHttps) {
   net::TestServer https_server(
       net::TestServer::TYPE_HTTPS, net::TestServer::kLocalhost,
-      base::FilePath(FILE_PATH_LITERAL("chrome/test/data")));
+      net::TestServer::GetTestDataPath());
   ASSERT_TRUE(https_server.Start());
   GURL https_url = https_server.GetURL("files/prerender/prerender_page.html");
   PrerenderTestURL(https_url,
                    FINAL_STATUS_USED,
                    1);
   NavigateToDestURL();
 }
 
 // Checks that client-issued redirects to an https page will cancel prerenders.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderClientRedirectToHttps) {
   net::TestServer https_server(
       net::TestServer::TYPE_HTTPS, net::TestServer::kLocalhost,
-      base::FilePath(FILE_PATH_LITERAL("chrome/test/data")));
+      net::TestServer::GetTestDataPath());
   ASSERT_TRUE(https_server.Start());
   GURL https_url = https_server.GetURL("files/prerender/prerender_page.html");
   PrerenderTestURL(CreateClientRedirect(https_url.spec()),
                    FINAL_STATUS_USED,
                    2);
   NavigateToDestURL();
 }
 
 // Checks that client-issued redirects within an iframe in a prerendered
 // page will not count as an "alias" for the prerendered page.
@@ skipping 14 matching lines @@
   NavigateToDestURL();
 }
 
 // Checks that client-issued redirects within an iframe in a prerendered
 // page to an https page will not cancel the prerender, nor will it
 // count as an "alias" for the prerendered page.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
                        PrerenderClientRedirectToHttpsInIframe) {
   net::TestServer https_server(
       net::TestServer::TYPE_HTTPS, net::TestServer::kLocalhost,
-      base::FilePath(FILE_PATH_LITERAL("chrome/test/data")));
+      net::TestServer::GetTestDataPath());
   ASSERT_TRUE(https_server.Start());
   GURL https_url = https_server.GetURL("files/prerender/prerender_page.html");
   std::string redirect_path = CreateClientRedirect(https_url.spec());
   std::vector<net::TestServer::StringPair> replacement_text;
   replacement_text.push_back(
       std::make_pair("REPLACE_WITH_URL", "/" + redirect_path));
   std::string replacement_path;
   ASSERT_TRUE(net::TestServer::GetFilePathWithReplacements(
       "files/prerender/prerender_with_iframe.html",
       replacement_text,
@@ skipping 37 matching lines @@
   PrerenderTestURL(prerender_url, destination_url, FINAL_STATUS_USED, 1);
   OpenDestURLViaClick();
 }
 
 // Checks that server-issued redirects from an http to an https
 // location will cancel prerendering.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
                        PrerenderServerRedirectToHttps) {
   net::TestServer https_server(
       net::TestServer::TYPE_HTTPS, net::TestServer::kLocalhost,
-      base::FilePath(FILE_PATH_LITERAL("chrome/test/data")));
+      net::TestServer::GetTestDataPath());
   ASSERT_TRUE(https_server.Start());
   GURL https_url = https_server.GetURL("files/prerender/prerender_page.html");
   PrerenderTestURL(CreateServerRedirect(https_url.spec()),
                    FINAL_STATUS_USED,
                    1);
   NavigateToDestURL();
 }
 
 // Checks that server-issued redirects within an iframe in a prerendered
 // page will not count as an "alias" for the prerendered page.
@@ skipping 14 matching lines @@
   NavigateToDestURL();
 }
 
 // Checks that server-issued redirects within an iframe in a prerendered
 // page to an https page will not cancel the prerender, nor will it
 // count as an "alias" for the prerendered page.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
                        PrerenderServerRedirectToHttpsInIframe) {
   net::TestServer https_server(
       net::TestServer::TYPE_HTTPS, net::TestServer::kLocalhost,
-      base::FilePath(FILE_PATH_LITERAL("chrome/test/data")));
+      net::TestServer::GetTestDataPath());
   ASSERT_TRUE(https_server.Start());
   GURL https_url = https_server.GetURL("files/prerender/prerender_page.html");
   std::string redirect_path = CreateServerRedirect(https_url.spec());
   std::vector<net::TestServer::StringPair> replacement_text;
   replacement_text.push_back(
       std::make_pair("REPLACE_WITH_URL", "/" + redirect_path));
   std::string replacement_path;
   ASSERT_TRUE(net::TestServer::GetFilePathWithReplacements(
       "files/prerender/prerender_with_iframe.html",
       replacement_text,
@@ skipping 456 matching lines @@
   PrerenderTestURL("files/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::TestServer::SSLOptions ssl_options;
   ssl_options.server_certificate =
       net::TestServer::SSLOptions::CERT_MISMATCHED_NAME;
-    net::TestServer https_server(
-        net::TestServer::TYPE_HTTPS, ssl_options,
-        base::FilePath(FILE_PATH_LITERAL("chrome/test/data")));
+  net::TestServer https_server(
+      net::TestServer::TYPE_HTTPS, ssl_options,
+      net::TestServer::GetTestDataPath());
   ASSERT_TRUE(https_server.Start());
   GURL https_url = https_server.GetURL("files/prerender/prerender_page.html");
   PrerenderTestURL(https_url,
                    FINAL_STATUS_SSL_ERROR,
                    1);
 }
 
 // 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::TestServer::SSLOptions ssl_options;
   ssl_options.server_certificate =
       net::TestServer::SSLOptions::CERT_MISMATCHED_NAME;
-    net::TestServer https_server(
-        net::TestServer::TYPE_HTTPS, ssl_options,
-        base::FilePath(FILE_PATH_LITERAL("chrome/test/data")));
+  net::TestServer https_server(
+      net::TestServer::TYPE_HTTPS, ssl_options,
+      net::TestServer::GetTestDataPath());
   ASSERT_TRUE(https_server.Start());
   GURL https_url = https_server.GetURL("files/prerender/image.jpeg");
   std::vector<net::TestServer::StringPair> replacement_text;
   replacement_text.push_back(
       std::make_pair("REPLACE_WITH_IMAGE_URL", https_url.spec()));
   std::string replacement_path;
   ASSERT_TRUE(net::TestServer::GetFilePathWithReplacements(
       "files/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::TestServer::SSLOptions ssl_options;
   ssl_options.server_certificate =
       net::TestServer::SSLOptions::CERT_MISMATCHED_NAME;
-    net::TestServer https_server(
-        net::TestServer::TYPE_HTTPS, ssl_options,
-        base::FilePath(FILE_PATH_LITERAL("chrome/test/data")));
+  net::TestServer https_server(
+      net::TestServer::TYPE_HTTPS, ssl_options,
+      net::TestServer::GetTestDataPath());
   ASSERT_TRUE(https_server.Start());
   GURL https_url = https_server.GetURL(
       "files/prerender/prerender_embedded_content.html");
   std::vector<net::TestServer::StringPair> replacement_text;
   replacement_text.push_back(
       std::make_pair("REPLACE_WITH_URL", https_url.spec()));
   std::string replacement_path;
   ASSERT_TRUE(net::TestServer::GetFilePathWithReplacements(
       "files/prerender/prerender_with_iframe.html",
       replacement_text,
@@ skipping 27 matching lines @@
                    FINAL_STATUS_APP_TERMINATING,
                    1);
   OpenDestURLViaClickTarget();
 }
 
 // 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) {
   net::TestServer::SSLOptions ssl_options;
   ssl_options.request_client_certificate = true;
-    net::TestServer https_server(
-        net::TestServer::TYPE_HTTPS, ssl_options,
-        base::FilePath(FILE_PATH_LITERAL("chrome/test/data")));
+  net::TestServer https_server(
+      net::TestServer::TYPE_HTTPS, ssl_options,
+      net::TestServer::GetTestDataPath());
   ASSERT_TRUE(https_server.Start());
   GURL https_url = https_server.GetURL("files/prerender/prerender_page.html");
   PrerenderTestURL(https_url, FINAL_STATUS_SSL_CLIENT_CERTIFICATE_REQUESTED, 1);
 }
 
 // Checks that an SSL Client Certificate request that originates from a
 // subresource will cancel the prerendered page.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
                        PrerenderSSLClientCertSubresource) {
   net::TestServer::SSLOptions ssl_options;
   ssl_options.request_client_certificate = true;
-    net::TestServer https_server(
-        net::TestServer::TYPE_HTTPS, ssl_options,
-        base::FilePath(FILE_PATH_LITERAL("chrome/test/data")));
+  net::TestServer https_server(
+      net::TestServer::TYPE_HTTPS, ssl_options,
+      net::TestServer::GetTestDataPath());
   ASSERT_TRUE(https_server.Start());
   GURL https_url = https_server.GetURL("files/prerender/image.jpeg");
   std::vector<net::TestServer::StringPair> replacement_text;
   replacement_text.push_back(
       std::make_pair("REPLACE_WITH_IMAGE_URL", https_url.spec()));
   std::string replacement_path;
   ASSERT_TRUE(net::TestServer::GetFilePathWithReplacements(
       "files/prerender/prerender_with_image.html",
       replacement_text,
       &replacement_path));
   PrerenderTestURL(replacement_path,
                    FINAL_STATUS_SSL_CLIENT_CERTIFICATE_REQUESTED,
                    1);
 }
 
 // Checks that an SSL Client Certificate request that originates from an
 // iframe will cancel the prerendered page.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderSSLClientCertIframe) {
   net::TestServer::SSLOptions ssl_options;
   ssl_options.request_client_certificate = true;
-    net::TestServer https_server(
-        net::TestServer::TYPE_HTTPS, ssl_options,
-        base::FilePath(FILE_PATH_LITERAL("chrome/test/data")));
+  net::TestServer https_server(
+      net::TestServer::TYPE_HTTPS, ssl_options,
+      net::TestServer::GetTestDataPath());
   ASSERT_TRUE(https_server.Start());
   GURL https_url = https_server.GetURL(
       "files/prerender/prerender_embedded_content.html");
   std::vector<net::TestServer::StringPair> replacement_text;
   replacement_text.push_back(
       std::make_pair("REPLACE_WITH_URL", https_url.spec()));
   std::string replacement_path;
   ASSERT_TRUE(net::TestServer::GetFilePathWithReplacements(
       "files/prerender/prerender_with_iframe.html",
       replacement_text,
@@ skipping 448 matching lines @@
   channel_close_watcher.WatchChannel(browser()->tab_strip_model()->
       GetActiveWebContents()->GetRenderProcessHost());
   NavigateToDestURL();
   channel_close_watcher.WaitForChannelClose();
 
   ASSERT_TRUE(IsEmptyPrerenderLinkManager());
   ASSERT_TRUE(catcher.GetNextResult()) << catcher.message();
 }
 
 }  // namespace prerender