Adding SSL ETS Tests

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 59 matching lines @@
 #include "net/http/http_response_headers.h"
 #include "net/http/http_util.h"
 #include "net/log/net_log.h"
 #include "net/log/test_net_log.h"
 #include "net/log/test_net_log_entry.h"
 #include "net/log/test_net_log_util.h"
 #include "net/proxy/proxy_service.h"
 #include "net/socket/ssl_client_socket.h"
 #include "net/ssl/ssl_cipher_suite_names.h"
 #include "net/ssl/ssl_connection_status_flags.h"
+#include "net/ssl/ssl_server_config.h"
 #include "net/test/cert_test_util.h"
 #include "net/test/embedded_test_server/embedded_test_server.h"
 #include "net/test/embedded_test_server/http_request.h"
 #include "net/test/embedded_test_server/http_response.h"
 #include "net/test/spawned_test_server/spawned_test_server.h"
 #include "net/test/url_request/url_request_failed_job.h"
 #include "net/url_request/data_protocol_handler.h"
 #include "net/url_request/static_http_user_agent_settings.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_filter.h"
@@ skipping 128 matching lines @@
   }
 
   for (size_t i = 0; i < len; i++) {
     buffer[i] = static_cast<char>(rand());
     if (!buffer[i])
       buffer[i] = 'g';
   }
 }
 #endif
 
-#if !defined(OS_IOS)
 void TestLoadTimingCacheHitNoNetwork(
     const LoadTimingInfo& load_timing_info) {
   EXPECT_FALSE(load_timing_info.socket_reused);
   EXPECT_EQ(NetLog::Source::kInvalidId, load_timing_info.socket_log_id);
 
   EXPECT_FALSE(load_timing_info.request_start_time.is_null());
   EXPECT_FALSE(load_timing_info.request_start.is_null());
 
   ExpectConnectTimingHasNoTimes(load_timing_info.connect_timing);
   EXPECT_LE(load_timing_info.request_start, load_timing_info.send_start);
@@ skipping 72 matching lines @@
                              const GURL& host_url) {
   std::string sent_value;
 
   EXPECT_TRUE(headers.GetHeader("Host", &sent_value));
   EXPECT_EQ(GetHostAndOptionalPort(host_url), sent_value);
 
   EXPECT_TRUE(headers.GetHeader("Connection", &sent_value));
   EXPECT_EQ("keep-alive", sent_value);
 }
 
+#if !defined(OS_IOS)
 bool FingerprintsEqual(const HashValueVector& a, const HashValueVector& b) {
   size_t size = a.size();
 
   if (size != b.size())
     return false;
 
   for (size_t i = 0; i < size; ++i) {
     if (!a[i].Equals(b[i]))
       return false;
   }
@@ skipping 1855 matching lines @@
   EXPECT_EQ(MAXIMUM_PRIORITY, req->priority());
 
   req->SetPriority(MAXIMUM_PRIORITY);
   EXPECT_EQ(MAXIMUM_PRIORITY, req->priority());
 
   req->Start();
   EXPECT_EQ(MAXIMUM_PRIORITY, req->priority());
   EXPECT_EQ(MAXIMUM_PRIORITY, job->priority());
 }
 
-// TODO(droger): Support SpawnedTestServer on iOS (see http://crbug.com/148666).
-#if !defined(OS_IOS)
 namespace {
 
 // Less verbose way of running a simple testserver for the tests below.
-class LocalHttpTestServer : public SpawnedTestServer {
+class LocalHttpTestServer : public EmbeddedTestServer {
  public:
-  explicit LocalHttpTestServer(const base::FilePath& document_root)
-      : SpawnedTestServer(SpawnedTestServer::TYPE_HTTP,
-                          SpawnedTestServer::kLocalhost,
-                          document_root) {}
-  LocalHttpTestServer()
-      : SpawnedTestServer(SpawnedTestServer::TYPE_HTTP,
-                          SpawnedTestServer::kLocalhost,
-                          base::FilePath()) {}
+  explicit LocalHttpTestServer(const base::FilePath& document_root) {
+    AddDefaultHandlers(document_root);
+  }
+
+  LocalHttpTestServer() { AddDefaultHandlers(base::FilePath()); }
 };
 
-scoped_ptr<net::test_server::HttpResponse> HandleSetCookieRequest(
-    const test_server::HttpRequest& request) {
-  scoped_ptr<test_server::BasicHttpResponse> http_response(
-      new test_server::BasicHttpResponse());
-  if (request.relative_url.find("/set-cookie?") != 0) {
-    http_response->set_code(net::HTTP_NOT_FOUND);
-    http_response->set_content("hello");
-    return http_response.Pass();
-  }
-  http_response->set_code(net::HTTP_OK);
-  http_response->set_content("hello");
-  http_response->set_content_type("text/plain");
-  http_response->AddCustomHeader(
-      "Set-Cookie",
-      request.relative_url.substr(request.relative_url.find("?") + 1));
-  return http_response.Pass();
-}
-
 }  // namespace
 
 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;
   context.set_cookie_store(delayed_cm.get());
 
   // Set up a cookie.
   {
     TestNetworkDelegate network_delegate;
     context.set_network_delegate(&network_delegate);
     TestDelegate d;
     scoped_ptr<URLRequest> req(context.CreateRequest(
-        test_server.GetURL("set-cookie?CookieToNotSend=1"), DEFAULT_PRIORITY,
+        test_server.GetURL("/set-cookie?CookieToNotSend=1"), DEFAULT_PRIORITY,
         &d));
     req->Start();
     base::RunLoop().Run();
     EXPECT_EQ(0, network_delegate.blocked_get_cookies_count());
     EXPECT_EQ(0, network_delegate.blocked_set_cookie_count());
     EXPECT_EQ(1, network_delegate.set_cookie_count());
   }
 
   // Verify that the cookie is set.
   {
     TestNetworkDelegate network_delegate;
     context.set_network_delegate(&network_delegate);
     TestDelegate d;
     scoped_ptr<URLRequest> req(context.CreateRequest(
-        test_server.GetURL("echoheader?Cookie"), DEFAULT_PRIORITY, &d));
+        test_server.GetURL("/echoheader?Cookie"), DEFAULT_PRIORITY, &d));
     req->Start();
     base::RunLoop().Run();
 
     EXPECT_TRUE(d.data_received().find("CookieToNotSend=1")
                 != std::string::npos);
     EXPECT_EQ(0, network_delegate.blocked_get_cookies_count());
     EXPECT_EQ(0, network_delegate.blocked_set_cookie_count());
   }
 }
 
 TEST_F(URLRequestTest, DoNotSendCookies) {
   LocalHttpTestServer test_server;
   ASSERT_TRUE(test_server.Start());
 
   // Set up a cookie.
   {
     TestNetworkDelegate network_delegate;
     default_context_.set_network_delegate(&network_delegate);
     TestDelegate d;
     scoped_ptr<URLRequest> req(default_context_.CreateRequest(
-        test_server.GetURL("set-cookie?CookieToNotSend=1"), DEFAULT_PRIORITY,
+        test_server.GetURL("/set-cookie?CookieToNotSend=1"), DEFAULT_PRIORITY,
         &d));
     req->Start();
     base::RunLoop().Run();
     EXPECT_EQ(0, network_delegate.blocked_get_cookies_count());
     EXPECT_EQ(0, network_delegate.blocked_set_cookie_count());
   }
 
   // Verify that the cookie is set.
   {
     TestNetworkDelegate network_delegate;
     default_context_.set_network_delegate(&network_delegate);
     TestDelegate d;
     scoped_ptr<URLRequest> req(default_context_.CreateRequest(
-        test_server.GetURL("echoheader?Cookie"), DEFAULT_PRIORITY, &d));
+        test_server.GetURL("/echoheader?Cookie"), DEFAULT_PRIORITY, &d));
     req->Start();
     base::RunLoop().Run();
 
     EXPECT_TRUE(d.data_received().find("CookieToNotSend=1")
                 != std::string::npos);
     EXPECT_EQ(0, network_delegate.blocked_get_cookies_count());
     EXPECT_EQ(0, network_delegate.blocked_set_cookie_count());
   }
 
   // Verify that the cookie isn't sent when LOAD_DO_NOT_SEND_COOKIES is set.
   {
     TestNetworkDelegate network_delegate;
     default_context_.set_network_delegate(&network_delegate);
     TestDelegate d;
     scoped_ptr<URLRequest> req(default_context_.CreateRequest(
-        test_server.GetURL("echoheader?Cookie"), DEFAULT_PRIORITY, &d));
+        test_server.GetURL("/echoheader?Cookie"), DEFAULT_PRIORITY, &d));
     req->SetLoadFlags(LOAD_DO_NOT_SEND_COOKIES);
     req->Start();
     base::RunLoop().Run();
 
     EXPECT_TRUE(d.data_received().find("Cookie: CookieToNotSend=1")
                 == std::string::npos);
 
     // LOAD_DO_NOT_SEND_COOKIES does not trigger OnGetCookies.
     EXPECT_EQ(0, network_delegate.blocked_get_cookies_count());
     EXPECT_EQ(0, network_delegate.blocked_set_cookie_count());
   }
 }
 
 TEST_F(URLRequestTest, DoNotSaveCookies) {
   LocalHttpTestServer test_server;
   ASSERT_TRUE(test_server.Start());
 
   // Set up a cookie.
   {
     TestNetworkDelegate network_delegate;
     default_context_.set_network_delegate(&network_delegate);
     TestDelegate d;
     scoped_ptr<URLRequest> req(default_context_.CreateRequest(
-        test_server.GetURL("set-cookie?CookieToNotUpdate=2"), DEFAULT_PRIORITY,
+        test_server.GetURL("/set-cookie?CookieToNotUpdate=2"), DEFAULT_PRIORITY,
         &d));
     req->Start();
     base::RunLoop().Run();
 
     EXPECT_EQ(0, network_delegate.blocked_get_cookies_count());
     EXPECT_EQ(0, network_delegate.blocked_set_cookie_count());
     EXPECT_EQ(1, network_delegate.set_cookie_count());
   }
 
   // Try to set-up another cookie and update the previous cookie.
   {
     TestNetworkDelegate network_delegate;
     default_context_.set_network_delegate(&network_delegate);
     TestDelegate d;
     scoped_ptr<URLRequest> req(default_context_.CreateRequest(
-        test_server.GetURL("set-cookie?CookieToNotSave=1&CookieToNotUpdate=1"),
+        test_server.GetURL("/set-cookie?CookieToNotSave=1&CookieToNotUpdate=1"),
         DEFAULT_PRIORITY, &d));
     req->SetLoadFlags(LOAD_DO_NOT_SAVE_COOKIES);
     req->Start();
 
     base::RunLoop().Run();
 
     // LOAD_DO_NOT_SAVE_COOKIES does not trigger OnSetCookie.
     EXPECT_EQ(0, network_delegate.blocked_get_cookies_count());
     EXPECT_EQ(0, network_delegate.blocked_set_cookie_count());
     EXPECT_EQ(0, network_delegate.set_cookie_count());
   }
 
   // Verify the cookies weren't saved or updated.
   {
     TestNetworkDelegate network_delegate;
     default_context_.set_network_delegate(&network_delegate);
     TestDelegate d;
     scoped_ptr<URLRequest> req(default_context_.CreateRequest(
-        test_server.GetURL("echoheader?Cookie"), DEFAULT_PRIORITY, &d));
+        test_server.GetURL("/echoheader?Cookie"), DEFAULT_PRIORITY, &d));
     req->Start();
     base::RunLoop().Run();
 
     EXPECT_TRUE(d.data_received().find("CookieToNotSave=1")
                 == std::string::npos);
     EXPECT_TRUE(d.data_received().find("CookieToNotUpdate=2")
                 != std::string::npos);
 
     EXPECT_EQ(0, network_delegate.blocked_get_cookies_count());
     EXPECT_EQ(0, network_delegate.blocked_set_cookie_count());
     EXPECT_EQ(0, network_delegate.set_cookie_count());
   }
 }
 
 TEST_F(URLRequestTest, DoNotSendCookies_ViaPolicy) {
   LocalHttpTestServer test_server;
   ASSERT_TRUE(test_server.Start());
 
   // Set up a cookie.
   {
     TestNetworkDelegate network_delegate;
     default_context_.set_network_delegate(&network_delegate);
     TestDelegate d;
     scoped_ptr<URLRequest> req(default_context_.CreateRequest(
-        test_server.GetURL("set-cookie?CookieToNotSend=1"), DEFAULT_PRIORITY,
+        test_server.GetURL("/set-cookie?CookieToNotSend=1"), DEFAULT_PRIORITY,
         &d));
     req->Start();
     base::RunLoop().Run();
 
     EXPECT_EQ(0, network_delegate.blocked_get_cookies_count());
     EXPECT_EQ(0, network_delegate.blocked_set_cookie_count());
   }
 
   // Verify that the cookie is set.
   {
     TestNetworkDelegate network_delegate;
     default_context_.set_network_delegate(&network_delegate);
     TestDelegate d;
     scoped_ptr<URLRequest> req(default_context_.CreateRequest(
-        test_server.GetURL("echoheader?Cookie"), DEFAULT_PRIORITY, &d));
+        test_server.GetURL("/echoheader?Cookie"), DEFAULT_PRIORITY, &d));
     req->Start();
     base::RunLoop().Run();
 
     EXPECT_TRUE(d.data_received().find("CookieToNotSend=1")
                 != std::string::npos);
 
     EXPECT_EQ(0, network_delegate.blocked_get_cookies_count());
     EXPECT_EQ(0, network_delegate.blocked_set_cookie_count());
   }
 
   // Verify that the cookie isn't sent.
   {
     TestNetworkDelegate network_delegate;
     default_context_.set_network_delegate(&network_delegate);
     TestDelegate d;
     network_delegate.set_cookie_options(TestNetworkDelegate::NO_GET_COOKIES);
     scoped_ptr<URLRequest> req(default_context_.CreateRequest(
-        test_server.GetURL("echoheader?Cookie"), DEFAULT_PRIORITY, &d));
+        test_server.GetURL("/echoheader?Cookie"), DEFAULT_PRIORITY, &d));
     req->Start();
     base::RunLoop().Run();
 
     EXPECT_TRUE(d.data_received().find("Cookie: CookieToNotSend=1")
                 == std::string::npos);
 
     EXPECT_EQ(1, network_delegate.blocked_get_cookies_count());
     EXPECT_EQ(0, network_delegate.blocked_set_cookie_count());
   }
 }
 
 TEST_F(URLRequestTest, DoNotSaveCookies_ViaPolicy) {
   LocalHttpTestServer test_server;
   ASSERT_TRUE(test_server.Start());
 
   // Set up a cookie.
   {
     TestNetworkDelegate network_delegate;
     default_context_.set_network_delegate(&network_delegate);
     TestDelegate d;
     scoped_ptr<URLRequest> req(default_context_.CreateRequest(
-        test_server.GetURL("set-cookie?CookieToNotUpdate=2"), DEFAULT_PRIORITY,
+        test_server.GetURL("/set-cookie?CookieToNotUpdate=2"), DEFAULT_PRIORITY,
         &d));
     req->Start();
     base::RunLoop().Run();
 
     EXPECT_EQ(0, network_delegate.blocked_get_cookies_count());
     EXPECT_EQ(0, network_delegate.blocked_set_cookie_count());
   }
 
   // Try to set-up another cookie and update the previous cookie.
   {
     TestNetworkDelegate network_delegate;
     default_context_.set_network_delegate(&network_delegate);
     TestDelegate d;
     network_delegate.set_cookie_options(TestNetworkDelegate::NO_SET_COOKIE);
     scoped_ptr<URLRequest> req(default_context_.CreateRequest(
-        test_server.GetURL("set-cookie?CookieToNotSave=1&CookieToNotUpdate=1"),
+        test_server.GetURL("/set-cookie?CookieToNotSave=1&CookieToNotUpdate=1"),
         DEFAULT_PRIORITY, &d));
     req->Start();
 
     base::RunLoop().Run();
 
     EXPECT_EQ(0, network_delegate.blocked_get_cookies_count());
     EXPECT_EQ(2, network_delegate.blocked_set_cookie_count());
   }
 
   // Verify the cookies weren't saved or updated.
   {
     TestNetworkDelegate network_delegate;
     default_context_.set_network_delegate(&network_delegate);
     TestDelegate d;
     scoped_ptr<URLRequest> req(default_context_.CreateRequest(
-        test_server.GetURL("echoheader?Cookie"), DEFAULT_PRIORITY, &d));
+        test_server.GetURL("/echoheader?Cookie"), DEFAULT_PRIORITY, &d));
     req->Start();
     base::RunLoop().Run();
 
     EXPECT_TRUE(d.data_received().find("CookieToNotSave=1")
                 == std::string::npos);
     EXPECT_TRUE(d.data_received().find("CookieToNotUpdate=2")
                 != std::string::npos);
 
     EXPECT_EQ(0, network_delegate.blocked_get_cookies_count());
     EXPECT_EQ(0, network_delegate.blocked_set_cookie_count());
   }
 }
 
 TEST_F(URLRequestTest, DoNotSaveEmptyCookies) {
   LocalHttpTestServer test_server;
   ASSERT_TRUE(test_server.Start());
 
   // Set up an empty cookie.
   {
     TestNetworkDelegate network_delegate;
     default_context_.set_network_delegate(&network_delegate);
     TestDelegate d;
     scoped_ptr<URLRequest> req(default_context_.CreateRequest(
-        test_server.GetURL("set-cookie"), DEFAULT_PRIORITY, &d));
+        test_server.GetURL("/set-cookie"), DEFAULT_PRIORITY, &d));
     req->Start();
     base::RunLoop().Run();
 
     EXPECT_EQ(0, network_delegate.blocked_get_cookies_count());
     EXPECT_EQ(0, network_delegate.blocked_set_cookie_count());
     EXPECT_EQ(0, network_delegate.set_cookie_count());
   }
 }
 
 TEST_F(URLRequestTest, DoNotSendCookies_ViaPolicy_Async) {
   LocalHttpTestServer test_server;
   ASSERT_TRUE(test_server.Start());
 
   // Set up a cookie.
   {
     TestNetworkDelegate network_delegate;
     default_context_.set_network_delegate(&network_delegate);
     TestDelegate d;
     scoped_ptr<URLRequest> req(default_context_.CreateRequest(
-        test_server.GetURL("set-cookie?CookieToNotSend=1"), DEFAULT_PRIORITY,
+        test_server.GetURL("/set-cookie?CookieToNotSend=1"), DEFAULT_PRIORITY,
         &d));
     req->Start();
     base::RunLoop().Run();
 
     EXPECT_EQ(0, network_delegate.blocked_get_cookies_count());
     EXPECT_EQ(0, network_delegate.blocked_set_cookie_count());
   }
 
   // Verify that the cookie is set.
   {
     TestNetworkDelegate network_delegate;
     default_context_.set_network_delegate(&network_delegate);
     TestDelegate d;
     scoped_ptr<URLRequest> req(default_context_.CreateRequest(
-        test_server.GetURL("echoheader?Cookie"), DEFAULT_PRIORITY, &d));
+        test_server.GetURL("/echoheader?Cookie"), DEFAULT_PRIORITY, &d));
     req->Start();
     base::RunLoop().Run();
 
     EXPECT_TRUE(d.data_received().find("CookieToNotSend=1")
                 != std::string::npos);
 
     EXPECT_EQ(0, network_delegate.blocked_get_cookies_count());
     EXPECT_EQ(0, network_delegate.blocked_set_cookie_count());
   }
 
   // Verify that the cookie isn't sent.
   {
     TestNetworkDelegate network_delegate;
     default_context_.set_network_delegate(&network_delegate);
     TestDelegate d;
     network_delegate.set_cookie_options(TestNetworkDelegate::NO_GET_COOKIES);
     scoped_ptr<URLRequest> req(default_context_.CreateRequest(
-        test_server.GetURL("echoheader?Cookie"), DEFAULT_PRIORITY, &d));
+        test_server.GetURL("/echoheader?Cookie"), DEFAULT_PRIORITY, &d));
     req->Start();
     base::RunLoop().Run();
 
     EXPECT_TRUE(d.data_received().find("Cookie: CookieToNotSend=1")
                 == std::string::npos);
 
     EXPECT_EQ(1, network_delegate.blocked_get_cookies_count());
     EXPECT_EQ(0, network_delegate.blocked_set_cookie_count());
   }
 }
 
 TEST_F(URLRequestTest, DoNotSaveCookies_ViaPolicy_Async) {
   LocalHttpTestServer test_server;
   ASSERT_TRUE(test_server.Start());
 
   // Set up a cookie.
   {
     TestNetworkDelegate network_delegate;
     default_context_.set_network_delegate(&network_delegate);
     TestDelegate d;
     scoped_ptr<URLRequest> req(default_context_.CreateRequest(
-        test_server.GetURL("set-cookie?CookieToNotUpdate=2"), DEFAULT_PRIORITY,
+        test_server.GetURL("/set-cookie?CookieToNotUpdate=2"), DEFAULT_PRIORITY,
         &d));
     req->Start();
     base::RunLoop().Run();
 
     EXPECT_EQ(0, network_delegate.blocked_get_cookies_count());
     EXPECT_EQ(0, network_delegate.blocked_set_cookie_count());
   }
 
   // Try to set-up another cookie and update the previous cookie.
   {
     TestNetworkDelegate network_delegate;
     default_context_.set_network_delegate(&network_delegate);
     TestDelegate d;
     network_delegate.set_cookie_options(TestNetworkDelegate::NO_SET_COOKIE);
     scoped_ptr<URLRequest> req(default_context_.CreateRequest(
-        test_server.GetURL("set-cookie?CookieToNotSave=1&CookieToNotUpdate=1"),
+        test_server.GetURL("/set-cookie?CookieToNotSave=1&CookieToNotUpdate=1"),
         DEFAULT_PRIORITY, &d));
     req->Start();
 
     base::RunLoop().Run();
 
     EXPECT_EQ(0, network_delegate.blocked_get_cookies_count());
     EXPECT_EQ(2, network_delegate.blocked_set_cookie_count());
   }
 
   // Verify the cookies weren't saved or updated.
   {
     TestNetworkDelegate network_delegate;
     default_context_.set_network_delegate(&network_delegate);
     TestDelegate d;
     scoped_ptr<URLRequest> req(default_context_.CreateRequest(
-        test_server.GetURL("echoheader?Cookie"), DEFAULT_PRIORITY, &d));
+        test_server.GetURL("/echoheader?Cookie"), DEFAULT_PRIORITY, &d));
     req->Start();
     base::RunLoop().Run();
 
     EXPECT_TRUE(d.data_received().find("CookieToNotSave=1")
                 == std::string::npos);
     EXPECT_TRUE(d.data_received().find("CookieToNotUpdate=2")
                 != std::string::npos);
 
     EXPECT_EQ(0, network_delegate.blocked_get_cookies_count());
     EXPECT_EQ(0, network_delegate.blocked_set_cookie_count());
   }
 }
 
 TEST_F(URLRequestTest, FirstPartyOnlyCookiesEnabled) {
   LocalHttpTestServer test_server;
   ASSERT_TRUE(test_server.Start());
 
   // Set up a 'First-Party-Only' cookie (on '127.0.0.1', as that's where
   // LocalHttpTestServer points).
   {
     TestNetworkDelegate network_delegate;
     network_delegate.set_experimental_cookie_features_enabled(true);
     default_context_.set_network_delegate(&network_delegate);
 
     TestDelegate d;
     scoped_ptr<URLRequest> req(default_context_.CreateRequest(
         test_server.GetURL(
-            "set-cookie?FirstPartyCookieToSet=1;First-Party-Only"),
+            "/set-cookie?FirstPartyCookieToSet=1;First-Party-Only"),
         DEFAULT_PRIORITY, &d));
     req->Start();
     base::RunLoop().Run();
     EXPECT_EQ(0, network_delegate.blocked_get_cookies_count());
     EXPECT_EQ(0, network_delegate.blocked_set_cookie_count());
     EXPECT_EQ(1, network_delegate.set_cookie_count());
   }
 
   // Verify that the cookie is sent for first-party requests.
   {
     TestNetworkDelegate network_delegate;
     network_delegate.set_experimental_cookie_features_enabled(true);
     default_context_.set_network_delegate(&network_delegate);
     TestDelegate d;
     scoped_ptr<URLRequest> req(default_context_.CreateRequest(
-        test_server.GetURL("echoheader?Cookie"), DEFAULT_PRIORITY, &d));
-    req->set_first_party_for_cookies(test_server.GetURL(""));
+        test_server.GetURL("/echoheader?Cookie"), DEFAULT_PRIORITY, &d));
+    req->set_first_party_for_cookies(test_server.GetURL("/"));
     req->Start();
     base::RunLoop().Run();
 
     EXPECT_TRUE(d.data_received().find("FirstPartyCookieToSet=1") !=
                 std::string::npos);
     EXPECT_EQ(0, network_delegate.blocked_get_cookies_count());
     EXPECT_EQ(0, network_delegate.blocked_set_cookie_count());
   }
 
   // Verify that the cookie is not-sent for non-first-party requests.
   {
     TestNetworkDelegate network_delegate;
     network_delegate.set_experimental_cookie_features_enabled(true);
     default_context_.set_network_delegate(&network_delegate);
     TestDelegate d;
     scoped_ptr<URLRequest> req(default_context_.CreateRequest(
-        test_server.GetURL("echoheader?Cookie"), DEFAULT_PRIORITY, &d));
+        test_server.GetURL("/echoheader?Cookie"), DEFAULT_PRIORITY, &d));
     req->set_first_party_for_cookies(GURL("http://third-party.test/"));
     req->Start();
     base::RunLoop().Run();
 
     EXPECT_TRUE(d.data_received().find("FirstPartyCookieToSet=1") ==
                 std::string::npos);
     EXPECT_EQ(0, network_delegate.blocked_get_cookies_count());
     EXPECT_EQ(0, network_delegate.blocked_set_cookie_count());
   }
 }
 
 TEST_F(URLRequestTest, FirstPartyOnlyCookiesDisabled) {
   LocalHttpTestServer test_server;
   ASSERT_TRUE(test_server.Start());
 
   // Set up a 'First-Party-Only' cookie (on '127.0.0.1', as that's where
   // LocalHttpTestServer points).
   {
     TestNetworkDelegate network_delegate;
     network_delegate.set_experimental_cookie_features_enabled(false);
     default_context_.set_network_delegate(&network_delegate);
 
     TestDelegate d;
     scoped_ptr<URLRequest> req(default_context_.CreateRequest(
         test_server.GetURL(
-            "set-cookie?FirstPartyCookieToSet=1;First-Party-Only"),
+            "/set-cookie?FirstPartyCookieToSet=1;First-Party-Only"),
         DEFAULT_PRIORITY, &d));
     req->Start();
     base::RunLoop().Run();
     EXPECT_EQ(0, network_delegate.blocked_get_cookies_count());
     EXPECT_EQ(0, network_delegate.blocked_set_cookie_count());
     EXPECT_EQ(1, network_delegate.set_cookie_count());
   }
 
   // Verify that the cookie is sent for first-party requests.
   {
     TestNetworkDelegate network_delegate;
     network_delegate.set_experimental_cookie_features_enabled(false);
     default_context_.set_network_delegate(&network_delegate);
     TestDelegate d;
     scoped_ptr<URLRequest> req(default_context_.CreateRequest(
-        test_server.GetURL("echoheader?Cookie"), DEFAULT_PRIORITY, &d));
-    req->set_first_party_for_cookies(test_server.GetURL(""));
+        test_server.GetURL("/echoheader?Cookie"), DEFAULT_PRIORITY, &d));
+    req->set_first_party_for_cookies(test_server.GetURL("/"));
     req->Start();
     base::RunLoop().Run();
 
     EXPECT_TRUE(d.data_received().find("FirstPartyCookieToSet=1") !=
                 std::string::npos);
     EXPECT_EQ(0, network_delegate.blocked_get_cookies_count());
     EXPECT_EQ(0, network_delegate.blocked_set_cookie_count());
   }
 
   // Verify that the cookie is also sent for non-first-party requests.
   {
     TestNetworkDelegate network_delegate;
     network_delegate.set_experimental_cookie_features_enabled(false);
     default_context_.set_network_delegate(&network_delegate);
     TestDelegate d;
     scoped_ptr<URLRequest> req(default_context_.CreateRequest(
-        test_server.GetURL("echoheader?Cookie"), DEFAULT_PRIORITY, &d));
+        test_server.GetURL("/echoheader?Cookie"), DEFAULT_PRIORITY, &d));
     req->set_first_party_for_cookies(GURL("http://third-party.test/"));
     req->Start();
     base::RunLoop().Run();
 
     EXPECT_TRUE(d.data_received().find("FirstPartyCookieToSet=1") !=
                 std::string::npos);
     EXPECT_EQ(0, network_delegate.blocked_get_cookies_count());
     EXPECT_EQ(0, network_delegate.blocked_set_cookie_count());
   }
 }
 
 // Tests that $Secure- cookies can't be set on non-secure origins.
 TEST_F(URLRequestTest, SecureCookiePrefixOnNonsecureOrigin) {
-  test_server::EmbeddedTestServer test_server;
-  test_server.RegisterRequestHandler(base::Bind(&HandleSetCookieRequest));
-  ASSERT_TRUE(test_server.InitializeAndWaitUntilReady());
-  SpawnedTestServer test_server_https(
-      SpawnedTestServer::TYPE_HTTPS, SpawnedTestServer::kLocalhost,
+  EmbeddedTestServer http_server;
+  http_server.AddDefaultHandlers(
       base::FilePath(FILE_PATH_LITERAL("net/data/ssl")));
-  ASSERT_TRUE(test_server_https.Start());
+  EmbeddedTestServer https_server(EmbeddedTestServer::TYPE_HTTPS);
+  https_server.AddDefaultHandlers(
+      base::FilePath(FILE_PATH_LITERAL("net/data/ssl")));
+  ASSERT_TRUE(http_server.Start());
+  ASSERT_TRUE(https_server.Start());
 
   TestExperimentalFeaturesNetworkDelegate network_delegate;
   TestURLRequestContext context(true);
   context.set_network_delegate(&network_delegate);
   context.Init();
 
   // Try to set a Secure $Secure- cookie, with experimental features
   // enabled.
   {
     TestDelegate d;
     scoped_ptr<URLRequest> req(context.CreateRequest(
-        test_server.GetURL("/set-cookie?$Secure-nonsecure-origin=1;Secure"),
+        http_server.GetURL("/set-cookie?$Secure-nonsecure-origin=1;Secure"),
         DEFAULT_PRIORITY, &d));
     req->Start();
     base::RunLoop().Run();
     EXPECT_EQ(0, network_delegate.blocked_get_cookies_count());
     EXPECT_EQ(0, network_delegate.blocked_set_cookie_count());
   }
 
   // Verify that the cookie is not set.
   {
     TestDelegate d;
     scoped_ptr<URLRequest> req(context.CreateRequest(
-        test_server_https.GetURL("echoheader?Cookie"), DEFAULT_PRIORITY, &d));
+        https_server.GetURL("/echoheader?Cookie"), DEFAULT_PRIORITY, &d));
     req->Start();
     base::RunLoop().Run();
 
     EXPECT_TRUE(d.data_received().find("$Secure-nonsecure-origin=1") ==
                 std::string::npos);
     EXPECT_EQ(0, network_delegate.blocked_get_cookies_count());
     EXPECT_EQ(0, network_delegate.blocked_set_cookie_count());
   }
 }
 
 TEST_F(URLRequestTest, SecureCookiePrefixNonexperimental) {
-  SpawnedTestServer test_server(
-      SpawnedTestServer::TYPE_HTTPS, SpawnedTestServer::kLocalhost,
+  EmbeddedTestServer https_server(EmbeddedTestServer::TYPE_HTTPS);
+  https_server.AddDefaultHandlers(
       base::FilePath(FILE_PATH_LITERAL("net/data/ssl")));
-  ASSERT_TRUE(test_server.Start());
+  ASSERT_TRUE(https_server.Start());
 
   TestNetworkDelegate network_delegate;
   TestURLRequestContext context(true);
   context.set_network_delegate(&network_delegate);
   context.Init();
 
   // Without experimental features, there should be no restrictions on
   // $Secure- cookies.
 
   // Set a non-Secure cookie with the $Secure- prefix.
   {
     TestDelegate d;
     scoped_ptr<URLRequest> req(context.CreateRequest(
-        test_server.GetURL("set-cookie?$Secure-nonsecure-not-experimental=1"),
+        https_server.GetURL("/set-cookie?$Secure-nonsecure-not-experimental=1"),
         DEFAULT_PRIORITY, &d));
     req->Start();
     base::RunLoop().Run();
     EXPECT_EQ(0, network_delegate.blocked_get_cookies_count());
     EXPECT_EQ(0, network_delegate.blocked_set_cookie_count());
   }
 
   // Set a Secure cookie with the $Secure- prefix.
   {
     TestDelegate d;
     scoped_ptr<URLRequest> req(context.CreateRequest(
-        test_server.GetURL(
-            "set-cookie?$Secure-secure-not-experimental=1;Secure"),
+        https_server.GetURL(
+            "/set-cookie?$Secure-secure-not-experimental=1;Secure"),
         DEFAULT_PRIORITY, &d));
     req->Start();
     base::RunLoop().Run();
     EXPECT_EQ(0, network_delegate.blocked_get_cookies_count());
     EXPECT_EQ(0, network_delegate.blocked_set_cookie_count());
   }
 
   // Verify that the cookies are set. Neither should have any
   // restrictions because the experimental flag is off.
   {
     TestDelegate d;
     scoped_ptr<URLRequest> req(context.CreateRequest(
-        test_server.GetURL("echoheader?Cookie"), DEFAULT_PRIORITY, &d));
+        https_server.GetURL("/echoheader?Cookie"), DEFAULT_PRIORITY, &d));
     req->Start();
     base::RunLoop().Run();
 
     EXPECT_TRUE(d.data_received().find("$Secure-secure-not-experimental=1") !=
                 std::string::npos);
     EXPECT_TRUE(
         d.data_received().find("$Secure-nonsecure-not-experimental=1") !=
         std::string::npos);
     EXPECT_EQ(0, network_delegate.blocked_get_cookies_count());
     EXPECT_EQ(0, network_delegate.blocked_set_cookie_count());
   }
 }
 
 TEST_F(URLRequestTest, SecureCookiePrefixExperimentalNonsecure) {
-  SpawnedTestServer test_server(
-      SpawnedTestServer::TYPE_HTTPS, SpawnedTestServer::kLocalhost,
+  EmbeddedTestServer https_server(EmbeddedTestServer::TYPE_HTTPS);
+  https_server.AddDefaultHandlers(
       base::FilePath(FILE_PATH_LITERAL("net/data/ssl")));
-  ASSERT_TRUE(test_server.Start());
+  ASSERT_TRUE(https_server.Start());
 
   TestExperimentalFeaturesNetworkDelegate network_delegate;
   TestURLRequestContext context(true);
   context.set_network_delegate(&network_delegate);
   context.Init();
 
   // Try to set a non-Secure $Secure- cookie, with experimental features
   // enabled.
   {
     TestDelegate d;
-    scoped_ptr<URLRequest> req(context.CreateRequest(
-        test_server.GetURL("set-cookie?$Secure-foo=1"), DEFAULT_PRIORITY, &d));
+    scoped_ptr<URLRequest> req(
+        context.CreateRequest(https_server.GetURL("/set-cookie?$Secure-foo=1"),
+                              DEFAULT_PRIORITY, &d));
     req->Start();
     base::RunLoop().Run();
     EXPECT_EQ(0, network_delegate.blocked_get_cookies_count());
     EXPECT_EQ(0, network_delegate.blocked_set_cookie_count());
   }
 
   // Verify that the cookie is not set.
   {
     TestDelegate d;
     scoped_ptr<URLRequest> req(context.CreateRequest(
-        test_server.GetURL("echoheader?Cookie"), DEFAULT_PRIORITY, &d));
+        https_server.GetURL("/echoheader?Cookie"), DEFAULT_PRIORITY, &d));
     req->Start();
     base::RunLoop().Run();
 
     EXPECT_TRUE(d.data_received().find("$Secure-foo=1") == std::string::npos);
     EXPECT_EQ(0, network_delegate.blocked_get_cookies_count());
     EXPECT_EQ(0, network_delegate.blocked_set_cookie_count());
   }
 }
 
 TEST_F(URLRequestTest, SecureCookiePrefixExperimentalSecure) {
-  SpawnedTestServer test_server(
-      SpawnedTestServer::TYPE_HTTPS, SpawnedTestServer::kLocalhost,
+  EmbeddedTestServer https_server(EmbeddedTestServer::TYPE_HTTPS);
+  https_server.AddDefaultHandlers(
       base::FilePath(FILE_PATH_LITERAL("net/data/ssl")));
-  ASSERT_TRUE(test_server.Start());
+  ASSERT_TRUE(https_server.Start());
 
   TestExperimentalFeaturesNetworkDelegate network_delegate;
   TestURLRequestContext context(true);
   context.set_network_delegate(&network_delegate);
   context.Init();
 
   // Try to set a Secure $Secure- cookie, with experimental features
   // enabled.
   {
     TestDelegate d;
     scoped_ptr<URLRequest> req(context.CreateRequest(
-        test_server.GetURL("set-cookie?$Secure-bar=1;Secure"), DEFAULT_PRIORITY,
-        &d));
+        https_server.GetURL("/set-cookie?$Secure-bar=1;Secure"),
+        DEFAULT_PRIORITY, &d));
     req->Start();
     base::RunLoop().Run();
     EXPECT_EQ(0, network_delegate.blocked_get_cookies_count());
     EXPECT_EQ(0, network_delegate.blocked_set_cookie_count());
   }
 
   // Verify that the cookie is set.
   {
     TestDelegate d;
     scoped_ptr<URLRequest> req(context.CreateRequest(
-        test_server.GetURL("echoheader?Cookie"), DEFAULT_PRIORITY, &d));
+        https_server.GetURL("/echoheader?Cookie"), DEFAULT_PRIORITY, &d));
     req->Start();
     base::RunLoop().Run();
 
     EXPECT_TRUE(d.data_received().find("$Secure-bar=1") != std::string::npos);
     EXPECT_EQ(0, network_delegate.blocked_get_cookies_count());
     EXPECT_EQ(0, network_delegate.blocked_set_cookie_count());
   }
 }
 
 // Tests that a request is cancelled while entering suspend mode. Uses mocks
