Ensure all content_browsertests call the host resolver in SetUpOnMainThread and not after.

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 <stddef.h>
 #include <stdint.h>
 #include <utility>
@@ skipping 72 matching lines @@
 class NetLogWithSource;
 }
 
 namespace content {
 
 namespace {
 
 // Default request count for parallel download tests.
 constexpr int kTestRequestCount = 3;
 
+const std::string kOriginOne = "one.example";
+const std::string kOriginTwo = "two.example";
+
 class MockDownloadItemObserver : public DownloadItem::Observer {
  public:
   MockDownloadItemObserver() {}
   virtual ~MockDownloadItemObserver() {}
 
   MOCK_METHOD1(OnDownloadUpdated, void(DownloadItem*));
   MOCK_METHOD1(OnDownloadOpened, void(DownloadItem*));
   MOCK_METHOD1(OnDownloadRemoved, void(DownloadItem*));
   MOCK_METHOD1(OnDownloadDestroyed, void(DownloadItem*));
 };
@@ skipping 485 matching lines @@
 
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         base::Bind(&net::URLRequestSlowDownloadJob::AddUrlHandler));
     base::FilePath mock_base(GetTestFilePath("download", ""));
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         base::Bind(
             &net::URLRequestMockHTTPJob::AddUrlHandlers, mock_base,
             make_scoped_refptr(content::BrowserThread::GetBlockingPool())));
+    ASSERT_TRUE(embedded_test_server()->Start());
+    const std::string real_host =
+        embedded_test_server()->host_port_pair().host();
+    host_resolver()->AddRule(kOriginOne, real_host);
+    host_resolver()->AddRule(kOriginTwo, real_host);
   }
 
   void SetUpCommandLine(base::CommandLine* command_line) override {
     IsolateAllSitesForTesting(command_line);
   }
 
   TestShellDownloadManagerDelegate* GetDownloadManagerDelegate() {
     return test_delegate_.get();
   }
 
