Migrating tests to use EmbeddedTestServer (/content)

content/browser/download/download_browsertest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // This file contains download browser tests that are known to be runnable
 // in a pure content context.  Over time tests should be migrated here.
 
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
@@ skipping 19 matching lines @@
 #include "content/public/test/download_test_observer.h"
 #include "content/public/test/test_file_error_injector.h"
 #include "content/public/test/test_utils.h"
 #include "content/shell/browser/shell.h"
 #include "content/shell/browser/shell_browser_context.h"
 #include "content/shell/browser/shell_download_manager_delegate.h"
 #include "content/shell/browser/shell_network_delegate.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_mock_http_job.h"

[mmenke, 2015/11/03 19:12:57]

Why did you remove the spawned_test_server header?  This file is still using it.

[svaldez, 2015/11/03 19:33:16]

Done.

 #include "net/test/url_request/url_request_slow_download_job.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
 #if defined(ENABLE_PLUGINS)
 #include "content/browser/plugin_service_impl.h"
 #endif
 
-using ::net::test_server::EmbeddedTestServer;
 using ::testing::AllOf;
 using ::testing::Field;
 using ::testing::InSequence;
 using ::testing::Property;
 using ::testing::Return;
 using ::testing::StrictMock;
 using ::testing::_;
 
 namespace content {
 
@@ skipping 452 matching lines @@
   if (request.relative_url == relative_url) {
     response.reset(new net::test_server::BasicHttpResponse);
     response->set_code(net::HTTP_FOUND);
     response->AddCustomHeader("Location", target_url.spec());
   }
   return response.Pass();
 }
 
 // Creates a request handler for EmbeddedTestServer that responds with a HTTP
 // 302 redirect if the request URL matches |relative_url|.