@@ skipping 74 matching lines @@
   LocalHttpTestServer test_server;
   ASSERT_TRUE(test_server.Start());
 
   // Set up an expired cookie.
   {
     TestNetworkDelegate network_delegate;
     default_context_.set_network_delegate(&network_delegate);
     TestDelegate d;
     scoped_ptr<URLRequest> req(default_context_.CreateRequest(
         test_server.GetURL(
-            "set-cookie?StillGood=1;expires=Mon,18-Apr-1977,22:50:13,GMT"),
+            "/set-cookie?StillGood=1;expires=Mon,18-Apr-1977,22:50:13,GMT"),
         DEFAULT_PRIORITY, &d));
     req->Start();
     base::RunLoop().Run();
   }
   // Verify that the cookie is not set.
   {
     TestNetworkDelegate network_delegate;
     default_context_.set_network_delegate(&network_delegate);
     TestDelegate d;
     scoped_ptr<URLRequest> req(default_context_.CreateRequest(
-        test_server.GetURL("echoheader?Cookie"), DEFAULT_PRIORITY, &d));
+        test_server.GetURL("/echoheader?Cookie"), DEFAULT_PRIORITY, &d));
     req->Start();
     base::RunLoop().Run();
 
     EXPECT_TRUE(d.data_received().find("StillGood=1") == std::string::npos);
   }
   // Set up a cookie with clock skew and "UTC" HTTP Date timezone specifier.
   {
     FixedDateNetworkDelegate network_delegate("18-Apr-1977 22:49:13 UTC");
     default_context_.set_network_delegate(&network_delegate);
     TestDelegate d;
     scoped_ptr<URLRequest> req(default_context_.CreateRequest(
         test_server.GetURL(
-            "set-cookie?StillGood=1;expires=Mon,18-Apr-1977,22:50:13,GMT"),
+            "/set-cookie?StillGood=1;expires=Mon,18-Apr-1977,22:50:13,GMT"),
         DEFAULT_PRIORITY, &d));
     req->Start();
     base::RunLoop().Run();
   }
   // Verify that the cookie is set.
   {
     TestNetworkDelegate network_delegate;
     default_context_.set_network_delegate(&network_delegate);
     TestDelegate d;
     scoped_ptr<URLRequest> req(default_context_.CreateRequest(
-        test_server.GetURL("echoheader?Cookie"), DEFAULT_PRIORITY, &d));
+        test_server.GetURL("/echoheader?Cookie"), DEFAULT_PRIORITY, &d));
     req->Start();
     base::RunLoop().Run();
 
     EXPECT_TRUE(d.data_received().find("StillGood=1") != std::string::npos);
   }
 }
 
 
 // Check that it is impossible to change the referrer in the extra headers of
 // an URLRequest.
 TEST_F(URLRequestTest, DoNotOverrideReferrer) {
   LocalHttpTestServer test_server;
   ASSERT_TRUE(test_server.Start());
 
   // If extra headers contain referer and the request contains a referer,
   // only the latter shall be respected.
   {
     TestDelegate d;
     scoped_ptr<URLRequest> req(default_context_.CreateRequest(
-        test_server.GetURL("echoheader?Referer"), DEFAULT_PRIORITY, &d));
+        test_server.GetURL("/echoheader?Referer"), DEFAULT_PRIORITY, &d));
     req->SetReferrer("http://foo.com/");
 
     HttpRequestHeaders headers;
     headers.SetHeader(HttpRequestHeaders::kReferer, "http://bar.com/");
     req->SetExtraRequestHeaders(headers);
 
     req->Start();
     base::RunLoop().Run();
 
     EXPECT_EQ("http://foo.com/", d.data_received());
   }
 
   // If extra headers contain a referer but the request does not, no referer
   // shall be sent in the header.
   {
     TestDelegate d;
     scoped_ptr<URLRequest> req(default_context_.CreateRequest(
-        test_server.GetURL("echoheader?Referer"), DEFAULT_PRIORITY, &d));
+        test_server.GetURL("/echoheader?Referer"), DEFAULT_PRIORITY, &d));
 
     HttpRequestHeaders headers;
     headers.SetHeader(HttpRequestHeaders::kReferer, "http://bar.com/");
     req->SetExtraRequestHeaders(headers);
     req->SetLoadFlags(LOAD_VALIDATE_CACHE);
 
     req->Start();
     base::RunLoop().Run();
 
     EXPECT_EQ("None", d.data_received());
@@ skipping 105 matching lines @@
         *ptr++ = marker;
         if (++marker > 'z')
           marker = 'a';
       }
     }
     uploadBytes[kMsgSize] = '\0';
 
     for (int i = 0; i < kIterations; ++i) {
       TestDelegate d;
       scoped_ptr<URLRequest> r(default_context_.CreateRequest(
-          test_server_.GetURL("echo"), DEFAULT_PRIORITY, &d));
+          test_server_.GetURL("/echo"), DEFAULT_PRIORITY, &d));
       r->set_method(method.c_str());
 
       r->set_upload(CreateSimpleUploadData(uploadBytes));
 
       r->Start();
       EXPECT_TRUE(r->is_pending());
 
       base::RunLoop().Run();
 
       ASSERT_EQ(1, d.response_started_count())
@@ skipping 26 matching lines @@
 
     EXPECT_FALSE(d->received_data_before_response());
 
     EXPECT_EQ(expected_data.size(), static_cast<size_t>(d->bytes_received()));
     EXPECT_EQ(expected_data, d->data_received());
   }
 
   bool DoManyCookiesRequest(int num_cookies) {
     TestDelegate d;
     scoped_ptr<URLRequest> r(default_context_.CreateRequest(
-        test_server_.GetURL("set-many-cookies?" +
+        test_server_.GetURL("/set-many-cookies?" +
                             base::IntToString(num_cookies)),
         DEFAULT_PRIORITY, &d));
 
     r->Start();
     EXPECT_TRUE(r->is_pending());
 
     base::RunLoop().Run();
 
     bool is_success = r->status().is_success();
 
-    if (!is_success) {
+    if (!is_success)
       EXPECT_TRUE(r->status().error() == ERR_RESPONSE_HEADERS_TOO_BIG);
-      // The test server appears to be unable to handle subsequent requests
-      // after this error is triggered. Force it to restart.
-      EXPECT_TRUE(test_server_.Stop());
-      EXPECT_TRUE(test_server_.Start());
-    }
 
     return is_success;
   }
 
-  LocalHttpTestServer* test_server() {
-    return &test_server_;
-  }
+  LocalHttpTestServer* http_test_server() { return &test_server_; }
 
- protected:
+ private:
   LocalHttpTestServer test_server_;
 };
 
-// In this unit test, we're using the HTTPTestServer as a proxy server and
+namespace {
+
+scoped_ptr<test_server::HttpResponse> HandleRedirectConnect(
+    const test_server::HttpRequest& request) {
+  if (request.headers.find("Host") == request.headers.end() ||
+      request.headers.at("Host") != "www.redirect.com" ||
+      request.method != test_server::METHOD_CONNECT) {
+    return nullptr;
+  }
+
+  scoped_ptr<test_server::BasicHttpResponse> http_response(
+      new test_server::BasicHttpResponse);
+  http_response->set_code(HTTP_FOUND);
+  http_response->AddCustomHeader("Location",
+                                 "http://www.destination.com/foo.js");
+  return http_response.Pass();
+}
+
+}  // namespace
+
+// In this unit test, we're using the EmbeddedTestServer as a proxy server and
 // issuing a CONNECT request with the magic host name "www.redirect.com".
-// The HTTPTestServer will return a 302 response, which we should not
+// The EmbeddedTestServer will return a 302 response, which we should not
 // follow.
 TEST_F(URLRequestTestHTTP, ProxyTunnelRedirectTest) {
-  ASSERT_TRUE(test_server_.Start());
+  http_test_server()->RegisterRequestHandler(
+      base::Bind(&HandleRedirectConnect));
+  ASSERT_TRUE(http_test_server()->Start());
 
   TestNetworkDelegate network_delegate;  // Must outlive URLRequest.
   TestURLRequestContextWithProxy context(
-      test_server_.host_port_pair().ToString(), &network_delegate);
+      http_test_server()->host_port_pair().ToString(), &network_delegate);
 
   TestDelegate d;
   {
     scoped_ptr<URLRequest> r(context.CreateRequest(
         GURL("https://www.redirect.com/"), DEFAULT_PRIORITY, &d));
     r->Start();
     EXPECT_TRUE(r->is_pending());
 
     base::RunLoop().Run();
 
     EXPECT_EQ(URLRequestStatus::FAILED, r->status().status());
     // The proxy server is not set before failure.
     EXPECT_TRUE(r->proxy_server().IsEmpty());
     EXPECT_EQ(ERR_TUNNEL_CONNECTION_FAILED, r->status().error());
     EXPECT_EQ(1, d.response_started_count());
     // We should not have followed the redirect.
     EXPECT_EQ(0, d.received_redirect_count());
   }
 }
 
 // This is the same as the previous test, but checks that the network delegate
 // registers the error.
 TEST_F(URLRequestTestHTTP, NetworkDelegateTunnelConnectionFailed) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
 
   TestNetworkDelegate network_delegate;  // Must outlive URLRequest.
   TestURLRequestContextWithProxy context(
-      test_server_.host_port_pair().ToString(), &network_delegate);
+      http_test_server()->host_port_pair().ToString(), &network_delegate);
 
   TestDelegate d;
   {
     scoped_ptr<URLRequest> r(context.CreateRequest(
         GURL("https://www.redirect.com/"), DEFAULT_PRIORITY, &d));
     r->Start();
     EXPECT_TRUE(r->is_pending());
 
     base::RunLoop().Run();
 
@@ skipping 12 matching lines @@
 
 // Tests that we can block and asynchronously return OK in various stages.
 TEST_F(URLRequestTestHTTP, NetworkDelegateBlockAsynchronously) {
   static const BlockingNetworkDelegate::Stage blocking_stages[] = {
     BlockingNetworkDelegate::ON_BEFORE_URL_REQUEST,
     BlockingNetworkDelegate::ON_BEFORE_SEND_HEADERS,
     BlockingNetworkDelegate::ON_HEADERS_RECEIVED
   };
   static const size_t blocking_stages_length = arraysize(blocking_stages);
 
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
 
   TestDelegate d;
   BlockingNetworkDelegate network_delegate(
       BlockingNetworkDelegate::USER_CALLBACK);
   network_delegate.set_block_on(
       BlockingNetworkDelegate::ON_BEFORE_URL_REQUEST |
       BlockingNetworkDelegate::ON_BEFORE_SEND_HEADERS |
       BlockingNetworkDelegate::ON_HEADERS_RECEIVED);
 
   TestURLRequestContext context(true);
   context.set_network_delegate(&network_delegate);
   context.Init();
 
   {
     scoped_ptr<URLRequest> r(context.CreateRequest(
-        test_server_.GetURL("empty.html"), DEFAULT_PRIORITY, &d));
+        http_test_server()->GetURL("/defaultresponse"), DEFAULT_PRIORITY, &d));
 
     r->Start();
     for (size_t i = 0; i < blocking_stages_length; ++i) {
       base::RunLoop().Run();
       EXPECT_EQ(blocking_stages[i],
                 network_delegate.stage_blocked_for_callback());
       network_delegate.DoCallback(OK);
     }
     base::RunLoop().Run();
     EXPECT_EQ(200, r->GetResponseCode());
     EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
     EXPECT_EQ(1, network_delegate.created_requests());
     EXPECT_EQ(0, network_delegate.destroyed_requests());
   }
   EXPECT_EQ(1, network_delegate.destroyed_requests());
 }
 
 // Tests that the network delegate can block and cancel a request.
 TEST_F(URLRequestTestHTTP, NetworkDelegateCancelRequest) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
 
   TestDelegate d;
   BlockingNetworkDelegate network_delegate(
       BlockingNetworkDelegate::AUTO_CALLBACK);
   network_delegate.set_block_on(BlockingNetworkDelegate::ON_BEFORE_URL_REQUEST);
   network_delegate.set_retval(ERR_EMPTY_RESPONSE);
 
   TestURLRequestContextWithProxy context(
-      test_server_.host_port_pair().ToString(), &network_delegate);
+      http_test_server()->host_port_pair().ToString(), &network_delegate);
 
   {
     scoped_ptr<URLRequest> r(context.CreateRequest(
-        test_server_.GetURL(std::string()), DEFAULT_PRIORITY, &d));
+        http_test_server()->GetURL("/"), DEFAULT_PRIORITY, &d));
 
     r->Start();
     base::RunLoop().Run();
 
     EXPECT_EQ(URLRequestStatus::FAILED, r->status().status());
     // The proxy server is not set before cancellation.
     EXPECT_TRUE(r->proxy_server().IsEmpty());
     EXPECT_EQ(ERR_EMPTY_RESPONSE, r->status().error());
     EXPECT_EQ(1, network_delegate.created_requests());
     EXPECT_EQ(0, network_delegate.destroyed_requests());
@@ skipping 29 matching lines @@
     EXPECT_EQ(ERR_BLOCKED_BY_CLIENT, r->status().error());
     EXPECT_EQ(1, network_delegate.created_requests());
     EXPECT_EQ(0, network_delegate.destroyed_requests());
   }
   EXPECT_EQ(1, network_delegate.destroyed_requests());
 }
 
 // The following 3 tests check that the network delegate can cancel a request
 // synchronously in various stages of the request.
 TEST_F(URLRequestTestHTTP, NetworkDelegateCancelRequestSynchronously1) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
   NetworkDelegateCancelRequest(BlockingNetworkDelegate::SYNCHRONOUS,
                                BlockingNetworkDelegate::ON_BEFORE_URL_REQUEST,
-                               test_server_.GetURL(std::string()));
+                               http_test_server()->GetURL("/"));
 }
 
 TEST_F(URLRequestTestHTTP, NetworkDelegateCancelRequestSynchronously2) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
   NetworkDelegateCancelRequest(BlockingNetworkDelegate::SYNCHRONOUS,
                                BlockingNetworkDelegate::ON_BEFORE_SEND_HEADERS,
-                               test_server_.GetURL(std::string()));
+                               http_test_server()->GetURL("/"));
 }
 
 TEST_F(URLRequestTestHTTP, NetworkDelegateCancelRequestSynchronously3) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
   NetworkDelegateCancelRequest(BlockingNetworkDelegate::SYNCHRONOUS,
                                BlockingNetworkDelegate::ON_HEADERS_RECEIVED,
-                               test_server_.GetURL(std::string()));
+                               http_test_server()->GetURL("/"));
 }
 
 // The following 3 tests check that the network delegate can cancel a request
 // asynchronously in various stages of the request.
 TEST_F(URLRequestTestHTTP, NetworkDelegateCancelRequestAsynchronously1) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
   NetworkDelegateCancelRequest(BlockingNetworkDelegate::AUTO_CALLBACK,
                                BlockingNetworkDelegate::ON_BEFORE_URL_REQUEST,
-                               test_server_.GetURL(std::string()));
+                               http_test_server()->GetURL("/"));
 }
 
 TEST_F(URLRequestTestHTTP, NetworkDelegateCancelRequestAsynchronously2) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
   NetworkDelegateCancelRequest(BlockingNetworkDelegate::AUTO_CALLBACK,
                                BlockingNetworkDelegate::ON_BEFORE_SEND_HEADERS,
-                               test_server_.GetURL(std::string()));
+                               http_test_server()->GetURL("/"));
 }
 
 TEST_F(URLRequestTestHTTP, NetworkDelegateCancelRequestAsynchronously3) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
   NetworkDelegateCancelRequest(BlockingNetworkDelegate::AUTO_CALLBACK,
                                BlockingNetworkDelegate::ON_HEADERS_RECEIVED,
-                               test_server_.GetURL(std::string()));
+                               http_test_server()->GetURL("/"));
 }
 
 // Tests that the network delegate can block and redirect a request to a new
 // URL.
 TEST_F(URLRequestTestHTTP, NetworkDelegateRedirectRequest) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
 
   TestDelegate d;
   BlockingNetworkDelegate network_delegate(
       BlockingNetworkDelegate::AUTO_CALLBACK);
   network_delegate.set_block_on(BlockingNetworkDelegate::ON_BEFORE_URL_REQUEST);
-  GURL redirect_url(test_server_.GetURL("simple.html"));
+  GURL redirect_url(http_test_server()->GetURL("/simple.html"));
   network_delegate.set_redirect_url(redirect_url);
 
   TestURLRequestContextWithProxy context(
-      test_server_.host_port_pair().ToString(), &network_delegate);
+      http_test_server()->host_port_pair().ToString(), &network_delegate);
 
   {
-    GURL original_url(test_server_.GetURL("empty.html"));
+    GURL original_url(http_test_server()->GetURL("/defaultresponse"));
     scoped_ptr<URLRequest> r(
         context.CreateRequest(original_url, DEFAULT_PRIORITY, &d));
 
     // Quit after hitting the redirect, so can check the headers.
     d.set_quit_on_redirect(true);
     r->Start();
     base::RunLoop().Run();
 
     // Check headers from URLRequestJob.
     EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
     EXPECT_EQ(307, r->GetResponseCode());
     EXPECT_EQ(307, r->response_headers()->response_code());
     std::string location;
     ASSERT_TRUE(r->response_headers()->EnumerateHeader(NULL, "Location",
                                                        &location));
     EXPECT_EQ(redirect_url, GURL(location));
 
     // Let the request finish.
     r->FollowDeferredRedirect();
     base::RunLoop().Run();
     EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
-    EXPECT_TRUE(r->proxy_server().Equals(test_server_.host_port_pair()));
+    EXPECT_TRUE(r->proxy_server().Equals(http_test_server()->host_port_pair()));
     EXPECT_EQ(
         1, network_delegate.observed_before_proxy_headers_sent_callbacks());
-    EXPECT_TRUE(
-        network_delegate.last_observed_proxy().Equals(
-            test_server_.host_port_pair()));
+    EXPECT_TRUE(network_delegate.last_observed_proxy().Equals(
+        http_test_server()->host_port_pair()));
 
     EXPECT_EQ(0, r->status().error());
     EXPECT_EQ(redirect_url, r->url());
     EXPECT_EQ(original_url, r->original_url());
     EXPECT_EQ(2U, r->url_chain().size());
     EXPECT_EQ(1, network_delegate.created_requests());
     EXPECT_EQ(0, network_delegate.destroyed_requests());
   }
   EXPECT_EQ(1, network_delegate.destroyed_requests());
 }
 
 // Tests that the network delegate can block and redirect a request to a new
 // URL by setting a redirect_url and returning in OnBeforeURLRequest directly.
 TEST_F(URLRequestTestHTTP, NetworkDelegateRedirectRequestSynchronously) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
 
   TestDelegate d;
   BlockingNetworkDelegate network_delegate(
       BlockingNetworkDelegate::SYNCHRONOUS);
-  GURL redirect_url(test_server_.GetURL("simple.html"));
+  GURL redirect_url(http_test_server()->GetURL("/simple.html"));
   network_delegate.set_redirect_url(redirect_url);
 
   TestURLRequestContextWithProxy context(
-      test_server_.host_port_pair().ToString(), &network_delegate);
+      http_test_server()->host_port_pair().ToString(), &network_delegate);
 
   {
-    GURL original_url(test_server_.GetURL("empty.html"));
+    GURL original_url(http_test_server()->GetURL("/defaultresponse"));
     scoped_ptr<URLRequest> r(
         context.CreateRequest(original_url, DEFAULT_PRIORITY, &d));
 
     // Quit after hitting the redirect, so can check the headers.
     d.set_quit_on_redirect(true);
     r->Start();
     base::RunLoop().Run();
 
     // Check headers from URLRequestJob.
     EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
     EXPECT_EQ(307, r->GetResponseCode());
     EXPECT_EQ(307, r->response_headers()->response_code());
     std::string location;
     ASSERT_TRUE(r->response_headers()->EnumerateHeader(NULL, "Location",
                                                        &location));
     EXPECT_EQ(redirect_url, GURL(location));
 
     // Let the request finish.
     r->FollowDeferredRedirect();
     base::RunLoop().Run();
 
     EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
-    EXPECT_TRUE(r->proxy_server().Equals(test_server_.host_port_pair()));
+    EXPECT_TRUE(r->proxy_server().Equals(http_test_server()->host_port_pair()));
     EXPECT_EQ(
         1, network_delegate.observed_before_proxy_headers_sent_callbacks());
-    EXPECT_TRUE(
-        network_delegate.last_observed_proxy().Equals(
-            test_server_.host_port_pair()));
+    EXPECT_TRUE(network_delegate.last_observed_proxy().Equals(
+        http_test_server()->host_port_pair()));
     EXPECT_EQ(0, r->status().error());
     EXPECT_EQ(redirect_url, r->url());
     EXPECT_EQ(original_url, r->original_url());
     EXPECT_EQ(2U, r->url_chain().size());
     EXPECT_EQ(1, network_delegate.created_requests());
     EXPECT_EQ(0, network_delegate.destroyed_requests());
   }
   EXPECT_EQ(1, network_delegate.destroyed_requests());
 }
 
 // Tests that redirects caused by the network delegate preserve POST data.
 TEST_F(URLRequestTestHTTP, NetworkDelegateRedirectRequestPost) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
 
   const char kData[] = "hello world";
 
   TestDelegate d;
   BlockingNetworkDelegate network_delegate(
       BlockingNetworkDelegate::AUTO_CALLBACK);
   network_delegate.set_block_on(BlockingNetworkDelegate::ON_BEFORE_URL_REQUEST);
-  GURL redirect_url(test_server_.GetURL("echo"));
+  GURL redirect_url(http_test_server()->GetURL("/echo"));
   network_delegate.set_redirect_url(redirect_url);
 
   TestURLRequestContext context(true);
   context.set_network_delegate(&network_delegate);
   context.Init();
 
   {
-    GURL original_url(test_server_.GetURL("empty.html"));
+    GURL original_url(http_test_server()->GetURL("/defaultresponse"));
     scoped_ptr<URLRequest> r(
         context.CreateRequest(original_url, DEFAULT_PRIORITY, &d));
     r->set_method("POST");
     r->set_upload(CreateSimpleUploadData(kData));
     HttpRequestHeaders headers;
     headers.SetHeader(HttpRequestHeaders::kContentLength,
                       base::SizeTToString(arraysize(kData) - 1));
     r->SetExtraRequestHeaders(headers);
 
     // Quit after hitting the redirect, so can check the headers.
@@ skipping 23 matching lines @@
     EXPECT_EQ(0, network_delegate.destroyed_requests());
     EXPECT_EQ("POST", r->method());
     EXPECT_EQ(kData, d.data_received());
   }
   EXPECT_EQ(1, network_delegate.destroyed_requests());
 }
 
 // Tests that the network delegate can block and redirect a request to a new
 // URL during OnHeadersReceived.
 TEST_F(URLRequestTestHTTP, NetworkDelegateRedirectRequestOnHeadersReceived) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
 
   TestDelegate d;
   BlockingNetworkDelegate network_delegate(
       BlockingNetworkDelegate::AUTO_CALLBACK);
   network_delegate.set_block_on(BlockingNetworkDelegate::ON_HEADERS_RECEIVED);
