[Downloads] Simplify DownloadContentTests.

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 543 matching lines @@
 
   bool used_ = false;
   base::RunLoop run_loop_;
   net::HttpRequestHeaders request_headers_;
   TestDownloadRequestHandler::OnStartResponseCallback response_callback_;
 };
 
 class DownloadContentTest : public ContentBrowserTest {
  protected:
   void SetUpOnMainThread() override {
+    // Enable downloads resumption.
+    base::FeatureList::ClearInstanceForTesting();
+    scoped_ptr<base::FeatureList> feature_list(new base::FeatureList);
+    feature_list->InitializeFromCommandLine(features::kDownloadResumption.name,
+                                            std::string());
+    base::FeatureList::SetInstance(std::move(feature_list));
+
     ASSERT_TRUE(downloads_directory_.CreateUniqueTempDir());
 
     test_delegate_.reset(new TestShellDownloadManagerDelegate());
     test_delegate_->SetDownloadBehaviorForTesting(downloads_directory_.path());
     DownloadManager* manager = DownloadManagerForShell(shell());
     manager->GetDelegate()->Shutdown();
     manager->SetDelegate(test_delegate_.get());
     test_delegate_->SetDownloadManager(manager);
 
     BrowserThread::PostTask(
@@ skipping 140 matching lines @@
       *result = false;
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                             base::MessageLoop::QuitWhenIdleClosure());
   }
 
   // Location of the downloads directory for these tests
   base::ScopedTempDir downloads_directory_;
   scoped_ptr<TestShellDownloadManagerDelegate> test_delegate_;
 };
 
-// Parameters for DownloadResumptionContentTest.
-enum class DownloadResumptionTestType {
-  RESUME_WITH_RENDERER,  // Resume() is called while the originating WebContents
-                         // is still alive.
-  RESUME_WITHOUT_RENDERER  // Resume() is called after the originating
-                           // WebContents has been deleted.
-};
-
-// Parameterized test for download resumption. Tests using this fixure will be
-// run once with RESUME_WITH_RENDERER and once with RESUME_WITHOUT_RENDERER.
-// Use initiator_shell_for_resumption() to retrieve the Shell object that should
-// be used as the originator for the initial download. Prior to calling
-// Resume(), call PrepareToResume() which will cause the originating Shell to be
-// deleted if the test parameter is RESUME_WITHOUT_RENDERER.
-class DownloadResumptionContentTest
-    : public DownloadContentTest,
-      public ::testing::WithParamInterface<DownloadResumptionTestType> {
- public:
-  void SetUpOnMainThread() override {
-    base::FeatureList::ClearInstanceForTesting();
-    scoped_ptr<base::FeatureList> feature_list(new base::FeatureList);
-    feature_list->InitializeFromCommandLine(
-        features::kDownloadResumption.name, std::string());
-    base::FeatureList::SetInstance(std::move(feature_list));
-
-    DownloadContentTest::SetUpOnMainThread();
-
-    if (GetParam() == DownloadResumptionTestType::RESUME_WITHOUT_RENDERER)
-      initiator_shell_for_resumption_ = CreateBrowser();
-    else
-      initiator_shell_for_resumption_ = shell();
-
-    ASSERT_EQ(DownloadManagerForShell(shell()),
-              DownloadManagerForShell(initiator_shell_for_resumption()));
-  }
-
-  // Shell to use for initiating a download. Only valid *before*
-  // PrepareToResume() is called.
-  Shell* initiator_shell_for_resumption() const {
-    DCHECK(initiator_shell_for_resumption_);
-    return initiator_shell_for_resumption_;
-  }
-
-  // Should be called once before calling DownloadItem::Resume() on an
-  // interrupted download. This may cause initiator_shell_for_resumption() to
-  // become invalidated.
-  void PrepareToResume() {
-    if (GetParam() == DownloadResumptionTestType::RESUME_WITH_RENDERER)
-      return;
-    DCHECK_NE(initiator_shell_for_resumption(), shell());
-    DCHECK(initiator_shell_for_resumption());
-    initiator_shell_for_resumption_->Close();
-    initiator_shell_for_resumption_ = nullptr;
-  }
-
- private:
-  Shell* initiator_shell_for_resumption_ = nullptr;
-};
-
-INSTANTIATE_TEST_CASE_P(
-    _,
-    DownloadResumptionContentTest,
-    ::testing::Values(DownloadResumptionTestType::RESUME_WITH_RENDERER,
-                      DownloadResumptionTestType::RESUME_WITHOUT_RENDERER));
-
 }  // namespace
 
 IN_PROC_BROWSER_TEST_F(DownloadContentTest, DownloadCancelled) {
   SetupEnsureNoPendingDownloads();
 
   // Create a download, wait until it's started, and confirm
   // we're in the expected state.
   DownloadItem* download = StartDownloadAndReturnItem(
       shell(), GURL(net::URLRequestSlowDownloadJob::kUnknownSizeUrl));
   ASSERT_EQ(DownloadItem::IN_PROGRESS, download->GetState());
@@ skipping 280 matching lines @@
   MockDownloadItemObserver observer;
   items[0]->AddObserver(&observer);
   EXPECT_CALL(observer, OnDownloadDestroyed(items[0]));
 
   // Shutdown the download manager.  Mostly this is confirming a lack of
   // crashes.
   DownloadManagerForShell(shell())->Shutdown();
 }
 
 // Test resumption with a response that contains strong validators.
