Make the TestServer use an absolute document root path.

net/url_request/url_request_unittest.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 "build/build_config.h"
 
 #if defined(OS_WIN)
 #include <windows.h>
 #include <shlobj.h>
 #endif
@@ skipping 1396 matching lines @@
 // TODO(droger): Support TestServer on iOS (see http://crbug.com/148666).
 #if !defined(OS_IOS)
 // A subclass of TestServer that uses a statically-configured hostname. This is
 // to work around mysterious failures in chrome_frame_net_tests. See:
 // http://crbug.com/114369
 class LocalHttpTestServer : public TestServer {
  public:
   explicit LocalHttpTestServer(const base::FilePath& document_root)
       : TestServer(TestServer::TYPE_HTTP,
                    ScopedCustomUrlRequestTestHttpHost::value(),
-                   document_root) {}
+                   GetSourceRelativePath(document_root)) {}
   LocalHttpTestServer()
       : TestServer(TestServer::TYPE_HTTP,
                    ScopedCustomUrlRequestTestHttpHost::value(),
-                   base::FilePath()) {}
+                   GetSourcePath()) {}
 };
 
 TEST_F(URLRequestTest, DelayedCookieCallback) {
   LocalHttpTestServer test_server;
   ASSERT_TRUE(test_server.Start());
 
   TestURLRequestContext context;
   scoped_refptr<DelayedCookieMonster> delayed_cm =
       new DelayedCookieMonster();
   scoped_refptr<CookieStore> cookie_store = delayed_cm;
@@ skipping 1510 matching lines @@
   }
 }
 
 // This test was disabled because it made chrome_frame_net_tests hang
 // (see bug 102991).
 TEST_F(URLRequestTestHTTP, DISABLED_HTTPSToHTTPRedirectNoRefererTest) {
   ASSERT_TRUE(test_server_.Start());
 
   TestServer https_test_server(
       TestServer::TYPE_HTTPS, TestServer::kLocalhost,
-      base::FilePath(FILE_PATH_LITERAL("net/data/ssl")));
+      TestServer::GetSourceRelativePath(
+          base::FilePath(FILE_PATH_LITERAL("net/data/ssl"))));
   ASSERT_TRUE(https_test_server.Start());
 
   // An https server is sent a request with an https referer,
   // and responds with a redirect to an http url. The http
   // server should not be sent the referer.
   GURL http_destination = test_server_.GetURL("");
   TestDelegate d;
   URLRequest req(https_test_server.GetURL(
       "server-redirect?" + http_destination.spec()), &d, &default_context_);
   req.set_referrer("https://www.referrer.com/");
@@ skipping 423 matching lines @@
   header.clear();
   EXPECT_TRUE(headers->GetNormalizedHeader("x-multiple-entries", &header));
   EXPECT_EQ("a, b", header);
 }
 
 TEST_F(URLRequestTestHTTP, ProcessSTS) {
   TestServer::SSLOptions ssl_options;
   TestServer https_test_server(
       TestServer::TYPE_HTTPS,
       ssl_options,
-      base::FilePath(FILE_PATH_LITERAL("net/data/url_request_unittest")));
+      TestServer::GetSourceRelativePath(
+          base::FilePath(FILE_PATH_LITERAL("net/data/url_request_unittest"))));
   ASSERT_TRUE(https_test_server.Start());
 
   TestDelegate d;
   URLRequest request(
       https_test_server.GetURL("files/hsts-headers.html"),
       &d,
       &default_context_);
   request.Start();
   MessageLoop::current()->Run();
 
   TransportSecurityState* security_state =
       default_context_.transport_security_state();
   bool sni_available = true;
   TransportSecurityState::DomainState domain_state;
   EXPECT_TRUE(security_state->GetDomainState(
       TestServer::kLocalhost, sni_available, &domain_state));
   EXPECT_EQ(TransportSecurityState::DomainState::MODE_FORCE_HTTPS,
             domain_state.upgrade_mode);
   EXPECT_TRUE(domain_state.include_subdomains);
 }
 
 TEST_F(URLRequestTestHTTP, ProcessSTSOnce) {
   TestServer::SSLOptions ssl_options;
   TestServer https_test_server(
       TestServer::TYPE_HTTPS,
       ssl_options,
-      base::FilePath(FILE_PATH_LITERAL("net/data/url_request_unittest")));
+      TestServer::GetSourceRelativePath(
+          base::FilePath(FILE_PATH_LITERAL("net/data/url_request_unittest"))));
   ASSERT_TRUE(https_test_server.Start());
 
   TestDelegate d;
   URLRequest request(
       https_test_server.GetURL("files/hsts-multiple-headers.html"),
       &d,
       &default_context_);
   request.Start();
   MessageLoop::current()->Run();
 