-  GURL redirect_url(test_server_.GetURL("simple.html"));
+  GURL redirect_url(http_test_server()->GetURL("/simple.html"));
   network_delegate.set_redirect_on_headers_received_url(redirect_url);
 
   TestURLRequestContextWithProxy context(
-      test_server_.host_port_pair().ToString(), &network_delegate);
+      http_test_server()->host_port_pair().ToString(), &network_delegate);
 
   {
-    GURL original_url(test_server_.GetURL("empty.html"));
+    GURL original_url(http_test_server()->GetURL("/defaultresponse"));
     scoped_ptr<URLRequest> r(
         context.CreateRequest(original_url, DEFAULT_PRIORITY, &d));
 
     r->Start();
     base::RunLoop().Run();
 
     EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
-    EXPECT_TRUE(r->proxy_server().Equals(test_server_.host_port_pair()));
+    EXPECT_TRUE(r->proxy_server().Equals(http_test_server()->host_port_pair()));
     EXPECT_EQ(
         2, network_delegate.observed_before_proxy_headers_sent_callbacks());
-    EXPECT_TRUE(
-        network_delegate.last_observed_proxy().Equals(
-            test_server_.host_port_pair()));
+    EXPECT_TRUE(network_delegate.last_observed_proxy().Equals(
+        http_test_server()->host_port_pair()));
 
     EXPECT_EQ(OK, r->status().error());
     EXPECT_EQ(redirect_url, r->url());
     EXPECT_EQ(original_url, r->original_url());
     EXPECT_EQ(2U, r->url_chain().size());
     EXPECT_EQ(2, network_delegate.created_requests());
     EXPECT_EQ(0, network_delegate.destroyed_requests());
   }
   EXPECT_EQ(1, network_delegate.destroyed_requests());
 }
 
 // Tests that the network delegate can synchronously complete OnAuthRequired
 // by taking no action. This indicates that the NetworkDelegate does not want to
 // handle the challenge, and is passing the buck along to the
 // URLRequest::Delegate.
 TEST_F(URLRequestTestHTTP, NetworkDelegateOnAuthRequiredSyncNoAction) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
 
   TestDelegate d;
   BlockingNetworkDelegate network_delegate(
       BlockingNetworkDelegate::SYNCHRONOUS);
 
   TestURLRequestContext context(true);
   context.set_network_delegate(&network_delegate);
   context.Init();
 
   d.set_credentials(AuthCredentials(kUser, kSecret));
 
   {
-    GURL url(test_server_.GetURL("auth-basic"));
+    GURL url(http_test_server()->GetURL("/auth-basic"));
     scoped_ptr<URLRequest> r(context.CreateRequest(url, DEFAULT_PRIORITY, &d));
     r->Start();
 
     base::RunLoop().Run();
 
     EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
     EXPECT_EQ(0, r->status().error());
     EXPECT_EQ(200, r->GetResponseCode());
     EXPECT_TRUE(d.auth_required_called());
     EXPECT_EQ(1, network_delegate.created_requests());
     EXPECT_EQ(0, network_delegate.destroyed_requests());
   }
   EXPECT_EQ(1, network_delegate.destroyed_requests());
 }
 
 TEST_F(URLRequestTestHTTP,
     NetworkDelegateOnAuthRequiredSyncNoAction_GetFullRequestHeaders) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
 
   TestDelegate d;
   BlockingNetworkDelegate network_delegate(
       BlockingNetworkDelegate::SYNCHRONOUS);
 
   TestURLRequestContext context(true);
   context.set_network_delegate(&network_delegate);
   context.Init();
 
   d.set_credentials(AuthCredentials(kUser, kSecret));
 
   {
-    GURL url(test_server_.GetURL("auth-basic"));
+    GURL url(http_test_server()->GetURL("/auth-basic"));
     scoped_ptr<URLRequest> r(context.CreateRequest(url, DEFAULT_PRIORITY, &d));
     r->Start();
 
     {
       HttpRequestHeaders headers;
       EXPECT_TRUE(r->GetFullRequestHeaders(&headers));
       EXPECT_FALSE(headers.HasHeader("Authorization"));
     }
 
     base::RunLoop().Run();
 
     EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
     EXPECT_EQ(0, r->status().error());
     EXPECT_EQ(200, r->GetResponseCode());
     EXPECT_TRUE(d.auth_required_called());
     EXPECT_EQ(1, network_delegate.created_requests());
     EXPECT_EQ(0, network_delegate.destroyed_requests());
   }
   EXPECT_EQ(1, network_delegate.destroyed_requests());
 }
 
 // Tests that the network delegate can synchronously complete OnAuthRequired
 // by setting credentials.
 TEST_F(URLRequestTestHTTP, NetworkDelegateOnAuthRequiredSyncSetAuth) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
 
   TestDelegate d;
   BlockingNetworkDelegate network_delegate(
       BlockingNetworkDelegate::SYNCHRONOUS);
   network_delegate.set_block_on(BlockingNetworkDelegate::ON_AUTH_REQUIRED);
   network_delegate.set_auth_retval(
       NetworkDelegate::AUTH_REQUIRED_RESPONSE_SET_AUTH);
 
   network_delegate.set_auth_credentials(AuthCredentials(kUser, kSecret));
 
   TestURLRequestContext context(true);
   context.set_network_delegate(&network_delegate);
   context.Init();
 
   {
-    GURL url(test_server_.GetURL("auth-basic"));
+    GURL url(http_test_server()->GetURL("/auth-basic"));
     scoped_ptr<URLRequest> r(context.CreateRequest(url, DEFAULT_PRIORITY, &d));
     r->Start();
     base::RunLoop().Run();
 
     EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
     EXPECT_EQ(0, r->status().error());
     EXPECT_EQ(200, r->GetResponseCode());
     EXPECT_FALSE(d.auth_required_called());
     EXPECT_EQ(1, network_delegate.created_requests());
     EXPECT_EQ(0, network_delegate.destroyed_requests());
   }
   EXPECT_EQ(1, network_delegate.destroyed_requests());
 }
 
 // Same as above, but also tests that GetFullRequestHeaders returns the proper
 // headers (for the first or second request) when called at the proper times.
 TEST_F(URLRequestTestHTTP,
     NetworkDelegateOnAuthRequiredSyncSetAuth_GetFullRequestHeaders) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
 
   TestDelegate d;
   BlockingNetworkDelegate network_delegate(
       BlockingNetworkDelegate::SYNCHRONOUS);
   network_delegate.set_block_on(BlockingNetworkDelegate::ON_AUTH_REQUIRED);
   network_delegate.set_auth_retval(
       NetworkDelegate::AUTH_REQUIRED_RESPONSE_SET_AUTH);
 
   network_delegate.set_auth_credentials(AuthCredentials(kUser, kSecret));
 
   TestURLRequestContext context(true);
   context.set_network_delegate(&network_delegate);
   context.Init();
 
   {
-    GURL url(test_server_.GetURL("auth-basic"));
+    GURL url(http_test_server()->GetURL("/auth-basic"));
     scoped_ptr<URLRequest> r(context.CreateRequest(url, DEFAULT_PRIORITY, &d));
     r->Start();
     base::RunLoop().Run();
 
     EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
     EXPECT_EQ(0, r->status().error());
     EXPECT_EQ(200, r->GetResponseCode());
     EXPECT_FALSE(d.auth_required_called());
     EXPECT_EQ(1, network_delegate.created_requests());
     EXPECT_EQ(0, network_delegate.destroyed_requests());
 
     {
       HttpRequestHeaders headers;
       EXPECT_TRUE(r->GetFullRequestHeaders(&headers));
       EXPECT_TRUE(headers.HasHeader("Authorization"));
     }
   }
   EXPECT_EQ(1, network_delegate.destroyed_requests());
 }
 
 // Tests that the network delegate can synchronously complete OnAuthRequired
 // by cancelling authentication.
 TEST_F(URLRequestTestHTTP, NetworkDelegateOnAuthRequiredSyncCancel) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
 
   TestDelegate d;
   BlockingNetworkDelegate network_delegate(
       BlockingNetworkDelegate::SYNCHRONOUS);
   network_delegate.set_block_on(BlockingNetworkDelegate::ON_AUTH_REQUIRED);
   network_delegate.set_auth_retval(
       NetworkDelegate::AUTH_REQUIRED_RESPONSE_CANCEL_AUTH);
 
   TestURLRequestContext context(true);
   context.set_network_delegate(&network_delegate);
   context.Init();
 
   {
-    GURL url(test_server_.GetURL("auth-basic"));
+    GURL url(http_test_server()->GetURL("/auth-basic"));
     scoped_ptr<URLRequest> r(context.CreateRequest(url, DEFAULT_PRIORITY, &d));
     r->Start();
     base::RunLoop().Run();
 
     EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
     EXPECT_EQ(OK, r->status().error());
     EXPECT_EQ(401, r->GetResponseCode());
     EXPECT_FALSE(d.auth_required_called());
     EXPECT_EQ(1, network_delegate.created_requests());
     EXPECT_EQ(0, network_delegate.destroyed_requests());
   }
   EXPECT_EQ(1, network_delegate.destroyed_requests());
 }
 
 // Tests that the network delegate can asynchronously complete OnAuthRequired
 // by taking no action. This indicates that the NetworkDelegate does not want
 // to handle the challenge, and is passing the buck along to the
 // URLRequest::Delegate.
 TEST_F(URLRequestTestHTTP, NetworkDelegateOnAuthRequiredAsyncNoAction) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
 
   TestDelegate d;
   BlockingNetworkDelegate network_delegate(
       BlockingNetworkDelegate::AUTO_CALLBACK);
   network_delegate.set_block_on(BlockingNetworkDelegate::ON_AUTH_REQUIRED);
 
   TestURLRequestContext context(true);
   context.set_network_delegate(&network_delegate);
   context.Init();
 
   d.set_credentials(AuthCredentials(kUser, kSecret));
 
   {
-    GURL url(test_server_.GetURL("auth-basic"));
+    GURL url(http_test_server()->GetURL("/auth-basic"));
     scoped_ptr<URLRequest> r(context.CreateRequest(url, DEFAULT_PRIORITY, &d));
     r->Start();
     base::RunLoop().Run();
 
     EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
     EXPECT_EQ(0, r->status().error());
     EXPECT_EQ(200, r->GetResponseCode());
     EXPECT_TRUE(d.auth_required_called());
     EXPECT_EQ(1, network_delegate.created_requests());
     EXPECT_EQ(0, network_delegate.destroyed_requests());
   }
   EXPECT_EQ(1, network_delegate.destroyed_requests());
 }
 
 // Tests that the network delegate can asynchronously complete OnAuthRequired
 // by setting credentials.
 TEST_F(URLRequestTestHTTP, NetworkDelegateOnAuthRequiredAsyncSetAuth) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
 
   TestDelegate d;
   BlockingNetworkDelegate network_delegate(
       BlockingNetworkDelegate::AUTO_CALLBACK);
   network_delegate.set_block_on(BlockingNetworkDelegate::ON_AUTH_REQUIRED);
   network_delegate.set_auth_retval(
       NetworkDelegate::AUTH_REQUIRED_RESPONSE_SET_AUTH);
 
   AuthCredentials auth_credentials(kUser, kSecret);
   network_delegate.set_auth_credentials(auth_credentials);
 
   TestURLRequestContext context(true);
   context.set_network_delegate(&network_delegate);
   context.Init();
 
   {
-    GURL url(test_server_.GetURL("auth-basic"));
+    GURL url(http_test_server()->GetURL("/auth-basic"));
     scoped_ptr<URLRequest> r(context.CreateRequest(url, DEFAULT_PRIORITY, &d));
     r->Start();
     base::RunLoop().Run();
 
     EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
     EXPECT_EQ(0, r->status().error());
 
     EXPECT_EQ(200, r->GetResponseCode());
     EXPECT_FALSE(d.auth_required_called());
     EXPECT_EQ(1, network_delegate.created_requests());
     EXPECT_EQ(0, network_delegate.destroyed_requests());
   }
   EXPECT_EQ(1, network_delegate.destroyed_requests());
 }
 
 // Tests that the network delegate can asynchronously complete OnAuthRequired
 // by cancelling authentication.
 TEST_F(URLRequestTestHTTP, NetworkDelegateOnAuthRequiredAsyncCancel) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
 
   TestDelegate d;
   BlockingNetworkDelegate network_delegate(
       BlockingNetworkDelegate::AUTO_CALLBACK);
   network_delegate.set_block_on(BlockingNetworkDelegate::ON_AUTH_REQUIRED);
   network_delegate.set_auth_retval(
       NetworkDelegate::AUTH_REQUIRED_RESPONSE_CANCEL_AUTH);
 
   TestURLRequestContext context(true);
   context.set_network_delegate(&network_delegate);
   context.Init();
 
   {
-    GURL url(test_server_.GetURL("auth-basic"));
+    GURL url(http_test_server()->GetURL("/auth-basic"));
     scoped_ptr<URLRequest> r(context.CreateRequest(url, DEFAULT_PRIORITY, &d));
     r->Start();
     base::RunLoop().Run();
 
     EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
     EXPECT_EQ(OK, r->status().error());
     EXPECT_EQ(401, r->GetResponseCode());
     EXPECT_FALSE(d.auth_required_called());
     EXPECT_EQ(1, network_delegate.created_requests());
     EXPECT_EQ(0, network_delegate.destroyed_requests());
   }
   EXPECT_EQ(1, network_delegate.destroyed_requests());
 }
 
 // Tests that we can handle when a network request was canceled while we were
 // waiting for the network delegate.
 // Part 1: Request is cancelled while waiting for OnBeforeURLRequest callback.
 TEST_F(URLRequestTestHTTP, NetworkDelegateCancelWhileWaiting1) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
 
   TestDelegate d;
   BlockingNetworkDelegate network_delegate(
       BlockingNetworkDelegate::USER_CALLBACK);
   network_delegate.set_block_on(BlockingNetworkDelegate::ON_BEFORE_URL_REQUEST);
 
   TestURLRequestContext context(true);
   context.set_network_delegate(&network_delegate);
   context.Init();
 
   {
     scoped_ptr<URLRequest> r(context.CreateRequest(
-        test_server_.GetURL(std::string()), DEFAULT_PRIORITY, &d));
+        http_test_server()->GetURL("/"), DEFAULT_PRIORITY, &d));
 
     r->Start();
     base::RunLoop().Run();
     EXPECT_EQ(BlockingNetworkDelegate::ON_BEFORE_URL_REQUEST,
               network_delegate.stage_blocked_for_callback());
     EXPECT_EQ(0, network_delegate.completed_requests());
     // Cancel before callback.
     r->Cancel();
     // Ensure that network delegate is notified.
     EXPECT_EQ(1, network_delegate.completed_requests());
     EXPECT_EQ(URLRequestStatus::CANCELED, r->status().status());
     EXPECT_EQ(ERR_ABORTED, r->status().error());
     EXPECT_EQ(1, network_delegate.created_requests());
     EXPECT_EQ(0, network_delegate.destroyed_requests());
   }
   EXPECT_EQ(1, network_delegate.destroyed_requests());
 }
 
 // Tests that we can handle when a network request was canceled while we were
 // waiting for the network delegate.
 // Part 2: Request is cancelled while waiting for OnBeforeSendHeaders callback.
 TEST_F(URLRequestTestHTTP, NetworkDelegateCancelWhileWaiting2) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
 
   TestDelegate d;
   BlockingNetworkDelegate network_delegate(
       BlockingNetworkDelegate::USER_CALLBACK);
   network_delegate.set_block_on(
       BlockingNetworkDelegate::ON_BEFORE_SEND_HEADERS);
 
   TestURLRequestContext context(true);
   context.set_network_delegate(&network_delegate);
   context.Init();
 
   {
     scoped_ptr<URLRequest> r(context.CreateRequest(
-        test_server_.GetURL(std::string()), DEFAULT_PRIORITY, &d));
+        http_test_server()->GetURL("/"), DEFAULT_PRIORITY, &d));
 
     r->Start();
     base::RunLoop().Run();
     EXPECT_EQ(BlockingNetworkDelegate::ON_BEFORE_SEND_HEADERS,
               network_delegate.stage_blocked_for_callback());
     EXPECT_EQ(0, network_delegate.completed_requests());
     // Cancel before callback.
     r->Cancel();
     // Ensure that network delegate is notified.
     EXPECT_EQ(1, network_delegate.completed_requests());
     EXPECT_EQ(URLRequestStatus::CANCELED, r->status().status());
     EXPECT_EQ(ERR_ABORTED, r->status().error());
     EXPECT_EQ(1, network_delegate.created_requests());
     EXPECT_EQ(0, network_delegate.destroyed_requests());
   }
   EXPECT_EQ(1, network_delegate.destroyed_requests());
 }
 
 // Tests that we can handle when a network request was canceled while we were
 // waiting for the network delegate.
 // Part 3: Request is cancelled while waiting for OnHeadersReceived callback.
 TEST_F(URLRequestTestHTTP, NetworkDelegateCancelWhileWaiting3) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
 
   TestDelegate d;
   BlockingNetworkDelegate network_delegate(
       BlockingNetworkDelegate::USER_CALLBACK);
   network_delegate.set_block_on(BlockingNetworkDelegate::ON_HEADERS_RECEIVED);
 
   TestURLRequestContext context(true);
   context.set_network_delegate(&network_delegate);
   context.Init();
 
   {
     scoped_ptr<URLRequest> r(context.CreateRequest(
-        test_server_.GetURL(std::string()), DEFAULT_PRIORITY, &d));
+        http_test_server()->GetURL("/"), DEFAULT_PRIORITY, &d));
 
     r->Start();
     base::RunLoop().Run();
     EXPECT_EQ(BlockingNetworkDelegate::ON_HEADERS_RECEIVED,
               network_delegate.stage_blocked_for_callback());
     EXPECT_EQ(0, network_delegate.completed_requests());
     // Cancel before callback.
     r->Cancel();
     // Ensure that network delegate is notified.
     EXPECT_EQ(1, network_delegate.completed_requests());
     EXPECT_EQ(URLRequestStatus::CANCELED, r->status().status());
     EXPECT_EQ(ERR_ABORTED, r->status().error());
     EXPECT_EQ(1, network_delegate.created_requests());
     EXPECT_EQ(0, network_delegate.destroyed_requests());
   }
   EXPECT_EQ(1, network_delegate.destroyed_requests());
 }
 
 // Tests that we can handle when a network request was canceled while we were
 // waiting for the network delegate.
 // Part 4: Request is cancelled while waiting for OnAuthRequired callback.
 TEST_F(URLRequestTestHTTP, NetworkDelegateCancelWhileWaiting4) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
 
   TestDelegate d;
   BlockingNetworkDelegate network_delegate(
       BlockingNetworkDelegate::USER_CALLBACK);
   network_delegate.set_block_on(BlockingNetworkDelegate::ON_AUTH_REQUIRED);
 
   TestURLRequestContext context(true);
   context.set_network_delegate(&network_delegate);
   context.Init();
 
   {
     scoped_ptr<URLRequest> r(context.CreateRequest(
-        test_server_.GetURL("auth-basic"), DEFAULT_PRIORITY, &d));
+        http_test_server()->GetURL("/auth-basic"), DEFAULT_PRIORITY, &d));
 
     r->Start();
     base::RunLoop().Run();
     EXPECT_EQ(BlockingNetworkDelegate::ON_AUTH_REQUIRED,
               network_delegate.stage_blocked_for_callback());
     EXPECT_EQ(0, network_delegate.completed_requests());
     // Cancel before callback.
     r->Cancel();
     // Ensure that network delegate is notified.
     EXPECT_EQ(1, network_delegate.completed_requests());
     EXPECT_EQ(URLRequestStatus::CANCELED, r->status().status());
     EXPECT_EQ(ERR_ABORTED, r->status().error());
     EXPECT_EQ(1, network_delegate.created_requests());
     EXPECT_EQ(0, network_delegate.destroyed_requests());
   }
   EXPECT_EQ(1, network_delegate.destroyed_requests());
 }
 
-// In this unit test, we're using the HTTPTestServer as a proxy server and
+namespace {
+
+scoped_ptr<test_server::HttpResponse> HandleServerAuthConnect(
+    const test_server::HttpRequest& request) {
+  if (request.headers.find("Host") == request.headers.end() ||
+      request.headers.at("Host") != "www.server-auth.com" ||
+      request.method != test_server::METHOD_CONNECT) {
+    return nullptr;
+  }
+
+  scoped_ptr<test_server::BasicHttpResponse> http_response(
+      new test_server::BasicHttpResponse);
+  http_response->set_code(HTTP_UNAUTHORIZED);
+  http_response->AddCustomHeader("WWW-Authenticate",
+                                 "Basic realm=\"WallyWorld\"");
+  return http_response.Pass();
+}
+
+}  // namespace
+
+// In this unit test, we're using the EmbeddedTestServer as a proxy server and
 // issuing a CONNECT request with the magic host name "www.server-auth.com".
-// The HTTPTestServer will return a 401 response, which we should balk at.
+// The EmbeddedTestServer will return a 401 response, which we should balk at.
 TEST_F(URLRequestTestHTTP, UnexpectedServerAuthTest) {
-  ASSERT_TRUE(test_server_.Start());
+  http_test_server()->RegisterRequestHandler(
+      base::Bind(&HandleServerAuthConnect));
+  ASSERT_TRUE(http_test_server()->Start());
 
   TestNetworkDelegate network_delegate;  // Must outlive URLRequest.
   TestURLRequestContextWithProxy context(
-      test_server_.host_port_pair().ToString(), &network_delegate);
+      http_test_server()->host_port_pair().ToString(), &network_delegate);
 
   TestDelegate d;
   {
     scoped_ptr<URLRequest> r(context.CreateRequest(
         GURL("https://www.server-auth.com/"), DEFAULT_PRIORITY, &d));
 
     r->Start();
     EXPECT_TRUE(r->is_pending());
 
     base::RunLoop().Run();
 
     EXPECT_EQ(URLRequestStatus::FAILED, r->status().status());
     // The proxy server is not set before failure.
     EXPECT_TRUE(r->proxy_server().IsEmpty());
     EXPECT_EQ(ERR_TUNNEL_CONNECTION_FAILED, r->status().error());
   }
 }
 
 TEST_F(URLRequestTestHTTP, GetTest_NoCache) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
 
   TestDelegate d;
   {
     scoped_ptr<URLRequest> r(default_context_.CreateRequest(
-        test_server_.GetURL(std::string()), DEFAULT_PRIORITY, &d));
+        http_test_server()->GetURL("/defaultresponse"), DEFAULT_PRIORITY, &d));
 
     r->Start();
     EXPECT_TRUE(r->is_pending());
 
     base::RunLoop().Run();
 
     EXPECT_EQ(1, d.response_started_count());
     EXPECT_FALSE(d.received_data_before_response());
     EXPECT_NE(0, d.bytes_received());
-    EXPECT_EQ(test_server_.host_port_pair().host(),
+    EXPECT_EQ(http_test_server()->host_port_pair().host(),
               r->GetSocketAddress().host());
-    EXPECT_EQ(test_server_.host_port_pair().port(),
+    EXPECT_EQ(http_test_server()->host_port_pair().port(),
               r->GetSocketAddress().port());
 
     // TODO(eroman): Add back the NetLog tests...
   }
 }
 
 // This test has the server send a large number of cookies to the client.
 // To ensure that no number of cookies causes a crash, a galloping binary
 // search is used to estimate that maximum number of cookies that are accepted
 // by the browser. Beyond the maximum number, the request will fail with
 // ERR_RESPONSE_HEADERS_TOO_BIG.
 #if defined(OS_WIN)
 // http://crbug.com/177916
 #define MAYBE_GetTest_ManyCookies DISABLED_GetTest_ManyCookies
 #else
 #define MAYBE_GetTest_ManyCookies GetTest_ManyCookies
 #endif  // defined(OS_WIN)
 TEST_F(URLRequestTestHTTP, MAYBE_GetTest_ManyCookies) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
 
   int lower_bound = 0;
   int upper_bound = 1;
 
   // Double the number of cookies until the response header limits are
   // exceeded.
   while (DoManyCookiesRequest(upper_bound)) {
     lower_bound = upper_bound;
     upper_bound *= 2;
     ASSERT_LT(upper_bound, 1000000);
@@ skipping 10 matching lines @@
 
     if (DoManyCookiesRequest(num_cookies))
       lower_bound = num_cookies;
     else
       upper_bound = num_cookies;
   }
   // Success: the test did not crash.
 }
 
 TEST_F(URLRequestTestHTTP, GetTest) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
 
   TestDelegate d;
   {
     scoped_ptr<URLRequest> r(default_context_.CreateRequest(
-        test_server_.GetURL(std::string()), DEFAULT_PRIORITY, &d));
+        http_test_server()->GetURL("/defaultresponse"), DEFAULT_PRIORITY, &d));
 
     r->Start();
     EXPECT_TRUE(r->is_pending());
 
     base::RunLoop().Run();
 
     EXPECT_EQ(1, d.response_started_count());
     EXPECT_FALSE(d.received_data_before_response());
     EXPECT_NE(0, d.bytes_received());
-    EXPECT_EQ(test_server_.host_port_pair().host(),
+    EXPECT_EQ(http_test_server()->host_port_pair().host(),
               r->GetSocketAddress().host());
-    EXPECT_EQ(test_server_.host_port_pair().port(),
+    EXPECT_EQ(http_test_server()->host_port_pair().port(),
               r->GetSocketAddress().port());
   }
 }
 
 TEST_F(URLRequestTestHTTP, GetTest_GetFullRequestHeaders) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
 
   TestDelegate d;
   {
-    GURL test_url(test_server_.GetURL(std::string()));
+    GURL test_url(http_test_server()->GetURL("/defaultresponse"));
     scoped_ptr<URLRequest> r(
         default_context_.CreateRequest(test_url, DEFAULT_PRIORITY, &d));
 
     HttpRequestHeaders headers;
     EXPECT_FALSE(r->GetFullRequestHeaders(&headers));
 
     r->Start();
     EXPECT_TRUE(r->is_pending());
 
     base::RunLoop().Run();
 
     EXPECT_EQ(1, d.response_started_count());
     EXPECT_FALSE(d.received_data_before_response());
     EXPECT_NE(0, d.bytes_received());
-    EXPECT_EQ(test_server_.host_port_pair().host(),
+    EXPECT_EQ(http_test_server()->host_port_pair().host(),
               r->GetSocketAddress().host());
-    EXPECT_EQ(test_server_.host_port_pair().port(),
+    EXPECT_EQ(http_test_server()->host_port_pair().port(),
               r->GetSocketAddress().port());
 
     EXPECT_TRUE(d.have_full_request_headers());
     CheckFullRequestHeaders(d.full_request_headers(), test_url);
   }
 }
 
 TEST_F(URLRequestTestHTTP, GetTestLoadTiming) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
 
   TestDelegate d;
   {
     scoped_ptr<URLRequest> r(default_context_.CreateRequest(
-        test_server_.GetURL(std::string()), DEFAULT_PRIORITY, &d));
+        http_test_server()->GetURL("/defaultresponse"), DEFAULT_PRIORITY, &d));
 
     r->Start();
     EXPECT_TRUE(r->is_pending());
 
     base::RunLoop().Run();
 
     LoadTimingInfo load_timing_info;
     r->GetLoadTimingInfo(&load_timing_info);
     TestLoadTimingNotReused(load_timing_info, CONNECT_TIMING_HAS_DNS_TIMES);
 
     EXPECT_EQ(1, d.response_started_count());
     EXPECT_FALSE(d.received_data_before_response());
     EXPECT_NE(0, d.bytes_received());
-    EXPECT_EQ(test_server_.host_port_pair().host(),
+    EXPECT_EQ(http_test_server()->host_port_pair().host(),
               r->GetSocketAddress().host());
-    EXPECT_EQ(test_server_.host_port_pair().port(),
+    EXPECT_EQ(http_test_server()->host_port_pair().port(),
               r->GetSocketAddress().port());
   }
 }
 
+// TODO(droger): Support SpawnedTestServer on iOS (see http://crbug.com/148666).
+#if !defined(OS_IOS)
 TEST_F(URLRequestTestHTTP, GetZippedTest) {
-  ASSERT_TRUE(test_server_.Start());
+  SpawnedTestServer test_server(SpawnedTestServer::TYPE_HTTP,
+                                SpawnedTestServer::kLocalhost,
+                                base::FilePath(kTestFilePath));
+
+  ASSERT_TRUE(test_server.Start());
 
   // Parameter that specifies the Content-Length field in the response:
   // C - Compressed length.
   // U - Uncompressed length.
   // L - Large length (larger than both C & U).
   // M - Medium length (between C & U).
   // S - Small length (smaller than both C & U).
   const char test_parameters[] = "CULMS";
   const int num_tests = arraysize(test_parameters)- 1;  // Skip NULL.
   // C & U should be OK.
   // L & M are larger than the data sent, and show an error.
   // S has too little data, but we seem to accept it.
   const bool test_expect_success[num_tests] =
       { true, true, false, false, true };
 
   for (int i = 0; i < num_tests ; i++) {
     TestDelegate d;
     {
-      std::string test_file =
-          base::StringPrintf("compressedfiles/BullRunSpeech.txt?%c",
-                             test_parameters[i]);
+      std::string test_file = base::StringPrintf(
+          "compressedfiles/BullRunSpeech.txt?%c", test_parameters[i]);
 
       TestNetworkDelegate network_delegate;  // Must outlive URLRequest.
       TestURLRequestContext context(true);
       context.set_network_delegate(&network_delegate);
       context.Init();
 
       scoped_ptr<URLRequest> r(context.CreateRequest(
-          test_server_.GetURL(test_file), DEFAULT_PRIORITY, &d));
+          test_server.GetURL(test_file), DEFAULT_PRIORITY, &d));
       r->Start();
       EXPECT_TRUE(r->is_pending());
 
       base::RunLoop().Run();
 
       EXPECT_EQ(1, d.response_started_count());
       EXPECT_FALSE(d.received_data_before_response());
       VLOG(1) << " Received " << d.bytes_received() << " bytes"
               << " status = " << r->status().status()
               << " error = " << r->status().error();
       if (test_expect_success[i]) {
         EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status())
             << " Parameter = \"" << test_file << "\"";
       } else {
         EXPECT_EQ(URLRequestStatus::FAILED, r->status().status());
         EXPECT_EQ(ERR_CONTENT_LENGTH_MISMATCH, r->status().error())
             << " Parameter = \"" << test_file << "\"";
       }
     }
   }
 }
+#endif  // !defined(OS_IOS)
 
 TEST_F(URLRequestTestHTTP, NetworkQualityEstimator) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
   // Enable requests to local host to be used for network quality estimation.
   std::map<std::string, std::string> variation_params;
   NetworkQualityEstimator estimator(scoped_ptr<net::ExternalEstimateProvider>(),
                                     variation_params, true, true);
 
   TestDelegate d;
   TestNetworkDelegate network_delegate;  // Must outlive URLRequest.
   TestURLRequestContext context(true);
   context.set_network_quality_estimator(&estimator);
   context.set_network_delegate(&network_delegate);
   context.Init();
 
-  std::string url = "echo.html";
+  std::string url = "/defaultresponse";
 