-IN_PROC_BROWSER_TEST_P(DownloadResumptionContentTest, StrongValidators) {
+IN_PROC_BROWSER_TEST_F(DownloadContentTest, StrongValidators) {
   TestDownloadRequestHandler request_handler;
   TestDownloadRequestHandler::Parameters parameters =
       TestDownloadRequestHandler::Parameters::WithSingleInterruption();
   const TestDownloadRequestHandler::InjectedError interruption =
       parameters.injected_errors.front();
   request_handler.StartServing(parameters);
 
-  DownloadItem* download = StartDownloadAndReturnItem(
-      initiator_shell_for_resumption(), request_handler.url());
+  DownloadItem* download =
+      StartDownloadAndReturnItem(shell(), request_handler.url());
   WaitForInterrupt(download);
 
   ASSERT_EQ(interruption.offset, download->GetReceivedBytes());
   ASSERT_EQ(parameters.size, download->GetTotalBytes());
 
-  PrepareToResume();
   download->Resume();
   WaitForCompletion(download);
 
   ASSERT_EQ(parameters.size, download->GetReceivedBytes());
   ASSERT_EQ(parameters.size, download->GetTotalBytes());
   ASSERT_NO_FATAL_FAILURE(ReadAndVerifyFileContents(
       parameters.pattern_generator_seed, parameters.size,
       download->GetTargetFilePath()));
 
   // Characterization risk: The next portion of the test examines the requests
@@ skipping 19 matching lines @@
   EXPECT_EQ(parameters.etag, value);
 
   ASSERT_TRUE(requests[1].request_headers.GetHeader(
       net::HttpRequestHeaders::kRange, &value));
   EXPECT_EQ(base::StringPrintf("bytes=%" PRId64 "-", interruption.offset),
             value);
 }
 
 // Resumption should only attempt to contact the final URL if the download has a
 // URL chain.
-IN_PROC_BROWSER_TEST_P(DownloadResumptionContentTest, RedirectBeforeResume) {
+IN_PROC_BROWSER_TEST_F(DownloadContentTest, RedirectBeforeResume) {
   TestDownloadRequestHandler request_handler_1(
       GURL("http://example.com/first-url"));
   request_handler_1.StartServingStaticResponse(
       "HTTP/1.1 302 Redirect\r\n"
       "Location: http://example.com/second-url\r\n"
       "\r\n");
 
   TestDownloadRequestHandler request_handler_2(
       GURL("http://example.com/second-url"));
   request_handler_2.StartServingStaticResponse(
       "HTTP/1.1 302 Redirect\r\n"
       "Location: http://example.com/third-url\r\n"
       "\r\n");
 
   TestDownloadRequestHandler request_handler_3(
       GURL("http://example.com/third-url"));
   request_handler_3.StartServingStaticResponse(
       "HTTP/1.1 302 Redirect\r\n"
       "Location: http://example.com/download\r\n"
       "\r\n");
 
   TestDownloadRequestHandler resumable_request_handler(
       GURL("http://example.com/download"));
   TestDownloadRequestHandler::Parameters parameters =
       TestDownloadRequestHandler::Parameters::WithSingleInterruption();
   resumable_request_handler.StartServing(parameters);
 
-  DownloadItem* download = StartDownloadAndReturnItem(
-      initiator_shell_for_resumption(), request_handler_1.url());
+  DownloadItem* download =
+      StartDownloadAndReturnItem(shell(), request_handler_1.url());
   WaitForInterrupt(download);
 
   EXPECT_EQ(4u, download->GetUrlChain().size());
   EXPECT_EQ(request_handler_1.url(), download->GetOriginalUrl());
   EXPECT_EQ(resumable_request_handler.url(), download->GetURL());
 
   // Now that the download is interrupted, make all intermediate servers return
   // a 404. The only way a resumption request would succeed if the resumption
   // request is sent to the final server in the chain.
   const char k404Response[] = "HTTP/1.1 404 Not found\r\n\r\n";
   request_handler_1.StartServingStaticResponse(k404Response);
   request_handler_2.StartServingStaticResponse(k404Response);
   request_handler_3.StartServingStaticResponse(k404Response);
 
-  PrepareToResume();
   download->Resume();
   WaitForCompletion(download);
 
   ASSERT_NO_FATAL_FAILURE(ReadAndVerifyFileContents(
       parameters.pattern_generator_seed, parameters.size,
       download->GetTargetFilePath()));
 }
 
 // If a resumption request results in a redirect, the response should be ignored
 // and the download should be marked as interrupted again.
-IN_PROC_BROWSER_TEST_P(DownloadResumptionContentTest, RedirectWhileResume) {
+IN_PROC_BROWSER_TEST_F(DownloadContentTest, RedirectWhileResume) {
   TestDownloadRequestHandler request_handler(
       GURL("http://example.com/first-url"));
   TestDownloadRequestHandler::Parameters parameters =
       TestDownloadRequestHandler::Parameters::WithSingleInterruption();
   ++parameters.pattern_generator_seed;
   request_handler.StartServing(parameters);
 
   // We should never send a request to the decoy. If we do, the request will
   // always succeed, which results in behavior that diverges from what we want,
   // which is for the download to return to being interrupted.
   TestDownloadRequestHandler decoy_request_handler(
       GURL("http://example.com/decoy"));
   decoy_request_handler.StartServing(TestDownloadRequestHandler::Parameters());
 
-  DownloadItem* download = StartDownloadAndReturnItem(
-      initiator_shell_for_resumption(), request_handler.url());
+  DownloadItem* download =
+      StartDownloadAndReturnItem(shell(), request_handler.url());
   WaitForInterrupt(download);
 
   // Upon resumption, the server starts responding with a redirect. This
   // response should not be accepted.
   request_handler.StartServingStaticResponse(
       "HTTP/1.1 302 Redirect\r\n"
       "Location: http://example.com/decoy\r\n"
       "\r\n");
-  PrepareToResume();
   download->Resume();
   WaitForInterrupt(download);
   EXPECT_EQ(DOWNLOAD_INTERRUPT_REASON_SERVER_UNREACHABLE,
             download->GetLastReason());
 
   // Back to the original request handler. Resumption should now succeed, and
   // use the partial data it had prior to the first interruption.
   request_handler.StartServing(parameters);
   download->Resume();
   WaitForCompletion(download);
@@ skipping 17 matching lines @@
   // redirect response shows up as a response with 0 bytes transferred.
   EXPECT_GT(parameters.size, requests[0].transferred_byte_count);
   EXPECT_EQ(0, requests[1].transferred_byte_count);
   EXPECT_GT(parameters.size, requests[2].transferred_byte_count);
 }
 
 // If the server response for the resumption request specifies a bad range (i.e.
 // not the range that was requested or an invalid or missing Content-Range
 // header), then the download should be marked as interrupted again without
 // discarding the partial state.
-IN_PROC_BROWSER_TEST_P(DownloadResumptionContentTest, BadRangeHeader) {
+IN_PROC_BROWSER_TEST_F(DownloadContentTest, BadRangeHeader) {
   TestDownloadRequestHandler request_handler;
   TestDownloadRequestHandler::Parameters parameters =
       TestDownloadRequestHandler::Parameters::WithSingleInterruption();
   request_handler.StartServing(parameters);
 
-  DownloadItem* download = StartDownloadAndReturnItem(
-      initiator_shell_for_resumption(), request_handler.url());
+  DownloadItem* download =
+      StartDownloadAndReturnItem(shell(), request_handler.url());
   WaitForInterrupt(download);
 
   // Upon resumption, the server starts responding with a bad range header.
   request_handler.StartServingStaticResponse(
       "HTTP/1.1 206 Partial Content\r\n"
       "Content-Range: bytes 1000000-2000000/3000000\r\n"
       "\r\n");
-  PrepareToResume();
   download->Resume();
   WaitForInterrupt(download);
   EXPECT_EQ(DOWNLOAD_INTERRUPT_REASON_SERVER_BAD_CONTENT,
             download->GetLastReason());
 
   // Or this time, the server sends a response with an invalid Content-Range
   // header.
   request_handler.StartServingStaticResponse(
       "HTTP/1.1 206 Partial Content\r\n"
       "Content-Range: ooga-booga-booga-booga\r\n"
@@ skipping 40 matching lines @@
   EXPECT_EQ(0, requests[2].transferred_byte_count);
   EXPECT_EQ(0, requests[3].transferred_byte_count);
   EXPECT_GT(parameters.size, requests[4].transferred_byte_count);
 }
 
 // A partial resumption results in an HTTP 200 response. I.e. the server ignored
 // the range request and sent the entire resource instead. For If-Range requests
 // (as opposed to If-Match), the behavior for a precondition failure is also to
 // respond with a 200. So this test case covers both validation failure and
 // ignoring the range request.
-IN_PROC_BROWSER_TEST_P(DownloadResumptionContentTest,
-                       RestartIfNotPartialResponse) {
+IN_PROC_BROWSER_TEST_F(DownloadContentTest, RestartIfNotPartialResponse) {
   const int kOriginalPatternGeneratorSeed = 1;
   const int kNewPatternGeneratorSeed = 2;
 
   TestDownloadRequestHandler::Parameters parameters =
       TestDownloadRequestHandler::Parameters::WithSingleInterruption();
   parameters.pattern_generator_seed = kOriginalPatternGeneratorSeed;
   const TestDownloadRequestHandler::InjectedError interruption =
       parameters.injected_errors.front();
 
   TestDownloadRequestHandler request_handler;
   request_handler.StartServing(parameters);
 
-  DownloadItem* download = StartDownloadAndReturnItem(
-      initiator_shell_for_resumption(), request_handler.url());
+  DownloadItem* download =
+      StartDownloadAndReturnItem(shell(), request_handler.url());
   WaitForInterrupt(download);
 
   ASSERT_EQ(interruption.offset, download->GetReceivedBytes());
   ASSERT_EQ(parameters.size, download->GetTotalBytes());
 
   parameters = TestDownloadRequestHandler::Parameters();
   parameters.support_byte_ranges = false;
   parameters.pattern_generator_seed = kNewPatternGeneratorSeed;
   request_handler.StartServing(parameters);
 
-  PrepareToResume();
   download->Resume();
   WaitForCompletion(download);
 
   ASSERT_EQ(parameters.size, download->GetReceivedBytes());
   ASSERT_EQ(parameters.size, download->GetTotalBytes());
   ASSERT_NO_FATAL_FAILURE(
       ReadAndVerifyFileContents(kNewPatternGeneratorSeed, parameters.size,
                                 download->GetTargetFilePath()));
 
   // When the downloads system sees the full response, it should accept the
@@ skipping 17 matching lines @@
       net::HttpRequestHeaders::kIfRange, &value));
   EXPECT_EQ(parameters.etag, value);
 
   ASSERT_TRUE(requests[1].request_headers.GetHeader(
       net::HttpRequestHeaders::kRange, &value));
   EXPECT_EQ(base::StringPrintf("bytes=%" PRId64 "-", interruption.offset),
             value);
 }
 
 // Confirm we restart if we don't have a verifier.
-IN_PROC_BROWSER_TEST_P(DownloadResumptionContentTest, RestartIfNoETag) {
+IN_PROC_BROWSER_TEST_F(DownloadContentTest, RestartIfNoETag) {
   const int kOriginalPatternGeneratorSeed = 1;
   const int kNewPatternGeneratorSeed = 2;
 
   TestDownloadRequestHandler::Parameters parameters =
       TestDownloadRequestHandler::Parameters::WithSingleInterruption();
   ASSERT_EQ(1u, parameters.injected_errors.size());
   parameters.etag.clear();
   parameters.pattern_generator_seed = kOriginalPatternGeneratorSeed;
 
   TestDownloadRequestHandler request_handler;
   request_handler.StartServing(parameters);
-  DownloadItem* download = StartDownloadAndReturnItem(
-      initiator_shell_for_resumption(), request_handler.url());
+  DownloadItem* download =
+      StartDownloadAndReturnItem(shell(), request_handler.url());
   WaitForInterrupt(download);
 
   parameters.pattern_generator_seed = kNewPatternGeneratorSeed;
   parameters.ClearInjectedErrors();
   request_handler.StartServing(parameters);
 
-  PrepareToResume();
   download->Resume();
   WaitForCompletion(download);
 
   ASSERT_EQ(parameters.size, download->GetReceivedBytes());
   ASSERT_EQ(parameters.size, download->GetTotalBytes());
   ASSERT_NO_FATAL_FAILURE(
       ReadAndVerifyFileContents(kNewPatternGeneratorSeed, parameters.size,
                                 download->GetTargetFilePath()));
 
   TestDownloadRequestHandler::CompletedRequests requests;
   request_handler.GetCompletedRequestInfo(&requests);
 
   // Neither If-Range nor Range headers should be present in the second request.
   ASSERT_EQ(2u, requests.size());
   std::string value;
   EXPECT_FALSE(requests[1].request_headers.GetHeader(
       net::HttpRequestHeaders::kIfRange, &value));
   EXPECT_FALSE(requests[1].request_headers.GetHeader(
       net::HttpRequestHeaders::kRange, &value));
 }
 
 // Partial file goes missing before the download is resumed. The download should
 // restart.
-IN_PROC_BROWSER_TEST_P(DownloadResumptionContentTest, RestartIfNoPartialFile) {
+IN_PROC_BROWSER_TEST_F(DownloadContentTest, RestartIfNoPartialFile) {
   TestDownloadRequestHandler::Parameters parameters =
       TestDownloadRequestHandler::Parameters::WithSingleInterruption();
 
   TestDownloadRequestHandler request_handler;
   request_handler.StartServing(parameters);
-  DownloadItem* download = StartDownloadAndReturnItem(
-      initiator_shell_for_resumption(), request_handler.url());
+  DownloadItem* download =
+      StartDownloadAndReturnItem(shell(), request_handler.url());
   WaitForInterrupt(download);
 
   // Delete the intermediate file.
   ASSERT_TRUE(base::PathExists(download->GetFullPath()));
   ASSERT_TRUE(base::DeleteFile(download->GetFullPath(), false));
 
   parameters.ClearInjectedErrors();
   request_handler.StartServing(parameters);
 
-  PrepareToResume();
   download->Resume();
   WaitForCompletion(download);
 
   ASSERT_EQ(parameters.size, download->GetReceivedBytes());
   ASSERT_EQ(parameters.size, download->GetTotalBytes());
   ASSERT_NO_FATAL_FAILURE(ReadAndVerifyFileContents(
       parameters.pattern_generator_seed, parameters.size,
       download->GetTargetFilePath()));
 }
 
-IN_PROC_BROWSER_TEST_P(DownloadResumptionContentTest,
-                       RecoverFromInitFileError) {
+IN_PROC_BROWSER_TEST_F(DownloadContentTest, RecoverFromInitFileError) {
   TestDownloadRequestHandler request_handler;
   request_handler.StartServing(TestDownloadRequestHandler::Parameters());
 
   // Setup the error injector.
-  scoped_refptr<TestFileErrorInjector> injector(TestFileErrorInjector::Create(
-      DownloadManagerForShell(initiator_shell_for_resumption())));
+  scoped_refptr<TestFileErrorInjector> injector(
+      TestFileErrorInjector::Create(DownloadManagerForShell(shell())));
 
   const TestFileErrorInjector::FileErrorInfo err = {
       TestFileErrorInjector::FILE_OPERATION_INITIALIZE, 0,
       DOWNLOAD_INTERRUPT_REASON_FILE_NO_SPACE};
   injector->InjectError(err);
 
   // Start and watch for interrupt.
-  DownloadItem* download(StartDownloadAndReturnItem(
-      initiator_shell_for_resumption(), request_handler.url()));
+  DownloadItem* download(
+      StartDownloadAndReturnItem(shell(), request_handler.url()));
   WaitForInterrupt(download);
   ASSERT_EQ(DownloadItem::INTERRUPTED, download->GetState());
   EXPECT_EQ(DOWNLOAD_INTERRUPT_REASON_FILE_NO_SPACE,
             download->GetLastReason());
   EXPECT_EQ(0, download->GetReceivedBytes());
   EXPECT_TRUE(download->GetFullPath().empty());
   EXPECT_FALSE(download->GetTargetFilePath().empty());
 
   // We need to make sure that any cross-thread downloads communication has
   // quiesced before clearing and injecting the new errors, as the
   // InjectErrors() routine alters the currently in use download file
   // factory, which is a file thread object.
   RunAllPendingInMessageLoop(BrowserThread::FILE);
   RunAllPendingInMessageLoop();
 
   // Clear the old errors list.
   injector->ClearError();
 
   // Resume and watch completion.
-  PrepareToResume();
   download->Resume();
   WaitForCompletion(download);
   EXPECT_EQ(download->GetState(), DownloadItem::COMPLETE);
 }
 
-IN_PROC_BROWSER_TEST_P(DownloadResumptionContentTest,
+IN_PROC_BROWSER_TEST_F(DownloadContentTest,
                        RecoverFromIntermediateFileRenameError) {
   TestDownloadRequestHandler request_handler;
   request_handler.StartServing(TestDownloadRequestHandler::Parameters());
 
   // Setup the error injector.
-  scoped_refptr<TestFileErrorInjector> injector(TestFileErrorInjector::Create(
-      DownloadManagerForShell(initiator_shell_for_resumption())));
+  scoped_refptr<TestFileErrorInjector> injector(
+      TestFileErrorInjector::Create(DownloadManagerForShell(shell())));
 
   const TestFileErrorInjector::FileErrorInfo err = {
       TestFileErrorInjector::FILE_OPERATION_RENAME_UNIQUIFY, 0,
       DOWNLOAD_INTERRUPT_REASON_FILE_NO_SPACE};
   injector->InjectError(err);
 
   // Start and watch for interrupt.
-  DownloadItem* download(StartDownloadAndReturnItem(
-      initiator_shell_for_resumption(), request_handler.url()));
+  DownloadItem* download(
+      StartDownloadAndReturnItem(shell(), request_handler.url()));
   WaitForInterrupt(download);
   ASSERT_EQ(DownloadItem::INTERRUPTED, download->GetState());
   EXPECT_EQ(DOWNLOAD_INTERRUPT_REASON_FILE_NO_SPACE,
             download->GetLastReason());
   EXPECT_TRUE(download->GetFullPath().empty());
   // Target path will have been set after file name determination. GetFullPath()
   // being empty is sufficient to signal that filename determination needs to be
   // redone.
   EXPECT_FALSE(download->GetTargetFilePath().empty());
 
   // We need to make sure that any cross-thread downloads communication has
   // quiesced before clearing and injecting the new errors, as the
   // InjectErrors() routine alters the currently in use download file
   // factory, which is a file thread object.
   RunAllPendingInMessageLoop(BrowserThread::FILE);
   RunAllPendingInMessageLoop();
 
   // Clear the old errors list.
   injector->ClearError();
 
-  PrepareToResume();
   download->Resume();
   WaitForCompletion(download);
   EXPECT_EQ(download->GetState(), DownloadItem::COMPLETE);
 }
 
-IN_PROC_BROWSER_TEST_P(DownloadResumptionContentTest,
-                       RecoverFromFinalRenameError) {
+IN_PROC_BROWSER_TEST_F(DownloadContentTest, RecoverFromFinalRenameError) {
   TestDownloadRequestHandler request_handler;
   request_handler.StartServing(TestDownloadRequestHandler::Parameters());
 
   // Setup the error injector.
-  scoped_refptr<TestFileErrorInjector> injector(TestFileErrorInjector::Create(
-      DownloadManagerForShell(initiator_shell_for_resumption())));
+  scoped_refptr<TestFileErrorInjector> injector(
+      TestFileErrorInjector::Create(DownloadManagerForShell(shell())));
 
-  DownloadManagerForShell(initiator_shell_for_resumption())
-      ->RemoveAllDownloads();
+  DownloadManagerForShell(shell())->RemoveAllDownloads();
   TestFileErrorInjector::FileErrorInfo err = {
       TestFileErrorInjector::FILE_OPERATION_RENAME_ANNOTATE, 0,
       DOWNLOAD_INTERRUPT_REASON_FILE_FAILED};
   injector->InjectError(err);
 
   // Start and watch for interrupt.
-  DownloadItem* download(StartDownloadAndReturnItem(
-      initiator_shell_for_resumption(), request_handler.url()));
+  DownloadItem* download(
+      StartDownloadAndReturnItem(shell(), request_handler.url()));
   WaitForInterrupt(download);
   ASSERT_EQ(DownloadItem::INTERRUPTED, download->GetState());
   EXPECT_EQ(DOWNLOAD_INTERRUPT_REASON_FILE_FAILED, download->GetLastReason());
   EXPECT_TRUE(download->GetFullPath().empty());
   // Target path should still be intact.
   EXPECT_FALSE(download->GetTargetFilePath().empty());
 
   // We need to make sure that any cross-thread downloads communication has
   // quiesced before clearing and injecting the new errors, as the
   // InjectErrors() routine alters the currently in use download file
   // factory, which is a file thread object.
   RunAllPendingInMessageLoop(BrowserThread::FILE);
   RunAllPendingInMessageLoop();
 
   // Clear the old errors list.
   injector->ClearError();
 
-  PrepareToResume();
   download->Resume();
   WaitForCompletion(download);
   EXPECT_EQ(download->GetState(), DownloadItem::COMPLETE);
 }
 
-IN_PROC_BROWSER_TEST_P(DownloadResumptionContentTest, Resume_Hash) {
+IN_PROC_BROWSER_TEST_F(DownloadContentTest, Resume_Hash) {
   using InjectedError = TestDownloadRequestHandler::InjectedError;
   const char kExpectedHash[] =
       "\xa7\x44\x49\x86\x24\xc6\x84\x6c\x89\xdf\xd8\xec\xa0\xe0\x61\x12\xdc\x80"
       "\x13\xf2\x83\x49\xa9\x14\x52\x32\xf0\x95\x20\xca\x5b\x30";
   std::string expected_hash(kExpectedHash);
   TestDownloadRequestHandler request_handler;
   TestDownloadRequestHandler::Parameters parameters;
 
   // As a control, let's try GetHash() on an uninterrupted download.
   request_handler.StartServing(parameters);
-  DownloadItem* uninterrupted_download(StartDownloadAndReturnItem(
-      initiator_shell_for_resumption(), request_handler.url()));
+  DownloadItem* uninterrupted_download(
+      StartDownloadAndReturnItem(shell(), request_handler.url()));
   WaitForCompletion(uninterrupted_download);
   EXPECT_EQ(expected_hash, uninterrupted_download->GetHash());
 
   // Now with interruptions.
   parameters.injected_errors.push(
       InjectedError(100, net::ERR_CONNECTION_RESET));
   parameters.injected_errors.push(
       InjectedError(211, net::ERR_CONNECTION_RESET));
   parameters.injected_errors.push(
       InjectedError(337, net::ERR_CONNECTION_RESET));
   parameters.injected_errors.push(
       InjectedError(400, net::ERR_CONNECTION_RESET));
   parameters.injected_errors.push(
       InjectedError(512, net::ERR_CONNECTION_RESET));
   request_handler.StartServing(parameters);
 
   // Start and watch for interrupt.
-  DownloadItem* download(StartDownloadAndReturnItem(
-      initiator_shell_for_resumption(), request_handler.url()));
+  DownloadItem* download(
+      StartDownloadAndReturnItem(shell(), request_handler.url()));
   WaitForInterrupt(download);
 
-  PrepareToResume();
   download->Resume();
   WaitForInterrupt(download);
 
   download->Resume();
   WaitForInterrupt(download);
 
   download->Resume();
   WaitForInterrupt(download);
 
   download->Resume();
   WaitForInterrupt(download);
 
   download->Resume();
   WaitForCompletion(download);
 
   EXPECT_EQ(expected_hash, download->GetHash());
 }
 
 // An interrupted download should remove the intermediate file when it is
 // cancelled.
-IN_PROC_BROWSER_TEST_P(DownloadResumptionContentTest,
-                       CancelInterruptedDownload) {
+IN_PROC_BROWSER_TEST_F(DownloadContentTest, CancelInterruptedDownload) {
   TestDownloadRequestHandler request_handler;
   request_handler.StartServing(
       TestDownloadRequestHandler::Parameters::WithSingleInterruption());
 
-  DownloadItem* download = StartDownloadAndReturnItem(
-      initiator_shell_for_resumption(), request_handler.url());
+  DownloadItem* download =
+      StartDownloadAndReturnItem(shell(), request_handler.url());
   WaitForInterrupt(download);
 
   base::FilePath intermediate_path = download->GetFullPath();
   ASSERT_FALSE(intermediate_path.empty());
   ASSERT_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_P(DownloadResumptionContentTest,
-                       RemoveInterruptedDownload) {
+IN_PROC_BROWSER_TEST_F(DownloadContentTest, RemoveInterruptedDownload) {
   TestDownloadRequestHandler request_handler;
   request_handler.StartServing(
       TestDownloadRequestHandler::Parameters::WithSingleInterruption());
 
-  DownloadItem* download = StartDownloadAndReturnItem(
-      initiator_shell_for_resumption(), request_handler.url());
+  DownloadItem* download =
+      StartDownloadAndReturnItem(shell(), request_handler.url());
   WaitForInterrupt(download);
 
   base::FilePath intermediate_path = download->GetFullPath();
   ASSERT_FALSE(intermediate_path.empty());
   ASSERT_TRUE(base::PathExists(intermediate_path));
 
   download->Remove();
   RunAllPendingInMessageLoop(BrowserThread::FILE);
   RunAllPendingInMessageLoop();
 
@@ skipping 16 matching lines @@
   base::FilePath target_path(download->GetTargetFilePath());
   EXPECT_TRUE(base::PathExists(target_path));
   download->Remove();
   RunAllPendingInMessageLoop(BrowserThread::FILE);
   RunAllPendingInMessageLoop();
 
   // The file should still exist.
   EXPECT_TRUE(base::PathExists(target_path));
 }
 
-IN_PROC_BROWSER_TEST_P(DownloadResumptionContentTest, RemoveResumingDownload) {
+IN_PROC_BROWSER_TEST_F(DownloadContentTest, RemoveResumingDownload) {
   TestDownloadRequestHandler::Parameters parameters =
       TestDownloadRequestHandler::Parameters::WithSingleInterruption();
   TestDownloadRequestHandler request_handler;
   request_handler.StartServing(parameters);
 
-  DownloadItem* download = StartDownloadAndReturnItem(
-      initiator_shell_for_resumption(), request_handler.url());
+  DownloadItem* download =
+      StartDownloadAndReturnItem(shell(), request_handler.url());
   WaitForInterrupt(download);
 
   base::FilePath intermediate_path(download->GetFullPath());
   ASSERT_FALSE(intermediate_path.empty());
   EXPECT_TRUE(base::PathExists(intermediate_path));
 
   // Resume and remove download. We expect only a single OnDownloadCreated()
   // call, and that's for the second download created below.
-  MockDownloadManagerObserver dm_observer(
-      DownloadManagerForShell(initiator_shell_for_resumption()));
+  MockDownloadManagerObserver dm_observer(DownloadManagerForShell(shell()));
   EXPECT_CALL(dm_observer, OnDownloadCreated(_,_)).Times(1);
 
   TestRequestStartHandler request_start_handler;
   parameters.on_start_handler = request_start_handler.GetOnStartHandler();
   request_handler.StartServing(parameters);
 
-  PrepareToResume();
   download->Resume();
   request_start_handler.WaitForCallback();
 
   // At this point, the download resumption request has been sent out, but the
   // reponse hasn't been received yet.
   download->Remove();
 
   request_start_handler.RespondWith(std::string(), net::OK);
 
   // The intermediate file should now be gone.
   RunAllPendingInMessageLoop(BrowserThread::FILE);
   RunAllPendingInMessageLoop();
   EXPECT_FALSE(base::PathExists(intermediate_path));
 
   parameters.ClearInjectedErrors();
   parameters.on_start_handler.Reset();
   request_handler.StartServing(parameters);
 
   // Start the second download and wait until it's done. This exercises the
   // entire downloads stack and effectively flushes all of our worker threads.
   // We are testing whether the URL request created in the previous
   // DownloadItem::Resume() call reulted in a new download or not.
   NavigateToURLAndWaitForDownload(shell(), request_handler.url(),
                                   DownloadItem::COMPLETE);
   EXPECT_TRUE(EnsureNoPendingDownloads());
 }
 
-IN_PROC_BROWSER_TEST_P(DownloadResumptionContentTest, CancelResumingDownload) {
+IN_PROC_BROWSER_TEST_F(DownloadContentTest, CancelResumingDownload) {
   TestDownloadRequestHandler::Parameters parameters =
       TestDownloadRequestHandler::Parameters::WithSingleInterruption();
   TestDownloadRequestHandler request_handler;
   request_handler.StartServing(parameters);
 
-  DownloadItem* download = StartDownloadAndReturnItem(
-      initiator_shell_for_resumption(), request_handler.url());
+  DownloadItem* download =
+      StartDownloadAndReturnItem(shell(), request_handler.url());
   WaitForInterrupt(download);
 
   base::FilePath intermediate_path(download->GetFullPath());
   ASSERT_FALSE(intermediate_path.empty());
   EXPECT_TRUE(base::PathExists(intermediate_path));
 
   // Resume and cancel download. We expect only a single OnDownloadCreated()
   // call, and that's for the second download created below.
-  MockDownloadManagerObserver dm_observer(
-      DownloadManagerForShell(initiator_shell_for_resumption()));
+  MockDownloadManagerObserver dm_observer(DownloadManagerForShell(shell()));
   EXPECT_CALL(dm_observer, OnDownloadCreated(_,_)).Times(1);
 
   TestRequestStartHandler request_start_handler;
   parameters.on_start_handler = request_start_handler.GetOnStartHandler();
   request_handler.StartServing(parameters);
 
-  PrepareToResume();
   download->Resume();
   request_start_handler.WaitForCallback();
 
   // At this point, the download item has initiated a network request for the
   // resumption attempt, but hasn't received a response yet.
   download->Cancel(true /* user_cancel */);
 
   request_start_handler.RespondWith(std::string(), net::OK);
 
   // The intermediate file should now be gone.
   RunAllPendingInMessageLoop(BrowserThread::IO);
   RunAllPendingInMessageLoop(BrowserThread::FILE);
   RunAllPendingInMessageLoop();
   EXPECT_FALSE(base::PathExists(intermediate_path));
 
   parameters.ClearInjectedErrors();
   parameters.on_start_handler.Reset();
   request_handler.StartServing(parameters);
 
   // Start the second download and wait until it's done. This exercises the
   // entire downloads stack and effectively flushes all of our worker threads.
   // We are testing whether the URL request created in the previous
   // DownloadItem::Resume() call reulted in a new download or not.
   NavigateToURLAndWaitForDownload(shell(), request_handler.url(),
                                   DownloadItem::COMPLETE);
   EXPECT_TRUE(EnsureNoPendingDownloads());
 }
 
-IN_PROC_BROWSER_TEST_P(DownloadResumptionContentTest, RemoveResumedDownload) {
+IN_PROC_BROWSER_TEST_F(DownloadContentTest, RemoveResumedDownload) {
   TestDownloadRequestHandler::Parameters parameters =
       TestDownloadRequestHandler::Parameters::WithSingleInterruption();
   TestDownloadRequestHandler request_handler;
   request_handler.StartServing(parameters);
 
-  DownloadItem* download = StartDownloadAndReturnItem(
-      initiator_shell_for_resumption(), request_handler.url());
+  DownloadItem* download =
+      StartDownloadAndReturnItem(shell(), request_handler.url());
   WaitForInterrupt(download);
 
   base::FilePath intermediate_path(download->GetFullPath());
   base::FilePath target_path(download->GetTargetFilePath());
   ASSERT_FALSE(intermediate_path.empty());
   EXPECT_TRUE(base::PathExists(intermediate_path));
   EXPECT_FALSE(base::PathExists(target_path));
 
   // Resume and remove download. We don't expect OnDownloadCreated() calls.
-  MockDownloadManagerObserver dm_observer(
-      DownloadManagerForShell(initiator_shell_for_resumption()));
+  MockDownloadManagerObserver dm_observer(DownloadManagerForShell(shell()));
   EXPECT_CALL(dm_observer, OnDownloadCreated(_, _)).Times(0);
 
-  PrepareToResume();
   download->Resume();
   WaitForInProgress(download);
 
   download->Remove();
 
   // The intermediate file should now be gone.
   RunAllPendingInMessageLoop(BrowserThread::FILE);
   RunAllPendingInMessageLoop();
   EXPECT_FALSE(base::PathExists(intermediate_path));
   EXPECT_FALSE(base::PathExists(target_path));
   EXPECT_TRUE(EnsureNoPendingDownloads());
 }
 
-IN_PROC_BROWSER_TEST_P(DownloadResumptionContentTest, CancelResumedDownload) {
+IN_PROC_BROWSER_TEST_F(DownloadContentTest, CancelResumedDownload) {
   TestDownloadRequestHandler::Parameters parameters =
       TestDownloadRequestHandler::Parameters::WithSingleInterruption();
   TestDownloadRequestHandler request_handler;
   request_handler.StartServing(parameters);
 
-  DownloadItem* download = StartDownloadAndReturnItem(
-      initiator_shell_for_resumption(), request_handler.url());
+  DownloadItem* download =
+      StartDownloadAndReturnItem(shell(), request_handler.url());
   WaitForInterrupt(download);
 
   base::FilePath intermediate_path(download->GetFullPath());
   base::FilePath target_path(download->GetTargetFilePath());
   ASSERT_FALSE(intermediate_path.empty());
   EXPECT_TRUE(base::PathExists(intermediate_path));
   EXPECT_FALSE(base::PathExists(target_path));
 
   // Resume and remove download. We don't expect OnDownloadCreated() calls.
-  MockDownloadManagerObserver dm_observer(
-      DownloadManagerForShell(initiator_shell_for_resumption()));
+  MockDownloadManagerObserver dm_observer(DownloadManagerForShell(shell()));
   EXPECT_CALL(dm_observer, OnDownloadCreated(_, _)).Times(0);
 
-  PrepareToResume();
   download->Resume();
   WaitForInProgress(download);
 
   download->Cancel(true);
 
   // The intermediate file should now be gone.
   RunAllPendingInMessageLoop(BrowserThread::FILE);
   RunAllPendingInMessageLoop();
   EXPECT_FALSE(base::PathExists(intermediate_path));
   EXPECT_FALSE(base::PathExists(target_path));
@@ skipping 232 matching lines @@
 
   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