Give the BackgroundFetchJobController a simple state.

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 <string>
 #include <vector>
 
 #include "base/bind_helpers.h"
@@ skipping 142 matching lines @@
 
   void TearDown() override { job_controller_->Shutdown(); }
 
   void InitializeJobController(
       const BackgroundFetchRegistrationId& registration_id) {
     job_controller_ = base::MakeUnique<BackgroundFetchJobController>(
         registration_id, BackgroundFetchOptions(), &browser_context_,
         BrowserContext::GetDefaultStoragePartition(&browser_context_),
         data_manager_.get(),
         base::BindOnce(&BackgroundFetchJobControllerTest::DidCompleteJob,
-                       base::Unretained(this), registration_id));
+                       base::Unretained(this)));
   }
 
-  void DidCompleteJob(
-      const BackgroundFetchRegistrationId& original_registration_id,
-      const BackgroundFetchRegistrationId& registration_id,
-      bool aborted_by_developer) {
-    ASSERT_EQ(registration_id, original_registration_id);
-    did_complete_job_ = true;
-    did_abort_by_developer_ = aborted_by_developer;
+  void DidCompleteJob(BackgroundFetchJobController* controller) {
+    DCHECK(controller);
+    EXPECT_TRUE(
+        controller->state() == BackgroundFetchJobController::State::ABORTED ||
+        controller->state() == BackgroundFetchJobController::State::COMPLETED);
   }
 
   void StartProcessing() {
     base::RunLoop run_loop;
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         base::Bind(&BackgroundFetchJobControllerTest::StartProcessingOnIO,
                    base::Unretained(this), run_loop.QuitClosure()));
     run_loop.Run();
   }
 
   void StartProcessingOnIO(const base::Closure& closure) {
     job_controller_->StartProcessing();
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, closure);
   }
 
   BackgroundFetchJobController* job_controller() {
     return job_controller_.get();
   }
+
+  BackgroundFetchJobController::State state() const {
+    return job_controller_->state();
+  }
+
   MockDownloadManagerWithCallback* download_manager() {
     return download_manager_;
   }
 
   DownloadItem::Observer* ItemObserver() const { return job_controller_.get(); }
 
-  bool did_complete_job() const { return did_complete_job_; }
-  bool did_abort_by_developer() const { return did_abort_by_developer_; }
-
   FakeBackgroundFetchDataManager* data_manager() const {
     return data_manager_.get();
   }
 
  private:
-  bool did_complete_job_ = false;
-  bool did_abort_by_developer_ = false;
   TestBrowserThreadBundle thread_bundle_;
   TestBrowserContext browser_context_;
   std::unique_ptr<FakeBackgroundFetchDataManager> data_manager_;
   std::unique_ptr<BackgroundFetchJobController> job_controller_;
   MockDownloadManagerWithCallback* download_manager_;
 };
 
 TEST_F(BackgroundFetchJobControllerTest, SingleRequestJob) {
   BackgroundFetchRegistrationId registration_id(
       kServiceWorkerRegistrationId, url::Origin(GURL(kOrigin)), kTag);
@@ skipping 14 matching lines @@
   StartProcessing();
 
   // Get the pending download from the download manager.
   auto& download_items = download_manager()->download_items();
   ASSERT_EQ(1U, download_items.size());
   FakeDownloadItem* item = download_items[0].get();
 
   // Update the observer with no actual change.
   ItemObserver()->OnDownloadUpdated(item);
   EXPECT_EQ(DownloadItem::DownloadState::IN_PROGRESS, request_info.state());
-  EXPECT_FALSE(did_complete_job());
+  EXPECT_EQ(BackgroundFetchJobController::State::FETCHING, state());
 
   // Update the item to be completed then update the observer. The JobController
   // should update the JobData that the request is complete.
   item->SetState(DownloadItem::DownloadState::COMPLETE);
   ItemObserver()->OnDownloadUpdated(item);
 
   EXPECT_EQ(DownloadItem::DownloadState::COMPLETE, request_info.state());
-  EXPECT_TRUE(did_complete_job());
-  EXPECT_FALSE(did_abort_by_developer());
+  EXPECT_EQ(BackgroundFetchJobController::State::COMPLETED, state());
 }
 
 TEST_F(BackgroundFetchJobControllerTest, MultipleRequestJob) {
   BackgroundFetchRegistrationId registration_id(
       kServiceWorkerRegistrationId, url::Origin(GURL(kOrigin)), kTag);
 
   std::vector<BackgroundFetchRequestInfo> request_infos;
   for (int i = 0; i < 10; i++) {
     ServiceWorkerHeaderMap headers;
     ServiceWorkerFetchRequest request(GURL(kTestUrl), "GET", headers,
@@ skipping 25 matching lines @@
     if (i < 9)
       data_manager()->set_next_request(&request_infos[i + 1]);
 
     // Update the next item to be completed then update the observer.
     ASSERT_EQ(i + 1, download_items.size());
     item = download_items[i].get();
     item->SetState(DownloadItem::DownloadState::COMPLETE);
     ItemObserver()->OnDownloadUpdated(item);
     EXPECT_EQ(DownloadItem::DownloadState::COMPLETE, request_infos[i].state());
   }
-  EXPECT_FALSE(did_complete_job());
+
+  EXPECT_EQ(BackgroundFetchJobController::State::FETCHING, state());
 
   // Finally, update the last request to be complete. The JobController should
   // see that there are no more requests and mark the job as done.
   ASSERT_EQ(10U, download_items.size());
   item = download_items[9].get();
   item->SetState(DownloadItem::DownloadState::COMPLETE);
   ItemObserver()->OnDownloadUpdated(item);
 
-  EXPECT_TRUE(did_complete_job());
-  EXPECT_FALSE(did_abort_by_developer());
+  EXPECT_EQ(BackgroundFetchJobController::State::COMPLETED, state());
 }
 
 TEST_F(BackgroundFetchJobControllerTest, UpdateStorageState) {
   BackgroundFetchRegistrationId registration_id(
       kServiceWorkerRegistrationId, url::Origin(GURL(kOrigin)), kTag);
 
   ServiceWorkerHeaderMap headers;
   ServiceWorkerFetchRequest request(GURL(kTestUrl), "GET", headers, Referrer(),
                                     false /* is_reload */);
   BackgroundFetchRequestInfo request_info(request);
@@ skipping 16 matching lines @@
   item->SetTargetFilePath(base::FilePath(kFileName));
   item->SetReceivedBytes(123);
   item->SetState(DownloadItem::DownloadState::COMPLETE);
 
   // Trigger the observer. The JobController should update the JobData that the
   // request is complete and should fill in storage state.
   ItemObserver()->OnDownloadUpdated(item);
 
   EXPECT_EQ(123, request_info.received_bytes());
   EXPECT_TRUE(data_manager()->IsComplete(kJobGuid));
-  EXPECT_TRUE(did_complete_job());
-  EXPECT_FALSE(did_abort_by_developer());
+  EXPECT_EQ(BackgroundFetchJobController::State::COMPLETED, state());
 }
 
 }  // namespace content