-  scoped_ptr<URLRequest> r(
-      context.CreateRequest(test_server_.GetURL(url), DEFAULT_PRIORITY, &d));
+  scoped_ptr<URLRequest> r(context.CreateRequest(
+      http_test_server()->GetURL(url), DEFAULT_PRIORITY, &d));
   r->Start();
 
   base::RunLoop().Run();
 
   base::TimeDelta rtt;
   int32_t kbps;
   EXPECT_TRUE(estimator.GetRTTEstimate(&rtt));
   EXPECT_TRUE(estimator.GetDownlinkThroughputKbpsEstimate(&kbps));
   EXPECT_GE(rtt, base::TimeDelta());
   EXPECT_LT(rtt, base::TimeDelta::Max());
   EXPECT_GT(kbps, 0);
 
   // Verify that histograms are not populated. They should populate only when
   // there is a change in ConnectionType.
   base::HistogramTester histogram_tester;
   histogram_tester.ExpectTotalCount("NQE.PeakKbps.Unknown", 0);
   histogram_tester.ExpectTotalCount("NQE.FastestRTT.Unknown", 0);
 
   NetworkChangeNotifier::NotifyObserversOfConnectionTypeChangeForTests(
       NetworkChangeNotifier::ConnectionType::CONNECTION_WIFI);
   base::MessageLoop::current()->RunUntilIdle();
   histogram_tester.ExpectTotalCount("NQE.PeakKbps.Unknown", 1);
   histogram_tester.ExpectTotalCount("NQE.FastestRTT.Unknown", 1);
 }
 
 TEST_F(URLRequestTestHTTP, RedirectLoadTiming) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
 
-  GURL destination_url = test_server_.GetURL(std::string());
+  GURL destination_url = http_test_server()->GetURL("/");
   GURL original_url =
-      test_server_.GetURL("server-redirect?" + destination_url.spec());
+      http_test_server()->GetURL("/server-redirect?" + destination_url.spec());
   TestDelegate d;
   scoped_ptr<URLRequest> req(
       default_context_.CreateRequest(original_url, DEFAULT_PRIORITY, &d));
   req->Start();
   base::RunLoop().Run();
 
   EXPECT_EQ(1, d.response_started_count());
   EXPECT_EQ(1, d.received_redirect_count());
   EXPECT_EQ(destination_url, req->url());
   EXPECT_EQ(original_url, req->original_url());
@@ skipping 14 matching lines @@
   // Check that a new socket was used on redirect, since the server does not
   // supposed keep-alive sockets, and that the times before the redirect are
   // before the ones recorded for the second request.
   EXPECT_NE(load_timing_info_before_redirect.socket_log_id,
             load_timing_info.socket_log_id);
   EXPECT_LE(load_timing_info_before_redirect.receive_headers_end,
             load_timing_info.connect_timing.connect_start);
 }
 
 TEST_F(URLRequestTestHTTP, MultipleRedirectTest) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
 
-  GURL destination_url = test_server_.GetURL(std::string());
+  GURL destination_url = http_test_server()->GetURL("/");
   GURL middle_redirect_url =
-      test_server_.GetURL("server-redirect?" + destination_url.spec());
-  GURL original_url = test_server_.GetURL(
-      "server-redirect?" + middle_redirect_url.spec());
+      http_test_server()->GetURL("/server-redirect?" + destination_url.spec());
+  GURL original_url = http_test_server()->GetURL("/server-redirect?" +
+                                                 middle_redirect_url.spec());
   TestDelegate d;
   scoped_ptr<URLRequest> req(
       default_context_.CreateRequest(original_url, DEFAULT_PRIORITY, &d));
   req->Start();
   base::RunLoop().Run();
 
   EXPECT_EQ(1, d.response_started_count());
   EXPECT_EQ(2, d.received_redirect_count());
   EXPECT_EQ(destination_url, req->url());
   EXPECT_EQ(original_url, req->original_url());
@@ skipping 300 matching lines @@
     TestDelegate::OnReadCompleted(request, bytes_read);
   }
 
   const CancelStage cancel_stage_;
 
   DISALLOW_COPY_AND_ASSIGN(AsyncLoggingUrlRequestDelegate);
 };
 
 // Tests handling of delegate info before a request starts.
 TEST_F(URLRequestTestHTTP, DelegateInfoBeforeStart) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
 
   TestDelegate request_delegate;
   TestURLRequestContext context(true);
   context.set_network_delegate(NULL);
   context.set_net_log(&net_log_);
   context.Init();
 
   {
     scoped_ptr<URLRequest> r(
-        context.CreateRequest(test_server_.GetURL("empty.html"),
+        context.CreateRequest(http_test_server()->GetURL("/defaultresponse"),
                               DEFAULT_PRIORITY, &request_delegate));
     LoadStateWithParam load_state = r->GetLoadState();
     EXPECT_EQ(LOAD_STATE_IDLE, load_state.state);
     EXPECT_EQ(base::string16(), load_state.param);
 
     AsyncDelegateLogger::Run(
         r.get(),
         LOAD_STATE_WAITING_FOR_DELEGATE,
         LOAD_STATE_WAITING_FOR_DELEGATE,
         LOAD_STATE_IDLE,
@@ skipping 15 matching lines @@
 
   log_position = AsyncDelegateLogger::CheckDelegateInfo(entries, log_position);
 
   // Nothing else should add any delegate info to the request.
   EXPECT_FALSE(LogContainsEntryWithTypeAfter(
       entries, log_position + 1, NetLog::TYPE_DELEGATE_INFO));
 }
 
 // Tests handling of delegate info from a network delegate.
 TEST_F(URLRequestTestHTTP, NetworkDelegateInfo) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
 
   TestDelegate request_delegate;
   AsyncLoggingNetworkDelegate network_delegate;
   TestURLRequestContext context(true);
   context.set_network_delegate(&network_delegate);
   context.set_net_log(&net_log_);
   context.Init();
 
   {
     scoped_ptr<URLRequest> r(
-        context.CreateRequest(test_server_.GetURL("simple.html"),
+        context.CreateRequest(http_test_server()->GetURL("/simple.html"),
                               DEFAULT_PRIORITY, &request_delegate));
     LoadStateWithParam load_state = r->GetLoadState();
     EXPECT_EQ(LOAD_STATE_IDLE, load_state.state);
     EXPECT_EQ(base::string16(), load_state.param);
 
     r->Start();
     base::RunLoop().Run();
 
     EXPECT_EQ(200, r->GetResponseCode());
     EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
@@ skipping 25 matching lines @@
     }
   }
 
   EXPECT_FALSE(LogContainsEntryWithTypeAfter(
       entries, log_position + 1, NetLog::TYPE_DELEGATE_INFO));
 }
 
 // Tests handling of delegate info from a network delegate in the case of an
 // HTTP redirect.
 TEST_F(URLRequestTestHTTP, NetworkDelegateInfoRedirect) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
 
   TestDelegate request_delegate;
   AsyncLoggingNetworkDelegate network_delegate;
   TestURLRequestContext context(true);
   context.set_network_delegate(&network_delegate);
   context.set_net_log(&net_log_);
   context.Init();
 
   {
     scoped_ptr<URLRequest> r(context.CreateRequest(
-        test_server_.GetURL("server-redirect?simple.html"), DEFAULT_PRIORITY,
-        &request_delegate));
+        http_test_server()->GetURL("/server-redirect?simple.html"),
+        DEFAULT_PRIORITY, &request_delegate));
     LoadStateWithParam load_state = r->GetLoadState();
     EXPECT_EQ(LOAD_STATE_IDLE, load_state.state);
     EXPECT_EQ(base::string16(), load_state.param);
 
     r->Start();
     base::RunLoop().Run();
 
     EXPECT_EQ(200, r->GetResponseCode());
     EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
     EXPECT_EQ(2, network_delegate.created_requests());
@@ skipping 49 matching lines @@
     EXPECT_EQ(NetLog::PHASE_END, entries[log_position].phase);
   }
 
   EXPECT_FALSE(LogContainsEntryWithTypeAfter(
       entries, log_position + 1, NetLog::TYPE_DELEGATE_INFO));
 }
 
 // Tests handling of delegate info from a network delegate in the case of HTTP
 // AUTH.
 TEST_F(URLRequestTestHTTP, NetworkDelegateInfoAuth) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
 
   TestDelegate request_delegate;
   AsyncLoggingNetworkDelegate network_delegate;
   TestURLRequestContext context(true);
   context.set_network_delegate(&network_delegate);
   context.set_net_log(&net_log_);
   context.Init();
 
   {
     scoped_ptr<URLRequest> r(
-        context.CreateRequest(test_server_.GetURL("auth-basic"),
+        context.CreateRequest(http_test_server()->GetURL("/auth-basic"),
                               DEFAULT_PRIORITY, &request_delegate));
     LoadStateWithParam load_state = r->GetLoadState();
     EXPECT_EQ(LOAD_STATE_IDLE, load_state.state);
     EXPECT_EQ(base::string16(), load_state.param);
 
     r->Start();
     base::RunLoop().Run();
 
     EXPECT_EQ(200, r->GetResponseCode());
     EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
@@ skipping 25 matching lines @@
     if (i == 1) {
       log_position = AsyncDelegateLogger::ExpectBeforeNetworkEvents(
           entries, log_position + 1);
     }
   }
 
   EXPECT_FALSE(LogContainsEntryWithTypeAfter(
       entries, log_position + 1, NetLog::TYPE_DELEGATE_INFO));
 }
 
+// TODO(droger): Support SpawnedTestServer on iOS (see http://crbug.com/148666).
+#if !defined(OS_IOS)
 // Tests handling of delegate info from a URLRequest::Delegate.
 TEST_F(URLRequestTestHTTP, URLRequestDelegateInfo) {
-  ASSERT_TRUE(test_server_.Start());
+  SpawnedTestServer test_server(SpawnedTestServer::TYPE_HTTP,
+                                SpawnedTestServer::kLocalhost,
+                                base::FilePath(kTestFilePath));
+
+  ASSERT_TRUE(test_server.Start());
 
   AsyncLoggingUrlRequestDelegate request_delegate(
       AsyncLoggingUrlRequestDelegate::NO_CANCEL);
   TestURLRequestContext context(true);
   context.set_network_delegate(NULL);
   context.set_net_log(&net_log_);
   context.Init();
 
   {
     // A chunked response with delays between chunks is used to make sure that
     // attempts by the URLRequest delegate to log information while reading the
     // body are ignored.  Since they are ignored, this test is robust against
     // the possibility of multiple reads being combined in the unlikely event
     // that it occurs.
     scoped_ptr<URLRequest> r(context.CreateRequest(
-        test_server_.GetURL("chunked?waitBetweenChunks=20"), DEFAULT_PRIORITY,
+        test_server.GetURL("/chunked?waitBetweenChunks=20"), DEFAULT_PRIORITY,
         &request_delegate));
     LoadStateWithParam load_state = r->GetLoadState();
     r->Start();
     base::RunLoop().Run();
 
     EXPECT_EQ(200, r->GetResponseCode());
     EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
   }
 
   TestNetLogEntry::List entries;
@@ skipping 17 matching lines @@
 
   ASSERT_LT(log_position, entries.size());
   EXPECT_EQ(NetLog::TYPE_URL_REQUEST_DELEGATE, entries[log_position].type);
   EXPECT_EQ(NetLog::PHASE_END, entries[log_position].phase);
 
   EXPECT_FALSE(LogContainsEntryWithTypeAfter(
       entries, log_position + 1, NetLog::TYPE_DELEGATE_INFO));
   EXPECT_FALSE(LogContainsEntryWithTypeAfter(
       entries, log_position + 1, NetLog::TYPE_URL_REQUEST_DELEGATE));
 }
+#endif  // !defined(OS_IOS)
 
 // Tests handling of delegate info from a URLRequest::Delegate in the case of
 // an HTTP redirect.
 TEST_F(URLRequestTestHTTP, URLRequestDelegateInfoOnRedirect) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
 
   AsyncLoggingUrlRequestDelegate request_delegate(
       AsyncLoggingUrlRequestDelegate::NO_CANCEL);
   TestURLRequestContext context(true);
   context.set_network_delegate(NULL);
   context.set_net_log(&net_log_);
   context.Init();
 
   {
     scoped_ptr<URLRequest> r(context.CreateRequest(
-        test_server_.GetURL("server-redirect?simple.html"), DEFAULT_PRIORITY,
-        &request_delegate));
+        http_test_server()->GetURL("/server-redirect?simple.html"),
+        DEFAULT_PRIORITY, &request_delegate));
     LoadStateWithParam load_state = r->GetLoadState();
     r->Start();
     base::RunLoop().Run();
 
     EXPECT_EQ(200, r->GetResponseCode());
     EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
   }
 
   TestNetLogEntry::List entries;
   net_log_.GetEntries(&entries);
@@ skipping 23 matching lines @@
 
   EXPECT_FALSE(LogContainsEntryWithTypeAfter(
       entries, log_position + 1, NetLog::TYPE_DELEGATE_INFO));
   EXPECT_FALSE(LogContainsEntryWithTypeAfter(
       entries, log_position + 1, NetLog::TYPE_URL_REQUEST_DELEGATE));
 }
 
 // Tests handling of delegate info from a URLRequest::Delegate in the case of
 // an HTTP redirect, with cancellation at various points.
 TEST_F(URLRequestTestHTTP, URLRequestDelegateOnRedirectCancelled) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
 
   const AsyncLoggingUrlRequestDelegate::CancelStage kCancelStages[] = {
     AsyncLoggingUrlRequestDelegate::CANCEL_ON_RECEIVED_REDIRECT,
     AsyncLoggingUrlRequestDelegate::CANCEL_ON_RESPONSE_STARTED,
     AsyncLoggingUrlRequestDelegate::CANCEL_ON_READ_COMPLETED,
   };
 
   for (size_t test_case = 0; test_case < arraysize(kCancelStages);
        ++test_case) {
     AsyncLoggingUrlRequestDelegate request_delegate(kCancelStages[test_case]);
     TestURLRequestContext context(true);
     TestNetLog net_log;
     context.set_network_delegate(NULL);
     context.set_net_log(&net_log);
     context.Init();
 
     {
       scoped_ptr<URLRequest> r(context.CreateRequest(
-          test_server_.GetURL("server-redirect?simple.html"), DEFAULT_PRIORITY,
-          &request_delegate));
+          http_test_server()->GetURL("/server-redirect?simple.html"),
+          DEFAULT_PRIORITY, &request_delegate));
       LoadStateWithParam load_state = r->GetLoadState();
       r->Start();
       base::RunLoop().Run();
       EXPECT_EQ(URLRequestStatus::CANCELED, r->status().status());
     }
 
     TestNetLogEntry::List entries;
     net_log.GetEntries(&entries);
 
     // Delegate info is always logged in both OnReceivedRedirect and
@@ skipping 38 matching lines @@
                           const RedirectInfo& redirect_info,
                           bool* defer_redirect) override {
     TestDelegate::OnReceivedRedirect(request, redirect_info, defer_redirect);
     request->SetExtraRequestHeaderByName(kExtraHeader, kExtraValue, false);
   }
 };
 
 }  // namespace
 
 TEST_F(URLRequestTestHTTP, RedirectWithAdditionalHeadersTest) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
 
-  GURL destination_url = test_server_.GetURL(
-      "echoheader?" + std::string(kExtraHeader));
-  GURL original_url = test_server_.GetURL(
-      "server-redirect?" + destination_url.spec());
+  GURL destination_url =
+      http_test_server()->GetURL("/echoheader?" + std::string(kExtraHeader));
+  GURL original_url =
+      http_test_server()->GetURL("/server-redirect?" + destination_url.spec());
   RedirectWithAdditionalHeadersDelegate d;
   scoped_ptr<URLRequest> req(
       default_context_.CreateRequest(original_url, DEFAULT_PRIORITY, &d));
   req->Start();
   base::RunLoop().Run();
 
   std::string value;
   const HttpRequestHeaders& headers = req->extra_request_headers();
   EXPECT_TRUE(headers.GetHeader(kExtraHeader, &value));
   EXPECT_EQ(kExtraValue, value);
@@ skipping 11 matching lines @@
                           const RedirectInfo& redirect_info,
                           bool* defer_redirect) override {
     TestDelegate::OnReceivedRedirect(request, redirect_info, defer_redirect);
     request->RemoveRequestHeaderByName(kExtraHeaderToRemove);
   }
 };
 
 }  // namespace
 
 TEST_F(URLRequestTestHTTP, RedirectWithHeaderRemovalTest) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
 
-  GURL destination_url = test_server_.GetURL(
-      "echoheader?" + std::string(kExtraHeaderToRemove));
-  GURL original_url = test_server_.GetURL(
-      "server-redirect?" + destination_url.spec());
+  GURL destination_url = http_test_server()->GetURL(
+      "/echoheader?" + std::string(kExtraHeaderToRemove));
+  GURL original_url =
+      http_test_server()->GetURL("/server-redirect?" + destination_url.spec());
   RedirectWithHeaderRemovalDelegate d;
   scoped_ptr<URLRequest> req(
       default_context_.CreateRequest(original_url, DEFAULT_PRIORITY, &d));
   req->SetExtraRequestHeaderByName(kExtraHeaderToRemove, "dummy", false);
   req->Start();
   base::RunLoop().Run();
 
   std::string value;
   const HttpRequestHeaders& headers = req->extra_request_headers();
   EXPECT_FALSE(headers.GetHeader(kExtraHeaderToRemove, &value));
@@ skipping 17 matching lines @@
 
     // We expect to receive OnResponseStarted even though the request has been
     // cancelled.
     EXPECT_EQ(1, d.response_started_count());
     EXPECT_EQ(0, d.bytes_received());
     EXPECT_FALSE(d.received_data_before_response());
   }
 }
 
 TEST_F(URLRequestTestHTTP, CancelTest2) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
 
   TestDelegate d;
   {
     scoped_ptr<URLRequest> r(default_context_.CreateRequest(
-        test_server_.GetURL(std::string()), DEFAULT_PRIORITY, &d));
+        http_test_server()->GetURL("/"), DEFAULT_PRIORITY, &d));
 
     d.set_cancel_in_response_started(true);
 
     r->Start();
     EXPECT_TRUE(r->is_pending());
 
     base::RunLoop().Run();
 
     EXPECT_EQ(1, d.response_started_count());
     EXPECT_EQ(0, d.bytes_received());
     EXPECT_FALSE(d.received_data_before_response());
     EXPECT_EQ(URLRequestStatus::CANCELED, r->status().status());
   }
 }
 
 TEST_F(URLRequestTestHTTP, CancelTest3) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
 
   TestDelegate d;
   {
     scoped_ptr<URLRequest> r(default_context_.CreateRequest(
-        test_server_.GetURL(std::string()), DEFAULT_PRIORITY, &d));
+        http_test_server()->GetURL("/"), DEFAULT_PRIORITY, &d));
 
     d.set_cancel_in_received_data(true);
 
     r->Start();
     EXPECT_TRUE(r->is_pending());
 
     base::RunLoop().Run();
 
     EXPECT_EQ(1, d.response_started_count());
     // There is no guarantee about how much data was received
     // before the cancel was issued.  It could have been 0 bytes,
     // or it could have been all the bytes.
     // EXPECT_EQ(0, d.bytes_received());
     EXPECT_FALSE(d.received_data_before_response());
     EXPECT_EQ(URLRequestStatus::CANCELED, r->status().status());
   }
 }
 
 TEST_F(URLRequestTestHTTP, CancelTest4) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
 
   TestDelegate d;
   {
     scoped_ptr<URLRequest> r(default_context_.CreateRequest(
-        test_server_.GetURL(std::string()), DEFAULT_PRIORITY, &d));
+        http_test_server()->GetURL("/"), DEFAULT_PRIORITY, &d));
 
     r->Start();
     EXPECT_TRUE(r->is_pending());
 
     // The request will be implicitly canceled when it is destroyed. The
     // test delegate must not post a quit message when this happens because
     // this test doesn't actually have a message loop. The quit message would
     // get put on this thread's message queue and the next test would exit
     // early, causing problems.
     d.set_quit_on_complete(false);
   }
   // expect things to just cleanup properly.
 
   // we won't actually get a received reponse here because we've never run the
   // message loop
   EXPECT_FALSE(d.received_data_before_response());
   EXPECT_EQ(0, d.bytes_received());
 }
 
 TEST_F(URLRequestTestHTTP, CancelTest5) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
 
   // populate cache
   {
     TestDelegate d;
     scoped_ptr<URLRequest> r(default_context_.CreateRequest(
-        test_server_.GetURL("cachetime"), DEFAULT_PRIORITY, &d));
+        http_test_server()->GetURL("/cachetime"), DEFAULT_PRIORITY, &d));
     r->Start();
     base::RunLoop().Run();
     EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
   }
 
   // cancel read from cache (see bug 990242)
   {
     TestDelegate d;
     scoped_ptr<URLRequest> r(default_context_.CreateRequest(
-        test_server_.GetURL("cachetime"), DEFAULT_PRIORITY, &d));
+        http_test_server()->GetURL("/cachetime"), DEFAULT_PRIORITY, &d));
     r->Start();
     r->Cancel();
     base::RunLoop().Run();
 
     EXPECT_EQ(URLRequestStatus::CANCELED, r->status().status());
     EXPECT_EQ(1, d.response_started_count());
     EXPECT_EQ(0, d.bytes_received());
     EXPECT_FALSE(d.received_data_before_response());
   }
 }
 
 TEST_F(URLRequestTestHTTP, PostTest) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
   HTTPUploadDataOperationTest("POST");
 }
 
 TEST_F(URLRequestTestHTTP, PutTest) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
   HTTPUploadDataOperationTest("PUT");
 }
 
 TEST_F(URLRequestTestHTTP, PostEmptyTest) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
 
   TestDelegate d;
   {
     scoped_ptr<URLRequest> r(default_context_.CreateRequest(
-        test_server_.GetURL("echo"), DEFAULT_PRIORITY, &d));
+        http_test_server()->GetURL("/echo"), DEFAULT_PRIORITY, &d));
     r->set_method("POST");
 
     r->Start();
     EXPECT_TRUE(r->is_pending());
 
     base::RunLoop().Run();
 
     ASSERT_EQ(1, d.response_started_count())
         << "request failed: " << r->status().status()
         << ", error: " << r->status().error();
 
     EXPECT_FALSE(d.received_data_before_response());
     EXPECT_TRUE(d.data_received().empty());
   }
 }
 
 TEST_F(URLRequestTestHTTP, PostFileTest) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
 
   TestDelegate d;
   {
     scoped_ptr<URLRequest> r(default_context_.CreateRequest(
-        test_server_.GetURL("echo"), DEFAULT_PRIORITY, &d));
+        http_test_server()->GetURL("/echo"), DEFAULT_PRIORITY, &d));
     r->set_method("POST");
 
     base::FilePath dir;
     PathService::Get(base::DIR_EXE, &dir);
     base::SetCurrentDirectory(dir);
 
     ScopedVector<UploadElementReader> element_readers;
 
     base::FilePath path;
     PathService::Get(base::DIR_SOURCE_ROOT, &path);
@@ skipping 23 matching lines @@
         << ", error: " << r->status().error();
 
     EXPECT_FALSE(d.received_data_before_response());
 
     EXPECT_EQ(size, d.bytes_received());
     EXPECT_EQ(std::string(&buf[0], size), d.data_received());
   }
 }
 
 TEST_F(URLRequestTestHTTP, PostUnreadableFileTest) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
 
   TestDelegate d;
   {
     scoped_ptr<URLRequest> r(default_context_.CreateRequest(
-        test_server_.GetURL("echo"), DEFAULT_PRIORITY, &d));
+        http_test_server()->GetURL("/echo"), DEFAULT_PRIORITY, &d));
     r->set_method("POST");
 
     ScopedVector<UploadElementReader> element_readers;
 
     element_readers.push_back(new UploadFileElementReader(
         base::ThreadTaskRunnerHandle::Get().get(),
         base::FilePath(FILE_PATH_LITERAL(
             "c:\\path\\to\\non\\existant\\file.randomness.12345")),
         0, kuint64max, base::Time()));
     r->set_upload(make_scoped_ptr<UploadDataStream>(
         new ElementsUploadDataStream(element_readers.Pass(), 0)));
 
     r->Start();
     EXPECT_TRUE(r->is_pending());
 
     base::RunLoop().Run();
 
     EXPECT_TRUE(d.request_failed());
     EXPECT_FALSE(d.received_data_before_response());
     EXPECT_EQ(0, d.bytes_received());
     EXPECT_EQ(URLRequestStatus::FAILED, r->status().status());
     EXPECT_EQ(ERR_FILE_NOT_FOUND, r->status().error());
   }
 }
 
 TEST_F(URLRequestTestHTTP, TestPostChunkedDataBeforeStart) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
 
   TestDelegate d;
   {
     scoped_ptr<URLRequest> r(default_context_.CreateRequest(
-        test_server_.GetURL("echo"), DEFAULT_PRIORITY, &d));
+        http_test_server()->GetURL("/echo"), DEFAULT_PRIORITY, &d));
     r->EnableChunkedUpload();
     r->set_method("POST");
     AddChunksToUpload(r.get());
     r->Start();
     EXPECT_TRUE(r->is_pending());
 
     base::RunLoop().Run();
 
     VerifyReceivedDataMatchesChunks(r.get(), &d);
   }
 }
 
 TEST_F(URLRequestTestHTTP, TestPostChunkedDataJustAfterStart) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
 
   TestDelegate d;
   {
     scoped_ptr<URLRequest> r(default_context_.CreateRequest(
-        test_server_.GetURL("echo"), DEFAULT_PRIORITY, &d));
+        http_test_server()->GetURL("/echo"), DEFAULT_PRIORITY, &d));
     r->EnableChunkedUpload();
     r->set_method("POST");
     r->Start();
     EXPECT_TRUE(r->is_pending());
     AddChunksToUpload(r.get());
     base::RunLoop().Run();
 
     VerifyReceivedDataMatchesChunks(r.get(), &d);
   }
 }
 
 TEST_F(URLRequestTestHTTP, TestPostChunkedDataAfterStart) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
 
   TestDelegate d;
   {
     scoped_ptr<URLRequest> r(default_context_.CreateRequest(
-        test_server_.GetURL("echo"), DEFAULT_PRIORITY, &d));
+        http_test_server()->GetURL("/echo"), DEFAULT_PRIORITY, &d));
     r->EnableChunkedUpload();
     r->set_method("POST");
     r->Start();
     EXPECT_TRUE(r->is_pending());
 
     base::RunLoop().RunUntilIdle();
     AddChunksToUpload(r.get());
     base::RunLoop().Run();
 
     VerifyReceivedDataMatchesChunks(r.get(), &d);
   }
 }
 
 TEST_F(URLRequestTestHTTP, ResponseHeadersTest) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
 
   TestDelegate d;
   scoped_ptr<URLRequest> req(default_context_.CreateRequest(
-      test_server_.GetURL("files/with-headers.html"), DEFAULT_PRIORITY, &d));
+      http_test_server()->GetURL("/with-headers.html"), DEFAULT_PRIORITY, &d));
   req->Start();
   base::RunLoop().Run();
 
   const HttpResponseHeaders* headers = req->response_headers();
 
   // Simple sanity check that response_info() accesses the same data.
   EXPECT_EQ(headers, req->response_info().headers.get());
 
   std::string header;
   EXPECT_TRUE(headers->GetNormalizedHeader("cache-control", &header));
   EXPECT_EQ("private", header);
 
   header.clear();
   EXPECT_TRUE(headers->GetNormalizedHeader("content-type", &header));
   EXPECT_EQ("text/html; charset=ISO-8859-1", header);
 
   // The response has two "X-Multiple-Entries" headers.
   // This verfies our output has them concatenated together.
   header.clear();
   EXPECT_TRUE(headers->GetNormalizedHeader("x-multiple-entries", &header));
   EXPECT_EQ("a, b", header);
 }
 
+// TODO(svaldez): iOS tests are flaky with EmbeddedTestServer and transport
+// security state.
+#if !defined(OS_IOS)
+
 TEST_F(URLRequestTestHTTP, ProcessSTS) {
-  SpawnedTestServer::SSLOptions ssl_options(
-      SpawnedTestServer::SSLOptions::CERT_COMMON_NAME_IS_DOMAIN);
-  SpawnedTestServer https_test_server(SpawnedTestServer::TYPE_HTTPS,
-                                      ssl_options,
-                                      base::FilePath(kTestFilePath));
+  EmbeddedTestServer https_test_server(net::EmbeddedTestServer::TYPE_HTTPS);
+  https_test_server.SetSSLConfig(
+      net::EmbeddedTestServer::CERT_COMMON_NAME_IS_DOMAIN);
+  https_test_server.ServeFilesFromSourceDirectory(
+      base::FilePath(kTestFilePath));
   ASSERT_TRUE(https_test_server.Start());
 
-  std::string test_server_hostname = https_test_server.GetURL("").host();
-
+  std::string test_server_hostname = https_test_server.GetURL("/").host();
   TestDelegate d;
   scoped_ptr<URLRequest> request(default_context_.CreateRequest(
-      https_test_server.GetURL("files/hsts-headers.html"), DEFAULT_PRIORITY,
-      &d));
+      https_test_server.GetURL("/hsts-headers.html"), DEFAULT_PRIORITY, &d));
   request->Start();
   base::RunLoop().Run();
 
   TransportSecurityState* security_state =
       default_context_.transport_security_state();
   TransportSecurityState::STSState sts_state;
   TransportSecurityState::PKPState pkp_state;
   EXPECT_TRUE(
       security_state->GetDynamicSTSState(test_server_hostname, &sts_state));
   EXPECT_FALSE(
       security_state->GetDynamicPKPState(test_server_hostname, &pkp_state));
   EXPECT_EQ(TransportSecurityState::STSState::MODE_FORCE_HTTPS,
             sts_state.upgrade_mode);
   EXPECT_TRUE(sts_state.include_subdomains);
   EXPECT_FALSE(pkp_state.include_subdomains);
 #if defined(OS_ANDROID)
   // Android's CertVerifyProc does not (yet) handle pins.
 #else
   EXPECT_FALSE(pkp_state.HasPublicKeyPins());
 #endif
 }
 
 TEST_F(URLRequestTestHTTP, STSNotProcessedOnIP) {
-  SpawnedTestServer https_test_server(SpawnedTestServer::TYPE_HTTPS,
-                                      SpawnedTestServer::SSLOptions(),
-                                      base::FilePath(kTestFilePath));
+  EmbeddedTestServer https_test_server(net::EmbeddedTestServer::TYPE_HTTPS);
+  https_test_server.ServeFilesFromSourceDirectory(
+      base::FilePath(kTestFilePath));
   ASSERT_TRUE(https_test_server.Start());
   // Make sure this test fails if the test server is changed to not
   // listen on an IP by default.
-  ASSERT_TRUE(https_test_server.GetURL("").HostIsIPAddress());
-  std::string test_server_hostname = https_test_server.GetURL("").host();
+  ASSERT_TRUE(https_test_server.GetURL("/").HostIsIPAddress());
+  std::string test_server_hostname = https_test_server.GetURL("/").host();
 
   TestDelegate d;
   scoped_ptr<URLRequest> request(default_context_.CreateRequest(
-      https_test_server.GetURL("files/hsts-headers.html"), DEFAULT_PRIORITY,
-      &d));
+      https_test_server.GetURL("/hsts-headers.html"), DEFAULT_PRIORITY, &d));
   request->Start();
   base::RunLoop().Run();