@@ skipping 705 matching lines @@
  protected:
   TestNetworkDelegate default_network_delegate_;  // Must outlive URLRequest.
   TestURLRequestContext default_context_;
 };
 
 // This test was disabled because it made chrome_frame_net_tests hang
 // (see bug 102991).
 TEST_F(HTTPSRequestTest, DISABLED_HTTPSGetTest) {
   TestServer test_server(TestServer::TYPE_HTTPS,
                          TestServer::kLocalhost,
-                         base::FilePath(FILE_PATH_LITERAL("net/data/ssl")));
+                         TestServer::GetSourceRelativePath(base::FilePath(
+                             FILE_PATH_LITERAL("net/data/ssl"))));
   ASSERT_TRUE(test_server.Start());
 
   TestDelegate d;
   {
     URLRequest r(test_server.GetURL(""), &d, &default_context_);
     r.Start();
     EXPECT_TRUE(r.is_pending());
 
     MessageLoop::current()->Run();
 
     EXPECT_EQ(1, d.response_started_count());
     EXPECT_FALSE(d.received_data_before_response());
     EXPECT_NE(0, d.bytes_received());
     CheckSSLInfo(r.ssl_info());
     EXPECT_EQ(test_server.host_port_pair().host(),
               r.GetSocketAddress().host());
     EXPECT_EQ(test_server.host_port_pair().port(),
               r.GetSocketAddress().port());
   }
 }
 
 TEST_F(HTTPSRequestTest, HTTPSMismatchedTest) {
   TestServer::SSLOptions ssl_options(
       TestServer::SSLOptions::CERT_MISMATCHED_NAME);
   TestServer test_server(TestServer::TYPE_HTTPS,
                          ssl_options,
-                         base::FilePath(FILE_PATH_LITERAL("net/data/ssl")));
+                         TestServer::GetSourceRelativePath(base::FilePath(
+                             FILE_PATH_LITERAL("net/data/ssl"))));
   ASSERT_TRUE(test_server.Start());
 
   bool err_allowed = true;
   for (int i = 0; i < 2 ; i++, err_allowed = !err_allowed) {
     TestDelegate d;
     {
       d.set_allow_certificate_errors(err_allowed);
       URLRequest r(test_server.GetURL(""), &d, &default_context_);
 
       r.Start();
@@ skipping 12 matching lines @@
       }
     }
   }
 }
 
 TEST_F(HTTPSRequestTest, HTTPSExpiredTest) {
   TestServer::SSLOptions ssl_options(
       TestServer::SSLOptions::CERT_EXPIRED);
   TestServer test_server(TestServer::TYPE_HTTPS,
                          ssl_options,
-                         base::FilePath(FILE_PATH_LITERAL("net/data/ssl")));
+                         TestServer::GetSourceRelativePath(base::FilePath(
+                             FILE_PATH_LITERAL("net/data/ssl"))));
   ASSERT_TRUE(test_server.Start());
 
   // Iterate from false to true, just so that we do the opposite of the
   // previous test in order to increase test coverage.
   bool err_allowed = false;
   for (int i = 0; i < 2 ; i++, err_allowed = !err_allowed) {
     TestDelegate d;
     {
       d.set_allow_certificate_errors(err_allowed);
       URLRequest r(test_server.GetURL(""), &d, &default_context_);
@@ skipping 26 matching lines @@
 #endif
   if (default_version_max <= SSL_PROTOCOL_VERSION_TLS1)
     return;
 
   TestServer::SSLOptions ssl_options(
       TestServer::SSLOptions::CERT_OK);
   ssl_options.tls_intolerant =
       TestServer::SSLOptions::TLS_INTOLERANT_TLS1_1;
   TestServer test_server(TestServer::TYPE_HTTPS,
                          ssl_options,
-                         base::FilePath(FILE_PATH_LITERAL("net/data/ssl")));
+                         TestServer::GetSourceRelativePath(base::FilePath(
+                             FILE_PATH_LITERAL("net/data/ssl"))));
   ASSERT_TRUE(test_server.Start());
 
   TestDelegate d;
   TestURLRequestContext context(true);
   context.Init();
   d.set_allow_certificate_errors(true);
   URLRequest r(test_server.GetURL(""), &d, &context);
   r.Start();
 
   MessageLoop::current()->Run();
 
   EXPECT_EQ(1, d.response_started_count());
   EXPECT_NE(0, d.bytes_received());
   EXPECT_EQ(static_cast<int>(SSL_CONNECTION_VERSION_TLS1),
             SSLConnectionStatusToVersion(r.ssl_info().connection_status));
   EXPECT_TRUE(r.ssl_info().connection_status & SSL_CONNECTION_VERSION_FALLBACK);
 }
 
 // This tests that a load of www.google.com with a certificate error sets
 // the |certificate_errors_are_fatal| flag correctly. This flag will cause
 // the interstitial to be fatal.
 TEST_F(HTTPSRequestTest, HTTPSPreloadedHSTSTest) {
   TestServer::SSLOptions ssl_options(
       TestServer::SSLOptions::CERT_MISMATCHED_NAME);
   TestServer test_server(TestServer::TYPE_HTTPS,
                          ssl_options,
-                         base::FilePath(FILE_PATH_LITERAL("net/data/ssl")));
+                         TestServer::GetSourceRelativePath(base::FilePath(
+                             FILE_PATH_LITERAL("net/data/ssl"))));
   ASSERT_TRUE(test_server.Start());
 
   // We require that the URL be www.google.com in order to pick up the
   // preloaded HSTS entries in the TransportSecurityState. This means that we
   // have to use a MockHostResolver in order to direct www.google.com to the
   // testserver. By default, MockHostResolver maps all hosts to 127.0.0.1.
 
   MockHostResolver host_resolver;
   TestNetworkDelegate network_delegate;  // Must outlive URLRequest.
   TestURLRequestContext context(true);