@@ skipping 1687 matching lines @@
 }
 
 // Test that the referrer header is set correctly for a download that's resumed
 // partially.
 IN_PROC_BROWSER_TEST_F(DownloadContentTest, ReferrerForPartialResumption) {
   TestDownloadRequestHandler request_handler;
   TestDownloadRequestHandler::Parameters parameters =
       TestDownloadRequestHandler::Parameters::WithSingleInterruption();
   request_handler.StartServing(parameters);
 
-  ASSERT_TRUE(embedded_test_server()->Start());
   GURL document_url = embedded_test_server()->GetURL(
       std::string("/download/download-link.html?dl=")
           .append(request_handler.url().spec()));
 
   DownloadItem* download = StartDownloadAndReturnItem(shell(), document_url);
   WaitForInterrupt(download);
 
   download->Resume();
   WaitForCompletion(download);
 
@@ skipping 149 matching lines @@
 
   EXPECT_EQ(FILE_PATH_LITERAL("suggested-filename"),
             downloads[0]->GetTargetFilePath().BaseName().value());
   ASSERT_TRUE(origin_one.ShutdownAndWaitUntilComplete());
   ASSERT_TRUE(origin_two.ShutdownAndWaitUntilComplete());
 }
 
 // A request for a non-existent resource should still result in a DownloadItem
 // that's created in an interrupted state.
 IN_PROC_BROWSER_TEST_F(DownloadContentTest, DownloadAttributeServerError) {
-  ASSERT_TRUE(embedded_test_server()->Start());
-
   GURL download_url =
       embedded_test_server()->GetURL("/download/does-not-exist");
   GURL document_url = embedded_test_server()->GetURL(
       std::string("/download/download-attribute.html?target=") +
       download_url.spec());
 
   DownloadItem* download = StartDownloadAndReturnItem(shell(), document_url);
   WaitForInterrupt(download);
 
   EXPECT_EQ(DOWNLOAD_INTERRUPT_REASON_SERVER_BAD_CONTENT,
             download->GetLastReason());
 }
 
 namespace {
 
 void ErrorReturningRequestHandler(
     const net::HttpRequestHeaders& headers,
     const TestDownloadRequestHandler::OnStartResponseCallback& callback) {
   callback.Run(std::string(), net::ERR_INTERNET_DISCONNECTED);
 }
 
 }  // namespace
 
 // A request that fails before it gets a response from the server should also
 // result in a DownloadItem that's created in an interrupted state.
 IN_PROC_BROWSER_TEST_F(DownloadContentTest, DownloadAttributeNetworkError) {
-  ASSERT_TRUE(embedded_test_server()->Start());
   TestDownloadRequestHandler request_handler;
   TestDownloadRequestHandler::Parameters parameters;
 
   parameters.on_start_handler = base::Bind(&ErrorReturningRequestHandler);
   request_handler.StartServing(parameters);
 
   GURL document_url = embedded_test_server()->GetURL(
       std::string("/download/download-attribute.html?target=") +
       request_handler.url().spec());
   DownloadItem* download = StartDownloadAndReturnItem(shell(), document_url);
   WaitForInterrupt(download);
 
   EXPECT_EQ(DOWNLOAD_INTERRUPT_REASON_NETWORK_DISCONNECTED,
             download->GetLastReason());
 }
 
 // A request that fails due to it being rejected by policy should result in a
 // DownloadItem that's marked as interrupted.
 IN_PROC_BROWSER_TEST_F(DownloadContentTest, DownloadAttributeInvalidURL) {
-  ASSERT_TRUE(embedded_test_server()->Start());
-
   GURL document_url = embedded_test_server()->GetURL(
       "/download/download-attribute.html?target=about:version");
   DownloadItem* download = StartDownloadAndReturnItem(shell(), document_url);
   WaitForInterrupt(download);
 
   EXPECT_EQ(DOWNLOAD_INTERRUPT_REASON_NETWORK_INVALID_REQUEST,
             download->GetLastReason());
   EXPECT_FALSE(download->CanResume());
 }
 
 IN_PROC_BROWSER_TEST_F(DownloadContentTest, DownloadAttributeBlobURL) {
-  ASSERT_TRUE(embedded_test_server()->Start());
-
   GURL document_url =
       embedded_test_server()->GetURL("/download/download-attribute-blob.html");
   DownloadItem* download = StartDownloadAndReturnItem(shell(), document_url);
   WaitForCompletion(download);
 
   EXPECT_STREQ(FILE_PATH_LITERAL("suggested-filename.txt"),
                download->GetTargetFilePath().BaseName().value().c_str());
 }
 
 IN_PROC_BROWSER_TEST_F(DownloadContentTest, DownloadAttributeSameSiteCookie) {
   base::ThreadRestrictions::ScopedAllowIO allow_io_during_test;
 
-  const std::string kOriginOne = "one.example";
-  const std::string kOriginTwo = "two.example";
-
-  ASSERT_TRUE(embedded_test_server()->Start());
-
-  const std::string real_host = embedded_test_server()->host_port_pair().host();
-  host_resolver()->AddRule(kOriginOne, real_host);
-  host_resolver()->AddRule(kOriginTwo, real_host);
-
   GURL echo_cookie_url =
       embedded_test_server()->GetURL(kOriginOne, "/echoheader?cookie");
 
   // download-attribute-same-site-cookie sets two cookies. One "A=B" is set with
   // SameSite=Strict. The other one "B=C" doesn't have this flag. In general
   // a[download] should behave the same as a top level navigation.
   //
   // The page then simulates a click on an <a download> link whose target is the
   // /echoheader handler on the same origin.
   DownloadItem* download = StartDownloadAndReturnItem(
@@ skipping 68 matching lines @@
 IN_PROC_BROWSER_TEST_F(DownloadContentTest, SniffedMimeType) {
   GURL url = net::URLRequestMockHTTPJob::GetMockUrl("gzip-content.gz");
   DownloadItem* item = StartDownloadAndReturnItem(shell(), url);
   WaitForCompletion(item);
 
   EXPECT_STREQ("application/x-gzip", item->GetMimeType().c_str());
   EXPECT_TRUE(item->GetOriginalMimeType().empty());
 }
 
 IN_PROC_BROWSER_TEST_F(DownloadContentTest, DuplicateContentDisposition) {
-  ASSERT_TRUE(embedded_test_server()->Start());
-
   // double-content-disposition.txt is served with two Content-Disposition
   // headers, both of which are identical.
   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());
 }
 
 IN_PROC_BROWSER_TEST_F(DownloadContentTest, DownloadAttributeSameOriginIFrame) {
-  ASSERT_TRUE(embedded_test_server()->Start());
-
   GURL frame_url = embedded_test_server()->GetURL(
       "/download/download-attribute.html?target=/download/download-test.lib");
   GURL document_url = embedded_test_server()->GetURL(
       "/download/iframe-host.html?target=" + frame_url.spec());
   DownloadItem* download = StartDownloadAndReturnItem(shell(), document_url);
   WaitForCompletion(download);
 
   EXPECT_STREQ(FILE_PATH_LITERAL("suggested-filename"),
                download->GetTargetFilePath().BaseName().value().c_str());
 }
@@ skipping 44 matching lines @@
 
   TestDownloadRequestHandler::CompletedRequests completed_requests;
   request_handler.GetCompletedRequestInfo(&completed_requests);
   EXPECT_EQ(kTestRequestCount, static_cast<int>(completed_requests.size()));
 
   ReadAndVerifyFileContents(parameters.pattern_generator_seed, parameters.size,
                             download->GetTargetFilePath());
 }
 
 }  // namespace content