Migrate part of the BackgroundFetchJobController to the UI thread

content/browser/background_fetch/background_fetch_job_controller_unittest.cc

 // Copyright 2017 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 "content/browser/background_fetch/background_fetch_job_controller.h"
 
 #include <memory>
 #include <string>
 #include <unordered_map>
 
 #include "base/guid.h"
 #include "base/macros.h"
 #include "base/run_loop.h"
 #include "content/browser/background_fetch/background_fetch_constants.h"
 #include "content/browser/background_fetch/background_fetch_data_manager.h"
 #include "content/browser/background_fetch/background_fetch_registration_id.h"
 #include "content/browser/background_fetch/background_fetch_test_base.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/download_item.h"
+#include "content/public/browser/storage_partition.h"
 #include "content/public/test/fake_download_item.h"
 #include "content/public/test/mock_download_manager.h"
+#include "net/url_request/url_request_context_getter.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 using testing::_;
 
 namespace content {
 namespace {
 
 const char kExampleTag[] = "my-example-tag";
 
 // Use the basic MockDownloadManager, but override it so that it implements the
@@ skipping 120 matching lines @@
 
     ASSERT_EQ(error, blink::mojom::BackgroundFetchError::NONE);
     ASSERT_GE(out_initial_requests->size(), 1u);
     ASSERT_LE(out_initial_requests->size(),
               kMaximumBackgroundFetchParallelRequests);
   }
 
   // Creates a new BackgroundFetchJobController instance.
   std::unique_ptr<BackgroundFetchJobController> CreateJobController(
       const BackgroundFetchRegistrationId& registration_id) {
+    StoragePartition* storage_partition =
+        BrowserContext::GetDefaultStoragePartition(browser_context());
+
     return base::MakeUnique<BackgroundFetchJobController>(
-        registration_id, BackgroundFetchOptions(), download_manager_,
-        BrowserContext::GetDefaultStoragePartition(browser_context()),
-        &data_manager_,
+        registration_id, BackgroundFetchOptions(), &data_manager_,
+        download_manager_,
+        make_scoped_refptr(storage_partition->GetURLRequestContext()),
         base::BindOnce(&BackgroundFetchJobControllerTest::DidCompleteJob,
                        base::Unretained(this)));
   }
 
  protected:
   BackgroundFetchDataManager data_manager_;
   MockDownloadManagerWithCallback* download_manager_;  // BrowserContext owned
   bool did_complete_job_ = false;
 
   // Closure that will be invoked when the JobController has completed all
@@ skipping 51 matching lines @@
 
   // Allows for proper initialization of the FakeDownloadItems.
   base::RunLoop().RunUntilIdle();
 
   std::vector<FakeDownloadItem*> download_items =
       download_manager_->GetDownloadItems();
   ASSERT_EQ(download_items.size(), 1u);
 
   // Mark the single download item as finished, completing the job.
   {
+    base::RunLoop run_loop;
+    job_completed_closure_ = run_loop.QuitClosure();
+
     FakeDownloadItem* item = download_items[0];
 
     EXPECT_EQ(DownloadItem::DownloadState::IN_PROGRESS, item->GetState());
 
     item->SetState(DownloadItem::DownloadState::COMPLETE);
     item->NotifyDownloadUpdated();
+
+    run_loop.Run();
   }
 
   EXPECT_EQ(controller->state(),
             BackgroundFetchJobController::State::COMPLETED);
   EXPECT_TRUE(did_complete_job_);
 }
 
 TEST_F(BackgroundFetchJobControllerTest, MultipleRequestJob) {
   BackgroundFetchRegistrationId registration_id;
   std::vector<BackgroundFetchRequestInfo> initial_requests;
@@ skipping 45 matching lines @@
 
   ASSERT_NO_FATAL_FAILURE(CreateRegistrationForRequests(
       &registration_id, &initial_requests,
       {{"https://example.com/sad_cat.png", "GET"}}));
 
   std::unique_ptr<BackgroundFetchJobController> controller =
       CreateJobController(registration_id);
 
   EXPECT_EQ(controller->state(),
             BackgroundFetchJobController::State::INITIALIZED);
-  EXPECT_CALL(*download_manager_, DownloadUrlMock(_)).Times(1);
 
-  controller->Start(initial_requests /* deliberate copy */);
-  EXPECT_EQ(controller->state(), BackgroundFetchJobController::State::FETCHING);
+  // Start the set of |initial_requests|, and abort them immediately after.
+  {
+    base::RunLoop run_loop;
+    job_completed_closure_ = run_loop.QuitClosure();
 
-  controller->Abort();
+    controller->Start(initial_requests /* deliberate copy */);
+    EXPECT_EQ(controller->state(),
+              BackgroundFetchJobController::State::FETCHING);
+
+    controller->Abort();
+
+    run_loop.Run();
+  }
 
   // TODO(peter): Verify that the issued download items have had their state
   // updated to be cancelled as well.
 
   EXPECT_EQ(controller->state(), BackgroundFetchJobController::State::ABORTED);
   EXPECT_TRUE(did_complete_job_);
 }
 
 }  // namespace
 }  // namespace content