@@ skipping 22 matching lines @@
 
 // This tests that cached HTTPS page loads do not cause any updates to the
 // TransportSecurityState.
 TEST_F(HTTPSRequestTest, HTTPSErrorsNoClobberTSSTest) {
   // The actual problem -- CERT_MISMATCHED_NAME in this case -- doesn't
   // matter. It just has to be any error.
   TestServer::SSLOptions ssl_options(
       TestServer::SSLOptions::CERT_MISMATCHED_NAME);
   TestServer test_server(TestServer::TYPE_HTTPS,
                          ssl_options,
-                         base::FilePath(FILE_PATH_LITERAL("net/data/ssl")));
+                         TestServer::GetSourceRelativePath(base::FilePath(
+                             FILE_PATH_LITERAL("net/data/ssl"))));
   ASSERT_TRUE(test_server.Start());
 
   // We require that the URL be www.google.com in order to pick up the
   // preloaded and dynamic HSTS and public key pin entries in the
   // TransportSecurityState. This means that we have to use a
   // MockHostResolver in order to direct www.google.com to the testserver.
   // By default, MockHostResolver maps all hosts to 127.0.0.1.
 
   MockHostResolver host_resolver;
   TestNetworkDelegate network_delegate;  // Must outlive URLRequest.
@@ skipping 38 matching lines @@
                                 domain_state.bad_static_spki_hashes));
 }
 
 // Make sure HSTS preserves a POST request's method and body.
 TEST_F(HTTPSRequestTest, HSTSPreservesPosts) {
   static const char kData[] = "hello world";
 
   TestServer::SSLOptions ssl_options(TestServer::SSLOptions::CERT_OK);
   TestServer test_server(TestServer::TYPE_HTTPS,
                          ssl_options,
-                         base::FilePath(FILE_PATH_LITERAL("net/data/ssl")));
+                         TestServer::GetSourceRelativePath(base::FilePath(
+                             FILE_PATH_LITERAL("net/data/ssl"))));
   ASSERT_TRUE(test_server.Start());
 
 
   // Per spec, TransportSecurityState expects a domain name, rather than an IP
   // address, so a MockHostResolver is needed to redirect www.somewhere.com to
   // the TestServer.  By default, MockHostResolver maps all hosts to 127.0.0.1.
   MockHostResolver host_resolver;
 
   // Force https for www.somewhere.com.
   TransportSecurityState transport_security_state;
@@ skipping 29 matching lines @@
   EXPECT_EQ("POST", req.method());
   EXPECT_EQ(kData, d.data_received());
 }
 
 TEST_F(HTTPSRequestTest, SSLv3Fallback) {
   TestServer::SSLOptions ssl_options(
       TestServer::SSLOptions::CERT_OK);
   ssl_options.tls_intolerant = TestServer::SSLOptions::TLS_INTOLERANT_ALL;
   TestServer test_server(TestServer::TYPE_HTTPS,
                          ssl_options,
-                         base::FilePath(FILE_PATH_LITERAL("net/data/ssl")));
+                         TestServer::GetSourceRelativePath(base::FilePath(
+                             FILE_PATH_LITERAL("net/data/ssl"))));
   ASSERT_TRUE(test_server.Start());
 
   TestDelegate d;
   TestURLRequestContext context(true);
   context.Init();
   d.set_allow_certificate_errors(true);
   URLRequest r(test_server.GetURL(""), &d, &context);
   r.Start();
 
   MessageLoop::current()->Run();
