Clean up URLFetcher unit tests, part 1

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 <algorithm>
 #include <string>
 
 #include "base/bind.h"
@@ skipping 36 matching lines @@
 // TODO(akalin): Move all the test data to somewhere under net/.
 const base::FilePath::CharType kDocRoot[] =
     FILE_PATH_LITERAL("net/data/url_fetcher_impl_unittest");
 const char kTestServerFilePrefix[] = "files/";
 
 class ThrottlingTestURLRequestContext : public TestURLRequestContext {
  public:
   ThrottlingTestURLRequestContext() : TestURLRequestContext(true) {
     set_throttler_manager(&throttler_manager_);
     Init();
-    DCHECK(throttler_manager() != NULL);
+    DCHECK(throttler_manager() != nullptr);
   }
 
  private:
   URLRequestThrottlerManager throttler_manager_;
 };
 
 class ThrottlingTestURLRequestContextGetter
     : public TestURLRequestContextGetter {
  public:
   ThrottlingTestURLRequestContextGetter(
@@ skipping 10 matching lines @@
   ~ThrottlingTestURLRequestContextGetter() override {}
 
   TestURLRequestContext* const context_;
 };
 
 }  // namespace
 
 class URLFetcherTest : public testing::Test,
                        public URLFetcherDelegate {
  public:
-  URLFetcherTest() : fetcher_(NULL), expected_status_code_(200) {}
+  URLFetcherTest()
+      : io_message_loop_proxy_(base::MessageLoopProxy::current()),
+        fetcher_(nullptr),
+        expected_status_code_(200) {}
 
   static int GetNumFetcherCores() {
     return URLFetcherImpl::GetNumFetcherCores();
   }
 
   // Creates a URLFetcher, using the program's main thread to do IO.
   virtual void CreateFetcher(const GURL& url);
 
   // URLFetcherDelegate:
   // Subclasses that override this should either call this function or
   // CleanupAfterFetchComplete() at the end of their processing, depending on
   // whether they want to check for a non-empty HTTP 200 response or not.
   void OnURLFetchComplete(const URLFetcher* source) override;
 
   // Deletes |fetcher| and terminates the message loop.
   void CleanupAfterFetchComplete();
 
   scoped_refptr<base::MessageLoopProxy> io_message_loop_proxy() {
     return io_message_loop_proxy_;
   }
 
   TestURLRequestContext* request_context() {
     return context_.get();
   }
 
  protected:
   // testing::Test:
   void SetUp() override {
-    testing::Test::SetUp();
+    SetUpServer();
+    ASSERT_TRUE(test_server_->Start());
 
     context_.reset(new ThrottlingTestURLRequestContext());
-    io_message_loop_proxy_ = base::MessageLoopProxy::current();
 
 #if defined(USE_NSS) || defined(OS_IOS)
     crypto::EnsureNSSInit();
     EnsureNSSHttpIOInit();
 #endif
   }
 
   void TearDown() override {
 #if defined(USE_NSS) || defined(OS_IOS)
     ShutdownNSSHttpIO();
 #endif
   }
 
+  // Initializes |test_server_| without starting it.  Allows subclasses to use
+  // their own server configuration.
+  virtual void SetUpServer() {
+    test_server_.reset(new SpawnedTestServer(SpawnedTestServer::TYPE_HTTP,
+                                             SpawnedTestServer::kLocalhost,
+                                             base::FilePath(kDocRoot)));
+  }
+
   // URLFetcher is designed to run on the main UI thread, but in our tests
   // we assume that the current thread is the IO thread where the URLFetcher
   // dispatches its requests to.  When we wish to simulate being used from
   // a UI thread, we dispatch a worker thread to do so.
   scoped_refptr<base::MessageLoopProxy> io_message_loop_proxy_;
 
+  scoped_ptr<SpawnedTestServer> test_server_;
+
   URLFetcherImpl* fetcher_;
   scoped_ptr<TestURLRequestContext> context_;
   int expected_status_code_;
 };
 
 // A test fixture that uses a MockHostResolver, so that name resolutions can
 // be manipulated by the tests to keep connections in the resolving state.
 class URLFetcherMockDnsTest : public URLFetcherTest {
  public:
   // testing::Test:
   void SetUp() override;
 
   // URLFetcherTest:
   void CreateFetcher(const GURL& url) override;
 
   // URLFetcherDelegate:
   void OnURLFetchComplete(const URLFetcher* source) override;
 
  protected:
   GURL test_url_;
-  scoped_ptr<SpawnedTestServer> test_server_;
   MockHostResolver resolver_;
   scoped_ptr<URLFetcher> completed_fetcher_;
 };
 
 void URLFetcherTest::CreateFetcher(const GURL& url) {
   fetcher_ = new URLFetcherImpl(url, URLFetcher::GET, this);
   fetcher_->SetRequestContext(new ThrottlingTestURLRequestContextGetter(
       io_message_loop_proxy().get(), request_context()));
   fetcher_->Start();
 }