-
   TransportSecurityState* security_state =
       default_context_.transport_security_state();
   TransportSecurityState::STSState sts_state;
   EXPECT_FALSE(
       security_state->GetDynamicSTSState(test_server_hostname, &sts_state));
 }
 
 // Android's CertVerifyProc does not (yet) handle pins. Therefore, it will
 // reject HPKP headers, and a test setting only HPKP headers will fail (no
 // PKPState present because header rejected).
@@ skipping 12 matching lines @@
 #endif
 
 namespace {
 const char kHPKPReportUri[] = "https://hpkp-report.test";
 }  // namespace
 
 // Tests that enabling HPKP on a domain does not affect the HSTS
 // validity/expiration.
 TEST_F(URLRequestTestHTTP, MAYBE_ProcessPKP) {
   GURL report_uri(kHPKPReportUri);
-  SpawnedTestServer::SSLOptions ssl_options(
-      SpawnedTestServer::SSLOptions::CERT_COMMON_NAME_IS_DOMAIN);
-  SpawnedTestServer https_test_server(SpawnedTestServer::TYPE_HTTPS,
-                                      ssl_options,
-                                      base::FilePath(kTestFilePath));
+  EmbeddedTestServer https_test_server(net::EmbeddedTestServer::TYPE_HTTPS);
+  https_test_server.SetSSLConfig(
+      net::EmbeddedTestServer::CERT_COMMON_NAME_IS_DOMAIN);
+  https_test_server.ServeFilesFromSourceDirectory(
+      base::FilePath(kTestFilePath));
   ASSERT_TRUE(https_test_server.Start());
 
-  std::string test_server_hostname = https_test_server.GetURL("").host();
+  std::string test_server_hostname = https_test_server.GetURL("/").host();
 
   TestDelegate d;
   scoped_ptr<URLRequest> request(default_context_.CreateRequest(
-      https_test_server.GetURL("files/hpkp-headers.html"), DEFAULT_PRIORITY,
-      &d));
+      https_test_server.GetURL("/hpkp-headers.html"), DEFAULT_PRIORITY, &d));
   request->Start();
   base::RunLoop().Run();
-
   TransportSecurityState* security_state =
       default_context_.transport_security_state();
   TransportSecurityState::STSState sts_state;
   TransportSecurityState::PKPState pkp_state;
   EXPECT_FALSE(
       security_state->GetDynamicSTSState(test_server_hostname, &sts_state));
   EXPECT_TRUE(
       security_state->GetDynamicPKPState(test_server_hostname, &pkp_state));
   EXPECT_EQ(TransportSecurityState::STSState::MODE_DEFAULT,
             sts_state.upgrade_mode);
   EXPECT_FALSE(sts_state.include_subdomains);
   EXPECT_FALSE(pkp_state.include_subdomains);
   EXPECT_TRUE(pkp_state.HasPublicKeyPins());
   EXPECT_EQ(report_uri, pkp_state.report_uri);
   EXPECT_NE(sts_state.expiry, pkp_state.expiry);
 }
 
 // Tests that reports get sent on HPKP violations when a report-uri is set.
 TEST_F(URLRequestTestHTTP, MAYBE_ProcessPKPAndSendReport) {
   GURL report_uri(kHPKPReportUri);
-  SpawnedTestServer::SSLOptions ssl_options(
-      SpawnedTestServer::SSLOptions::CERT_COMMON_NAME_IS_DOMAIN);
-  SpawnedTestServer https_test_server(SpawnedTestServer::TYPE_HTTPS,
-                                      ssl_options,
-                                      base::FilePath(kTestFilePath));
-
+  EmbeddedTestServer https_test_server(net::EmbeddedTestServer::TYPE_HTTPS);
+  https_test_server.SetSSLConfig(
+      net::EmbeddedTestServer::CERT_COMMON_NAME_IS_DOMAIN);
+  https_test_server.ServeFilesFromSourceDirectory(
+      base::FilePath(kTestFilePath));
   ASSERT_TRUE(https_test_server.Start());
 
-  std::string test_server_hostname = https_test_server.GetURL("").host();
+  std::string test_server_hostname = https_test_server.GetURL("/").host();
 
   // Set up a pin for |test_server_hostname|.
   TransportSecurityState security_state;
   const base::Time current_time(base::Time::Now());
   const base::Time expiry = current_time + base::TimeDelta::FromSeconds(1000);
   HashValueVector hashes;
   HashValue hash1;
   HashValue hash2;
   // The values here don't matter, as long as they are different from
   // the mocked CertVerifyResult below.
@@ skipping 28 matching lines @@
   TestNetworkDelegate network_delegate;
   TestURLRequestContext context(true);
   context.set_transport_security_state(&security_state);
   context.set_network_delegate(&network_delegate);
   context.set_cert_verifier(&cert_verifier);
   context.Init();
 
   // Now send a request to trigger the violation.
   TestDelegate d;
   scoped_ptr<URLRequest> violating_request(context.CreateRequest(
-      https_test_server.GetURL("files/simple.html"), DEFAULT_PRIORITY, &d));
+      https_test_server.GetURL("/simple.html"), DEFAULT_PRIORITY, &d));
   violating_request->Start();
   base::RunLoop().Run();
 
   // Check that a report was sent.
   EXPECT_EQ(report_uri, mock_report_sender.latest_report_uri());
   ASSERT_FALSE(mock_report_sender.latest_report().empty());
   scoped_ptr<base::Value> value(
       base::JSONReader::Read(mock_report_sender.latest_report()));
   ASSERT_TRUE(value);
   ASSERT_TRUE(value->IsType(base::Value::TYPE_DICTIONARY));
   base::DictionaryValue* report_dict;
   ASSERT_TRUE(value->GetAsDictionary(&report_dict));
   std::string report_hostname;
   EXPECT_TRUE(report_dict->GetString("hostname", &report_hostname));
   EXPECT_EQ(test_server_hostname, report_hostname);
 }
 
 // Tests that reports get sent on requests with
 // Public-Key-Pins-Report-Only headers.
 TEST_F(URLRequestTestHTTP, MAYBE_ProcessPKPReportOnly) {
   GURL report_uri(kHPKPReportUri);
-  SpawnedTestServer::SSLOptions ssl_options(
-      SpawnedTestServer::SSLOptions::CERT_COMMON_NAME_IS_DOMAIN);
-  SpawnedTestServer https_test_server(SpawnedTestServer::TYPE_HTTPS,
-                                      ssl_options,
-                                      base::FilePath(kTestFilePath));
-
+  EmbeddedTestServer https_test_server(net::EmbeddedTestServer::TYPE_HTTPS);
+  https_test_server.SetSSLConfig(
+      net::EmbeddedTestServer::CERT_COMMON_NAME_IS_DOMAIN);
+  https_test_server.ServeFilesFromSourceDirectory(
+      base::FilePath(kTestFilePath));
   ASSERT_TRUE(https_test_server.Start());
 
-  std::string test_server_hostname = https_test_server.GetURL("").host();
+  std::string test_server_hostname = https_test_server.GetURL("/").host();
 
   TransportSecurityState security_state;
   MockCertificateReportSender mock_report_sender;
   security_state.SetReportSender(&mock_report_sender);
 
   // Set up a MockCertVerifier to violate the pin in the Report-Only
   // header.
   scoped_refptr<X509Certificate> cert = https_test_server.GetCertificate();
   ASSERT_TRUE(cert);
 
@@ skipping 12 matching lines @@
   TestNetworkDelegate network_delegate;
   TestURLRequestContext context(true);
   context.set_transport_security_state(&security_state);
   context.set_network_delegate(&network_delegate);
   context.set_cert_verifier(&cert_verifier);
   context.Init();
 
   // Now send a request to trigger the violation.
   TestDelegate d;
   scoped_ptr<URLRequest> violating_request(context.CreateRequest(
-      https_test_server.GetURL("files/hpkp-headers-report-only.html"),
+      https_test_server.GetURL("/hpkp-headers-report-only.html"),
       DEFAULT_PRIORITY, &d));
   violating_request->Start();
   base::RunLoop().Run();
 
   // Check that a report was sent.
   EXPECT_EQ(report_uri, mock_report_sender.latest_report_uri());
   ASSERT_FALSE(mock_report_sender.latest_report().empty());
   scoped_ptr<base::Value> value(
       base::JSONReader::Read(mock_report_sender.latest_report()));
   ASSERT_TRUE(value);
   ASSERT_TRUE(value->IsType(base::Value::TYPE_DICTIONARY));
   base::DictionaryValue* report_dict;
   ASSERT_TRUE(value->GetAsDictionary(&report_dict));
   std::string report_hostname;
   EXPECT_TRUE(report_dict->GetString("hostname", &report_hostname));
   EXPECT_EQ(test_server_hostname, report_hostname);
 }
 
 // Tests that reports do not get sent on requests with
 // Public-Key-Pins-Report-Only headers that don't have pin violations.
 TEST_F(URLRequestTestHTTP, MAYBE_ProcessPKPReportOnlyWithNoViolation) {
   GURL report_uri(kHPKPReportUri);
-  SpawnedTestServer::SSLOptions ssl_options(
-      SpawnedTestServer::SSLOptions::CERT_COMMON_NAME_IS_DOMAIN);
-  SpawnedTestServer https_test_server(SpawnedTestServer::TYPE_HTTPS,
-                                      ssl_options,
-                                      base::FilePath(kTestFilePath));
-
+  EmbeddedTestServer https_test_server(net::EmbeddedTestServer::TYPE_HTTPS);
+  https_test_server.SetSSLConfig(
+      net::EmbeddedTestServer::CERT_COMMON_NAME_IS_DOMAIN);
+  https_test_server.ServeFilesFromSourceDirectory(
+      base::FilePath(kTestFilePath));
   ASSERT_TRUE(https_test_server.Start());
 
-  std::string test_server_hostname = https_test_server.GetURL("").host();
+  std::string test_server_hostname = https_test_server.GetURL("/").host();
 
   TransportSecurityState security_state;
   MockCertificateReportSender mock_report_sender;
   security_state.SetReportSender(&mock_report_sender);
 
   TestNetworkDelegate network_delegate;
   MockCertVerifier mock_cert_verifier;
   TestURLRequestContext context(true);
   context.set_transport_security_state(&security_state);
   context.set_network_delegate(&network_delegate);
   context.set_cert_verifier(&mock_cert_verifier);
   mock_cert_verifier.set_default_result(OK);
   context.Init();
 
   // Now send a request that does not trigger the violation.
   TestDelegate d;
   scoped_ptr<URLRequest> request(context.CreateRequest(
-      https_test_server.GetURL("files/hpkp-headers-report-only.html"),
+      https_test_server.GetURL("/hpkp-headers-report-only.html"),
       DEFAULT_PRIORITY, &d));
   request->Start();
   base::RunLoop().Run();
 
   // Check that a report was not sent.
   EXPECT_EQ(GURL(), mock_report_sender.latest_report_uri());
   EXPECT_EQ(std::string(), mock_report_sender.latest_report());
 }
 
 TEST_F(URLRequestTestHTTP, PKPNotProcessedOnIP) {
-  SpawnedTestServer https_test_server(SpawnedTestServer::TYPE_HTTPS,
-                                      SpawnedTestServer::SSLOptions(),
-                                      base::FilePath(kTestFilePath));
+  EmbeddedTestServer https_test_server(net::EmbeddedTestServer::TYPE_HTTPS);
+  https_test_server.ServeFilesFromSourceDirectory(
+      base::FilePath(kTestFilePath));
   ASSERT_TRUE(https_test_server.Start());
   // Make sure this test fails if the test server is changed to not
   // listen on an IP by default.
-  ASSERT_TRUE(https_test_server.GetURL("").HostIsIPAddress());
-  std::string test_server_hostname = https_test_server.GetURL("").host();
+  ASSERT_TRUE(https_test_server.GetURL("/").HostIsIPAddress());
+  std::string test_server_hostname = https_test_server.GetURL("/").host();
 
   TestDelegate d;
   scoped_ptr<URLRequest> request(default_context_.CreateRequest(
-      https_test_server.GetURL("files/hpkp-headers.html"), DEFAULT_PRIORITY,
-      &d));
+      https_test_server.GetURL("/hpkp-headers.html"), DEFAULT_PRIORITY, &d));
   request->Start();
   base::RunLoop().Run();
 
   TransportSecurityState* security_state =
       default_context_.transport_security_state();
   TransportSecurityState::PKPState pkp_state;
   EXPECT_FALSE(
       security_state->GetDynamicPKPState(test_server_hostname, &pkp_state));
 }
 
 TEST_F(URLRequestTestHTTP, ProcessSTSOnce) {
-  SpawnedTestServer::SSLOptions ssl_options(
-      SpawnedTestServer::SSLOptions::CERT_COMMON_NAME_IS_DOMAIN);
-  SpawnedTestServer https_test_server(SpawnedTestServer::TYPE_HTTPS,
-                                      ssl_options,
-                                      base::FilePath(kTestFilePath));
+  EmbeddedTestServer https_test_server(net::EmbeddedTestServer::TYPE_HTTPS);
+  https_test_server.SetSSLConfig(
+      net::EmbeddedTestServer::CERT_COMMON_NAME_IS_DOMAIN);
+  https_test_server.ServeFilesFromSourceDirectory(
+      base::FilePath(kTestFilePath));
   ASSERT_TRUE(https_test_server.Start());
 
-  std::string test_server_hostname = https_test_server.GetURL("").host();
+  std::string test_server_hostname = https_test_server.GetURL("/").host();
 
   TestDelegate d;
   scoped_ptr<URLRequest> request(default_context_.CreateRequest(
-      https_test_server.GetURL("files/hsts-multiple-headers.html"),
-      DEFAULT_PRIORITY, &d));
+      https_test_server.GetURL("/hsts-multiple-headers.html"), DEFAULT_PRIORITY,
+      &d));
   request->Start();
   base::RunLoop().Run();
 
   // We should have set parameters from the first header, not the second.
   TransportSecurityState* security_state =
       default_context_.transport_security_state();
   TransportSecurityState::STSState sts_state;
   EXPECT_TRUE(
       security_state->GetDynamicSTSState(test_server_hostname, &sts_state));
   EXPECT_EQ(TransportSecurityState::STSState::MODE_FORCE_HTTPS,
             sts_state.upgrade_mode);
   EXPECT_FALSE(sts_state.include_subdomains);
   EXPECT_FALSE(sts_state.include_subdomains);
 }
 
 TEST_F(URLRequestTestHTTP, ProcessSTSAndPKP) {
-  SpawnedTestServer::SSLOptions ssl_options(
-      SpawnedTestServer::SSLOptions::CERT_COMMON_NAME_IS_DOMAIN);
-  SpawnedTestServer https_test_server(SpawnedTestServer::TYPE_HTTPS,
-                                      ssl_options,
-                                      base::FilePath(kTestFilePath));
+  EmbeddedTestServer https_test_server(net::EmbeddedTestServer::TYPE_HTTPS);
+  https_test_server.SetSSLConfig(
+      net::EmbeddedTestServer::CERT_COMMON_NAME_IS_DOMAIN);
+  https_test_server.ServeFilesFromSourceDirectory(
+      base::FilePath(kTestFilePath));
   ASSERT_TRUE(https_test_server.Start());
 
-  std::string test_server_hostname = https_test_server.GetURL("").host();
+  std::string test_server_hostname = https_test_server.GetURL("/").host();
 
   TestDelegate d;
   scoped_ptr<URLRequest> request(default_context_.CreateRequest(
-      https_test_server.GetURL("files/hsts-and-hpkp-headers.html"),
-      DEFAULT_PRIORITY, &d));
+      https_test_server.GetURL("/hsts-and-hpkp-headers.html"), DEFAULT_PRIORITY,
+      &d));
   request->Start();
   base::RunLoop().Run();
 
   // We should have set parameters from the first header, not the second.
   TransportSecurityState* security_state =
       default_context_.transport_security_state();
   TransportSecurityState::STSState sts_state;
   TransportSecurityState::PKPState pkp_state;
   EXPECT_TRUE(
       security_state->GetDynamicSTSState(test_server_hostname, &sts_state));
@@ skipping 11 matching lines @@
   // Even though there is an HSTS header asserting includeSubdomains, it is
   // the *second* such header, and we MUST process only the first.
   EXPECT_FALSE(sts_state.include_subdomains);
   // includeSubdomains does not occur in the test HPKP header.
   EXPECT_FALSE(pkp_state.include_subdomains);
 }
 
 // Tests that when multiple HPKP headers are present, asserting different
 // policies, that only the first such policy is processed.
 TEST_F(URLRequestTestHTTP, ProcessSTSAndPKP2) {
-  SpawnedTestServer::SSLOptions ssl_options(
-      SpawnedTestServer::SSLOptions::CERT_COMMON_NAME_IS_DOMAIN);
-  SpawnedTestServer https_test_server(SpawnedTestServer::TYPE_HTTPS,
-                                      ssl_options,
-                                      base::FilePath(kTestFilePath));
+  EmbeddedTestServer https_test_server(net::EmbeddedTestServer::TYPE_HTTPS);
+  https_test_server.SetSSLConfig(
+      net::EmbeddedTestServer::CERT_COMMON_NAME_IS_DOMAIN);
+  https_test_server.ServeFilesFromSourceDirectory(
+      base::FilePath(kTestFilePath));
   ASSERT_TRUE(https_test_server.Start());
 
-  std::string test_server_hostname = https_test_server.GetURL("").host();
+  std::string test_server_hostname = https_test_server.GetURL("/").host();
 
   TestDelegate d;
   scoped_ptr<URLRequest> request(default_context_.CreateRequest(
-      https_test_server.GetURL("files/hsts-and-hpkp-headers2.html"),
+      https_test_server.GetURL("/hsts-and-hpkp-headers2.html"),
       DEFAULT_PRIORITY, &d));
   request->Start();
   base::RunLoop().Run();
 
   TransportSecurityState* security_state =
       default_context_.transport_security_state();
   TransportSecurityState::STSState sts_state;
   TransportSecurityState::PKPState pkp_state;
   EXPECT_TRUE(
       security_state->GetDynamicSTSState(test_server_hostname, &sts_state));
   EXPECT_TRUE(
       security_state->GetDynamicPKPState(test_server_hostname, &pkp_state));
   EXPECT_EQ(TransportSecurityState::STSState::MODE_FORCE_HTTPS,
             sts_state.upgrade_mode);
 #if defined(OS_ANDROID)
   // Android's CertVerifyProc does not (yet) handle pins.
 #else
   EXPECT_TRUE(pkp_state.HasPublicKeyPins());
 #endif
   EXPECT_NE(sts_state.expiry, pkp_state.expiry);
 
   EXPECT_TRUE(sts_state.include_subdomains);
   EXPECT_FALSE(pkp_state.include_subdomains);
 }
 
+#endif  // !defined(OS_IOS)
+
 TEST_F(URLRequestTestHTTP, ContentTypeNormalizationTest) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
 
   TestDelegate d;
   scoped_ptr<URLRequest> req(default_context_.CreateRequest(
-      test_server_.GetURL("files/content-type-normalization.html"),
+      http_test_server()->GetURL("/content-type-normalization.html"),
       DEFAULT_PRIORITY, &d));
   req->Start();
   base::RunLoop().Run();
 
   std::string mime_type;
   req->GetMimeType(&mime_type);
   EXPECT_EQ("text/html", mime_type);
 
   std::string charset;
   req->GetCharset(&charset);
@@ skipping 17 matching lines @@
   GURL file_url("file:///foo.txt");
   FileProtocolHandler file_protocol_handler(
       base::ThreadTaskRunnerHandle::Get());
   EXPECT_FALSE(file_protocol_handler.IsSafeRedirectTarget(file_url));
 
   // Test URLRequestJobFactoryImpl::IsSafeRedirectTarget().
   EXPECT_FALSE(job_factory_->IsSafeRedirectTarget(file_url));
 }
 
 TEST_F(URLRequestTestHTTP, RestrictFileRedirects) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
 
   TestDelegate d;
   scoped_ptr<URLRequest> req(default_context_.CreateRequest(
-      test_server_.GetURL("files/redirect-to-file.html"), DEFAULT_PRIORITY,
+      http_test_server()->GetURL("/redirect-to-file.html"), DEFAULT_PRIORITY,
       &d));
   req->Start();
   base::RunLoop().Run();
 
   EXPECT_EQ(URLRequestStatus::FAILED, req->status().status());
   EXPECT_EQ(ERR_UNSAFE_REDIRECT, req->status().error());
 }
 #endif  // !defined(DISABLE_FILE_SUPPORT)
 
 TEST_F(URLRequestTestHTTP, RestrictDataRedirects) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
 
   TestDelegate d;
   scoped_ptr<URLRequest> req(default_context_.CreateRequest(
-      test_server_.GetURL("files/redirect-to-data.html"), DEFAULT_PRIORITY,
+      http_test_server()->GetURL("/redirect-to-data.html"), DEFAULT_PRIORITY,
       &d));
   req->Start();
   base::MessageLoop::current()->Run();
 
   EXPECT_EQ(URLRequestStatus::FAILED, req->status().status());
   EXPECT_EQ(ERR_UNSAFE_REDIRECT, req->status().error());
 }
 
 TEST_F(URLRequestTestHTTP, RedirectToInvalidURL) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
 
   TestDelegate d;
   scoped_ptr<URLRequest> req(default_context_.CreateRequest(
-      test_server_.GetURL("files/redirect-to-invalid-url.html"),
+      http_test_server()->GetURL("/redirect-to-invalid-url.html"),
       DEFAULT_PRIORITY, &d));
   req->Start();
   base::RunLoop().Run();
 
   EXPECT_EQ(URLRequestStatus::FAILED, req->status().status());
   EXPECT_EQ(ERR_INVALID_URL, req->status().error());
 }
 
 // Make sure redirects are cached, despite not reading their bodies.
 TEST_F(URLRequestTestHTTP, CacheRedirect) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
   GURL redirect_url =
-      test_server_.GetURL("files/redirect302-to-echo-cacheable");
+      http_test_server()->GetURL("/redirect302-to-echo-cacheable");
 
   {
     TestDelegate d;
     scoped_ptr<URLRequest> req(
         default_context_.CreateRequest(redirect_url, DEFAULT_PRIORITY, &d));
     req->Start();
     base::RunLoop().Run();
     EXPECT_EQ(URLRequestStatus::SUCCESS, req->status().status());
     EXPECT_EQ(1, d.received_redirect_count());
-    EXPECT_EQ(test_server_.GetURL("echo"), req->url());
+    EXPECT_EQ(http_test_server()->GetURL("/echo"), req->url());
   }
 
   {
     TestDelegate d;
     d.set_quit_on_redirect(true);
     scoped_ptr<URLRequest> req(
         default_context_.CreateRequest(redirect_url, DEFAULT_PRIORITY, &d));
     req->Start();
     base::RunLoop().Run();
 
     EXPECT_EQ(1, d.received_redirect_count());
     EXPECT_EQ(0, d.response_started_count());
     EXPECT_TRUE(req->was_cached());
 
     req->FollowDeferredRedirect();
     base::RunLoop().Run();
     EXPECT_EQ(1, d.received_redirect_count());
     EXPECT_EQ(1, d.response_started_count());
     EXPECT_EQ(URLRequestStatus::SUCCESS, req->status().status());
-    EXPECT_EQ(test_server_.GetURL("echo"), req->url());
+    EXPECT_EQ(http_test_server()->GetURL("/echo"), req->url());
   }
 }
 
 // Make sure a request isn't cached when a NetworkDelegate forces a redirect
 // when the headers are read, since the body won't have been read.
 TEST_F(URLRequestTestHTTP, NoCacheOnNetworkDelegateRedirect) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
   // URL that is normally cached.
-  GURL initial_url = test_server_.GetURL("cachetime");
+  GURL initial_url = http_test_server()->GetURL("/cachetime");
 
   {
     // Set up the TestNetworkDelegate tp force a redirect.
-    GURL redirect_to_url = test_server_.GetURL("echo");
+    GURL redirect_to_url = http_test_server()->GetURL("/echo");
     default_network_delegate_.set_redirect_on_headers_received_url(
         redirect_to_url);
 
     TestDelegate d;
     scoped_ptr<URLRequest> req(
         default_context_.CreateRequest(initial_url, DEFAULT_PRIORITY, &d));
     req->Start();
     base::RunLoop().Run();
     EXPECT_EQ(URLRequestStatus::SUCCESS, req->status().status());
     EXPECT_EQ(1, d.received_redirect_count());
@@ skipping 10 matching lines @@
     EXPECT_EQ(URLRequestStatus::SUCCESS, req->status().status());
     EXPECT_FALSE(req->was_cached());
     EXPECT_EQ(0, d.received_redirect_count());
     EXPECT_EQ(initial_url, req->url());
   }
 }
 
 // Tests that redirection to an unsafe URL is allowed when it has been marked as
 // safe.
 TEST_F(URLRequestTestHTTP, UnsafeRedirectToWhitelistedUnsafeURL) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
 
   GURL unsafe_url("data:text/html,this-is-considered-an-unsafe-url");
   default_network_delegate_.set_redirect_on_headers_received_url(unsafe_url);
   default_network_delegate_.set_allowed_unsafe_redirect_url(unsafe_url);
 
   TestDelegate d;
   {
     scoped_ptr<URLRequest> r(default_context_.CreateRequest(
-        test_server_.GetURL("whatever"), DEFAULT_PRIORITY, &d));
+        http_test_server()->GetURL("/whatever"), DEFAULT_PRIORITY, &d));
 
     r->Start();
     base::RunLoop().Run();
 
     EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
 
     EXPECT_EQ(2U, r->url_chain().size());
     EXPECT_EQ(OK, r->status().error());
     EXPECT_EQ(unsafe_url, r->url());
     EXPECT_EQ("this-is-considered-an-unsafe-url", d.data_received());
   }
 }
 
 // Tests that a redirect to a different unsafe URL is blocked, even after adding
 // some other URL to the whitelist.
 TEST_F(URLRequestTestHTTP, UnsafeRedirectToDifferentUnsafeURL) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
 
   GURL unsafe_url("data:text/html,something");
   GURL different_unsafe_url("data:text/html,something-else");
   default_network_delegate_.set_redirect_on_headers_received_url(unsafe_url);
   default_network_delegate_.set_allowed_unsafe_redirect_url(
       different_unsafe_url);
 
   TestDelegate d;
   {
     scoped_ptr<URLRequest> r(default_context_.CreateRequest(
-        test_server_.GetURL("whatever"), DEFAULT_PRIORITY, &d));
+        http_test_server()->GetURL("/whatever"), DEFAULT_PRIORITY, &d));
 
     r->Start();
     base::RunLoop().Run();
 
     EXPECT_EQ(URLRequestStatus::FAILED, r->status().status());
     EXPECT_EQ(ERR_UNSAFE_REDIRECT, r->status().error());
   }
 }
 
 // Redirects from an URL with fragment to an unsafe URL with fragment should
 // be allowed, and the reference fragment of the target URL should be preserved.
 TEST_F(URLRequestTestHTTP, UnsafeRedirectWithDifferentReferenceFragment) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
 
-  GURL original_url(test_server_.GetURL("original#fragment1"));
+  GURL original_url(http_test_server()->GetURL("/original#fragment1"));
   GURL unsafe_url("data:,url-marked-safe-and-used-in-redirect#fragment2");
   GURL expected_url("data:,url-marked-safe-and-used-in-redirect#fragment2");
 
   default_network_delegate_.set_redirect_on_headers_received_url(unsafe_url);
   default_network_delegate_.set_allowed_unsafe_redirect_url(unsafe_url);
 
   TestDelegate d;
   {
     scoped_ptr<URLRequest> r(
         default_context_.CreateRequest(original_url, DEFAULT_PRIORITY, &d));
 
     r->Start();
     base::RunLoop().Run();
 
     EXPECT_EQ(2U, r->url_chain().size());
     EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
     EXPECT_EQ(OK, r->status().error());
     EXPECT_EQ(original_url, r->original_url());
     EXPECT_EQ(expected_url, r->url());
   }
 }
 
 // When a delegate has specified a safe redirect URL, but it does not match the
 // redirect target, then do not prevent the reference fragment from being added.
 TEST_F(URLRequestTestHTTP, RedirectWithReferenceFragmentAndUnrelatedUnsafeUrl) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
 
-  GURL original_url(test_server_.GetURL("original#expected-fragment"));
+  GURL original_url(http_test_server()->GetURL("/original#expected-fragment"));
   GURL unsafe_url("data:text/html,this-url-does-not-match-redirect-url");
-  GURL redirect_url(test_server_.GetURL("target"));
-  GURL expected_redirect_url(test_server_.GetURL("target#expected-fragment"));
+  GURL redirect_url(http_test_server()->GetURL("/target"));
+  GURL expected_redirect_url(
+      http_test_server()->GetURL("/target#expected-fragment"));
 
   default_network_delegate_.set_redirect_on_headers_received_url(redirect_url);
   default_network_delegate_.set_allowed_unsafe_redirect_url(unsafe_url);
 
   TestDelegate d;
   {
     scoped_ptr<URLRequest> r(
         default_context_.CreateRequest(original_url, DEFAULT_PRIORITY, &d));
 
     r->Start();
     base::RunLoop().Run();
 
     EXPECT_EQ(2U, r->url_chain().size());
     EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
     EXPECT_EQ(OK, r->status().error());
     EXPECT_EQ(original_url, r->original_url());
     EXPECT_EQ(expected_redirect_url, r->url());
   }
 }
 
 // When a delegate has specified a safe redirect URL, assume that the redirect
 // URL should not be changed. In particular, the reference fragment should not
 // be modified.
 TEST_F(URLRequestTestHTTP, RedirectWithReferenceFragment) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
 
-  GURL original_url(test_server_.GetURL("original#should-not-be-appended"));
+  GURL original_url(
+      http_test_server()->GetURL("/original#should-not-be-appended"));
   GURL redirect_url("data:text/html,expect-no-reference-fragment");
 
   default_network_delegate_.set_redirect_on_headers_received_url(redirect_url);
   default_network_delegate_.set_allowed_unsafe_redirect_url(redirect_url);
 
   TestDelegate d;
   {
     scoped_ptr<URLRequest> r(
         default_context_.CreateRequest(original_url, DEFAULT_PRIORITY, &d));
 
     r->Start();
     base::RunLoop().Run();
 
     EXPECT_EQ(2U, r->url_chain().size());
     EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
     EXPECT_EQ(OK, r->status().error());
     EXPECT_EQ(original_url, r->original_url());
     EXPECT_EQ(redirect_url, r->url());
   }
 }
 
 // When a URLRequestRedirectJob is created, the redirection must be followed and
 // the reference fragment of the target URL must not be modified.
 TEST_F(URLRequestTestHTTP, RedirectJobWithReferenceFragment) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
 