-EmbeddedTestServer::HandleRequestCallback CreateRedirectHandler(
+net::EmbeddedTestServer::HandleRequestCallback CreateRedirectHandler(
     const std::string& relative_url,
     const GURL& target_url) {
   return base::Bind(
       &HandleRequestAndSendRedirectResponse, relative_url, target_url);
 }
 
 // Request handler to be used with CreateBasicResponseHandler().
 scoped_ptr<net::test_server::HttpResponse> HandleRequestAndSendBasicResponse(
     const std::string& relative_url,
     const std::string& content_type,
     const std::string& body,
     const net::test_server::HttpRequest& request) {
   scoped_ptr<net::test_server::BasicHttpResponse> response;
   if (request.relative_url == relative_url) {
     response.reset(new net::test_server::BasicHttpResponse);
     response->set_content_type(content_type);
     response->set_content(body);
   }
   return response.Pass();
 }
 
 // Creates a request handler for an EmbeddedTestServer that response with an
 // HTTP 200 status code, a Content-Type header and a body.
-EmbeddedTestServer::HandleRequestCallback CreateBasicResponseHandler(
+net::EmbeddedTestServer::HandleRequestCallback CreateBasicResponseHandler(
     const std::string& relative_url,
     const std::string& content_type,
     const std::string& body) {
   return base::Bind(
       &HandleRequestAndSendBasicResponse, relative_url, content_type, body);
 }
 
 }  // namespace
 
 class DownloadContentTest : public ContentBrowserTest {
@@ skipping 136 matching lines @@
     ASSERT_EQ(size, download->GetReceivedBytes());
     ASSERT_EQ(DownloadItem::IN_PROGRESS, download->GetState());
   }
 
   // Tell the test server to release a pending RST and confirm
   // that the interrupt is received properly (for download resumption
   // testing).
   void ReleaseRSTAndConfirmInterruptForResume(DownloadItem* download) {
     scoped_ptr<DownloadTestObserver> rst_observer(
         CreateInterruptedWaiter(shell(), 1));
-    NavigateToURL(shell(), test_server()->GetURL("download-finish"));
+    NavigateToURL(shell(), spawned_test_server()->GetURL("download-finish"));
     rst_observer->WaitForFinished();
     EXPECT_EQ(DownloadItem::INTERRUPTED, download->GetState());
   }
 
   // Confirm file status expected for the given location in a stream
   // provided by the resume test server.
   void ConfirmFileStatusForResume(
       DownloadItem* download, bool file_exists,
       int received_bytes, int total_bytes,
       const base::FilePath& expected_filename) {
@@ skipping 349 matching lines @@
   EXPECT_CALL(observer, OnDownloadDestroyed(items[0]));
 
   // Shutdown the download manager.  Mostly this is confirming a lack of
   // crashes.
   DownloadManagerForShell(shell())->Shutdown();
 }
 
 IN_PROC_BROWSER_TEST_F(DownloadContentTest, ResumeInterruptedDownload) {
   base::CommandLine::ForCurrentProcess()->AppendSwitch(
       switches::kEnableDownloadResumption);
-  ASSERT_TRUE(test_server()->Start());
+  ASSERT_TRUE(spawned_test_server()->Start());
 
-  GURL url = test_server()->GetURL(
+  GURL url = spawned_test_server()->GetURL(
       base::StringPrintf("rangereset?size=%d&rst_boundary=%d",
-                   GetSafeBufferChunk() * 3, GetSafeBufferChunk()));
+                         GetSafeBufferChunk() * 3, GetSafeBufferChunk()));
 
   MockDownloadManagerObserver dm_observer(DownloadManagerForShell(shell()));
   EXPECT_CALL(dm_observer, OnDownloadCreated(_,_)).Times(1);
 
   DownloadItem* download(StartDownloadAndReturnItem(url));
   WaitForData(download, GetSafeBufferChunk());
   ::testing::Mock::VerifyAndClearExpectations(&dm_observer);
 
   // Confirm resumption while in progress doesn't do anything.
   download->Resume();
@@ skipping 42 matching lines @@
   ASSERT_EQ(DownloadItem::COMPLETE, download->GetState());
   RunAllPendingInMessageLoop();
   ASSERT_EQ(GetSafeBufferChunk() * 3, download->GetReceivedBytes());
   ASSERT_EQ(DownloadItem::COMPLETE, download->GetState());
 }
 
 // Confirm restart fallback happens if a range request is bounced.
 IN_PROC_BROWSER_TEST_F(DownloadContentTest, ResumeInterruptedDownloadNoRange) {
   base::CommandLine::ForCurrentProcess()->AppendSwitch(
       switches::kEnableDownloadResumption);
-  ASSERT_TRUE(test_server()->Start());
+  ASSERT_TRUE(spawned_test_server()->Start());
 
   // Auto-restart if server doesn't handle ranges.
-  GURL url = test_server()->GetURL(
-      base::StringPrintf(
-          // First download hits an RST, rest don't, no ranges.
-          "rangereset?size=%d&rst_boundary=%d&"
-          "token=NoRange&rst_limit=1&bounce_range",
-          GetSafeBufferChunk() * 3, GetSafeBufferChunk()));
+  GURL url = spawned_test_server()->GetURL(base::StringPrintf(
+      // First download hits an RST, rest don't, no ranges.
+      "rangereset?size=%d&rst_boundary=%d&"
+      "token=NoRange&rst_limit=1&bounce_range",
+      GetSafeBufferChunk() * 3, GetSafeBufferChunk()));
 
   // Start the download and wait for first data chunk.
   DownloadItem* download(StartDownloadAndReturnItem(url));
   WaitForData(download, GetSafeBufferChunk());
 
   RecordingDownloadObserver recorder(download);
 
   ReleaseRSTAndConfirmInterruptForResume(download);
   ConfirmFileStatusForResume(
       download, true, GetSafeBufferChunk(), GetSafeBufferChunk() * 3,
@@ skipping 20 matching lines @@
   };
 
   recorder.CompareToExpectedRecord(expected_record, arraysize(expected_record));
 }
 
 // Confirm restart fallback happens if a precondition is failed.
 IN_PROC_BROWSER_TEST_F(DownloadContentTest,
                        ResumeInterruptedDownloadBadPrecondition) {
   base::CommandLine::ForCurrentProcess()->AppendSwitch(
       switches::kEnableDownloadResumption);
-  ASSERT_TRUE(test_server()->Start());
+  ASSERT_TRUE(spawned_test_server()->Start());
 
-  GURL url = test_server()->GetURL(base::StringPrintf(
+  GURL url = spawned_test_server()->GetURL(base::StringPrintf(
       // First download hits an RST, rest don't, precondition fail.
       "rangereset?size=%d&rst_boundary=%d&"
       "token=BadPrecondition&rst_limit=1&fail_precondition=2",
-      GetSafeBufferChunk() * 3,
-      GetSafeBufferChunk()));
+      GetSafeBufferChunk() * 3, GetSafeBufferChunk()));
 
   // Start the download and wait for first data chunk.
   DownloadItem* download(StartDownloadAndReturnItem(url));
   WaitForData(download, GetSafeBufferChunk());
 
   RecordingDownloadObserver recorder(download);
 
   ReleaseRSTAndConfirmInterruptForResume(download);
   ConfirmFileStatusForResume(
       download, true, GetSafeBufferChunk(), GetSafeBufferChunk() * 3,
@@ skipping 24 matching lines @@
   };
 
   recorder.CompareToExpectedRecord(expected_record, arraysize(expected_record));
 }
 
 // Confirm we don't try to resume if we don't have a verifier.
 IN_PROC_BROWSER_TEST_F(DownloadContentTest,
                        ResumeInterruptedDownloadNoVerifiers) {
   base::CommandLine::ForCurrentProcess()->AppendSwitch(
       switches::kEnableDownloadResumption);
-  ASSERT_TRUE(test_server()->Start());
+  ASSERT_TRUE(spawned_test_server()->Start());
 
-  GURL url = test_server()->GetURL(
-      base::StringPrintf(
-          // First download hits an RST, rest don't, no verifiers.
-          "rangereset?size=%d&rst_boundary=%d&"
-          "token=NoRange&rst_limit=1&no_verifiers",
-          GetSafeBufferChunk() * 3, GetSafeBufferChunk()));
+  GURL url = spawned_test_server()->GetURL(base::StringPrintf(
+      // First download hits an RST, rest don't, no verifiers.
+      "rangereset?size=%d&rst_boundary=%d&"
+      "token=NoRange&rst_limit=1&no_verifiers",
+      GetSafeBufferChunk() * 3, GetSafeBufferChunk()));
 
   // Start the download and wait for first data chunk.
   DownloadItem* download(StartDownloadAndReturnItem(url));
   WaitForData(download, GetSafeBufferChunk());
 
   RecordingDownloadObserver recorder(download);
 
   ReleaseRSTAndConfirmInterruptForResume(download);
   ConfirmFileStatusForResume(
       download, false, GetSafeBufferChunk(), GetSafeBufferChunk() * 3,
@@ skipping 16 matching lines @@
     // Completion.
     {DownloadItem::COMPLETE, GetSafeBufferChunk() * 3},
   };
 
   recorder.CompareToExpectedRecord(expected_record, arraysize(expected_record));
 }
 
 IN_PROC_BROWSER_TEST_F(DownloadContentTest, ResumeWithDeletedFile) {
   base::CommandLine::ForCurrentProcess()->AppendSwitch(
       switches::kEnableDownloadResumption);
-  ASSERT_TRUE(test_server()->Start());
+  ASSERT_TRUE(spawned_test_server()->Start());
 
-  GURL url = test_server()->GetURL(
-      base::StringPrintf(
-          // First download hits an RST, rest don't
-          "rangereset?size=%d&rst_boundary=%d&"
-          "token=NoRange&rst_limit=1",
-          GetSafeBufferChunk() * 3, GetSafeBufferChunk()));
+  GURL url = spawned_test_server()->GetURL(base::StringPrintf(
+      // First download hits an RST, rest don't
+      "rangereset?size=%d&rst_boundary=%d&"
+      "token=NoRange&rst_limit=1",
+      GetSafeBufferChunk() * 3, GetSafeBufferChunk()));
 
   // Start the download and wait for first data chunk.
   DownloadItem* download(StartDownloadAndReturnItem(url));
   WaitForData(download, GetSafeBufferChunk());
 
   RecordingDownloadObserver recorder(download);
 
   ReleaseRSTAndConfirmInterruptForResume(download);
   ConfirmFileStatusForResume(
       download, true, GetSafeBufferChunk(), GetSafeBufferChunk() * 3,
@@ skipping 176 matching lines @@
   download->Resume();
   completion_observer.WaitForEvent();
   EXPECT_EQ(download->GetState(), DownloadItem::COMPLETE);
 }
 
 // An interrupted download should remove the intermediate file when it is
 // cancelled.
 IN_PROC_BROWSER_TEST_F(DownloadContentTest, CancelInterruptedDownload) {
   base::CommandLine::ForCurrentProcess()->AppendSwitch(
       switches::kEnableDownloadResumption);
-  ASSERT_TRUE(test_server()->Start());
+  ASSERT_TRUE(spawned_test_server()->Start());
 
-  GURL url1 = test_server()->GetURL(
+  GURL url1 = spawned_test_server()->GetURL(
       base::StringPrintf("rangereset?size=%d&rst_boundary=%d",
                          GetSafeBufferChunk() * 3, GetSafeBufferChunk()));
 
   DownloadItem* download(StartDownloadAndReturnItem(url1));
   WaitForData(download, GetSafeBufferChunk());
 
   ReleaseRSTAndConfirmInterruptForResume(download);
   ConfirmFileStatusForResume(
       download, true, GetSafeBufferChunk(), GetSafeBufferChunk() * 3,
       base::FilePath(FILE_PATH_LITERAL("rangereset.crdownload")));
 
   base::FilePath intermediate_path(download->GetFullPath());
   ASSERT_FALSE(intermediate_path.empty());
   EXPECT_TRUE(base::PathExists(intermediate_path));
 
   download->Cancel(true /* user_cancel */);
   RunAllPendingInMessageLoop(BrowserThread::FILE);
   RunAllPendingInMessageLoop();
 
   // The intermediate file should now be gone.
   EXPECT_FALSE(base::PathExists(intermediate_path));
   EXPECT_TRUE(download->GetFullPath().empty());
 }
 
 IN_PROC_BROWSER_TEST_F(DownloadContentTest, RemoveDownload) {
   base::CommandLine::ForCurrentProcess()->AppendSwitch(
       switches::kEnableDownloadResumption);
-  ASSERT_TRUE(test_server()->Start());
+  ASSERT_TRUE(spawned_test_server()->Start());
 
   // An interrupted download should remove the intermediate file when it is
   // removed.
   {
-    GURL url1 = test_server()->GetURL(
+    GURL url1 = spawned_test_server()->GetURL(
         base::StringPrintf("rangereset?size=%d&rst_boundary=%d",
                            GetSafeBufferChunk() * 3, GetSafeBufferChunk()));
 
     DownloadItem* download(StartDownloadAndReturnItem(url1));
     WaitForData(download, GetSafeBufferChunk());
     ReleaseRSTAndConfirmInterruptForResume(download);
     ConfirmFileStatusForResume(
         download, true, GetSafeBufferChunk(), GetSafeBufferChunk() * 3,
         base::FilePath(FILE_PATH_LITERAL("rangereset.crdownload")));
 
@@ skipping 28 matching lines @@
 
     // The file should still exist.
     EXPECT_TRUE(base::PathExists(target_path));
   }
 }
 
 IN_PROC_BROWSER_TEST_F(DownloadContentTest, RemoveResumingDownload) {
   SetupEnsureNoPendingDownloads();
   base::CommandLine::ForCurrentProcess()->AppendSwitch(
       switches::kEnableDownloadResumption);
-  ASSERT_TRUE(test_server()->Start());
+  ASSERT_TRUE(spawned_test_server()->Start());
 
-  GURL url = test_server()->GetURL(
+  GURL url = spawned_test_server()->GetURL(
       base::StringPrintf("rangereset?size=%d&rst_boundary=%d",
                          GetSafeBufferChunk() * 3, GetSafeBufferChunk()));
 
   MockDownloadManagerObserver dm_observer(DownloadManagerForShell(shell()));
   EXPECT_CALL(dm_observer, OnDownloadCreated(_,_)).Times(1);
 
   DownloadItem* download(StartDownloadAndReturnItem(url));
   WaitForData(download, GetSafeBufferChunk());
   ::testing::Mock::VerifyAndClearExpectations(&dm_observer);
 
@@ skipping 14 matching lines @@
   download->Remove();
 
   // The intermediate file should now be gone.
   RunAllPendingInMessageLoop(BrowserThread::FILE);
   RunAllPendingInMessageLoop();
   EXPECT_FALSE(base::PathExists(intermediate_path));
 
   // Start the second download and wait until it's done. The test server is
   // single threaded. The response to this download request should follow the
   // response to the previous resumption request.
-  GURL url2(test_server()->GetURL("rangereset?size=100&rst_limit=0&token=x"));
+  GURL url2(
+      spawned_test_server()->GetURL("rangereset?size=100&rst_limit=0&token=x"));
   NavigateToURLAndWaitForDownload(shell(), url2, DownloadItem::COMPLETE);
 
   EXPECT_TRUE(EnsureNoPendingDownloads());
 }
 
 IN_PROC_BROWSER_TEST_F(DownloadContentTest, CancelResumingDownload) {
   SetupEnsureNoPendingDownloads();
   base::CommandLine::ForCurrentProcess()->AppendSwitch(
       switches::kEnableDownloadResumption);
-  ASSERT_TRUE(test_server()->Start());
+  ASSERT_TRUE(spawned_test_server()->Start());
 
-  GURL url = test_server()->GetURL(
+  GURL url = spawned_test_server()->GetURL(
       base::StringPrintf("rangereset?size=%d&rst_boundary=%d",
                          GetSafeBufferChunk() * 3, GetSafeBufferChunk()));
 
   MockDownloadManagerObserver dm_observer(DownloadManagerForShell(shell()));
   EXPECT_CALL(dm_observer, OnDownloadCreated(_,_)).Times(1);
 
   DownloadItem* download(StartDownloadAndReturnItem(url));
   WaitForData(download, GetSafeBufferChunk());
   ::testing::Mock::VerifyAndClearExpectations(&dm_observer);
 
@@ skipping 15 matching lines @@
 
   // The intermediate file should now be gone.
   RunAllPendingInMessageLoop(BrowserThread::FILE);
   RunAllPendingInMessageLoop();
   EXPECT_FALSE(base::PathExists(intermediate_path));
   EXPECT_TRUE(download->GetFullPath().empty());
 
   // Start the second download and wait until it's done. The test server is
   // single threaded. The response to this download request should follow the
   // response to the previous resumption request.
-  GURL url2(test_server()->GetURL("rangereset?size=100&rst_limit=0&token=x"));
+  GURL url2(
+      spawned_test_server()->GetURL("rangereset?size=100&rst_limit=0&token=x"));
   NavigateToURLAndWaitForDownload(shell(), url2, DownloadItem::COMPLETE);
 
   EXPECT_TRUE(EnsureNoPendingDownloads());
 }
 
 // Check that the cookie policy is correctly updated when downloading a file
 // that redirects cross origin.
 IN_PROC_BROWSER_TEST_F(DownloadContentTest, CookiePolicy) {
-  ASSERT_TRUE(test_server()->Start());
-  net::HostPortPair host_port = test_server()->host_port_pair();
+  ASSERT_TRUE(spawned_test_server()->Start());
+  net::HostPortPair host_port = spawned_test_server()->host_port_pair();
   DCHECK_EQ(host_port.host(), std::string("127.0.0.1"));
 
   // Block third-party cookies.
   ShellNetworkDelegate::SetAcceptAllCookies(false);
 
   // |url| redirects to a different origin |download| which tries to set a
   // cookie.
   std::string download(base::StringPrintf(
       "http://localhost:%d/set-cookie?A=B", host_port.port()));
-  GURL url(test_server()->GetURL("server-redirect?" + download));
+  GURL url(spawned_test_server()->GetURL("server-redirect?" + download));
 
   // Download the file.
   SetupEnsureNoPendingDownloads();
   scoped_ptr<DownloadUrlParameters> dl_params(
       DownloadUrlParameters::FromWebContents(shell()->web_contents(), url));
   scoped_ptr<DownloadTestObserver> observer(CreateWaiter(shell(), 1));
   DownloadManagerForShell(shell())->DownloadUrl(dl_params.Pass());
   observer->WaitForFinished();
 
   // Get the important info from other threads and check it.
   EXPECT_TRUE(EnsureNoPendingDownloads());
 
   std::vector<DownloadItem*> downloads;
   DownloadManagerForShell(shell())->GetAllDownloads(&downloads);
   ASSERT_EQ(1u, downloads.size());
   ASSERT_EQ(DownloadItem::COMPLETE, downloads[0]->GetState());
 
   // Check that the cookies were correctly set.
   EXPECT_EQ("A=B",
             content::GetCookies(shell()->web_contents()->GetBrowserContext(),
                                 GURL(download)));
 }
 
 // A filename suggestion specified via a @download attribute should not be
 // effective if the final download URL is in another origin from the original
 // download URL.
 IN_PROC_BROWSER_TEST_F(DownloadContentTest,
                        DownloadAttributeCrossOriginRedirect) {
-  EmbeddedTestServer origin_one;
-  EmbeddedTestServer origin_two;
-  ASSERT_TRUE(origin_one.InitializeAndWaitUntilReady());
-  ASSERT_TRUE(origin_two.InitializeAndWaitUntilReady());
+  net::EmbeddedTestServer origin_one;
+  net::EmbeddedTestServer origin_two;
+  ASSERT_TRUE(origin_one.Start());
+  ASSERT_TRUE(origin_two.Start());
 
   // The download-attribute.html page contains an anchor element whose href is
   // set to the value of the query parameter (specified as |target| in the URL
   // below). The suggested filename for the anchor is 'suggested-filename'. When
   // the page is loaded, a script simulates a click on the anchor, triggering a
   // download of the target URL.
   //
   // We construct two test servers; origin_one and origin_two. Once started, the
   // server URLs will differ by the port number. Therefore they will be in
   // different origins.
@@ skipping 21 matching lines @@
   ASSERT_TRUE(origin_one.ShutdownAndWaitUntilComplete());
   ASSERT_TRUE(origin_two.ShutdownAndWaitUntilComplete());
 }
 
 // A filename suggestion specified via a @download attribute should be effective
 // if the final download URL is in the same origin as the initial download URL.
 // Test that this holds even if there are cross origin redirects in the middle
 // of the redirect chain.
 IN_PROC_BROWSER_TEST_F(DownloadContentTest,
                        DownloadAttributeSameOriginRedirect) {
-  EmbeddedTestServer origin_one;
-  EmbeddedTestServer origin_two;
-  ASSERT_TRUE(origin_one.InitializeAndWaitUntilReady());
-  ASSERT_TRUE(origin_two.InitializeAndWaitUntilReady());
+  net::EmbeddedTestServer origin_one;
+  net::EmbeddedTestServer origin_two;
+  ASSERT_TRUE(origin_one.Start());
+  ASSERT_TRUE(origin_two.Start());
 
   // The download-attribute.html page contains an anchor element whose href is
   // set to the value of the query parameter (specified as |target| in the URL
   // below). The suggested filename for the anchor is 'suggested-filename'. When
   // the page is loaded, a script simulates a click on the anchor, triggering a
   // download of the target URL.
   //
   // We construct two test servers; origin_one and origin_two. Once started, the
   // server URLs will differ by the port number. Therefore they will be in
   // different origins.
@@ skipping 22 matching lines @@
   EXPECT_EQ(FILE_PATH_LITERAL("suggested-filename"),
             downloads[0]->GetTargetFilePath().BaseName().value());
   ASSERT_TRUE(origin_one.ShutdownAndWaitUntilComplete());
   ASSERT_TRUE(origin_two.ShutdownAndWaitUntilComplete());
 }
 
 // The file empty.bin is served with a MIME type of application/octet-stream.
 // The content body is empty. Make sure this case is handled properly and we
 // don't regress on http://crbug.com/320394.
 IN_PROC_BROWSER_TEST_F(DownloadContentTest, DownloadGZipWithNoContent) {
-  EmbeddedTestServer test_server;
-  ASSERT_TRUE(test_server.InitializeAndWaitUntilReady());
+  net::EmbeddedTestServer test_server;
+  ASSERT_TRUE(test_server.Start());
 
   GURL url = test_server.GetURL("/empty.bin");
   test_server.ServeFilesFromDirectory(GetTestFilePath("download", ""));
 
   NavigateToURLAndWaitForDownload(shell(), url, DownloadItem::COMPLETE);
   // That's it. This should work without crashing.
 }
 
 IN_PROC_BROWSER_TEST_F(DownloadContentTest, Spam) {
-  ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
+  ASSERT_TRUE(embedded_test_server()->Start());
 
   NavigateToURLAndWaitForDownload(
       shell(),
       embedded_test_server()->GetURL(
           "/download/double-content-disposition.txt"),
       DownloadItem::COMPLETE);
 
   std::vector<DownloadItem*> downloads;
   DownloadManagerForShell(shell())->GetAllDownloads(&downloads);
   ASSERT_EQ(1u, downloads.size());
 
   EXPECT_EQ(FILE_PATH_LITERAL("Jumboshrimp.txt"),
             downloads[0]->GetTargetFilePath().BaseName().value());
 }
 
 }  // namespace content