@@ skipping 23 matching lines @@
 void URLFetcherMockDnsTest::SetUp() {
   URLFetcherTest::SetUp();
 
   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 SpawnedTestServer(SpawnedTestServer::TYPE_HTTP,
-                                           SpawnedTestServer::kLocalhost,
-                                           base::FilePath(kDocRoot)));
-  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());
 }
 
 void URLFetcherMockDnsTest::CreateFetcher(const GURL& url) {
@@ skipping 202 matching lines @@
 
  private:
   Time start_time_;
 };
 
 // Version of URLFetcherTest that tests bad HTTPS requests.
 class URLFetcherBadHTTPSTest : public URLFetcherTest {
  public:
   URLFetcherBadHTTPSTest();
 
+  // URLFetcherTest:
+  void SetUpServer() override;
+
   // URLFetcherDelegate:
   void OnURLFetchComplete(const URLFetcher* source) override;
 
  private:
   base::FilePath cert_dir_;
 };
 
 // Version of URLFetcherTest that tests request cancellation on shutdown.
 class URLFetcherCancelTest : public URLFetcherTest {
  public:
@@ skipping 393 matching lines @@
 
 URLFetcherBadHTTPSTest::URLFetcherBadHTTPSTest() {
   PathService::Get(base::DIR_SOURCE_ROOT, &cert_dir_);
   cert_dir_ = cert_dir_.AppendASCII("chrome");
   cert_dir_ = cert_dir_.AppendASCII("test");
   cert_dir_ = cert_dir_.AppendASCII("data");
   cert_dir_ = cert_dir_.AppendASCII("ssl");
   cert_dir_ = cert_dir_.AppendASCII("certificates");
 }
 
+void URLFetcherBadHTTPSTest::SetUpServer() {
+  SpawnedTestServer::SSLOptions ssl_options(
+      SpawnedTestServer::SSLOptions::CERT_EXPIRED);
+  test_server_.reset(new SpawnedTestServer(
+      SpawnedTestServer::TYPE_HTTPS, ssl_options, base::FilePath(kDocRoot)));
+}
+
 // The "server certificate expired" error should result in automatic
 // cancellation of the request by
 // URLRequest::Delegate::OnSSLCertificateError.
 void URLFetcherBadHTTPSTest::OnURLFetchComplete(
     const URLFetcher* source) {
   // This part is different from URLFetcherTest::OnURLFetchComplete
   // because this test expects the request to be cancelled.
   EXPECT_EQ(URLRequestStatus::CANCELED, source->GetStatus().status());
   EXPECT_EQ(ERR_ABORTED, source->GetStatus().error());
   EXPECT_EQ(-1, source->GetResponseCode());
@@ skipping 81 matching lines @@
 
     EXPECT_TRUE(base::ContentsEqual(expected_file_, file_path_));
   } else {
     EXPECT_FALSE(source->GetStatus().is_success());
     EXPECT_EQ(expected_file_error_, source->GetStatus().error());
   }
   CleanupAfterFetchComplete();
 }
 
 TEST_F(URLFetcherTest, SameThreadsTest) {
-  SpawnedTestServer test_server(SpawnedTestServer::TYPE_HTTP,
-                                SpawnedTestServer::kLocalhost,
-                                base::FilePath(kDocRoot));
-  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"));
+  CreateFetcher(test_server_->GetURL("defaultresponse"));
 
   base::MessageLoop::current()->Run();
 }
 
 TEST_F(URLFetcherTest, DifferentThreadsTest) {
-  SpawnedTestServer test_server(SpawnedTestServer::TYPE_HTTP,
-                                SpawnedTestServer::kLocalhost,
-                                base::FilePath(kDocRoot));
-  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")));
+      base::Bind(&URLFetcherTest::CreateFetcher, base::Unretained(this),
+                 test_server_->GetURL("defaultresponse")));
 
   base::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) {
-  SpawnedTestServer test_server(SpawnedTestServer::TYPE_HTTP,
-                                SpawnedTestServer::kLocalhost,
-                                base::FilePath(kDocRoot));
-  ASSERT_TRUE(test_server.Start());
   EXPECT_EQ(0, GetNumFetcherCores());
 
-  CreateFetcher(test_server.GetURL("defaultresponse"));
+  CreateFetcher(test_server_->GetURL("defaultresponse"));
   io_message_loop_proxy()->PostTaskAndReply(
       FROM_HERE, base::Bind(&CancelAllOnIO), base::MessageLoop::QuitClosure());
   base::MessageLoop::current()->Run();
   EXPECT_EQ(0, GetNumFetcherCores());
   delete fetcher_;
 }
 
 TEST_F(URLFetcherMockDnsTest, DontRetryOnNetworkChangedByDefault) {
   EXPECT_EQ(0, GetNumFetcherCores());
   EXPECT_FALSE(resolver_.has_pending_requests());
@@ skipping 96 matching lines @@
   EXPECT_EQ(0, GetNumFetcherCores());
   EXPECT_FALSE(resolver_.has_pending_requests());
   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) {
-  SpawnedTestServer test_server(SpawnedTestServer::TYPE_HTTP,
-                                SpawnedTestServer::kLocalhost,
-                                base::FilePath(kDocRoot));
-  ASSERT_TRUE(test_server.Start());
-
-  CreateFetcher(test_server.GetURL("echo"));
+  CreateFetcher(test_server_->GetURL("echo"));
   base::MessageLoop::current()->Run();
 }
 
 TEST_F(URLFetcherPostFileTest, Basic) {
-  SpawnedTestServer test_server(SpawnedTestServer::TYPE_HTTP,
-                                SpawnedTestServer::kLocalhost,
-                                base::FilePath(kDocRoot));
-  ASSERT_TRUE(test_server.Start());
-
-  CreateFetcher(test_server.GetURL("echo"));
+  CreateFetcher(test_server_->GetURL("echo"));
   base::MessageLoop::current()->Run();
 }
 
 TEST_F(URLFetcherPostFileTest, Range) {
-  SpawnedTestServer test_server(SpawnedTestServer::TYPE_HTTP,
-                                SpawnedTestServer::kLocalhost,
-                                base::FilePath(kDocRoot));
-  ASSERT_TRUE(test_server.Start());
-
   SetUploadRange(30, 100);
 
-  CreateFetcher(test_server.GetURL("echo"));
+  CreateFetcher(test_server_->GetURL("echo"));
   base::MessageLoop::current()->Run();
 }
 
 TEST_F(URLFetcherSetUploadFactoryTest, Basic) {
-  SpawnedTestServer test_server(SpawnedTestServer::TYPE_HTTP,
-                                SpawnedTestServer::kLocalhost,
-                                base::FilePath(kDocRoot));
-  ASSERT_TRUE(test_server.Start());
-
-  CreateFetcher(test_server.GetURL("echo"));
+  CreateFetcher(test_server_->GetURL("echo"));
   base::MessageLoop::current()->Run();
   ASSERT_EQ(1u, create_stream_count());
 }
 
 TEST_F(URLFetcherSetUploadFactoryTest, Retry) {
-  SpawnedTestServer test_server(SpawnedTestServer::TYPE_HTTP,
-                                SpawnedTestServer::kLocalhost,
-                                base::FilePath(kDocRoot));
-  ASSERT_TRUE(test_server.Start());
   expected_status_code_ = 500;
-  CreateFetcher(test_server.GetURL("echo?status=500"));
+  CreateFetcher(test_server_->GetURL("echo?status=500"));
   base::MessageLoop::current()->Run();
   ASSERT_EQ(2u, create_stream_count());
 }
 
 TEST_F(URLFetcherEmptyPostTest, Basic) {
-  SpawnedTestServer test_server(SpawnedTestServer::TYPE_HTTP,
-                                SpawnedTestServer::kLocalhost,
-                                base::FilePath(kDocRoot));
-  ASSERT_TRUE(test_server.Start());
-
-  CreateFetcher(test_server.GetURL("echo"));
+  CreateFetcher(test_server_->GetURL("echo"));
   base::MessageLoop::current()->Run();
 }
 
 TEST_F(URLFetcherUploadProgressTest, Basic) {
-  SpawnedTestServer test_server(SpawnedTestServer::TYPE_HTTP,
-                                SpawnedTestServer::kLocalhost,
-                                base::FilePath(kDocRoot));
-  ASSERT_TRUE(test_server.Start());
-
-  CreateFetcher(test_server.GetURL("echo"));
+  CreateFetcher(test_server_->GetURL("echo"));
   base::MessageLoop::current()->Run();
 }
 
 TEST_F(URLFetcherDownloadProgressTest, Basic) {
-  SpawnedTestServer test_server(SpawnedTestServer::TYPE_HTTP,
-                                SpawnedTestServer::kLocalhost,
-                                base::FilePath(kDocRoot));
-  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));
+  CreateFetcher(
+      test_server_->GetURL(std::string(kTestServerFilePrefix) + kFileToFetch));
 
   base::MessageLoop::current()->Run();
 }
 
 TEST_F(URLFetcherDownloadProgressCancelTest, CancelWhileProgressReport) {
-  SpawnedTestServer test_server(SpawnedTestServer::TYPE_HTTP,
-                                SpawnedTestServer::kLocalhost,
-                                base::FilePath(kDocRoot));
-  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));
+  CreateFetcher(
+      test_server_->GetURL(std::string(kTestServerFilePrefix) + kFileToFetch));
 
   base::MessageLoop::current()->Run();
 }
 
 TEST_F(URLFetcherHeadersTest, Headers) {
-  SpawnedTestServer test_server(
-      SpawnedTestServer::TYPE_HTTP,
-      SpawnedTestServer::kLocalhost,
-      base::FilePath(FILE_PATH_LITERAL("net/data/url_request_unittest")));
-  ASSERT_TRUE(test_server.Start());
-
-  CreateFetcher(test_server.GetURL("files/with-headers.html"));
+  CreateFetcher(test_server_->GetURL("set-header?cache-control: private"));
   base::MessageLoop::current()->Run();
   // The actual tests are in the URLFetcherHeadersTest fixture.
 }
 
 TEST_F(URLFetcherSocketAddressTest, SocketAddress) {
-  SpawnedTestServer test_server(
-      SpawnedTestServer::TYPE_HTTP,
-      SpawnedTestServer::kLocalhost,
-      base::FilePath(FILE_PATH_LITERAL("net/data/url_request_unittest")));
-  ASSERT_TRUE(test_server.Start());
-  expected_port_ = test_server.host_port_pair().port();
+  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"));
+  CreateFetcher(test_server_->GetURL("defaultresponse"));
   base::MessageLoop::current()->Run();
   // The actual tests are in the URLFetcherSocketAddressTest fixture.
 }
 
 TEST_F(URLFetcherStopOnRedirectTest, StopOnRedirect) {
-  SpawnedTestServer test_server(SpawnedTestServer::TYPE_HTTP,
-                                SpawnedTestServer::kLocalhost,
-                                base::FilePath(kDocRoot));
-  ASSERT_TRUE(test_server.Start());
-
   CreateFetcher(
-      test_server.GetURL(std::string("server-redirect?") + kRedirectTarget));
+      test_server_->GetURL(std::string("server-redirect?") + kRedirectTarget));
   base::MessageLoop::current()->Run();
   EXPECT_TRUE(callback_called_);
 }
 
 TEST_F(URLFetcherProtectTest, Overload) {
-  SpawnedTestServer test_server(SpawnedTestServer::TYPE_HTTP,
-                                SpawnedTestServer::kLocalhost,
-                                base::FilePath(kDocRoot));
-  ASSERT_TRUE(test_server.Start());
-
-  GURL url(test_server.GetURL("defaultresponse"));
+  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(),
                                    std::string(),
                                    200,
                                    3,
                                    1,
                                    2.0,
                                    0.0,
                                    256));
   request_context()->throttler_manager()
       ->OverrideEntryForTests(url, entry.get());
 
   CreateFetcher(url);
 
   base::MessageLoop::current()->Run();
 }
 
 TEST_F(URLFetcherProtectTest, ServerUnavailable) {
-  SpawnedTestServer test_server(SpawnedTestServer::TYPE_HTTP,
-                                SpawnedTestServer::kLocalhost,
-                                base::FilePath(kDocRoot));
-  ASSERT_TRUE(test_server.Start());
-
-  GURL url(test_server.GetURL("files/server-unavailable.html"));
+  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(),
                                    std::string(),
                                    200,
                                    3,
                                    1,
                                    2.0,
                                    0.0,
                                    256));
   request_context()->throttler_manager()
       ->OverrideEntryForTests(url, entry.get());
 
   CreateFetcher(url);
 
   base::MessageLoop::current()->Run();
 }
 
 TEST_F(URLFetcherProtectTestPassedThrough, ServerUnavailablePropagateResponse) {
-  SpawnedTestServer test_server(SpawnedTestServer::TYPE_HTTP,
-                                SpawnedTestServer::kLocalhost,
-                                base::FilePath(kDocRoot));
-  ASSERT_TRUE(test_server.Start());
-
-  GURL url(test_server.GetURL("files/server-unavailable.html"));
+  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(),
                                    std::string(),
                                    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.get());
 
   CreateFetcher(url);
 
   base::MessageLoop::current()->Run();
 }
 
 TEST_F(URLFetcherBadHTTPSTest, BadHTTPSTest) {
-  SpawnedTestServer::SSLOptions ssl_options(
-      SpawnedTestServer::SSLOptions::CERT_EXPIRED);
-  SpawnedTestServer test_server(SpawnedTestServer::TYPE_HTTPS,
-                                ssl_options,
-                                base::FilePath(kDocRoot));
-  ASSERT_TRUE(test_server.Start());
-
-  CreateFetcher(test_server.GetURL("defaultresponse"));
+  CreateFetcher(test_server_->GetURL("defaultresponse"));
   base::MessageLoop::current()->Run();
 }
 
 TEST_F(URLFetcherCancelTest, ReleasesContext) {
-  SpawnedTestServer test_server(SpawnedTestServer::TYPE_HTTP,
-                                SpawnedTestServer::kLocalhost,
-                                base::FilePath(kDocRoot));
-  ASSERT_TRUE(test_server.Start());
-
-  GURL url(test_server.GetURL("files/server-unavailable.html"));
+  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));
 
   base::MessageLoop::current()->Run();
 }
 
 TEST_F(URLFetcherCancelTest, CancelWhileDelayedStartTaskPending) {
-  SpawnedTestServer test_server(SpawnedTestServer::TYPE_HTTP,
-                                SpawnedTestServer::kLocalhost,
-                                base::FilePath(kDocRoot));
-  ASSERT_TRUE(test_server.Start());
-
-  GURL url(test_server.GetURL("files/server-unavailable.html"));
+  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(),
                                    std::string(),
                                    4000,
                                    1,
                                    2000,
@@ skipping 12 matching lines @@
   base::Thread t("URLFetcher test thread");
   ASSERT_TRUE(t.Start());
   t.message_loop()->PostTask(
       FROM_HERE,
       base::Bind(&URLFetcherTest::CreateFetcher, base::Unretained(this), url));
 
   base::MessageLoop::current()->Run();
 }
 
 TEST_F(URLFetcherMultipleAttemptTest, SameData) {
-  SpawnedTestServer test_server(SpawnedTestServer::TYPE_HTTP,
-                                SpawnedTestServer::kLocalhost,
-                                base::FilePath(kDocRoot));
-  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"));
+  CreateFetcher(test_server_->GetURL("defaultresponse"));
 
   base::MessageLoop::current()->Run();
 }
 
 TEST_F(URLFetcherFileTest, SmallGet) {
-  SpawnedTestServer test_server(SpawnedTestServer::TYPE_HTTP,
-                                SpawnedTestServer::kLocalhost,
-                                base::FilePath(kDocRoot));
-  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);
+  expected_file_ = test_server_->GetDocumentRoot().AppendASCII(kFileToFetch);
   CreateFetcherForFile(
-      test_server.GetURL(std::string(kTestServerFilePrefix) + kFileToFetch),
+      test_server_->GetURL(std::string(kTestServerFilePrefix) + kFileToFetch),
       temp_dir.path().AppendASCII(kFileToFetch));
 
   base::MessageLoop::current()->Run();  // OnURLFetchComplete() will Quit().
 
   ASSERT_FALSE(base::PathExists(file_path_))
       << file_path_.value() << " not removed.";
 }
 
 TEST_F(URLFetcherFileTest, LargeGet) {
-  SpawnedTestServer test_server(SpawnedTestServer::TYPE_HTTP,
-                                SpawnedTestServer::kLocalhost,
-                                base::FilePath(kDocRoot));
-  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);
+  expected_file_ = test_server_->GetDocumentRoot().AppendASCII(kFileToFetch);
   CreateFetcherForFile(
-      test_server.GetURL(std::string(kTestServerFilePrefix) + kFileToFetch),
+      test_server_->GetURL(std::string(kTestServerFilePrefix) + kFileToFetch),
       temp_dir.path().AppendASCII(kFileToFetch));
 
   base::MessageLoop::current()->Run();  // OnURLFetchComplete() will Quit().
 }
 
 TEST_F(URLFetcherFileTest, SavedOutputFileOwnerhisp) {
   // If the caller takes the ownership of the output file, the file should
   // persist even after URLFetcher is gone. If not, the file must be deleted.
   const bool kTake[] = {false, true};
   for (size_t i = 0; i < arraysize(kTake); ++i) {
     take_ownership_of_file_ = kTake[i];
-    SpawnedTestServer test_server(SpawnedTestServer::TYPE_HTTP,
-                                  SpawnedTestServer::kLocalhost,
-                                  base::FilePath(kDocRoot));
-    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);
+    expected_file_ = test_server_->GetDocumentRoot().AppendASCII(kFileToFetch);
     CreateFetcherForFile(
-        test_server.GetURL(std::string(kTestServerFilePrefix) + kFileToFetch),
+        test_server_->GetURL(std::string(kTestServerFilePrefix) + kFileToFetch),
         temp_dir.path().AppendASCII(kFileToFetch));
 
     base::MessageLoop::current()->Run();  // OnURLFetchComplete() will Quit().
 
     base::MessageLoop::current()->RunUntilIdle();
     ASSERT_EQ(kTake[i], base::PathExists(file_path_)) <<
         "FilePath: " << file_path_.value();
   }
 }
 
 TEST_F(URLFetcherFileTest, OverwriteExistingFile) {
-  SpawnedTestServer test_server(SpawnedTestServer::TYPE_HTTP,
-                                SpawnedTestServer::kLocalhost,
-                                base::FilePath(kDocRoot));
-  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";
   std::string data(10000, '?');  // Meant to be larger than simple.html.
   file_path_ = temp_dir.path().AppendASCII(kFileToFetch);
   ASSERT_EQ(static_cast<int>(data.size()),
             base::WriteFile(file_path_, data.data(), data.size()));
   ASSERT_TRUE(base::PathExists(file_path_));
-  expected_file_ = test_server.GetDocumentRoot().AppendASCII(kFileToFetch);
+  expected_file_ = test_server_->GetDocumentRoot().AppendASCII(kFileToFetch);
   ASSERT_FALSE(base::ContentsEqual(file_path_, expected_file_));
 
   // Get a small file.
   CreateFetcherForFile(
-      test_server.GetURL(std::string(kTestServerFilePrefix) + kFileToFetch),
+      test_server_->GetURL(std::string(kTestServerFilePrefix) + kFileToFetch),
       file_path_);
 
   base::MessageLoop::current()->Run();  // OnURLFetchComplete() will Quit().
 }
 
 TEST_F(URLFetcherFileTest, TryToOverwriteDirectory) {
-  SpawnedTestServer test_server(SpawnedTestServer::TYPE_HTTP,
-                                SpawnedTestServer::kLocalhost,
-                                base::FilePath(kDocRoot));
-  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(base::CreateDirectory(file_path_));
   ASSERT_TRUE(base::PathExists(file_path_));
 
   // Get a small file.
   expected_file_error_ = ERR_ACCESS_DENIED;
-  expected_file_ = test_server.GetDocumentRoot().AppendASCII(kFileToFetch);
+  expected_file_ = test_server_->GetDocumentRoot().AppendASCII(kFileToFetch);
   CreateFetcherForFile(
-      test_server.GetURL(std::string(kTestServerFilePrefix) + kFileToFetch),
+      test_server_->GetURL(std::string(kTestServerFilePrefix) + kFileToFetch),
       file_path_);
 
   base::MessageLoop::current()->Run();  // OnURLFetchComplete() will Quit().
 
   base::MessageLoop::current()->RunUntilIdle();
 }
 
 TEST_F(URLFetcherFileTest, SmallGetToTempFile) {
-  SpawnedTestServer test_server(SpawnedTestServer::TYPE_HTTP,
-                                SpawnedTestServer::kLocalhost,
-                                base::FilePath(kDocRoot));
-  ASSERT_TRUE(test_server.Start());
-
   // Get a small file.
   static const char kFileToFetch[] = "simple.html";
-  expected_file_ = test_server.GetDocumentRoot().AppendASCII(kFileToFetch);
+  expected_file_ = test_server_->GetDocumentRoot().AppendASCII(kFileToFetch);
   CreateFetcherForTempFile(
-      test_server.GetURL(std::string(kTestServerFilePrefix) + kFileToFetch));
+      test_server_->GetURL(std::string(kTestServerFilePrefix) + kFileToFetch));
 
   base::MessageLoop::current()->Run();  // OnURLFetchComplete() will Quit().
 
   ASSERT_FALSE(base::PathExists(file_path_))
       << file_path_.value() << " not removed.";
 }
 
 TEST_F(URLFetcherFileTest, LargeGetToTempFile) {
-  SpawnedTestServer test_server(SpawnedTestServer::TYPE_HTTP,
-                                SpawnedTestServer::kLocalhost,
-                                base::FilePath(kDocRoot));
-  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));
+  expected_file_ = test_server_->GetDocumentRoot().AppendASCII(kFileToFetch);
+  CreateFetcherForTempFile(
+      test_server_->GetURL(std::string(kTestServerFilePrefix) + kFileToFetch));
 
   base::MessageLoop::current()->Run();  // OnURLFetchComplete() will Quit().
 }
 
 TEST_F(URLFetcherFileTest, SavedOutputTempFileOwnerhisp) {
   // If the caller takes the ownership of the temp file, the file should persist
   // even after URLFetcher is gone. If not, the file must be deleted.
   const bool kTake[] = {false, true};
   for (size_t i = 0; i < arraysize(kTake); ++i) {
     take_ownership_of_file_ = kTake[i];
 
-    SpawnedTestServer test_server(SpawnedTestServer::TYPE_HTTP,
-                                  SpawnedTestServer::kLocalhost,
-                                  base::FilePath(kDocRoot));
-    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(
+    expected_file_ = test_server_->GetDocumentRoot().AppendASCII(kFileToFetch);
+    CreateFetcherForTempFile(test_server_->GetURL(
         std::string(kTestServerFilePrefix) + kFileToFetch));
 
     base::MessageLoop::current()->Run();  // OnURLFetchComplete() will Quit().
 
     base::MessageLoop::current()->RunUntilIdle();
     ASSERT_EQ(kTake[i], base::PathExists(file_path_)) <<
         "FilePath: " << file_path_.value();
   }
 }
 
 }  // namespace
 
 }  // namespace net