-  GURL original_url(test_server_.GetURL("original#should-not-be-appended"));
-  GURL redirect_url(test_server_.GetURL("echo"));
+  GURL original_url(
+      http_test_server()->GetURL("/original#should-not-be-appended"));
+  GURL redirect_url(http_test_server()->GetURL("/echo"));
 
   TestDelegate d;
   scoped_ptr<URLRequest> r(
       default_context_.CreateRequest(original_url, DEFAULT_PRIORITY, &d));
 
   URLRequestRedirectJob* job = new URLRequestRedirectJob(
       r.get(), &default_network_delegate_, redirect_url,
       URLRequestRedirectJob::REDIRECT_302_FOUND, "Very Good Reason");
   AddTestInterceptor()->set_main_intercept_job(job);
 
   r->Start();
   base::RunLoop().Run();
 
   EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
   EXPECT_EQ(OK, r->status().error());
   EXPECT_EQ(original_url, r->original_url());
   EXPECT_EQ(redirect_url, r->url());
 }
 
 TEST_F(URLRequestTestHTTP, NoUserPassInReferrer) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
 
   TestDelegate d;
   scoped_ptr<URLRequest> req(default_context_.CreateRequest(
-      test_server_.GetURL("echoheader?Referer"), DEFAULT_PRIORITY, &d));
+      http_test_server()->GetURL("/echoheader?Referer"), DEFAULT_PRIORITY, &d));
   req->SetReferrer("http://user:pass@foo.com/");
   req->Start();
   base::RunLoop().Run();
 
   EXPECT_EQ(std::string("http://foo.com/"), d.data_received());
 }
 
 TEST_F(URLRequestTestHTTP, NoFragmentInReferrer) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
 
   TestDelegate d;
   scoped_ptr<URLRequest> req(default_context_.CreateRequest(
-      test_server_.GetURL("echoheader?Referer"), DEFAULT_PRIORITY, &d));
+      http_test_server()->GetURL("/echoheader?Referer"), DEFAULT_PRIORITY, &d));
   req->SetReferrer("http://foo.com/test#fragment");
   req->Start();
   base::RunLoop().Run();
 
   EXPECT_EQ(std::string("http://foo.com/test"), d.data_received());
 }
 
 TEST_F(URLRequestTestHTTP, EmptyReferrerAfterValidReferrer) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
 
   TestDelegate d;
   scoped_ptr<URLRequest> req(default_context_.CreateRequest(
-      test_server_.GetURL("echoheader?Referer"), DEFAULT_PRIORITY, &d));
+      http_test_server()->GetURL("/echoheader?Referer"), DEFAULT_PRIORITY, &d));
   req->SetReferrer("http://foo.com/test#fragment");
   req->SetReferrer("");
   req->Start();
   base::RunLoop().Run();
 
   EXPECT_EQ(std::string("None"), d.data_received());
 }
 
 // Defer network start and then resume, checking that the request was a success
 // and bytes were received.
 TEST_F(URLRequestTestHTTP, DeferredBeforeNetworkStart) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
 
   TestDelegate d;
   {
     d.set_quit_on_network_start(true);
-    GURL test_url(test_server_.GetURL("echo"));
+    GURL test_url(http_test_server()->GetURL("/echo"));
     scoped_ptr<URLRequest> req(
         default_context_.CreateRequest(test_url, DEFAULT_PRIORITY, &d));
 
     req->Start();
     base::RunLoop().Run();
 
     EXPECT_EQ(1, d.received_before_network_start_count());
     EXPECT_EQ(0, d.response_started_count());
 
     req->ResumeNetworkStart();
     base::RunLoop().Run();
 
     EXPECT_EQ(1, d.response_started_count());
     EXPECT_NE(0, d.bytes_received());
     EXPECT_EQ(URLRequestStatus::SUCCESS, req->status().status());
   }
 }
 
 // Check that OnBeforeNetworkStart is only called once even if there is a
 // redirect.
 TEST_F(URLRequestTestHTTP, BeforeNetworkStartCalledOnce) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
 
   TestDelegate d;
   {
     d.set_quit_on_redirect(true);
     d.set_quit_on_network_start(true);
     scoped_ptr<URLRequest> req(default_context_.CreateRequest(
-        test_server_.GetURL("server-redirect?echo"), DEFAULT_PRIORITY, &d));
+        http_test_server()->GetURL("/server-redirect?echo"), DEFAULT_PRIORITY,
+        &d));
 
     req->Start();
     base::RunLoop().Run();
 
     EXPECT_EQ(1, d.received_before_network_start_count());
     EXPECT_EQ(0, d.response_started_count());
     EXPECT_EQ(0, d.received_redirect_count());
 
     req->ResumeNetworkStart();
     base::RunLoop().Run();
 
     EXPECT_EQ(1, d.received_redirect_count());
     req->FollowDeferredRedirect();
     base::RunLoop().Run();
 
     // Check that the redirect's new network transaction does not get propagated
     // to a second OnBeforeNetworkStart() notification.
     EXPECT_EQ(1, d.received_before_network_start_count());
 
     EXPECT_EQ(1, d.response_started_count());
     EXPECT_NE(0, d.bytes_received());
     EXPECT_EQ(URLRequestStatus::SUCCESS, req->status().status());
   }
 }
 
 // Cancel the request after learning that the request would use the network.
 TEST_F(URLRequestTestHTTP, CancelOnBeforeNetworkStart) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
 
   TestDelegate d;
   {
     d.set_quit_on_network_start(true);
-    GURL test_url(test_server_.GetURL("echo"));
+    GURL test_url(http_test_server()->GetURL("/echo"));
     scoped_ptr<URLRequest> req(
         default_context_.CreateRequest(test_url, DEFAULT_PRIORITY, &d));
 
     req->Start();
     base::RunLoop().Run();
 
     EXPECT_EQ(1, d.received_before_network_start_count());
     EXPECT_EQ(0, d.response_started_count());
 
     req->Cancel();
     base::RunLoop().Run();
 
     EXPECT_EQ(1, d.response_started_count());
     EXPECT_EQ(0, d.bytes_received());
     EXPECT_EQ(URLRequestStatus::CANCELED, req->status().status());
   }
 }
 
 TEST_F(URLRequestTestHTTP, CancelRedirect) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
 
   TestDelegate d;
   {
     d.set_cancel_in_received_redirect(true);
     scoped_ptr<URLRequest> req(default_context_.CreateRequest(
-        test_server_.GetURL("files/redirect-test.html"), DEFAULT_PRIORITY, &d));
+        http_test_server()->GetURL("/redirect-test.html"), DEFAULT_PRIORITY,
+        &d));
     req->Start();
     base::RunLoop().Run();
 
     EXPECT_EQ(1, d.response_started_count());
     EXPECT_EQ(0, d.bytes_received());
     EXPECT_FALSE(d.received_data_before_response());
     EXPECT_EQ(URLRequestStatus::CANCELED, req->status().status());
   }
 }
 
 TEST_F(URLRequestTestHTTP, DeferredRedirect) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
 
   TestDelegate d;
   {
     d.set_quit_on_redirect(true);
-    GURL test_url(test_server_.GetURL("files/redirect-test.html"));
+    GURL test_url(http_test_server()->GetURL("/redirect-test.html"));
     scoped_ptr<URLRequest> req(
         default_context_.CreateRequest(test_url, DEFAULT_PRIORITY, &d));
 
     req->Start();
     base::RunLoop().Run();
 
     EXPECT_EQ(1, d.received_redirect_count());
 
     req->FollowDeferredRedirect();
     base::RunLoop().Run();
 
     EXPECT_EQ(1, d.response_started_count());
     EXPECT_FALSE(d.received_data_before_response());
     EXPECT_EQ(URLRequestStatus::SUCCESS, req->status().status());
 
     base::FilePath path;
     PathService::Get(base::DIR_SOURCE_ROOT, &path);
     path = path.Append(kTestFilePath);
     path = path.Append(FILE_PATH_LITERAL("with-headers.html"));
 
     std::string contents;
     EXPECT_TRUE(base::ReadFileToString(path, &contents));
     EXPECT_EQ(contents, d.data_received());
   }
 }
 
 TEST_F(URLRequestTestHTTP, DeferredRedirect_GetFullRequestHeaders) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
 
   TestDelegate d;
   {
     d.set_quit_on_redirect(true);
-    GURL test_url(test_server_.GetURL("files/redirect-test.html"));
+    GURL test_url(http_test_server()->GetURL("/redirect-test.html"));
     scoped_ptr<URLRequest> req(
         default_context_.CreateRequest(test_url, DEFAULT_PRIORITY, &d));
 
     EXPECT_FALSE(d.have_full_request_headers());
 
     req->Start();
     base::RunLoop().Run();
 
     EXPECT_EQ(1, d.received_redirect_count());
     EXPECT_TRUE(d.have_full_request_headers());
     CheckFullRequestHeaders(d.full_request_headers(), test_url);
     d.ClearFullRequestHeaders();
 
     req->FollowDeferredRedirect();
     base::RunLoop().Run();
 
-    GURL target_url(test_server_.GetURL("files/with-headers.html"));
+    GURL target_url(http_test_server()->GetURL("/with-headers.html"));
     EXPECT_EQ(1, d.response_started_count());
     EXPECT_TRUE(d.have_full_request_headers());
     CheckFullRequestHeaders(d.full_request_headers(), target_url);
     EXPECT_FALSE(d.received_data_before_response());
     EXPECT_EQ(URLRequestStatus::SUCCESS, req->status().status());
 
     base::FilePath path;
     PathService::Get(base::DIR_SOURCE_ROOT, &path);
     path = path.Append(kTestFilePath);
     path = path.Append(FILE_PATH_LITERAL("with-headers.html"));
 
     std::string contents;
     EXPECT_TRUE(base::ReadFileToString(path, &contents));
     EXPECT_EQ(contents, d.data_received());
   }
 }
 
 TEST_F(URLRequestTestHTTP, CancelDeferredRedirect) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
 
   TestDelegate d;
   {
     d.set_quit_on_redirect(true);
     scoped_ptr<URLRequest> req(default_context_.CreateRequest(
-        test_server_.GetURL("files/redirect-test.html"), DEFAULT_PRIORITY, &d));
+        http_test_server()->GetURL("/redirect-test.html"), DEFAULT_PRIORITY,
+        &d));
     req->Start();
     base::RunLoop().Run();
 
     EXPECT_EQ(1, d.received_redirect_count());
 
     req->Cancel();
     base::RunLoop().Run();
 
     EXPECT_EQ(1, d.response_started_count());
     EXPECT_EQ(0, d.bytes_received());
     EXPECT_FALSE(d.received_data_before_response());
     EXPECT_EQ(URLRequestStatus::CANCELED, req->status().status());
   }
 }
 
 TEST_F(URLRequestTestHTTP, VaryHeader) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
 
   // Populate the cache.
   {
     TestDelegate d;
     scoped_ptr<URLRequest> req(default_context_.CreateRequest(
-        test_server_.GetURL("echoheadercache?foo"), DEFAULT_PRIORITY, &d));
+        http_test_server()->GetURL("/echoheadercache?foo"), DEFAULT_PRIORITY,
+        &d));
     HttpRequestHeaders headers;
     headers.SetHeader("foo", "1");
     req->SetExtraRequestHeaders(headers);
     req->Start();
     base::RunLoop().Run();
 
     LoadTimingInfo load_timing_info;
     req->GetLoadTimingInfo(&load_timing_info);
     TestLoadTimingNotReused(load_timing_info, CONNECT_TIMING_HAS_DNS_TIMES);
   }
 
   // Expect a cache hit.
   {
     TestDelegate d;
     scoped_ptr<URLRequest> req(default_context_.CreateRequest(
-        test_server_.GetURL("echoheadercache?foo"), DEFAULT_PRIORITY, &d));
+        http_test_server()->GetURL("/echoheadercache?foo"), DEFAULT_PRIORITY,
+        &d));
     HttpRequestHeaders headers;
     headers.SetHeader("foo", "1");
     req->SetExtraRequestHeaders(headers);
     req->Start();
     base::RunLoop().Run();
 
     EXPECT_TRUE(req->was_cached());
 
     LoadTimingInfo load_timing_info;
     req->GetLoadTimingInfo(&load_timing_info);
     TestLoadTimingCacheHitNoNetwork(load_timing_info);
   }
 
   // Expect a cache miss.
   {
     TestDelegate d;
     scoped_ptr<URLRequest> req(default_context_.CreateRequest(
-        test_server_.GetURL("echoheadercache?foo"), DEFAULT_PRIORITY, &d));
+        http_test_server()->GetURL("/echoheadercache?foo"), DEFAULT_PRIORITY,
+        &d));
     HttpRequestHeaders headers;
     headers.SetHeader("foo", "2");
     req->SetExtraRequestHeaders(headers);
     req->Start();
     base::RunLoop().Run();
 
     EXPECT_FALSE(req->was_cached());
 
     LoadTimingInfo load_timing_info;
     req->GetLoadTimingInfo(&load_timing_info);
     TestLoadTimingNotReused(load_timing_info, CONNECT_TIMING_HAS_DNS_TIMES);
   }
 }
 
 TEST_F(URLRequestTestHTTP, BasicAuth) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
 
   // populate the cache
   {
     TestDelegate d;
     d.set_credentials(AuthCredentials(kUser, kSecret));
 
     scoped_ptr<URLRequest> r(default_context_.CreateRequest(
-        test_server_.GetURL("auth-basic"), DEFAULT_PRIORITY, &d));
+        http_test_server()->GetURL("/auth-basic"), DEFAULT_PRIORITY, &d));
     r->Start();
 
     base::RunLoop().Run();
 
     EXPECT_TRUE(d.data_received().find("user/secret") != std::string::npos);
   }
 
   // repeat request with end-to-end validation.  since auth-basic results in a
   // cachable page, we expect this test to result in a 304.  in which case, the
   // response should be fetched from the cache.
   {
     TestDelegate d;
     d.set_credentials(AuthCredentials(kUser, kSecret));
 
     scoped_ptr<URLRequest> r(default_context_.CreateRequest(
-        test_server_.GetURL("auth-basic"), DEFAULT_PRIORITY, &d));
+        http_test_server()->GetURL("/auth-basic"), DEFAULT_PRIORITY, &d));
     r->SetLoadFlags(LOAD_VALIDATE_CACHE);
     r->Start();
 
     base::RunLoop().Run();
 
     EXPECT_TRUE(d.data_received().find("user/secret") != std::string::npos);
 
     // Should be the same cached document.
     EXPECT_TRUE(r->was_cached());
   }
 }
 
 // Check that Set-Cookie headers in 401 responses are respected.
 // http://crbug.com/6450
 TEST_F(URLRequestTestHTTP, BasicAuthWithCookies) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
 
   GURL url_requiring_auth =
-      test_server_.GetURL("auth-basic?set-cookie-if-challenged");
+      http_test_server()->GetURL("/auth-basic?set-cookie-if-challenged");
 
   // Request a page that will give a 401 containing a Set-Cookie header.
   // Verify that when the transaction is restarted, it includes the new cookie.
   {
     TestNetworkDelegate network_delegate;  // Must outlive URLRequest.
     TestURLRequestContext context(true);
     context.set_network_delegate(&network_delegate);
     context.Init();
 
     TestDelegate d;
@@ skipping 36 matching lines @@
     EXPECT_TRUE(d.data_received().find("user2/secret") != std::string::npos);
 
     // Make sure we sent the cookie in the restarted transaction.
     EXPECT_TRUE(d.data_received().find("Cookie: got_challenged=true")
         != std::string::npos);
   }
 }
 
 // Tests that load timing works as expected with auth and the cache.
 TEST_F(URLRequestTestHTTP, BasicAuthLoadTiming) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
 
   // populate the cache
   {
     TestDelegate d;
     d.set_credentials(AuthCredentials(kUser, kSecret));
 
     scoped_ptr<URLRequest> r(default_context_.CreateRequest(
-        test_server_.GetURL("auth-basic"), DEFAULT_PRIORITY, &d));
+        http_test_server()->GetURL("/auth-basic"), DEFAULT_PRIORITY, &d));
     r->Start();
 
     base::RunLoop().Run();
 
     EXPECT_TRUE(d.data_received().find("user/secret") != std::string::npos);
 
     LoadTimingInfo load_timing_info_before_auth;
     EXPECT_TRUE(default_network_delegate_.GetLoadTimingInfoBeforeAuth(
         &load_timing_info_before_auth));
     TestLoadTimingNotReused(load_timing_info_before_auth,
@@ skipping 11 matching lines @@
   }
 
   // Repeat request with end-to-end validation.  Since auth-basic results in a
   // cachable page, we expect this test to result in a 304.  In which case, the
   // response should be fetched from the cache.
   {
     TestDelegate d;
     d.set_credentials(AuthCredentials(kUser, kSecret));
 
     scoped_ptr<URLRequest> r(default_context_.CreateRequest(
-        test_server_.GetURL("auth-basic"), DEFAULT_PRIORITY, &d));
+        http_test_server()->GetURL("/auth-basic"), DEFAULT_PRIORITY, &d));
     r->SetLoadFlags(LOAD_VALIDATE_CACHE);
     r->Start();
 
     base::RunLoop().Run();
 
     EXPECT_TRUE(d.data_received().find("user/secret") != std::string::npos);
 
     // Should be the same cached document.
     EXPECT_TRUE(r->was_cached());
 
     // Since there was a request that went over the wire, the load timing
     // information should include connection times.
     LoadTimingInfo load_timing_info;
     r->GetLoadTimingInfo(&load_timing_info);
     TestLoadTimingNotReused(load_timing_info, CONNECT_TIMING_HAS_DNS_TIMES);
   }
 }
 
 // In this test, we do a POST which the server will 302 redirect.
 // The subsequent transaction should use GET, and should not send the
 // Content-Type header.
 // http://code.google.com/p/chromium/issues/detail?id=843
 TEST_F(URLRequestTestHTTP, Post302RedirectGet) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
 
   const char kData[] = "hello world";
 
   TestDelegate d;
   scoped_ptr<URLRequest> req(default_context_.CreateRequest(
-      test_server_.GetURL("files/redirect-to-echoall"), DEFAULT_PRIORITY, &d));
+      http_test_server()->GetURL("/redirect-to-echoall"), DEFAULT_PRIORITY,
+      &d));
   req->set_method("POST");
   req->set_upload(CreateSimpleUploadData(kData));
 
   // Set headers (some of which are specific to the POST).
   HttpRequestHeaders headers;
   headers.AddHeadersFromString(
     "Content-Type: multipart/form-data; "
     "boundary=----WebKitFormBoundaryAADeAA+NAAWMAAwZ\r\n"
     "Accept: text/xml,application/xml,application/xhtml+xml,text/html;q=0.9,"
     "text/plain;q=0.8,image/png,*/*;q=0.5\r\n"
@@ skipping 21 matching lines @@
   EXPECT_TRUE(ContainsString(data, "Accept-Language:"));
   EXPECT_TRUE(ContainsString(data, "Accept-Charset:"));
 }
 
 // The following tests check that we handle mutating the request for HTTP
 // redirects as expected.
 // See https://crbug.com/56373, https://crbug.com/102130, and
 // https://crbug.com/465517.
 
 TEST_F(URLRequestTestHTTP, Redirect301Tests) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
 
-  const GURL url = test_server_.GetURL("files/redirect301-to-echo");
+  const GURL url = http_test_server()->GetURL("/redirect301-to-echo");
   const GURL https_redirect_url =
-      test_server_.GetURL("files/redirect301-to-https");
+      http_test_server()->GetURL("/redirect301-to-https");
 
   HTTPRedirectMethodTest(url, "POST", "GET", true);
   HTTPRedirectMethodTest(url, "PUT", "PUT", true);
   HTTPRedirectMethodTest(url, "HEAD", "HEAD", false);
 
   HTTPRedirectOriginHeaderTest(url, "GET", "GET", url.GetOrigin().spec());
   HTTPRedirectOriginHeaderTest(https_redirect_url, "GET", "GET", "null");
   HTTPRedirectOriginHeaderTest(url, "POST", "GET", std::string());
   HTTPRedirectOriginHeaderTest(https_redirect_url, "POST", "GET",
                                std::string());
 }
 
 TEST_F(URLRequestTestHTTP, Redirect302Tests) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
 
-  const GURL url = test_server_.GetURL("files/redirect302-to-echo");
+  const GURL url = http_test_server()->GetURL("/redirect302-to-echo");
   const GURL https_redirect_url =
-      test_server_.GetURL("files/redirect302-to-https");
+      http_test_server()->GetURL("/redirect302-to-https");
 
   HTTPRedirectMethodTest(url, "POST", "GET", true);
   HTTPRedirectMethodTest(url, "PUT", "PUT", true);
   HTTPRedirectMethodTest(url, "HEAD", "HEAD", false);
 
   HTTPRedirectOriginHeaderTest(url, "GET", "GET", url.GetOrigin().spec());
   HTTPRedirectOriginHeaderTest(https_redirect_url, "GET", "GET", "null");
   HTTPRedirectOriginHeaderTest(url, "POST", "GET", std::string());
   HTTPRedirectOriginHeaderTest(https_redirect_url, "POST", "GET",
                                std::string());
 }
 
 TEST_F(URLRequestTestHTTP, Redirect303Tests) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
 
-  const GURL url = test_server_.GetURL("files/redirect303-to-echo");
+  const GURL url = http_test_server()->GetURL("/redirect303-to-echo");
   const GURL https_redirect_url =
-      test_server_.GetURL("files/redirect303-to-https");
+      http_test_server()->GetURL("/redirect303-to-https");
 
   HTTPRedirectMethodTest(url, "POST", "GET", true);
   HTTPRedirectMethodTest(url, "PUT", "GET", true);
   HTTPRedirectMethodTest(url, "HEAD", "HEAD", false);
 
   HTTPRedirectOriginHeaderTest(url, "GET", "GET", url.GetOrigin().spec());
   HTTPRedirectOriginHeaderTest(https_redirect_url, "GET", "GET", "null");
   HTTPRedirectOriginHeaderTest(url, "POST", "GET", std::string());
   HTTPRedirectOriginHeaderTest(https_redirect_url, "POST", "GET",
                                std::string());
 }
 
 TEST_F(URLRequestTestHTTP, Redirect307Tests) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
 
-  const GURL url = test_server_.GetURL("files/redirect307-to-echo");
+  const GURL url = http_test_server()->GetURL("/redirect307-to-echo");
   const GURL https_redirect_url =
-      test_server_.GetURL("files/redirect307-to-https");
+      http_test_server()->GetURL("/redirect307-to-https");
 
   HTTPRedirectMethodTest(url, "POST", "POST", true);
   HTTPRedirectMethodTest(url, "PUT", "PUT", true);
   HTTPRedirectMethodTest(url, "HEAD", "HEAD", false);
 
   HTTPRedirectOriginHeaderTest(url, "GET", "GET", url.GetOrigin().spec());
   HTTPRedirectOriginHeaderTest(https_redirect_url, "GET", "GET", "null");
   HTTPRedirectOriginHeaderTest(url, "POST", "POST", url.GetOrigin().spec());
   HTTPRedirectOriginHeaderTest(https_redirect_url, "POST", "POST", "null");
 }
 
 TEST_F(URLRequestTestHTTP, Redirect308Tests) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
 
-  const GURL url = test_server_.GetURL("files/redirect308-to-echo");
+  const GURL url = http_test_server()->GetURL("/redirect308-to-echo");
   const GURL https_redirect_url =
-      test_server_.GetURL("files/redirect308-to-https");
+      http_test_server()->GetURL("/redirect308-to-https");
 
   HTTPRedirectMethodTest(url, "POST", "POST", true);
   HTTPRedirectMethodTest(url, "PUT", "PUT", true);
   HTTPRedirectMethodTest(url, "HEAD", "HEAD", false);
 
   HTTPRedirectOriginHeaderTest(url, "GET", "GET", url.GetOrigin().spec());
   HTTPRedirectOriginHeaderTest(https_redirect_url, "GET", "GET", "null");
   HTTPRedirectOriginHeaderTest(url, "POST", "POST", url.GetOrigin().spec());
   HTTPRedirectOriginHeaderTest(https_redirect_url, "POST", "POST", "null");
 }
 
 // Make sure that 308 responses without bodies are not treated as redirects.
 // Certain legacy apis that pre-date the response code expect this behavior
 // (Like Google Drive).
 TEST_F(URLRequestTestHTTP, NoRedirectOn308WithoutLocationHeader) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
 
   TestDelegate d;
-  const GURL url = test_server_.GetURL("files/308-without-location-header");
+  const GURL url = http_test_server()->GetURL("/308-without-location-header");
 
   scoped_ptr<URLRequest> request(
       default_context_.CreateRequest(url, DEFAULT_PRIORITY, &d));
 
   request->Start();
   base::RunLoop().Run();
   EXPECT_EQ(URLRequestStatus::SUCCESS, request->status().status());
   EXPECT_EQ(OK, request->status().error());
   EXPECT_EQ(0, d.received_redirect_count());
   EXPECT_EQ(308, request->response_headers()->response_code());
   EXPECT_EQ("This is not a redirect.", d.data_received());
 }
 
 TEST_F(URLRequestTestHTTP, Redirect302PreserveReferenceFragment) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
 
-  GURL original_url(test_server_.GetURL("files/redirect302-to-echo#fragment"));
-  GURL expected_url(test_server_.GetURL("echo#fragment"));
+  GURL original_url(
+      http_test_server()->GetURL("/redirect302-to-echo#fragment"));
+  GURL expected_url(http_test_server()->GetURL("/echo#fragment"));
 
   TestDelegate d;
   {
     scoped_ptr<URLRequest> r(
         default_context_.CreateRequest(original_url, DEFAULT_PRIORITY, &d));
 
     r->Start();
     base::RunLoop().Run();
 
     EXPECT_EQ(2U, r->url_chain().size());
     EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
     EXPECT_EQ(OK, r->status().error());
     EXPECT_EQ(original_url, r->original_url());
     EXPECT_EQ(expected_url, r->url());
   }
 }
 
 TEST_F(URLRequestTestHTTP, RedirectPreserveFirstPartyURL) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
 
-  GURL url(test_server_.GetURL("files/redirect302-to-echo"));
+  GURL url(http_test_server()->GetURL("/redirect302-to-echo"));
   GURL first_party_url("http://example.com");
 
   TestDelegate d;
   {
     scoped_ptr<URLRequest> r(
         default_context_.CreateRequest(url, DEFAULT_PRIORITY, &d));
     r->set_first_party_for_cookies(first_party_url);
 
     r->Start();
     base::RunLoop().Run();
 
     EXPECT_EQ(2U, r->url_chain().size());
     EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
     EXPECT_EQ(OK, r->status().error());
     EXPECT_EQ(first_party_url, r->first_party_for_cookies());
   }
 }
 
 TEST_F(URLRequestTestHTTP, RedirectUpdateFirstPartyURL) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
 
-  GURL url(test_server_.GetURL("files/redirect302-to-echo"));
+  GURL url(http_test_server()->GetURL("/redirect302-to-echo"));
   GURL original_first_party_url("http://example.com");
