Make the TestServer use an absolute document root path.

net/url_request/url_fetcher_impl_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 "net/url_request/url_fetcher_impl.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/file_util.h"
@@ skipping 23 matching lines @@
 namespace net {
 
 using base::Time;
 using base::TimeDelta;
 
 // TODO(eroman): Add a regression test for http://crbug.com/40505.
 
 namespace {
 
 // TODO(akalin): Move all the test data to somewhere under net/.
-const base::FilePath::CharType kDocRoot[] =
-    FILE_PATH_LITERAL("chrome/test/data");
 const char kTestServerFilePrefix[] = "files/";
 
 class ThrottlingTestURLRequestContext : public TestURLRequestContext {
  public:
   ThrottlingTestURLRequestContext() : TestURLRequestContext(true) {
     set_throttler_manager(&throttler_manager_);
     Init();
     DCHECK(throttler_manager() != NULL);
   }
 
@@ skipping 139 matching lines @@
 
   resolver_.set_ondemand_mode(true);
   resolver_.rules()->AddRule("example.com", "127.0.0.1");
 
   context_.reset(new TestURLRequestContext(true));
   context_->set_host_resolver(&resolver_);
   context_->Init();
 
   test_server_.reset(new TestServer(TestServer::TYPE_HTTP,
                                     TestServer::kLocalhost,
-                                    base::FilePath(kDocRoot)));
+                                    TestServer::GetTestDataPath()));
   ASSERT_TRUE(test_server_->Start());
 
   // test_server_.GetURL() returns a URL with 127.0.0.1 (kLocalhost), that is
   // immediately resolved by the MockHostResolver. Use a hostname instead to
   // trigger an async resolve.
   test_url_ = GURL(
       base::StringPrintf("http://example.com:%d/defaultresponse",
       test_server_->host_port_pair().port()));
   ASSERT_TRUE(test_url_.is_valid());
 }
@@ skipping 655 matching lines @@
     base::PlatformFileError error_code = base::PLATFORM_FILE_OK;
     EXPECT_TRUE(fetcher_->FileErrorOccurred(&error_code));
     EXPECT_EQ(expected_file_error_, error_code);
   }
   CleanupAfterFetchComplete();
 }
 
 TEST_F(URLFetcherTest, SameThreadsTest) {
   TestServer test_server(TestServer::TYPE_HTTP,
                          TestServer::kLocalhost,
-                         base::FilePath(kDocRoot));
+                         TestServer::GetTestDataPath());
   ASSERT_TRUE(test_server.Start());
 
   // Create the fetcher on the main thread.  Since IO will happen on the main
   // thread, this will test URLFetcher's ability to do everything on one
   // thread.
   CreateFetcher(test_server.GetURL("defaultresponse"));
 
   MessageLoop::current()->Run();
 }
 
 TEST_F(URLFetcherTest, DifferentThreadsTest) {
   TestServer test_server(TestServer::TYPE_HTTP,
                          TestServer::kLocalhost,
-                         base::FilePath(kDocRoot));
+                         TestServer::GetTestDataPath());
   ASSERT_TRUE(test_server.Start());
 
   // Create a separate thread that will create the URLFetcher.  The current
   // (main) thread will do the IO, and when the fetch is complete it will
   // terminate the main thread's message loop; then the other thread's
   // message loop will be shut down automatically as the thread goes out of
   // scope.
   base::Thread t("URLFetcher test thread");
   ASSERT_TRUE(t.Start());
   t.message_loop()->PostTask(
       FROM_HERE,
       base::Bind(&URLFetcherTest::CreateFetcher,
                  base::Unretained(this),
                  test_server.GetURL("defaultresponse")));
 
   MessageLoop::current()->Run();
 }
 
 void CancelAllOnIO() {
   EXPECT_EQ(1, URLFetcherTest::GetNumFetcherCores());
   URLFetcherImpl::CancelAll();
   EXPECT_EQ(0, URLFetcherTest::GetNumFetcherCores());
 }
 
 // Tests to make sure CancelAll() will successfully cancel existing URLFetchers.
 TEST_F(URLFetcherTest, CancelAll) {
   TestServer test_server(TestServer::TYPE_HTTP,
                          TestServer::kLocalhost,
-                         base::FilePath(kDocRoot));
+                         TestServer::GetTestDataPath());
   ASSERT_TRUE(test_server.Start());
   EXPECT_EQ(0, GetNumFetcherCores());
 
   CreateFetcher(test_server.GetURL("defaultresponse"));
   io_message_loop_proxy()->PostTaskAndReply(
       FROM_HERE,
       base::Bind(&CancelAllOnIO),
       MessageLoop::QuitClosure());
   MessageLoop::current()->Run();
   EXPECT_EQ(0, GetNumFetcherCores());