@@ skipping 29 matching lines @@
 // TODO(davidben): Test the rest of the code. Specifically,
 // - Filtering which certificates to select.
 // - Sending a certificate back.
 // - Getting a certificate request in an SSL renegotiation sending the
 //   HTTP request.
 TEST_F(HTTPSRequestTest, ClientAuthTest) {
   TestServer::SSLOptions ssl_options;
   ssl_options.request_client_certificate = true;
   TestServer test_server(TestServer::TYPE_HTTPS,
                          ssl_options,
-                         base::FilePath(FILE_PATH_LITERAL("net/data/ssl")));
+                         TestServer::GetSourceRelativePath(base::FilePath(
+                             FILE_PATH_LITERAL("net/data/ssl"))));
   ASSERT_TRUE(test_server.Start());
 
   SSLClientAuthTestDelegate d;
   {
     URLRequest r(test_server.GetURL(""), &d, &default_context_);
 
     r.Start();
     EXPECT_TRUE(r.is_pending());
 
     MessageLoop::current()->Run();
@@ skipping 15 matching lines @@
   }
 }
 
 TEST_F(HTTPSRequestTest, ResumeTest) {
   // Test that we attempt a session resume when making two connections to the
   // same host.
   TestServer::SSLOptions ssl_options;
   ssl_options.record_resume = true;
   TestServer test_server(TestServer::TYPE_HTTPS,
                          ssl_options,
-                         base::FilePath(FILE_PATH_LITERAL("net/data/ssl")));
+                         TestServer::GetSourceRelativePath(base::FilePath(
+                             FILE_PATH_LITERAL("net/data/ssl"))));
   ASSERT_TRUE(test_server.Start());
 
   SSLClientSocket::ClearSessionCache();
 
   {
     TestDelegate d;
     URLRequest r(
         test_server.GetURL("ssl-session-cache"), &d, &default_context_);
 
     r.Start();
@@ skipping 47 matching lines @@
   }
 }
 
 TEST_F(HTTPSRequestTest, SSLSessionCacheShardTest) {
   // Test that sessions aren't resumed when the value of ssl_session_cache_shard
   // differs.
   TestServer::SSLOptions ssl_options;
   ssl_options.record_resume = true;
   TestServer test_server(TestServer::TYPE_HTTPS,
                          ssl_options,
-                         base::FilePath(FILE_PATH_LITERAL("net/data/ssl")));
+                         TestServer::GetSourceRelativePath(base::FilePath(
+                             FILE_PATH_LITERAL("net/data/ssl"))));
   ASSERT_TRUE(test_server.Start());
 
   SSLClientSocket::ClearSessionCache();
 
   {
     TestDelegate d;
     URLRequest r(
         test_server.GetURL("ssl-session-cache"), &d, &default_context_);
 
     r.Start();
@@ skipping 115 matching lines @@
     EnsureNSSHttpIOInit();
 #endif
   }
 
   void DoConnection(const TestServer::SSLOptions& ssl_options,
                     CertStatus* out_cert_status) {
     // We always overwrite out_cert_status.
     *out_cert_status = 0;
     TestServer test_server(TestServer::TYPE_HTTPS,
                            ssl_options,
-                           base::FilePath(FILE_PATH_LITERAL("net/data/ssl")));
+                           TestServer::GetSourceRelativePath(base::FilePath(
+                               FILE_PATH_LITERAL("net/data/ssl"))));
     ASSERT_TRUE(test_server.Start());
 
     TestDelegate d;
     d.set_allow_certificate_errors(true);
     URLRequest r(test_server.GetURL(""), &d, &context_);
     r.Start();
 
     MessageLoop::current()->Run();
 
     EXPECT_EQ(1, d.response_started_count());
@@ skipping 273 matching lines @@
   EXPECT_FALSE(cert_status & CERT_STATUS_IS_EV);
   EXPECT_FALSE(cert_status & CERT_STATUS_REV_CHECKING_ENABLED);
 }
 #endif  // !defined(OS_IOS)
 
 #if !defined(DISABLE_FTP_SUPPORT)
 class URLRequestTestFTP : public URLRequestTest {
  public:
   URLRequestTestFTP()
       : test_server_(TestServer::TYPE_FTP, TestServer::kLocalhost,
-                     base::FilePath()) {
+                     TestServer::GetSourcePath()) {
   }
 
  protected:
   TestServer test_server_;
 };
 
 // Make sure an FTP request using an unsafe ports fails.
 TEST_F(URLRequestTestFTP, UnsafePort) {
   ASSERT_TRUE(test_server_.Start());
 
@@ skipping 337 matching lines @@
 
     EXPECT_FALSE(r.is_pending());
     EXPECT_EQ(1, d->response_started_count());
     EXPECT_FALSE(d->received_data_before_response());
     EXPECT_EQ(d->bytes_received(), static_cast<int>(file_size));
   }
 }
 #endif  // !defined(DISABLE_FTP_SUPPORT)
 
 }  // namespace net