-  GURL expected_first_party_url(test_server_.GetURL("echo"));
+  GURL expected_first_party_url(http_test_server()->GetURL("/echo"));
 
   TestDelegate d;
   {
     scoped_ptr<URLRequest> r(
         default_context_.CreateRequest(url, DEFAULT_PRIORITY, &d));
     r->set_first_party_for_cookies(original_first_party_url);
     r->set_first_party_url_policy(
         URLRequest::UPDATE_FIRST_PARTY_URL_ON_REDIRECT);
 
     r->Start();
     base::RunLoop().Run();
 
     EXPECT_EQ(2U, r->url_chain().size());
     EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
     EXPECT_EQ(OK, r->status().error());
     EXPECT_EQ(expected_first_party_url, r->first_party_for_cookies());
   }
 }
 
 TEST_F(URLRequestTestHTTP, InterceptPost302RedirectGet) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
 
   const char kData[] = "hello world";
 
   TestDelegate d;
   scoped_ptr<URLRequest> req(default_context_.CreateRequest(
-      test_server_.GetURL("empty.html"), DEFAULT_PRIORITY, &d));
+      http_test_server()->GetURL("/defaultresponse"), DEFAULT_PRIORITY, &d));
   req->set_method("POST");
   req->set_upload(CreateSimpleUploadData(kData));
   HttpRequestHeaders headers;
   headers.SetHeader(HttpRequestHeaders::kContentLength,
                     base::SizeTToString(arraysize(kData) - 1));
   req->SetExtraRequestHeaders(headers);
 
   URLRequestRedirectJob* job = new URLRequestRedirectJob(
-      req.get(), &default_network_delegate_, test_server_.GetURL("echo"),
+      req.get(), &default_network_delegate_,
+      http_test_server()->GetURL("/echo"),
       URLRequestRedirectJob::REDIRECT_302_FOUND, "Very Good Reason");
   AddTestInterceptor()->set_main_intercept_job(job);
 
   req->Start();
   base::RunLoop().Run();
   EXPECT_EQ("GET", req->method());
 }
 
 TEST_F(URLRequestTestHTTP, InterceptPost307RedirectPost) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
 
   const char kData[] = "hello world";
 
   TestDelegate d;
   scoped_ptr<URLRequest> req(default_context_.CreateRequest(
-      test_server_.GetURL("empty.html"), DEFAULT_PRIORITY, &d));
+      http_test_server()->GetURL("/defaultresponse"), DEFAULT_PRIORITY, &d));
   req->set_method("POST");
   req->set_upload(CreateSimpleUploadData(kData));
   HttpRequestHeaders headers;
   headers.SetHeader(HttpRequestHeaders::kContentLength,
                     base::SizeTToString(arraysize(kData) - 1));
   req->SetExtraRequestHeaders(headers);
 
   URLRequestRedirectJob* job = new URLRequestRedirectJob(
-      req.get(), &default_network_delegate_, test_server_.GetURL("echo"),
+      req.get(), &default_network_delegate_,
+      http_test_server()->GetURL("/echo"),
       URLRequestRedirectJob::REDIRECT_307_TEMPORARY_REDIRECT,
       "Very Good Reason");
   AddTestInterceptor()->set_main_intercept_job(job);
 
   req->Start();
   base::RunLoop().Run();
   EXPECT_EQ("POST", req->method());
   EXPECT_EQ(kData, d.data_received());
 }
 
 // Check that default A-L header is sent.
 TEST_F(URLRequestTestHTTP, DefaultAcceptLanguage) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
 
   StaticHttpUserAgentSettings settings("en", std::string());
   TestNetworkDelegate network_delegate;  // Must outlive URLRequests.
   TestURLRequestContext context(true);
   context.set_network_delegate(&network_delegate);
   context.set_http_user_agent_settings(&settings);
   context.Init();
 
   TestDelegate d;
   scoped_ptr<URLRequest> req(context.CreateRequest(
-      test_server_.GetURL("echoheader?Accept-Language"), DEFAULT_PRIORITY, &d));
+      http_test_server()->GetURL("/echoheader?Accept-Language"),
+      DEFAULT_PRIORITY, &d));
   req->Start();
   base::RunLoop().Run();
   EXPECT_EQ("en", d.data_received());
 }
 
 // Check that an empty A-L header is not sent. http://crbug.com/77365.
 TEST_F(URLRequestTestHTTP, EmptyAcceptLanguage) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
 
   std::string empty_string;  // Avoid most vexing parse on line below.
   StaticHttpUserAgentSettings settings(empty_string, empty_string);
   TestNetworkDelegate network_delegate;  // Must outlive URLRequests.
   TestURLRequestContext context(true);
   context.set_network_delegate(&network_delegate);
   context.Init();
   // We override the language after initialization because empty entries
   // get overridden by Init().
   context.set_http_user_agent_settings(&settings);
 
   TestDelegate d;
   scoped_ptr<URLRequest> req(context.CreateRequest(
-      test_server_.GetURL("echoheader?Accept-Language"), DEFAULT_PRIORITY, &d));
+      http_test_server()->GetURL("/echoheader?Accept-Language"),
+      DEFAULT_PRIORITY, &d));
   req->Start();
   base::RunLoop().Run();
   EXPECT_EQ("None", d.data_received());
 }
 
 // Check that if request overrides the A-L header, the default is not appended.
 // See http://crbug.com/20894
 TEST_F(URLRequestTestHTTP, OverrideAcceptLanguage) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
 
   TestDelegate d;
   scoped_ptr<URLRequest> req(default_context_.CreateRequest(
-      test_server_.GetURL("echoheader?Accept-Language"), DEFAULT_PRIORITY, &d));
+      http_test_server()->GetURL("/echoheader?Accept-Language"),
+      DEFAULT_PRIORITY, &d));
   HttpRequestHeaders headers;
   headers.SetHeader(HttpRequestHeaders::kAcceptLanguage, "ru");
   req->SetExtraRequestHeaders(headers);
   req->Start();
   base::RunLoop().Run();
   EXPECT_EQ(std::string("ru"), d.data_received());
 }
 
 // Check that default A-E header is sent.
 TEST_F(URLRequestTestHTTP, DefaultAcceptEncoding) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
 
   TestDelegate d;
   scoped_ptr<URLRequest> req(default_context_.CreateRequest(
-      test_server_.GetURL("echoheader?Accept-Encoding"), DEFAULT_PRIORITY, &d));
+      http_test_server()->GetURL("/echoheader?Accept-Encoding"),
+      DEFAULT_PRIORITY, &d));
   HttpRequestHeaders headers;
   req->SetExtraRequestHeaders(headers);
   req->Start();
   base::RunLoop().Run();
   EXPECT_TRUE(ContainsString(d.data_received(), "gzip"));
 }
 
 // Check that if request overrides the A-E header, the default is not appended.
 // See http://crbug.com/47381
 TEST_F(URLRequestTestHTTP, OverrideAcceptEncoding) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
 
   TestDelegate d;
   scoped_ptr<URLRequest> req(default_context_.CreateRequest(
-      test_server_.GetURL("echoheader?Accept-Encoding"), DEFAULT_PRIORITY, &d));
+      http_test_server()->GetURL("/echoheader?Accept-Encoding"),
+      DEFAULT_PRIORITY, &d));
   HttpRequestHeaders headers;
   headers.SetHeader(HttpRequestHeaders::kAcceptEncoding, "identity");
   req->SetExtraRequestHeaders(headers);
   req->Start();
   base::RunLoop().Run();
   EXPECT_FALSE(ContainsString(d.data_received(), "gzip"));
   EXPECT_TRUE(ContainsString(d.data_received(), "identity"));
 }
 
 // Check that setting the A-C header sends the proper header.
 TEST_F(URLRequestTestHTTP, SetAcceptCharset) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
 
   TestDelegate d;
   scoped_ptr<URLRequest> req(default_context_.CreateRequest(
-      test_server_.GetURL("echoheader?Accept-Charset"), DEFAULT_PRIORITY, &d));
+      http_test_server()->GetURL("/echoheader?Accept-Charset"),
+      DEFAULT_PRIORITY, &d));
   HttpRequestHeaders headers;
   headers.SetHeader(HttpRequestHeaders::kAcceptCharset, "koi-8r");
   req->SetExtraRequestHeaders(headers);
   req->Start();
   base::RunLoop().Run();
   EXPECT_EQ(std::string("koi-8r"), d.data_received());
 }
 
 // Check that default User-Agent header is sent.
 TEST_F(URLRequestTestHTTP, DefaultUserAgent) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
 
   TestDelegate d;
   scoped_ptr<URLRequest> req(default_context_.CreateRequest(
-      test_server_.GetURL("echoheader?User-Agent"), DEFAULT_PRIORITY, &d));
+      http_test_server()->GetURL("/echoheader?User-Agent"), DEFAULT_PRIORITY,
+      &d));
   req->Start();
   base::RunLoop().Run();
   EXPECT_EQ(default_context_.http_user_agent_settings()->GetUserAgent(),
             d.data_received());
 }
 
 // Check that if request overrides the User-Agent header,
 // the default is not appended.
 TEST_F(URLRequestTestHTTP, OverrideUserAgent) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
 
   TestDelegate d;
   scoped_ptr<URLRequest> req(default_context_.CreateRequest(
-      test_server_.GetURL("echoheader?User-Agent"), DEFAULT_PRIORITY, &d));
+      http_test_server()->GetURL("/echoheader?User-Agent"), DEFAULT_PRIORITY,
+      &d));
   HttpRequestHeaders headers;
   headers.SetHeader(HttpRequestHeaders::kUserAgent, "Lynx (textmode)");
   req->SetExtraRequestHeaders(headers);
   req->Start();
   base::RunLoop().Run();
   EXPECT_EQ(std::string("Lynx (textmode)"), d.data_received());
 }
 
 // Check that a NULL HttpUserAgentSettings causes the corresponding empty
 // User-Agent header to be sent but does not send the Accept-Language and
 // Accept-Charset headers.
 TEST_F(URLRequestTestHTTP, EmptyHttpUserAgentSettings) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
 
   TestNetworkDelegate network_delegate;  // Must outlive URLRequests.
   TestURLRequestContext context(true);
   context.set_network_delegate(&network_delegate);
   context.Init();
   // We override the HttpUserAgentSettings after initialization because empty
   // entries get overridden by Init().
   context.set_http_user_agent_settings(NULL);
 
   struct {
     const char* request;
     const char* expected_response;
-  } tests[] = { { "echoheader?Accept-Language", "None" },
-                { "echoheader?Accept-Charset", "None" },
-                { "echoheader?User-Agent", "" } };
+  } tests[] = {{"/echoheader?Accept-Language", "None"},
+               {"/echoheader?Accept-Charset", "None"},
+               {"/echoheader?User-Agent", ""}};
 
   for (size_t i = 0; i < arraysize(tests); i++) {
     TestDelegate d;
     scoped_ptr<URLRequest> req(context.CreateRequest(
-        test_server_.GetURL(tests[i].request), DEFAULT_PRIORITY, &d));
+        http_test_server()->GetURL(tests[i].request), DEFAULT_PRIORITY, &d));
     req->Start();
     base::RunLoop().Run();
     EXPECT_EQ(tests[i].expected_response, d.data_received())
         << " Request = \"" << tests[i].request << "\"";
   }
 }
 
 // Make sure that URLRequest passes on its priority updates to
 // newly-created jobs after the first one.
 TEST_F(URLRequestTestHTTP, SetSubsequentJobPriority) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
 
   TestDelegate d;
   scoped_ptr<URLRequest> req(default_context_.CreateRequest(
-      test_server_.GetURL("empty.html"), DEFAULT_PRIORITY, &d));
+      http_test_server()->GetURL("/defaultresponse"), DEFAULT_PRIORITY, &d));
   EXPECT_EQ(DEFAULT_PRIORITY, req->priority());
 
-  scoped_refptr<URLRequestRedirectJob> redirect_job =
-      new URLRequestRedirectJob(
-          req.get(), &default_network_delegate_, test_server_.GetURL("echo"),
-          URLRequestRedirectJob::REDIRECT_302_FOUND, "Very Good Reason");
+  scoped_refptr<URLRequestRedirectJob> redirect_job = new URLRequestRedirectJob(
+      req.get(), &default_network_delegate_,
+      http_test_server()->GetURL("/echo"),
+      URLRequestRedirectJob::REDIRECT_302_FOUND, "Very Good Reason");
   AddTestInterceptor()->set_main_intercept_job(redirect_job.get());
 
   req->SetPriority(LOW);
   req->Start();
   EXPECT_TRUE(req->is_pending());
 
   scoped_refptr<URLRequestTestJob> job =
       new URLRequestTestJob(req.get(), &default_network_delegate_);
   AddTestInterceptor()->set_main_intercept_job(job.get());
 
@@ skipping 68 matching lines @@
       context.CreateRequest(GURL("http://127.0.0.1/"), DEFAULT_PRIORITY, &d));
   req->Start();
   base::RunLoop().Run();
 
   EXPECT_TRUE(d.request_failed());
   EXPECT_EQ(URLRequestStatus::FAILED, req->status().status());
   EXPECT_EQ(ERR_NETWORK_IO_SUSPENDED, req->status().error());
 }
 
 TEST_F(URLRequestTestHTTP, NetworkAccessedSetOnNetworkRequest) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
 
   TestDelegate d;
-  GURL test_url(test_server_.GetURL(std::string()));
+  GURL test_url(http_test_server()->GetURL("/"));
   scoped_ptr<URLRequest> req(
       default_context_.CreateRequest(test_url, DEFAULT_PRIORITY, &d));
 
   req->Start();
   base::RunLoop().Run();
 
   EXPECT_TRUE(req->response_info().network_accessed);
 }
 
 TEST_F(URLRequestTestHTTP, NetworkAccessedClearOnCachedResponse) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
 
   // Populate the cache.
   TestDelegate d;
   scoped_ptr<URLRequest> req(default_context_.CreateRequest(
-      test_server_.GetURL("cachetime"), DEFAULT_PRIORITY, &d));
+      http_test_server()->GetURL("/cachetime"), DEFAULT_PRIORITY, &d));
   req->Start();
   base::RunLoop().Run();
 
   EXPECT_EQ(URLRequestStatus::SUCCESS, req->status().status());
   EXPECT_TRUE(req->response_info().network_accessed);
   EXPECT_FALSE(req->response_info().was_cached);
 
-  req = default_context_.CreateRequest(test_server_.GetURL("cachetime"),
+  req = default_context_.CreateRequest(http_test_server()->GetURL("/cachetime"),
                                        DEFAULT_PRIORITY, &d);
   req->Start();
   base::RunLoop().Run();
 
   EXPECT_EQ(URLRequestStatus::SUCCESS, req->status().status());
   EXPECT_FALSE(req->response_info().network_accessed);
   EXPECT_TRUE(req->response_info().was_cached);
 }
 
 TEST_F(URLRequestTestHTTP, NetworkAccessedClearOnLoadOnlyFromCache) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(http_test_server()->Start());
 
   TestDelegate d;
-  GURL test_url(test_server_.GetURL(std::string()));
+  GURL test_url(http_test_server()->GetURL("/"));
   scoped_ptr<URLRequest> req(
       default_context_.CreateRequest(test_url, DEFAULT_PRIORITY, &d));
   req->SetLoadFlags(LOAD_ONLY_FROM_CACHE);
 
   req->Start();
   base::RunLoop().Run();
 
   EXPECT_FALSE(req->response_info().network_accessed);
 }
 
@@ skipping 18 matching lines @@
  private:
   MockURLRequestInterceptor* interceptor_;
 };
 
 TEST_F(URLRequestInterceptorTestHTTP,
        NetworkDelegateNotificationOnRedirectIntercept) {
   interceptor()->set_intercept_redirect(true);
   interceptor()->set_redirect_headers(MockURLRequestInterceptor::ok_headers());
   interceptor()->set_redirect_data(MockURLRequestInterceptor::ok_data());
 
-  ASSERT_TRUE(test_server()->Start());
+  ASSERT_TRUE(http_test_server()->Start());
 
   TestDelegate d;
   scoped_ptr<URLRequest> req(default_context().CreateRequest(
-      test_server()->GetURL("files/redirect-test.html"), DEFAULT_PRIORITY, &d));
+      http_test_server()->GetURL("/redirect-test.html"), DEFAULT_PRIORITY, &d));
   req->Start();
   base::RunLoop().Run();
 
   EXPECT_TRUE(interceptor()->did_intercept_redirect());
   // Check we got one good response
   EXPECT_TRUE(req->status().is_success());
   if (req->status().is_success())
     EXPECT_EQ(200, req->response_headers()->response_code());
 
   EXPECT_EQ(MockURLRequestInterceptor::ok_data(), d.data_received());
   EXPECT_EQ(1, d.response_started_count());
   EXPECT_EQ(0, d.received_redirect_count());
 
   EXPECT_EQ(1, default_network_delegate()->created_requests());
   EXPECT_EQ(1, default_network_delegate()->before_send_headers_count());
   EXPECT_EQ(1, default_network_delegate()->headers_received_count());
 }
 
 TEST_F(URLRequestInterceptorTestHTTP,
        NetworkDelegateNotificationOnErrorIntercept) {
   // Intercept that error and respond with an OK response.
   interceptor()->set_intercept_final_response(true);
   interceptor()->set_final_headers(MockURLRequestInterceptor::ok_headers());
   interceptor()->set_final_data(MockURLRequestInterceptor::ok_data());
   default_network_delegate()->set_can_be_intercepted_on_error(true);
 
-  ASSERT_TRUE(test_server()->Start());
+  ASSERT_TRUE(http_test_server()->Start());
 
   TestDelegate d;
   scoped_ptr<URLRequest> req(default_context().CreateRequest(
-      test_server()->GetURL("files/two-content-lengths.html"), DEFAULT_PRIORITY,
+      http_test_server()->GetURL("/two-content-lengths.html"), DEFAULT_PRIORITY,
       &d));
   req->set_method("GET");
   req->Start();
   base::RunLoop().Run();
 
   EXPECT_TRUE(interceptor()->did_intercept_final());
 
   // Check we received one good response.
   EXPECT_TRUE(req->status().is_success());
   if (req->status().is_success())
     EXPECT_EQ(200, req->response_headers()->response_code());
   EXPECT_EQ(MockURLRequestInterceptor::ok_data(), d.data_received());
   EXPECT_EQ(1, d.response_started_count());
   EXPECT_EQ(0, d.received_redirect_count());
 
   EXPECT_EQ(1, default_network_delegate()->created_requests());
   EXPECT_EQ(1, default_network_delegate()->before_send_headers_count());
   EXPECT_EQ(0, default_network_delegate()->headers_received_count());
 }
 
 TEST_F(URLRequestInterceptorTestHTTP,
        NetworkDelegateNotificationOnResponseIntercept) {
   // Intercept that error and respond with an OK response.
   interceptor()->set_intercept_final_response(true);
 
   // Intercept with a real URLRequestHttpJob.
   interceptor()->set_use_url_request_http_job(true);
 
-  ASSERT_TRUE(test_server()->Start());
+  ASSERT_TRUE(http_test_server()->Start());
 
   TestDelegate d;
   scoped_ptr<URLRequest> req(default_context().CreateRequest(
-      test_server()->GetURL("files/simple.html"), DEFAULT_PRIORITY, &d));
+      http_test_server()->GetURL("/simple.html"), DEFAULT_PRIORITY, &d));
   req->set_method("GET");
   req->Start();
   base::RunLoop().Run();
 
   EXPECT_TRUE(interceptor()->did_intercept_final());
 
   // Check we received one good response.
   EXPECT_TRUE(req->status().is_success());
   if (req->status().is_success())
     EXPECT_EQ(200, req->response_headers()->response_code());
   EXPECT_EQ("hello", d.data_received());
   EXPECT_EQ(1, d.response_started_count());
   EXPECT_EQ(0, d.received_redirect_count());
 
   EXPECT_EQ(1, default_network_delegate()->created_requests());
   EXPECT_EQ(2, default_network_delegate()->before_send_headers_count());
   EXPECT_EQ(2, default_network_delegate()->headers_received_count());
 }
 
 class URLRequestTestReferrerPolicy : public URLRequestTest {
  public:
   URLRequestTestReferrerPolicy() {}
 
-  void InstantiateSameOriginServers(SpawnedTestServer::Type origin_type) {
-    origin_server_.reset(new SpawnedTestServer(
-        origin_type, SpawnedTestServer::kLocalhost,
-        origin_type == SpawnedTestServer::TYPE_HTTPS
-            ? base::FilePath(FILE_PATH_LITERAL("net/data/ssl"))
-            : base::FilePath(kTestFilePath)));
+  void InstantiateSameOriginServers(bool is_ssl) {
+    if (is_ssl)
+      origin_server_.reset(
+          new EmbeddedTestServer(net::EmbeddedTestServer::TYPE_HTTPS));
+    else
+      origin_server_.reset(new EmbeddedTestServer);
+    if (is_ssl)
+      origin_server_->AddDefaultHandlers(
+          base::FilePath(FILE_PATH_LITERAL("net/data/ssl")));
+    else {
+      origin_server_->AddDefaultHandlers(base::FilePath(kTestFilePath));
+    }
     ASSERT_TRUE(origin_server_->Start());
   }
 
-  void InstantiateCrossOriginServers(SpawnedTestServer::Type origin_type,
-                                     SpawnedTestServer::Type destination_type) {
-    origin_server_.reset(new SpawnedTestServer(
-        origin_type, SpawnedTestServer::kLocalhost,
-        origin_type == SpawnedTestServer::TYPE_HTTPS
-            ? base::FilePath(FILE_PATH_LITERAL("net/data/ssl"))
-            : base::FilePath(kTestFilePath)));
+  void InstantiateCrossOriginServers(bool origin_is_ssl, bool dest_is_ssl) {
+    if (origin_is_ssl) {
+      origin_server_.reset(
+          new EmbeddedTestServer(net::EmbeddedTestServer::TYPE_HTTPS));
+      origin_server_->AddDefaultHandlers(
+          base::FilePath(FILE_PATH_LITERAL("net/data/ssl")));
+    } else {
+      origin_server_.reset(new EmbeddedTestServer);
+      origin_server_->AddDefaultHandlers(base::FilePath(kTestFilePath));
+    }
     ASSERT_TRUE(origin_server_->Start());
 
-    destination_server_.reset(new SpawnedTestServer(
-        destination_type, SpawnedTestServer::kLocalhost,
-        destination_type == SpawnedTestServer::TYPE_HTTPS
-            ? base::FilePath(FILE_PATH_LITERAL("net/data/ssl"))
-            : base::FilePath(kTestFilePath)));
+    if (dest_is_ssl) {
+      destination_server_.reset(
+          new EmbeddedTestServer(net::EmbeddedTestServer::TYPE_HTTPS));
+      destination_server_->AddDefaultHandlers(
+          base::FilePath(FILE_PATH_LITERAL("net/data/ssl")));
+    } else {
+      destination_server_.reset(new EmbeddedTestServer);
+      destination_server_->AddDefaultHandlers(base::FilePath(kTestFilePath));
+    }
     ASSERT_TRUE(destination_server_->Start());
   }
 
   void VerifyReferrerAfterRedirect(URLRequest::ReferrerPolicy policy,
                                    const GURL& referrer,
                                    const GURL& expected) {
     // Create and execute the request: we'll only have a |destination_server_|
     // if the origins are meant to be distinct. Otherwise, we'll use the
     // |origin_server_| for both endpoints.
     GURL destination_url =
-        destination_server_ ? destination_server_->GetURL("echoheader?Referer")
-                            : origin_server_->GetURL("echoheader?Referer");
+        destination_server_ ? destination_server_->GetURL("/echoheader?Referer")
+                            : origin_server_->GetURL("/echoheader?Referer");
     GURL origin_url =
-        origin_server_->GetURL("server-redirect?" + destination_url.spec());
+        origin_server_->GetURL("/server-redirect?" + destination_url.spec());
 
     TestDelegate d;
     scoped_ptr<URLRequest> req(
         default_context_.CreateRequest(origin_url, DEFAULT_PRIORITY, &d));
     req->set_referrer_policy(policy);
     req->SetReferrer(referrer.spec());
     req->Start();
     base::RunLoop().Run();
 
     EXPECT_EQ(1, d.response_started_count());
     EXPECT_EQ(1, d.received_redirect_count());
     EXPECT_EQ(destination_url, req->url());
     EXPECT_TRUE(req->status().is_success());
     EXPECT_EQ(200, req->response_headers()->response_code());
 
     EXPECT_EQ(expected.spec(), req->referrer());
     if (expected.is_empty())
       EXPECT_EQ("None", d.data_received());
     else
       EXPECT_EQ(expected.spec(), d.data_received());
   }
 
-  SpawnedTestServer* origin_server() const { return origin_server_.get(); }
+  EmbeddedTestServer* origin_server() const { return origin_server_.get(); }
 
  private:
-  scoped_ptr<SpawnedTestServer> origin_server_;
-  scoped_ptr<SpawnedTestServer> destination_server_;
+  scoped_ptr<EmbeddedTestServer> origin_server_;
+  scoped_ptr<EmbeddedTestServer> destination_server_;
 };
 
 TEST_F(URLRequestTestReferrerPolicy, HTTPToSameOriginHTTP) {
-  InstantiateSameOriginServers(SpawnedTestServer::TYPE_HTTP);
+  InstantiateSameOriginServers(false);
 
   VerifyReferrerAfterRedirect(
       URLRequest::CLEAR_REFERRER_ON_TRANSITION_FROM_SECURE_TO_INSECURE,
-      origin_server()->GetURL("path/to/file.html"),
-      origin_server()->GetURL("path/to/file.html"));
+      origin_server()->GetURL("/path/to/file.html"),
+      origin_server()->GetURL("/path/to/file.html"));
 
   VerifyReferrerAfterRedirect(
       URLRequest::REDUCE_REFERRER_GRANULARITY_ON_TRANSITION_CROSS_ORIGIN,
-      origin_server()->GetURL("path/to/file.html"),
-      origin_server()->GetURL("path/to/file.html"));
+      origin_server()->GetURL("/path/to/file.html"),
+      origin_server()->GetURL("/path/to/file.html"));
 
   VerifyReferrerAfterRedirect(
       URLRequest::ORIGIN_ONLY_ON_TRANSITION_CROSS_ORIGIN,
-      origin_server()->GetURL("path/to/file.html"),
-      origin_server()->GetURL("path/to/file.html"));
+      origin_server()->GetURL("/path/to/file.html"),
+      origin_server()->GetURL("/path/to/file.html"));
 
   VerifyReferrerAfterRedirect(URLRequest::NEVER_CLEAR_REFERRER,
-                              origin_server()->GetURL("path/to/file.html"),
-                              origin_server()->GetURL("path/to/file.html"));
+                              origin_server()->GetURL("/path/to/file.html"),
+                              origin_server()->GetURL("/path/to/file.html"));
 }
 
-// Can't spin up more than one SpawnedTestServer on Android.
-#if defined(OS_ANDROID)
-#define MAYBE_HTTPToCrossOriginHTTP DISABLED_HTTPToCrosOriginHTTP
-#else
-#define MAYBE_HTTPToCrossOriginHTTP HTTPToCrossOriginHTTP
-#endif
-TEST_F(URLRequestTestReferrerPolicy, MAYBE_HTTPToCrossOriginHTTP) {
-  InstantiateCrossOriginServers(SpawnedTestServer::TYPE_HTTP,
-                                SpawnedTestServer::TYPE_HTTP);
+TEST_F(URLRequestTestReferrerPolicy, HTTPToCrossOriginHTTP) {
+  InstantiateCrossOriginServers(false, false);
 
   VerifyReferrerAfterRedirect(
       URLRequest::CLEAR_REFERRER_ON_TRANSITION_FROM_SECURE_TO_INSECURE,
-      origin_server()->GetURL("path/to/file.html"),
-      origin_server()->GetURL("path/to/file.html"));
+      origin_server()->GetURL("/path/to/file.html"),
+      origin_server()->GetURL("/path/to/file.html"));
 
   VerifyReferrerAfterRedirect(
       URLRequest::REDUCE_REFERRER_GRANULARITY_ON_TRANSITION_CROSS_ORIGIN,
-      origin_server()->GetURL("path/to/file.html"),
-      origin_server()->GetURL(std::string()));
+      origin_server()->GetURL("/path/to/file.html"),
+      origin_server()->GetURL("/"));
 
   VerifyReferrerAfterRedirect(
       URLRequest::ORIGIN_ONLY_ON_TRANSITION_CROSS_ORIGIN,
-      origin_server()->GetURL("path/to/file.html"),
-      origin_server()->GetURL(std::string()));
+      origin_server()->GetURL("/path/to/file.html"),
+      origin_server()->GetURL("/"));
 
   VerifyReferrerAfterRedirect(URLRequest::NEVER_CLEAR_REFERRER,
-                              origin_server()->GetURL("path/to/file.html"),
-                              origin_server()->GetURL("path/to/file.html"));
+                              origin_server()->GetURL("/path/to/file.html"),
+                              origin_server()->GetURL("/path/to/file.html"));
 }
 
 TEST_F(URLRequestTestReferrerPolicy, HTTPSToSameOriginHTTPS) {
-  InstantiateSameOriginServers(SpawnedTestServer::TYPE_HTTPS);
+  InstantiateSameOriginServers(true);
 
   VerifyReferrerAfterRedirect(
       URLRequest::CLEAR_REFERRER_ON_TRANSITION_FROM_SECURE_TO_INSECURE,
-      origin_server()->GetURL("path/to/file.html"),
-      origin_server()->GetURL("path/to/file.html"));
+      origin_server()->GetURL("/path/to/file.html"),
+      origin_server()->GetURL("/path/to/file.html"));
 
   VerifyReferrerAfterRedirect(
       URLRequest::REDUCE_REFERRER_GRANULARITY_ON_TRANSITION_CROSS_ORIGIN,
-      origin_server()->GetURL("path/to/file.html"),
-      origin_server()->GetURL("path/to/file.html"));
+      origin_server()->GetURL("/path/to/file.html"),
+      origin_server()->GetURL("/path/to/file.html"));
 
   VerifyReferrerAfterRedirect(
       URLRequest::ORIGIN_ONLY_ON_TRANSITION_CROSS_ORIGIN,
-      origin_server()->GetURL("path/to/file.html"),
-      origin_server()->GetURL("path/to/file.html"));
+      origin_server()->GetURL("/path/to/file.html"),
+      origin_server()->GetURL("/path/to/file.html"));
 
   VerifyReferrerAfterRedirect(URLRequest::NEVER_CLEAR_REFERRER,
-                              origin_server()->GetURL("path/to/file.html"),
-                              origin_server()->GetURL("path/to/file.html"));
+                              origin_server()->GetURL("/path/to/file.html"),
+                              origin_server()->GetURL("/path/to/file.html"));
 }
 
-// Can't spin up more than one SpawnedTestServer on Android.
-#if defined(OS_ANDROID)
-#define MAYBE_HTTPSToCrossOriginHTTPS DISABLED_HTTPSToCrosOriginHTTPS
-#else
-#define MAYBE_HTTPSToCrossOriginHTTPS HTTPSToCrossOriginHTTPS
-#endif
-TEST_F(URLRequestTestReferrerPolicy, MAYBE_HTTPSToCrossOriginHTTPS) {
-  InstantiateCrossOriginServers(SpawnedTestServer::TYPE_HTTPS,
-                                SpawnedTestServer::TYPE_HTTPS);
+TEST_F(URLRequestTestReferrerPolicy, HTTPSToCrossOriginHTTPS) {
+  InstantiateCrossOriginServers(true, true);
 
   VerifyReferrerAfterRedirect(
       URLRequest::CLEAR_REFERRER_ON_TRANSITION_FROM_SECURE_TO_INSECURE,
-      origin_server()->GetURL("path/to/file.html"),
-      origin_server()->GetURL("path/to/file.html"));
+      origin_server()->GetURL("/path/to/file.html"),
+      origin_server()->GetURL("/path/to/file.html"));
 
   VerifyReferrerAfterRedirect(
       URLRequest::REDUCE_REFERRER_GRANULARITY_ON_TRANSITION_CROSS_ORIGIN,
-      origin_server()->GetURL("path/to/file.html"),
-      origin_server()->GetURL(std::string()));
+      origin_server()->GetURL("/path/to/file.html"),
+      origin_server()->GetURL("/"));
 
   VerifyReferrerAfterRedirect(
       URLRequest::ORIGIN_ONLY_ON_TRANSITION_CROSS_ORIGIN,
-      origin_server()->GetURL("path/to/file.html"),
-      origin_server()->GetURL(std::string()));
+      origin_server()->GetURL("/path/to/file.html"),
+      origin_server()->GetURL("/"));
 
   VerifyReferrerAfterRedirect(URLRequest::NEVER_CLEAR_REFERRER,
-                              origin_server()->GetURL("path/to/file.html"),
-                              origin_server()->GetURL("path/to/file.html"));
+                              origin_server()->GetURL("/path/to/file.html"),
+                              origin_server()->GetURL("/path/to/file.html"));
 }
 
-// Can't spin up more than one SpawnedTestServer on Android.
-#if defined(OS_ANDROID)
-#define MAYBE_HTTPToHTTPS DISABLED_HTTPToHTTPS
-#else
-#define MAYBE_HTTPToHTTPS HTTPToHTTPS
-#endif
-TEST_F(URLRequestTestReferrerPolicy, MAYBE_HTTPToHTTPS) {
-  InstantiateCrossOriginServers(SpawnedTestServer::TYPE_HTTP,
-                                SpawnedTestServer::TYPE_HTTPS);
+TEST_F(URLRequestTestReferrerPolicy, HTTPToHTTPS) {
+  InstantiateCrossOriginServers(false, true);
 
   VerifyReferrerAfterRedirect(
       URLRequest::CLEAR_REFERRER_ON_TRANSITION_FROM_SECURE_TO_INSECURE,
-      origin_server()->GetURL("path/to/file.html"),
-      origin_server()->GetURL("path/to/file.html"));
+      origin_server()->GetURL("/path/to/file.html"),
+      origin_server()->GetURL("/path/to/file.html"));
 
   VerifyReferrerAfterRedirect(
       URLRequest::REDUCE_REFERRER_GRANULARITY_ON_TRANSITION_CROSS_ORIGIN,
-      origin_server()->GetURL("path/to/file.html"),
-      origin_server()->GetURL(std::string()));
+      origin_server()->GetURL("/path/to/file.html"),
+      origin_server()->GetURL("/"));
 
   VerifyReferrerAfterRedirect(
       URLRequest::ORIGIN_ONLY_ON_TRANSITION_CROSS_ORIGIN,
-      origin_server()->GetURL("path/to/file.html"),
-      origin_server()->GetURL(std::string()));
+      origin_server()->GetURL("/path/to/file.html"),
+      origin_server()->GetURL("/"));
 
   VerifyReferrerAfterRedirect(URLRequest::NEVER_CLEAR_REFERRER,
-                              origin_server()->GetURL("path/to/file.html"),
-                              origin_server()->GetURL("path/to/file.html"));
+                              origin_server()->GetURL("/path/to/file.html"),
+                              origin_server()->GetURL("/path/to/file.html"));
 }
 