@@ skipping 104 matching lines @@
   ASSERT_TRUE(completed_fetcher_);
 
   // This time the request succeeded.
   EXPECT_EQ(OK, completed_fetcher_->GetStatus().error());
   EXPECT_EQ(200, completed_fetcher_->GetResponseCode());
 }
 
 TEST_F(URLFetcherPostTest, Basic) {
   TestServer test_server(TestServer::TYPE_HTTP,
                          TestServer::kLocalhost,
-                         base::FilePath(kDocRoot));
+                         TestServer::GetTestDataPath());
   ASSERT_TRUE(test_server.Start());
 
   CreateFetcher(test_server.GetURL("echo"));
   MessageLoop::current()->Run();
 }
 
 TEST_F(URLFetcherPostFileTest, Basic) {
   TestServer test_server(TestServer::TYPE_HTTP,
                          TestServer::kLocalhost,
-                         base::FilePath(kDocRoot));
+                         TestServer::GetTestDataPath());
   ASSERT_TRUE(test_server.Start());
 
   CreateFetcher(test_server.GetURL("echo"));
   MessageLoop::current()->Run();
 }
 
 TEST_F(URLFetcherEmptyPostTest, Basic) {
   TestServer test_server(TestServer::TYPE_HTTP,
                          TestServer::kLocalhost,
-                         base::FilePath(kDocRoot));
+                         TestServer::GetTestDataPath());
   ASSERT_TRUE(test_server.Start());
 
   CreateFetcher(test_server.GetURL("echo"));
   MessageLoop::current()->Run();
 }
 
 TEST_F(URLFetcherUploadProgressTest, Basic) {
   TestServer test_server(TestServer::TYPE_HTTP,
                          TestServer::kLocalhost,
-                         base::FilePath(kDocRoot));
+                         TestServer::GetTestDataPath());
   ASSERT_TRUE(test_server.Start());
 
   CreateFetcher(test_server.GetURL("echo"));
   MessageLoop::current()->Run();
 }
 
 TEST_F(URLFetcherDownloadProgressTest, Basic) {
   TestServer test_server(TestServer::TYPE_HTTP,
                          TestServer::kLocalhost,
-                         base::FilePath(kDocRoot));
+                         TestServer::GetTestDataPath());
   ASSERT_TRUE(test_server.Start());
 
   // Get a file large enough to require more than one read into
   // URLFetcher::Core's IOBuffer.
   static const char kFileToFetch[] = "animate1.gif";
   // Hardcoded file size - it cannot be easily fetched when a remote http server
   // is used for testing.
   static const int64 kFileSize = 19021;
 
   expected_total_ = kFileSize;
 
   CreateFetcher(test_server.GetURL(
       std::string(kTestServerFilePrefix) + kFileToFetch));
 
   MessageLoop::current()->Run();
 }
 
 TEST_F(URLFetcherDownloadProgressCancelTest, CancelWhileProgressReport) {
   TestServer test_server(TestServer::TYPE_HTTP,
                          TestServer::kLocalhost,
-                         base::FilePath(kDocRoot));
+                         TestServer::GetTestDataPath());
   ASSERT_TRUE(test_server.Start());
 
   // Get a file large enough to require more than one read into
   // URLFetcher::Core's IOBuffer.
   static const char kFileToFetch[] = "animate1.gif";
   CreateFetcher(test_server.GetURL(
       std::string(kTestServerFilePrefix) + kFileToFetch));
 
   MessageLoop::current()->Run();
 }
 
 TEST_F(URLFetcherHeadersTest, Headers) {
   TestServer test_server(
       TestServer::TYPE_HTTP,
       TestServer::kLocalhost,
-      base::FilePath(FILE_PATH_LITERAL("net/data/url_request_unittest")));
+      TestServer::GetSourceRelativePath(
+          base::FilePath(FILE_PATH_LITERAL("net/data/url_request_unittest"))));
   ASSERT_TRUE(test_server.Start());
 
   CreateFetcher(test_server.GetURL("files/with-headers.html"));
   MessageLoop::current()->Run();
   // The actual tests are in the URLFetcherHeadersTest fixture.
 }
 
 TEST_F(URLFetcherSocketAddressTest, SocketAddress) {
   TestServer test_server(
       TestServer::TYPE_HTTP,
       TestServer::kLocalhost,
-      base::FilePath(FILE_PATH_LITERAL("net/data/url_request_unittest")));
+      TestServer::GetSourceRelativePath(
+          base::FilePath(FILE_PATH_LITERAL("net/data/url_request_unittest"))));
   ASSERT_TRUE(test_server.Start());
   expected_port_ = test_server.host_port_pair().port();
 
   // Reusing "with-headers.html" but doesn't really matter.
   CreateFetcher(test_server.GetURL("files/with-headers.html"));
   MessageLoop::current()->Run();
   // The actual tests are in the URLFetcherSocketAddressTest fixture.
 }
 
 TEST_F(URLFetcherStopOnRedirectTest, StopOnRedirect) {
   TestServer test_server(TestServer::TYPE_HTTP,
                          TestServer::kLocalhost,
-                         base::FilePath(kDocRoot));
+                         TestServer::GetTestDataPath());
   ASSERT_TRUE(test_server.Start());
 
   CreateFetcher(
       test_server.GetURL(std::string("server-redirect?") + kRedirectTarget));
   MessageLoop::current()->Run();
   EXPECT_TRUE(callback_called_);
 }
 
 TEST_F(URLFetcherProtectTest, Overload) {
   TestServer test_server(TestServer::TYPE_HTTP,
                          TestServer::kLocalhost,
-                         base::FilePath(kDocRoot));
+                         TestServer::GetTestDataPath());
   ASSERT_TRUE(test_server.Start());
 
   GURL url(test_server.GetURL("defaultresponse"));
 
   // Registers an entry for test url. It only allows 3 requests to be sent
   // in 200 milliseconds.
   scoped_refptr<URLRequestThrottlerEntry> entry(
       new URLRequestThrottlerEntry(
           request_context()->throttler_manager(),
           "", 200, 3, 1, 2.0, 0.0, 256));
   request_context()->throttler_manager()->OverrideEntryForTests(url, entry);
 
   CreateFetcher(url);
 
   MessageLoop::current()->Run();
 }
 
 TEST_F(URLFetcherProtectTest, ServerUnavailable) {
   TestServer test_server(TestServer::TYPE_HTTP,
                          TestServer::kLocalhost,
-                         base::FilePath(kDocRoot));
+                         TestServer::GetTestDataPath());
   ASSERT_TRUE(test_server.Start());
 
   GURL url(test_server.GetURL("files/server-unavailable.html"));
 
   // Registers an entry for test url. The backoff time is calculated by:
   //     new_backoff = 2.0 * old_backoff + 0
   // and maximum backoff time is 256 milliseconds.
   // Maximum retries allowed is set to 11.
   scoped_refptr<URLRequestThrottlerEntry> entry(
       new URLRequestThrottlerEntry(
           request_context()->throttler_manager(),
           "", 200, 3, 1, 2.0, 0.0, 256));
   request_context()->throttler_manager()->OverrideEntryForTests(url, entry);
 
   CreateFetcher(url);
 
   MessageLoop::current()->Run();
 }
 
 TEST_F(URLFetcherProtectTestPassedThrough, ServerUnavailablePropagateResponse) {
   TestServer test_server(TestServer::TYPE_HTTP,
                          TestServer::kLocalhost,
-                         base::FilePath(kDocRoot));
+                         TestServer::GetTestDataPath());
   ASSERT_TRUE(test_server.Start());
 
   GURL url(test_server.GetURL("files/server-unavailable.html"));
 
   // Registers an entry for test url. The backoff time is calculated by:
   //     new_backoff = 2.0 * old_backoff + 0
   // and maximum backoff time is 150000 milliseconds.
   // Maximum retries allowed is set to 11.
   scoped_refptr<URLRequestThrottlerEntry> entry(
       new URLRequestThrottlerEntry(
           request_context()->throttler_manager(),
           "", 200, 3, 100, 2.0, 0.0, 150000));
   // Total time if *not* for not doing automatic backoff would be 150s.
   // In reality it should be "as soon as server responds".
   request_context()->throttler_manager()->OverrideEntryForTests(url, entry);
 
   CreateFetcher(url);
 
   MessageLoop::current()->Run();
 }
 
 TEST_F(URLFetcherBadHTTPSTest, BadHTTPSTest) {
   TestServer::SSLOptions ssl_options(
       TestServer::SSLOptions::CERT_EXPIRED);
   TestServer test_server(TestServer::TYPE_HTTPS,
                          ssl_options,
-                         base::FilePath(kDocRoot));
+                         TestServer::GetTestDataPath());
   ASSERT_TRUE(test_server.Start());
 
   CreateFetcher(test_server.GetURL("defaultresponse"));
   MessageLoop::current()->Run();
 }
 
 TEST_F(URLFetcherCancelTest, ReleasesContext) {
   TestServer test_server(TestServer::TYPE_HTTP,
                          TestServer::kLocalhost,
-                         base::FilePath(kDocRoot));
+                         TestServer::GetTestDataPath());
   ASSERT_TRUE(test_server.Start());
 
   GURL url(test_server.GetURL("files/server-unavailable.html"));
 
   // Create a separate thread that will create the URLFetcher.  The current
   // (main) thread will do the IO, and when the fetch is complete it will
   // terminate the main thread's message loop; then the other thread's
   // message loop will be shut down automatically as the thread goes out of
   // scope.
   base::Thread t("URLFetcher test thread");
   ASSERT_TRUE(t.Start());
   t.message_loop()->PostTask(
       FROM_HERE,
       base::Bind(&URLFetcherCancelTest::CreateFetcher,
                  base::Unretained(this), url));
 
   MessageLoop::current()->Run();
 }
 
 TEST_F(URLFetcherCancelTest, CancelWhileDelayedStartTaskPending) {
   TestServer test_server(TestServer::TYPE_HTTP,
                          TestServer::kLocalhost,
-                         base::FilePath(kDocRoot));
+                         TestServer::GetTestDataPath());
   ASSERT_TRUE(test_server.Start());
 
   GURL url(test_server.GetURL("files/server-unavailable.html"));
 
   // Register an entry for test url.
   // Using a sliding window of 4 seconds, and max of 1 request, under a fast
   // run we expect to have a 4 second delay when posting the Start task.
   scoped_refptr<URLRequestThrottlerEntry> entry(
       new URLRequestThrottlerEntry(
           request_context()->throttler_manager(),
@@ skipping 11 matching lines @@
   t.message_loop()->PostTask(
       FROM_HERE,
       base::Bind(&URLFetcherTest::CreateFetcher, base::Unretained(this), url));
 
   MessageLoop::current()->Run();
 }
 
 TEST_F(URLFetcherMultipleAttemptTest, SameData) {
   TestServer test_server(TestServer::TYPE_HTTP,
                          TestServer::kLocalhost,
-                         base::FilePath(kDocRoot));
+                         TestServer::GetTestDataPath());
   ASSERT_TRUE(test_server.Start());
 
   // Create the fetcher on the main thread.  Since IO will happen on the main
   // thread, this will test URLFetcher's ability to do everything on one
   // thread.
   CreateFetcher(test_server.GetURL("defaultresponse"));
 
   MessageLoop::current()->Run();
 }
 
 TEST_F(URLFetcherFileTest, SmallGet) {
   TestServer test_server(TestServer::TYPE_HTTP,
                          TestServer::kLocalhost,
-                         base::FilePath(kDocRoot));
+                         TestServer::GetTestDataPath());
   ASSERT_TRUE(test_server.Start());
 
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
 
   // Get a small file.
   static const char kFileToFetch[] = "simple.html";
   expected_file_ = test_server.GetDocumentRoot().AppendASCII(kFileToFetch);
   CreateFetcherForFile(
       test_server.GetURL(std::string(kTestServerFilePrefix) + kFileToFetch),
       temp_dir.path().AppendASCII(kFileToFetch));
 
   MessageLoop::current()->Run();  // OnURLFetchComplete() will Quit().
 
   ASSERT_FALSE(file_util::PathExists(file_path_))
       << file_path_.value() << " not removed.";
 }
 
 TEST_F(URLFetcherFileTest, LargeGet) {
   TestServer test_server(TestServer::TYPE_HTTP,
                          TestServer::kLocalhost,
-                         base::FilePath(kDocRoot));
+                         TestServer::GetTestDataPath());
   ASSERT_TRUE(test_server.Start());
 
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
 
   // Get a file large enough to require more than one read into
   // URLFetcher::Core's IOBuffer.
   static const char kFileToFetch[] = "animate1.gif";
   expected_file_ = test_server.GetDocumentRoot().AppendASCII(kFileToFetch);
   CreateFetcherForFile(
       test_server.GetURL(std::string(kTestServerFilePrefix) + kFileToFetch),
       temp_dir.path().AppendASCII(kFileToFetch));
 
   MessageLoop::current()->Run();  // OnURLFetchComplete() will Quit().
 }
 
 TEST_F(URLFetcherFileTest, CanTakeOwnershipOfFile) {
   TestServer test_server(TestServer::TYPE_HTTP,
                          TestServer::kLocalhost,
-                         base::FilePath(kDocRoot));
+                         TestServer::GetTestDataPath());
   ASSERT_TRUE(test_server.Start());
 
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
 
   // Get a small file.
   static const char kFileToFetch[] = "simple.html";
   expected_file_ = test_server.GetDocumentRoot().AppendASCII(kFileToFetch);
   CreateFetcherForFile(
       test_server.GetURL(std::string(kTestServerFilePrefix) + kFileToFetch),
       temp_dir.path().AppendASCII(kFileToFetch));
 
   MessageLoop::current()->Run();  // OnURLFetchComplete() will Quit().
 
   MessageLoop::current()->RunUntilIdle();
   ASSERT_FALSE(file_util::PathExists(file_path_))
       << file_path_.value() << " not removed.";
 }
 
 
 TEST_F(URLFetcherFileTest, OverwriteExistingFile) {
   TestServer test_server(TestServer::TYPE_HTTP,
                          TestServer::kLocalhost,
-                         base::FilePath(kDocRoot));
+                         TestServer::GetTestDataPath());
   ASSERT_TRUE(test_server.Start());
 
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
 
   // Create a file before trying to fetch.
   static const char kFileToFetch[] = "simple.html";
   static const char kData[] = "abcdefghijklmnopqrstuvwxyz";
   file_path_ = temp_dir.path().AppendASCII(kFileToFetch);
   const int data_size = arraysize(kData);
   ASSERT_EQ(file_util::WriteFile(file_path_, kData, data_size), data_size);
   ASSERT_TRUE(file_util::PathExists(file_path_));
   expected_file_ = test_server.GetDocumentRoot().AppendASCII(kFileToFetch);
   ASSERT_FALSE(file_util::ContentsEqual(file_path_, expected_file_));
 
   // Get a small file.
   CreateFetcherForFile(
       test_server.GetURL(std::string(kTestServerFilePrefix) + kFileToFetch),
       file_path_);
 
   MessageLoop::current()->Run();  // OnURLFetchComplete() will Quit().
 }
 
 TEST_F(URLFetcherFileTest, TryToOverwriteDirectory) {
   TestServer test_server(TestServer::TYPE_HTTP,
                          TestServer::kLocalhost,
-                         base::FilePath(kDocRoot));
+                         TestServer::GetTestDataPath());
   ASSERT_TRUE(test_server.Start());
 
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
 
   // Create a directory before trying to fetch.
   static const char kFileToFetch[] = "simple.html";
   file_path_ = temp_dir.path().AppendASCII(kFileToFetch);
   ASSERT_TRUE(file_util::CreateDirectory(file_path_));
   ASSERT_TRUE(file_util::PathExists(file_path_));
 
   // Get a small file.
   expected_file_error_ = base::PLATFORM_FILE_ERROR_ACCESS_DENIED;
   expected_file_ = test_server.GetDocumentRoot().AppendASCII(kFileToFetch);
   CreateFetcherForFile(
       test_server.GetURL(std::string(kTestServerFilePrefix) + kFileToFetch),
       file_path_);
 
   MessageLoop::current()->Run();  // OnURLFetchComplete() will Quit().
 
   MessageLoop::current()->RunUntilIdle();
 }
 
 TEST_F(URLFetcherFileTest, SmallGetToTempFile) {
   TestServer test_server(TestServer::TYPE_HTTP,
                          TestServer::kLocalhost,
-                         base::FilePath(kDocRoot));
+                         TestServer::GetTestDataPath());
   ASSERT_TRUE(test_server.Start());
 
   // Get a small file.
   static const char kFileToFetch[] = "simple.html";
   expected_file_ = test_server.GetDocumentRoot().AppendASCII(kFileToFetch);
   CreateFetcherForTempFile(
       test_server.GetURL(std::string(kTestServerFilePrefix) + kFileToFetch));
 
   MessageLoop::current()->Run();  // OnURLFetchComplete() will Quit().
 
   ASSERT_FALSE(file_util::PathExists(file_path_))
       << file_path_.value() << " not removed.";
 }
 
 TEST_F(URLFetcherFileTest, LargeGetToTempFile) {
   TestServer test_server(TestServer::TYPE_HTTP,
                          TestServer::kLocalhost,
-                         base::FilePath(kDocRoot));
+                         TestServer::GetTestDataPath());
   ASSERT_TRUE(test_server.Start());
 
   // Get a file large enough to require more than one read into
   // URLFetcher::Core's IOBuffer.
   static const char kFileToFetch[] = "animate1.gif";
   expected_file_ = test_server.GetDocumentRoot().AppendASCII(kFileToFetch);
   CreateFetcherForTempFile(test_server.GetURL(
       std::string(kTestServerFilePrefix) + kFileToFetch));
 
   MessageLoop::current()->Run();  // OnURLFetchComplete() will Quit().
 }
 
 TEST_F(URLFetcherFileTest, CanTakeOwnershipOfTempFile) {
   TestServer test_server(TestServer::TYPE_HTTP,
                          TestServer::kLocalhost,
-                         base::FilePath(kDocRoot));
+                         TestServer::GetTestDataPath());
   ASSERT_TRUE(test_server.Start());
 
   // Get a small file.
   static const char kFileToFetch[] = "simple.html";
   expected_file_ = test_server.GetDocumentRoot().AppendASCII(kFileToFetch);
   CreateFetcherForTempFile(test_server.GetURL(
       std::string(kTestServerFilePrefix) + kFileToFetch));
 
   MessageLoop::current()->Run();  // OnURLFetchComplete() will Quit().
 
   MessageLoop::current()->RunUntilIdle();
   ASSERT_FALSE(file_util::PathExists(file_path_))
       << file_path_.value() << " not removed.";
 }
 
 }  // namespace
 
 }  // namespace net