-// Can't spin up more than one SpawnedTestServer on Android.
-#if defined(OS_ANDROID)
-#define MAYBE_HTTPSToHTTP DISABLED_HTTPSToHTTP
-#else
-#define MAYBE_HTTPSToHTTP HTTPSToHTTP
-#endif
-TEST_F(URLRequestTestReferrerPolicy, MAYBE_HTTPSToHTTP) {
-  InstantiateCrossOriginServers(SpawnedTestServer::TYPE_HTTPS,
-                                SpawnedTestServer::TYPE_HTTP);
+TEST_F(URLRequestTestReferrerPolicy, HTTPSToHTTP) {
+  InstantiateCrossOriginServers(true, false);
 
   VerifyReferrerAfterRedirect(
       URLRequest::CLEAR_REFERRER_ON_TRANSITION_FROM_SECURE_TO_INSECURE,
-      origin_server()->GetURL("path/to/file.html"), GURL());
+      origin_server()->GetURL("/path/to/file.html"), GURL());
 
   VerifyReferrerAfterRedirect(
       URLRequest::REDUCE_REFERRER_GRANULARITY_ON_TRANSITION_CROSS_ORIGIN,
-      origin_server()->GetURL("path/to/file.html"), GURL());
+      origin_server()->GetURL("/path/to/file.html"), GURL());
 
   VerifyReferrerAfterRedirect(
       URLRequest::ORIGIN_ONLY_ON_TRANSITION_CROSS_ORIGIN,
-      origin_server()->GetURL("path/to/file.html"),
-      origin_server()->GetURL(std::string()));
+      origin_server()->GetURL("/path/to/file.html"),
+      origin_server()->GetURL("/"));
 
   VerifyReferrerAfterRedirect(URLRequest::NEVER_CLEAR_REFERRER,
-                              origin_server()->GetURL("path/to/file.html"),
-                              origin_server()->GetURL("path/to/file.html"));
+                              origin_server()->GetURL("/path/to/file.html"),
+                              origin_server()->GetURL("/path/to/file.html"));
 }
 
 class HTTPSRequestTest : public testing::Test {
  public:
   HTTPSRequestTest() : default_context_(true) {
     default_context_.set_network_delegate(&default_network_delegate_);
     default_context_.Init();
   }
   ~HTTPSRequestTest() override {}
 
  protected:
   TestNetworkDelegate default_network_delegate_;  // Must outlive URLRequest.
   TestURLRequestContext default_context_;
 };
 
 TEST_F(HTTPSRequestTest, HTTPSGetTest) {
-  SpawnedTestServer test_server(
-      SpawnedTestServer::TYPE_HTTPS,
-      SpawnedTestServer::kLocalhost,
+  EmbeddedTestServer test_server(net::EmbeddedTestServer::TYPE_HTTPS);
+  test_server.AddDefaultHandlers(
       base::FilePath(FILE_PATH_LITERAL("net/data/ssl")));
   ASSERT_TRUE(test_server.Start());
 
   TestDelegate d;
   {
     scoped_ptr<URLRequest> r(default_context_.CreateRequest(
-        test_server.GetURL(std::string()), DEFAULT_PRIORITY, &d));
+        test_server.GetURL("/defaultresponse"), DEFAULT_PRIORITY, &d));
     r->Start();
     EXPECT_TRUE(r->is_pending());
 
     base::RunLoop().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) {
-  SpawnedTestServer::SSLOptions ssl_options(
-      SpawnedTestServer::SSLOptions::CERT_MISMATCHED_NAME);
-  SpawnedTestServer test_server(
-      SpawnedTestServer::TYPE_HTTPS,
-      ssl_options,
+  EmbeddedTestServer test_server(net::EmbeddedTestServer::TYPE_HTTPS);
+  test_server.SetSSLConfig(net::EmbeddedTestServer::CERT_MISMATCHED_NAME);
+  test_server.AddDefaultHandlers(
       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);
       scoped_ptr<URLRequest> r(default_context_.CreateRequest(
-          test_server.GetURL(std::string()), DEFAULT_PRIORITY, &d));
+          test_server.GetURL("/defaultresponse"), DEFAULT_PRIORITY, &d));
 
       r->Start();
       EXPECT_TRUE(r->is_pending());
 
       base::RunLoop().Run();
 
       EXPECT_EQ(1, d.response_started_count());
       EXPECT_FALSE(d.received_data_before_response());
       EXPECT_TRUE(d.have_certificate_errors());
       if (err_allowed) {
         EXPECT_NE(0, d.bytes_received());
         CheckSSLInfo(r->ssl_info());
       } else {
         EXPECT_EQ(0, d.bytes_received());
       }
     }
   }
 }
 
 TEST_F(HTTPSRequestTest, HTTPSExpiredTest) {
-  SpawnedTestServer::SSLOptions ssl_options(
-      SpawnedTestServer::SSLOptions::CERT_EXPIRED);
-  SpawnedTestServer test_server(
-      SpawnedTestServer::TYPE_HTTPS,
-      ssl_options,
+  EmbeddedTestServer test_server(net::EmbeddedTestServer::TYPE_HTTPS);
+  test_server.SetSSLConfig(net::EmbeddedTestServer::CERT_EXPIRED);
+  test_server.AddDefaultHandlers(
       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);
       scoped_ptr<URLRequest> r(default_context_.CreateRequest(
-          test_server.GetURL(std::string()), DEFAULT_PRIORITY, &d));
+          test_server.GetURL("/defaultresponse"), DEFAULT_PRIORITY, &d));
 
       r->Start();
       EXPECT_TRUE(r->is_pending());
 
       base::RunLoop().Run();
 
       EXPECT_EQ(1, d.response_started_count());
       EXPECT_FALSE(d.received_data_before_response());
       EXPECT_TRUE(d.have_certificate_errors());
       if (err_allowed) {
         EXPECT_NE(0, d.bytes_received());
         CheckSSLInfo(r->ssl_info());
       } else {
         EXPECT_EQ(0, d.bytes_received());
       }
     }
   }
 }
 
+#if !defined(OS_IOS)
 // 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) {
-  SpawnedTestServer::SSLOptions ssl_options(
-      SpawnedTestServer::SSLOptions::CERT_MISMATCHED_NAME);
-  SpawnedTestServer test_server(
-      SpawnedTestServer::TYPE_HTTPS,
-      ssl_options,
-      base::FilePath(FILE_PATH_LITERAL("net/data/ssl")));
+  EmbeddedTestServer test_server(net::EmbeddedTestServer::TYPE_HTTPS);
+  test_server.SetSSLConfig(net::EmbeddedTestServer::CERT_MISMATCHED_NAME);
+  test_server.ServeFilesFromSourceDirectory("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 18 matching lines @@
   EXPECT_FALSE(d.received_data_before_response());
   EXPECT_TRUE(d.have_certificate_errors());
   EXPECT_TRUE(d.certificate_errors_are_fatal());
 }
 
 // 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.
-  SpawnedTestServer::SSLOptions ssl_options(
-      SpawnedTestServer::SSLOptions::CERT_MISMATCHED_NAME);
-  SpawnedTestServer test_server(
-      SpawnedTestServer::TYPE_HTTPS,
-      ssl_options,
-      base::FilePath(FILE_PATH_LITERAL("net/data/ssl")));
+  EmbeddedTestServer test_server(net::EmbeddedTestServer::TYPE_HTTPS);
+  test_server.SetSSLConfig(net::EmbeddedTestServer::CERT_MISMATCHED_NAME);
+  test_server.ServeFilesFromSourceDirectory("net/data/ssl");
   ASSERT_TRUE(test_server.Start());
 
   // We require that the URL be www.google.com in order to pick up the static
   // and dynamic STS and PKP 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 51 matching lines @@
   EXPECT_TRUE(FingerprintsEqual(new_static_pkp_state.spki_hashes,
                                 static_pkp_state.spki_hashes));
   EXPECT_TRUE(FingerprintsEqual(new_static_pkp_state.bad_spki_hashes,
                                 static_pkp_state.bad_spki_hashes));
 }
 
 // Make sure HSTS preserves a POST request's method and body.
 TEST_F(HTTPSRequestTest, HSTSPreservesPosts) {
   static const char kData[] = "hello world";
 
-  SpawnedTestServer::SSLOptions ssl_options(
-      SpawnedTestServer::SSLOptions::CERT_OK);
-  SpawnedTestServer test_server(
-      SpawnedTestServer::TYPE_HTTPS,
-      ssl_options,
+  EmbeddedTestServer test_server(net::EmbeddedTestServer::TYPE_HTTPS);
+  test_server.AddDefaultHandlers(
       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 SpawnedTestServer.  By default, MockHostResolver maps all hosts
+  // the EmbeddedTestServer.  By default, MockHostResolver maps all hosts
   // to 127.0.0.1.
   MockHostResolver host_resolver;
 
   // Force https for www.somewhere.com.
   TransportSecurityState transport_security_state;
   base::Time expiry = base::Time::Now() + base::TimeDelta::FromDays(1000);
   bool include_subdomains = false;
   transport_security_state.AddHSTS("www.somewhere.com", expiry,
                                    include_subdomains);
 
@@ skipping 27 matching lines @@
   LoadTimingInfo load_timing_info;
   network_delegate.GetLoadTimingInfoBeforeRedirect(&load_timing_info);
   // LoadTimingInfo of HSTS redirects is similar to that of network cache hits
   TestLoadTimingCacheHitNoNetwork(load_timing_info);
 }
 
 // Make sure that the CORS headers are added to cross-origin HSTS redirects.
 TEST_F(HTTPSRequestTest, HSTSCrossOriginAddHeaders) {
   static const char kOriginHeaderValue[] = "http://www.example.com";
 
-  SpawnedTestServer::SSLOptions ssl_options(
-      SpawnedTestServer::SSLOptions::CERT_OK);
-  SpawnedTestServer test_server(
-      SpawnedTestServer::TYPE_HTTPS,
-      ssl_options,
-      base::FilePath(FILE_PATH_LITERAL("net/data/ssl")));
+  EmbeddedTestServer test_server(net::EmbeddedTestServer::TYPE_HTTPS);
+  test_server.ServeFilesFromSourceDirectory("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 example.net to the
-  // SpawnedTestServer. MockHostResolver maps all hosts to 127.0.0.1 by default.
+  // EmbeddedTestServer. MockHostResolver maps all hosts to 127.0.0.1 by
+  // default.
   MockHostResolver host_resolver;
 
   TransportSecurityState transport_security_state;
   base::Time expiry = base::Time::Now() + base::TimeDelta::FromDays(1);
   bool include_subdomains = false;
   transport_security_state.AddHSTS("example.net", expiry, include_subdomains);
 
   TestNetworkDelegate network_delegate;  // Must outlive URLRequest.
 
   MockCertVerifier cert_verifier;
@@ skipping 79 matching lines @@
 };
 
 }  // namespace
 
 // 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) {
-  SpawnedTestServer::SSLOptions ssl_options;
-  ssl_options.request_client_certificate = true;
-  SpawnedTestServer test_server(
-      SpawnedTestServer::TYPE_HTTPS,
-      ssl_options,
+  EmbeddedTestServer test_server(net::EmbeddedTestServer::TYPE_HTTPS);
+  net::SSLServerConfig ssl_config;
+  ssl_config.require_client_cert = true;
+  test_server.SetSSLConfig(net::EmbeddedTestServer::CERT_OK, ssl_config);
+  test_server.AddDefaultHandlers(
       base::FilePath(FILE_PATH_LITERAL("net/data/ssl")));
   ASSERT_TRUE(test_server.Start());
 
   SSLClientAuthTestDelegate d;
   {
     scoped_ptr<URLRequest> r(default_context_.CreateRequest(
-        test_server.GetURL(std::string()), DEFAULT_PRIORITY, &d));
+        test_server.GetURL("/defaultresponse"), DEFAULT_PRIORITY, &d));
 
     r->Start();
     EXPECT_TRUE(r->is_pending());
 
     base::RunLoop().Run();
 
     EXPECT_EQ(1, d.on_certificate_requested_count());
     EXPECT_FALSE(d.received_data_before_response());
     EXPECT_EQ(0, d.bytes_received());
 
@@ skipping 184 matching lines @@
 }  // namespace
 
 // Test that ECDSA is disabled on Windows XP, where ECDSA certificates cannot be
 // verified.
 TEST_F(HTTPSRequestTest, DisableECDSAOnXP) {
   if (base::win::GetVersion() >= base::win::VERSION_VISTA) {
     LOG(INFO) << "Skipping test on this version.";
     return;
   }
 
-  SpawnedTestServer test_server(
-      SpawnedTestServer::TYPE_HTTPS,
-      SpawnedTestServer::kLocalhost,
-      base::FilePath(FILE_PATH_LITERAL("net/data/ssl")));
+  EmbeddedTestServer test_server(net::EmbeddedTestServer::TYPE_HTTPS);
+  test_server.ServeFilesFromSourceDirectory("net/data/ssl");
   ASSERT_TRUE(test_server.Start());
 
   TestDelegate d;
   scoped_ptr<URLRequest> r(default_context_.CreateRequest(
-      test_server.GetURL("client-cipher-list"), DEFAULT_PRIORITY, &d));
+      test_server.GetURL("/client-cipher-list"), DEFAULT_PRIORITY, &d));
   r->Start();
   EXPECT_TRUE(r->is_pending());
 
   base::RunLoop().Run();
 
   EXPECT_EQ(1, d.response_started_count());
   std::vector<std::string> lines = base::SplitString(
       d.data_received(), "\n", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
 
   for (size_t i = 0; i < lines.size(); i++) {
@@ skipping 78 matching lines @@
     DCHECK(!request_);
     context_.Init();
     delegate_.set_allow_certificate_errors(true);
 
     SpawnedTestServer test_server(
         SpawnedTestServer::TYPE_HTTPS,
         ssl_options,
         base::FilePath(FILE_PATH_LITERAL("net/data/ssl")));
     ASSERT_TRUE(test_server.Start());
 
-    request_ = context_.CreateRequest(test_server.GetURL(std::string()),
-                                      DEFAULT_PRIORITY, &delegate_);
+    request_ = context_.CreateRequest(test_server.GetURL("/"), DEFAULT_PRIORITY,
+                                      &delegate_);
     request_->Start();
 
     base::RunLoop().Run();
   }
 
   void set_fallback_min_version(uint16 version) {
     context_.set_fallback_min_version(version);
   }
 
   void ExpectConnection(int version) {
@@ skipping 134 matching lines @@
   // Make a connection that does a probe fallback to TLSv1 but fails because
   // TLSv1 fallback is disabled. We don't wish a session for this connection to
   // be inserted locally.
   {
     TestDelegate delegate;
     FallbackTestURLRequestContext context(true);
 
     context.set_fallback_min_version(SSL_PROTOCOL_VERSION_TLS1_2);
     context.Init();
     scoped_ptr<URLRequest> request(context.CreateRequest(
-        test_server.GetURL(std::string()), DEFAULT_PRIORITY, &delegate));
+        test_server.GetURL("/"), DEFAULT_PRIORITY, &delegate));
     request->Start();
 
     base::RunLoop().Run();
 
     EXPECT_EQ(1, delegate.response_started_count());
     EXPECT_FALSE(request->status().is_success());
     EXPECT_EQ(URLRequestStatus::FAILED, request->status().status());
     EXPECT_EQ(ERR_SSL_FALLBACK_BEYOND_MINIMUM_VERSION,
               request->status().error());
   }
@@ skipping 154 matching lines @@
     // We always overwrite out_cert_status.
     *out_cert_status = 0;
     SpawnedTestServer test_server(
         SpawnedTestServer::TYPE_HTTPS,
         ssl_options,
         base::FilePath(FILE_PATH_LITERAL("net/data/ssl")));
     ASSERT_TRUE(test_server.Start());
 
     TestDelegate d;
     d.set_allow_certificate_errors(true);
-    scoped_ptr<URLRequest> r(context_.CreateRequest(
-        test_server.GetURL(std::string()), DEFAULT_PRIORITY, &d));
+    scoped_ptr<URLRequest> r(
+        context_.CreateRequest(test_server.GetURL("/"), DEFAULT_PRIORITY, &d));
     r->Start();
 
     base::RunLoop().Run();
 
     EXPECT_EQ(1, d.response_started_count());
     *out_cert_status = r->ssl_info().cert_status;
   }
 
   ~HTTPSOCSPTest() override {
 #if defined(USE_NSS_CERTS) || defined(OS_IOS)
@@ skipping 475 matching lines @@
 #endif  // !defined(OS_IOS)
 
 #if !defined(DISABLE_FTP_SUPPORT) && !defined(OS_ANDROID)
 // These tests aren't passing on Android.  Either the RemoteTestServer isn't
 // starting up successfully, or it can't access the test files.
 // TODO(mmenke):  Fix this.  See http://crbug.com/495220
 class URLRequestTestFTP : public URLRequestTest {
  public:
   URLRequestTestFTP()
       : ftp_transaction_factory_(&host_resolver_),
-        test_server_(SpawnedTestServer::TYPE_FTP,
-                     SpawnedTestServer::kLocalhost,
-                     base::FilePath(kTestFilePath)) {
+        ftp_test_server_(SpawnedTestServer::TYPE_FTP,
+                         SpawnedTestServer::kLocalhost,
+                         base::FilePath(kTestFilePath)) {
     // Can't use |default_context_|'s HostResolver to set up the
     // FTPTransactionFactory because it hasn't been created yet.
     default_context_.set_host_resolver(&host_resolver_);
   }
 
   // URLRequestTest interface:
   void SetUpFactory() override {
     // Add FTP support to the default URLRequestContext.
     job_factory_impl_->SetProtocolHandler(
         "ftp",
         make_scoped_ptr(new FtpProtocolHandler(&ftp_transaction_factory_)));
   }
 
   std::string GetTestFileContents() {
     base::FilePath path;
     EXPECT_TRUE(PathService::Get(base::DIR_SOURCE_ROOT, &path));
     path = path.Append(kTestFilePath);
     path = path.AppendASCII(kFtpTestFile);
     std::string contents;
     EXPECT_TRUE(base::ReadFileToString(path, &contents));
     return contents;
   }
 
  protected:
   MockHostResolver host_resolver_;
   FtpNetworkLayer ftp_transaction_factory_;
 
-  SpawnedTestServer test_server_;
+  SpawnedTestServer ftp_test_server_;
 };
 
 // Make sure an FTP request using an unsafe ports fails.
 TEST_F(URLRequestTestFTP, UnsafePort) {
   GURL url("ftp://127.0.0.1:7");
 
   TestDelegate d;
   {
     scoped_ptr<URLRequest> r(
         default_context_.CreateRequest(url, DEFAULT_PRIORITY, &d));
     r->Start();
     EXPECT_TRUE(r->is_pending());
 
     base::RunLoop().Run();
 
     EXPECT_FALSE(r->is_pending());
     EXPECT_EQ(URLRequestStatus::FAILED, r->status().status());
     EXPECT_EQ(ERR_UNSAFE_PORT, r->status().error());
   }
 }
 
 TEST_F(URLRequestTestFTP, FTPDirectoryListing) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(ftp_test_server_.Start());
 
   TestDelegate d;
   {
     scoped_ptr<URLRequest> r(default_context_.CreateRequest(
-        test_server_.GetURL("/"), DEFAULT_PRIORITY, &d));
+        ftp_test_server_.GetURL("/"), DEFAULT_PRIORITY, &d));
     r->Start();
     EXPECT_TRUE(r->is_pending());
 
     base::RunLoop().Run();
 
     EXPECT_FALSE(r->is_pending());
     EXPECT_EQ(1, d.response_started_count());
     EXPECT_FALSE(d.received_data_before_response());
     EXPECT_LT(0, d.bytes_received());
-    EXPECT_EQ(test_server_.host_port_pair().host(),
+    EXPECT_EQ(ftp_test_server_.host_port_pair().host(),
               r->GetSocketAddress().host());
-    EXPECT_EQ(test_server_.host_port_pair().port(),
+    EXPECT_EQ(ftp_test_server_.host_port_pair().port(),
               r->GetSocketAddress().port());
   }
 }
 
 TEST_F(URLRequestTestFTP, FTPGetTestAnonymous) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(ftp_test_server_.Start());
 
   TestDelegate d;
   {
     scoped_ptr<URLRequest> r(default_context_.CreateRequest(
-        test_server_.GetURL(kFtpTestFile), DEFAULT_PRIORITY, &d));
+        ftp_test_server_.GetURL(kFtpTestFile), DEFAULT_PRIORITY, &d));
     r->Start();
     EXPECT_TRUE(r->is_pending());
 
     base::RunLoop().Run();
 
     EXPECT_FALSE(r->is_pending());
     EXPECT_EQ(1, d.response_started_count());
     EXPECT_FALSE(d.received_data_before_response());
     EXPECT_EQ(GetTestFileContents(), d.data_received());
-    EXPECT_EQ(test_server_.host_port_pair().host(),
+    EXPECT_EQ(ftp_test_server_.host_port_pair().host(),
               r->GetSocketAddress().host());
-    EXPECT_EQ(test_server_.host_port_pair().port(),
+    EXPECT_EQ(ftp_test_server_.host_port_pair().port(),
               r->GetSocketAddress().port());
   }
 }
 
 TEST_F(URLRequestTestFTP, FTPGetTest) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(ftp_test_server_.Start());
 
   TestDelegate d;
   {
-    scoped_ptr<URLRequest> r(
-        default_context_.CreateRequest(test_server_.GetURLWithUserAndPassword(
-                                           kFtpTestFile, "chrome", "chrome"),
-                                       DEFAULT_PRIORITY, &d));
+    scoped_ptr<URLRequest> r(default_context_.CreateRequest(
+        ftp_test_server_.GetURLWithUserAndPassword(kFtpTestFile, "chrome",
+                                                   "chrome"),
+        DEFAULT_PRIORITY, &d));
     r->Start();
     EXPECT_TRUE(r->is_pending());
 
     base::RunLoop().Run();
 
     EXPECT_FALSE(r->is_pending());
     EXPECT_EQ(1, d.response_started_count());
     EXPECT_FALSE(d.received_data_before_response());
     EXPECT_EQ(GetTestFileContents(), d.data_received());
-    EXPECT_EQ(test_server_.host_port_pair().host(),
+    EXPECT_EQ(ftp_test_server_.host_port_pair().host(),
               r->GetSocketAddress().host());
-    EXPECT_EQ(test_server_.host_port_pair().port(),
+    EXPECT_EQ(ftp_test_server_.host_port_pair().port(),
               r->GetSocketAddress().port());
 
     LoadTimingInfo load_timing_info;
     r->GetLoadTimingInfo(&load_timing_info);
     TestLoadTimingNoHttpResponse(load_timing_info);
   }
 }
 
 TEST_F(URLRequestTestFTP, FTPCheckWrongPassword) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(ftp_test_server_.Start());
 
   TestDelegate d;
   {
     scoped_ptr<URLRequest> r(default_context_.CreateRequest(
-        test_server_.GetURLWithUserAndPassword(kFtpTestFile, "chrome",
-                                               "wrong_password"),
+        ftp_test_server_.GetURLWithUserAndPassword(kFtpTestFile, "chrome",
+                                                   "wrong_password"),
         DEFAULT_PRIORITY, &d));
     r->Start();
     EXPECT_TRUE(r->is_pending());
 
     base::RunLoop().Run();
 
     EXPECT_FALSE(r->is_pending());
     EXPECT_EQ(1, d.response_started_count());
     EXPECT_FALSE(d.received_data_before_response());
     EXPECT_EQ(d.bytes_received(), 0);
   }
 }
 
 TEST_F(URLRequestTestFTP, FTPCheckWrongPasswordRestart) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(ftp_test_server_.Start());
 
   TestDelegate d;
   // Set correct login credentials. The delegate will be asked for them when
   // the initial login with wrong credentials will fail.
   d.set_credentials(AuthCredentials(kChrome, kChrome));
   {
     scoped_ptr<URLRequest> r(default_context_.CreateRequest(
-        test_server_.GetURLWithUserAndPassword(kFtpTestFile, "chrome",
-                                               "wrong_password"),
+        ftp_test_server_.GetURLWithUserAndPassword(kFtpTestFile, "chrome",
+                                                   "wrong_password"),
         DEFAULT_PRIORITY, &d));
     r->Start();
     EXPECT_TRUE(r->is_pending());
 
     base::RunLoop().Run();
 
     EXPECT_FALSE(r->is_pending());
     EXPECT_EQ(1, d.response_started_count());
     EXPECT_FALSE(d.received_data_before_response());
     EXPECT_EQ(GetTestFileContents(), d.data_received());
   }
 }
 
 TEST_F(URLRequestTestFTP, FTPCheckWrongUser) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(ftp_test_server_.Start());
 
   TestDelegate d;
   {
     scoped_ptr<URLRequest> r(default_context_.CreateRequest(
-        test_server_.GetURLWithUserAndPassword(kFtpTestFile, "wrong_user",
-                                               "chrome"),
+        ftp_test_server_.GetURLWithUserAndPassword(kFtpTestFile, "wrong_user",
+                                                   "chrome"),
         DEFAULT_PRIORITY, &d));
     r->Start();
     EXPECT_TRUE(r->is_pending());
 
     base::RunLoop().Run();
 
     EXPECT_FALSE(r->is_pending());
     EXPECT_EQ(1, d.response_started_count());
     EXPECT_FALSE(d.received_data_before_response());
     EXPECT_EQ(0, d.bytes_received());
   }
 }
 
 TEST_F(URLRequestTestFTP, FTPCheckWrongUserRestart) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(ftp_test_server_.Start());
 
   TestDelegate d;
   // Set correct login credentials. The delegate will be asked for them when
   // the initial login with wrong credentials will fail.
   d.set_credentials(AuthCredentials(kChrome, kChrome));
   {
     scoped_ptr<URLRequest> r(default_context_.CreateRequest(
-        test_server_.GetURLWithUserAndPassword(kFtpTestFile, "wrong_user",
-                                               "chrome"),
+        ftp_test_server_.GetURLWithUserAndPassword(kFtpTestFile, "wrong_user",
+                                                   "chrome"),
         DEFAULT_PRIORITY, &d));
     r->Start();
     EXPECT_TRUE(r->is_pending());
 
     base::RunLoop().Run();
 
     EXPECT_FALSE(r->is_pending());
     EXPECT_EQ(1, d.response_started_count());
     EXPECT_FALSE(d.received_data_before_response());
     EXPECT_EQ(GetTestFileContents(), d.data_received());
   }
 }
 
 TEST_F(URLRequestTestFTP, FTPCacheURLCredentials) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(ftp_test_server_.Start());
 
   scoped_ptr<TestDelegate> d(new TestDelegate);
   {
     // Pass correct login identity in the URL.
-    scoped_ptr<URLRequest> r(
-        default_context_.CreateRequest(test_server_.GetURLWithUserAndPassword(
-                                           kFtpTestFile, "chrome", "chrome"),
-                                       DEFAULT_PRIORITY, d.get()));
+    scoped_ptr<URLRequest> r(default_context_.CreateRequest(
+        ftp_test_server_.GetURLWithUserAndPassword(kFtpTestFile, "chrome",
+                                                   "chrome"),
+        DEFAULT_PRIORITY, d.get()));
     r->Start();
     EXPECT_TRUE(r->is_pending());
 
     base::RunLoop().Run();
 
     EXPECT_FALSE(r->is_pending());
     EXPECT_EQ(1, d->response_started_count());
     EXPECT_FALSE(d->received_data_before_response());
     EXPECT_EQ(GetTestFileContents(), d->data_received());
   }
 
   d.reset(new TestDelegate);
   {
     // This request should use cached identity from previous request.
     scoped_ptr<URLRequest> r(default_context_.CreateRequest(
-        test_server_.GetURL(kFtpTestFile), DEFAULT_PRIORITY, d.get()));
+        ftp_test_server_.GetURL(kFtpTestFile), DEFAULT_PRIORITY, d.get()));
     r->Start();
     EXPECT_TRUE(r->is_pending());
 
     base::RunLoop().Run();
 
     EXPECT_FALSE(r->is_pending());
     EXPECT_EQ(1, d->response_started_count());
     EXPECT_FALSE(d->received_data_before_response());
     EXPECT_EQ(GetTestFileContents(), d->data_received());
   }
 }
 
 TEST_F(URLRequestTestFTP, FTPCacheLoginBoxCredentials) {
-  ASSERT_TRUE(test_server_.Start());
+  ASSERT_TRUE(ftp_test_server_.Start());
 
   scoped_ptr<TestDelegate> d(new TestDelegate);
   // Set correct login credentials. The delegate will be asked for them when
   // the initial login with wrong credentials will fail.
   d->set_credentials(AuthCredentials(kChrome, kChrome));
   {
     scoped_ptr<URLRequest> r(default_context_.CreateRequest(
-        test_server_.GetURLWithUserAndPassword(kFtpTestFile, "chrome",
-                                               "wrong_password"),
+        ftp_test_server_.GetURLWithUserAndPassword(kFtpTestFile, "chrome",
+                                                   "wrong_password"),
         DEFAULT_PRIORITY, d.get()));
     r->Start();
     EXPECT_TRUE(r->is_pending());
 
     base::RunLoop().Run();
 
     EXPECT_FALSE(r->is_pending());
     EXPECT_EQ(1, d->response_started_count());
     EXPECT_FALSE(d->received_data_before_response());
     EXPECT_EQ(GetTestFileContents(), d->data_received());
   }
 
   // Use a new delegate without explicit credentials. The cached ones should be
   // used.
   d.reset(new TestDelegate);
   {
     // Don't pass wrong credentials in the URL, they would override valid cached
     // ones.
     scoped_ptr<URLRequest> r(default_context_.CreateRequest(
-        test_server_.GetURL(kFtpTestFile), DEFAULT_PRIORITY, d.get()));
+        ftp_test_server_.GetURL(kFtpTestFile), DEFAULT_PRIORITY, d.get()));
     r->Start();
     EXPECT_TRUE(r->is_pending());
 
     base::RunLoop().Run();
 
     EXPECT_FALSE(r->is_pending());
     EXPECT_EQ(1, d->response_started_count());
     EXPECT_FALSE(d->received_data_before_response());
     EXPECT_EQ(GetTestFileContents(), d->data_received());
   }
@@ skipping 69 matching lines @@
 
   req->Start();
   req->Cancel();
   job->DetachRequest();
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(URLRequestStatus::CANCELED, req->status().status());
   EXPECT_EQ(0, d.received_redirect_count());
 }
 
 }  // namespace net