BackgroundSync: Convert to base::BindOnce/OnceCallback/OnceClosure

content/browser/background_sync/background_sync_manager_unittest.cc

 // Copyright 2015 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_sync/background_sync_manager.h"
 
 #include <stdint.h>
 
 #include <memory>
 #include <utility>
@@ skipping 141 matching lines @@
   void TearDown() override {
     // Restore the network observer functionality for subsequent tests
     background_sync_test_util::SetIgnoreNetworkChangeNotifier(false);
   }
 
   void RegisterServiceWorkers() {
     bool called_1 = false;
     bool called_2 = false;
     helper_->context()->RegisterServiceWorker(
         GURL(kPattern1), GURL(kScript1), NULL,
-        base::Bind(&RegisterServiceWorkerCallback, &called_1,
-                   &sw_registration_id_1_));
+        base::AdaptCallbackForRepeating(
+            base::BindOnce(&RegisterServiceWorkerCallback, &called_1,
+                           &sw_registration_id_1_)));
 
     helper_->context()->RegisterServiceWorker(
         GURL(kPattern2), GURL(kScript2), NULL,
-        base::Bind(&RegisterServiceWorkerCallback, &called_2,
-                   &sw_registration_id_2_));
+        base::AdaptCallbackForRepeating(
+            base::BindOnce(&RegisterServiceWorkerCallback, &called_2,
+                           &sw_registration_id_2_)));
     base::RunLoop().RunUntilIdle();
     EXPECT_TRUE(called_1);
     EXPECT_TRUE(called_2);
 
     // Hang onto the registrations as they need to be "live" when
     // calling BackgroundSyncManager::Register.
     helper_->context_wrapper()->FindReadyRegistrationForId(
         sw_registration_id_1_, GURL(kPattern1).GetOrigin(),
-        base::Bind(FindServiceWorkerRegistrationCallback, &sw_registration_1_));
+        base::AdaptCallbackForRepeating(base::BindOnce(
+            FindServiceWorkerRegistrationCallback, &sw_registration_1_)));
 
     helper_->context_wrapper()->FindReadyRegistrationForId(
         sw_registration_id_2_, GURL(kPattern1).GetOrigin(),
-        base::Bind(FindServiceWorkerRegistrationCallback, &sw_registration_2_));
+        base::AdaptCallbackForRepeating(base::BindOnce(
+            FindServiceWorkerRegistrationCallback, &sw_registration_2_)));
     base::RunLoop().RunUntilIdle();
     EXPECT_TRUE(sw_registration_1_);
     EXPECT_TRUE(sw_registration_2_);
   }
 
   void SetNetwork(net::NetworkChangeNotifier::ConnectionType connection_type) {
     net::NetworkChangeNotifier::NotifyObserversOfNetworkChangeForTests(
         connection_type);
     if (test_background_sync_manager_) {
       BackgroundSyncNetworkObserver* network_observer =
@@ skipping 75 matching lines @@
   bool Register(const BackgroundSyncRegistrationOptions& sync_options) {
     return RegisterWithServiceWorkerId(sw_registration_id_1_, sync_options);
   }
 
   bool RegisterWithServiceWorkerId(
       int64_t sw_registration_id,
       const BackgroundSyncRegistrationOptions& options) {
     bool was_called = false;
     background_sync_manager_->Register(
         sw_registration_id, options,
-        base::Bind(&BackgroundSyncManagerTest::StatusAndRegistrationCallback,
-                   base::Unretained(this), &was_called));
+        base::BindOnce(
+            &BackgroundSyncManagerTest::StatusAndRegistrationCallback,
+            base::Unretained(this), &was_called));
     base::RunLoop().RunUntilIdle();
     EXPECT_TRUE(was_called);
     return callback_status_ == BACKGROUND_SYNC_STATUS_OK;
   }
 
   MockPermissionManager* GetPermissionManager() {
     return static_cast<MockPermissionManager*>(
         helper_->browser_context()->GetPermissionManager());
   }
 
   bool GetRegistration(
       const BackgroundSyncRegistrationOptions& registration_options) {
     return GetRegistrationWithServiceWorkerId(sw_registration_id_1_,
                                               registration_options);
   }
 
   bool GetRegistrationWithServiceWorkerId(
       int64_t sw_registration_id,
       const BackgroundSyncRegistrationOptions& registration_options) {
     bool was_called = false;
     background_sync_manager_->GetRegistrations(
         sw_registration_id,
-        base::Bind(&BackgroundSyncManagerTest::StatusAndRegistrationsCallback,
-                   base::Unretained(this), &was_called));
+        base::BindOnce(
+            &BackgroundSyncManagerTest::StatusAndRegistrationsCallback,
+            base::Unretained(this), &was_called));
     base::RunLoop().RunUntilIdle();
     EXPECT_TRUE(was_called);
 
     if (callback_status_ == BACKGROUND_SYNC_STATUS_OK) {
       for (auto iter = callback_registrations_.begin();
            iter < callback_registrations_.end(); ++iter) {
         if ((*iter)->options()->tag == registration_options.tag) {
           // Transfer the matching registration out of the vector into
           // callback_registration_ for testing.
           callback_registration_ = std::move(*iter);
           callback_registrations_.erase(iter);
           return true;
         }
       }
     }
     return false;
   }
 
   bool GetRegistrations() {
     return GetRegistrationsWithServiceWorkerId(sw_registration_id_1_);
   }
 
   bool GetRegistrationsWithServiceWorkerId(int64_t sw_registration_id) {
     bool was_called = false;
     background_sync_manager_->GetRegistrations(
         sw_registration_id,
-        base::Bind(&BackgroundSyncManagerTest::StatusAndRegistrationsCallback,
-                   base::Unretained(this), &was_called));
+        base::BindOnce(
+            &BackgroundSyncManagerTest::StatusAndRegistrationsCallback,
+            base::Unretained(this), &was_called));
     base::RunLoop().RunUntilIdle();
     EXPECT_TRUE(was_called);
 
     return callback_status_ == BACKGROUND_SYNC_STATUS_OK;
   }
 
   MockBackgroundSyncController* GetController() {
     return static_cast<MockBackgroundSyncController*>(
         helper_->browser_context()->GetBackgroundSyncController());
   }
 
   void StorageRegistrationCallback(ServiceWorkerStatusCode result) {
     callback_sw_status_code_ = result;
   }
 
   void UnregisterServiceWorker(uint64_t sw_registration_id) {
     bool called = false;
     helper_->context()->UnregisterServiceWorker(
         PatternForSWId(sw_registration_id),
-        base::Bind(&UnregisterServiceWorkerCallback, &called));
+        base::AdaptCallbackForRepeating(
+            base::BindOnce(&UnregisterServiceWorkerCallback, &called)));
     base::RunLoop().RunUntilIdle();
     EXPECT_TRUE(called);
   }
 
   GURL PatternForSWId(int64_t sw_id) {
     EXPECT_TRUE(sw_id == sw_registration_id_1_ ||
                 sw_id == sw_registration_id_2_);
     return sw_id == sw_registration_id_1_ ? GURL(kPattern1) : GURL(kPattern2);
   }
 
   void SetupForSyncEvent(
       const TestBackgroundSyncManager::DispatchSyncCallback& callback) {
     test_background_sync_manager_->set_dispatch_sync_callback(callback);
     SetNetwork(net::NetworkChangeNotifier::CONNECTION_WIFI);
   }
 
   void InitSyncEventTest() {
-    SetupForSyncEvent(
-        base::Bind(DispatchSyncSuccessfulCallback, &sync_events_called_));
+    SetupForSyncEvent(base::BindRepeating(DispatchSyncSuccessfulCallback,
+                                          &sync_events_called_));
   }
 
   void InitFailedSyncEventTest() {
     SetupForSyncEvent(
-        base::Bind(DispatchSyncFailedCallback, &sync_events_called_));
+        base::BindRepeating(DispatchSyncFailedCallback, &sync_events_called_));
   }
 
   void InitDelayedSyncEventTest() {
-    SetupForSyncEvent(base::Bind(DispatchSyncDelayedCallback,
-                                 &sync_events_called_, &sync_fired_callback_));
+    SetupForSyncEvent(base::BindRepeating(DispatchSyncDelayedCallback,
+                                          &sync_events_called_,
+                                          &sync_fired_callback_));
   }
 
   void RegisterAndVerifySyncEventDelayed(
       const BackgroundSyncRegistrationOptions& sync_options) {
     int sync_events_called = sync_events_called_;
     EXPECT_TRUE(sync_fired_callback_.is_null());
 
     EXPECT_TRUE(Register(sync_options));
 
     EXPECT_EQ(sync_events_called + 1, sync_events_called_);
@@ skipping 236 matching lines @@
 
 TEST_F(BackgroundSyncManagerTest, SequentialOperations) {
   // Schedule Init and all of the operations on a delayed backend. Verify that
   // the operations complete sequentially.
   SetupDelayedBackgroundSyncManager();
 
   bool register_called = false;
   bool get_registrations_called = false;
   test_background_sync_manager_->Register(
       sw_registration_id_1_, sync_options_1_,
-      base::Bind(&BackgroundSyncManagerTest::StatusAndRegistrationCallback,
-                 base::Unretained(this), &register_called));
+      base::AdaptCallbackForRepeating(base::BindOnce(
+          &BackgroundSyncManagerTest::StatusAndRegistrationCallback,
+          base::Unretained(this), &register_called)));
   test_background_sync_manager_->GetRegistrations(
       sw_registration_id_1_,
-      base::Bind(&BackgroundSyncManagerTest::StatusAndRegistrationsCallback,
-                 base::Unretained(this), &get_registrations_called));
+      base::AdaptCallbackForRepeating(base::BindOnce(
+          &BackgroundSyncManagerTest::StatusAndRegistrationsCallback,
+          base::Unretained(this), &get_registrations_called)));
 
   base::RunLoop().RunUntilIdle();
   // Init should be blocked while loading from the backend.
   EXPECT_FALSE(register_called);
   EXPECT_FALSE(get_registrations_called);
 
   test_background_sync_manager_->ResumeBackendOperation();
   base::RunLoop().RunUntilIdle();
   // Register should be blocked while storing to the backend.
   EXPECT_FALSE(register_called);
@@ skipping 14 matching lines @@
 }
 
 TEST_F(BackgroundSyncManagerTest,
        UnregisterServiceWorkerDuringSyncRegistration) {
   EXPECT_TRUE(Register(sync_options_1_));
 
   test_background_sync_manager_->set_delay_backend(true);
   bool callback_called = false;
   test_background_sync_manager_->Register(
       sw_registration_id_1_, sync_options_2_,
-      base::Bind(&BackgroundSyncManagerTest::StatusAndRegistrationCallback,
-                 base::Unretained(this), &callback_called));
+      base::AdaptCallbackForRepeating(base::BindOnce(
+          &BackgroundSyncManagerTest::StatusAndRegistrationCallback,
+          base::Unretained(this), &callback_called)));
 
   base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(callback_called);
   UnregisterServiceWorker(sw_registration_id_1_);
 
   test_background_sync_manager_->ResumeBackendOperation();
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(callback_called);
   EXPECT_EQ(BACKGROUND_SYNC_STATUS_STORAGE_ERROR, callback_status_);
 
@@ skipping 453 matching lines @@
   EXPECT_FALSE(GetRegistration(sync_options_1_));
 }
 
 TEST_F(BackgroundSyncManagerTest, TwoAttempts) {
   SetMaxSyncAttemptsAndRestartManager(2);
   InitFailedSyncEventTest();
 
   // The first run will fail but it will setup a timer to try again.
   EXPECT_TRUE(Register(sync_options_1_));
   EXPECT_TRUE(GetRegistration(sync_options_1_));
-  EXPECT_FALSE(test_background_sync_manager_->delayed_task().is_null());
+  EXPECT_TRUE(test_background_sync_manager_->IsDelayedTaskScheduled());
 
   // Make sure the delay is reasonable.
   EXPECT_LT(base::TimeDelta::FromMinutes(1),
             test_background_sync_manager_->delayed_task_delta());
   EXPECT_GT(base::TimeDelta::FromHours(1),
             test_background_sync_manager_->delayed_task_delta());
 
   // Fire again and this time it should permanently fail.
   test_clock_->Advance(test_background_sync_manager_->delayed_task_delta());
-  test_background_sync_manager_->delayed_task().Run();
+  test_background_sync_manager_->RunDelayedTask();
   base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(GetRegistration(sync_options_1_));
 }
 
 TEST_F(BackgroundSyncManagerTest, ThreeAttempts) {
   SetMaxSyncAttemptsAndRestartManager(3);
   InitFailedSyncEventTest();
 
   // The first run will fail but it will setup a timer to try again.
   EXPECT_TRUE(Register(sync_options_1_));
   EXPECT_TRUE(GetRegistration(sync_options_1_));
-  EXPECT_FALSE(test_background_sync_manager_->delayed_task().is_null());
+  EXPECT_TRUE(test_background_sync_manager_->IsDelayedTaskScheduled());
 
   // The second run will fail but it will setup a timer to try again.
   base::TimeDelta first_delta =
       test_background_sync_manager_->delayed_task_delta();
   test_clock_->Advance(test_background_sync_manager_->delayed_task_delta());
-  test_background_sync_manager_->delayed_task().Run();
+  test_background_sync_manager_->RunDelayedTask();
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(GetRegistration(sync_options_1_));
 
   // Verify that the delta grows for each attempt.
   EXPECT_LT(first_delta, test_background_sync_manager_->delayed_task_delta());
 
   // The third run will permanently fail.
   test_clock_->Advance(test_background_sync_manager_->delayed_task_delta());
-  test_background_sync_manager_->delayed_task().Run();
+  test_background_sync_manager_->RunDelayedTask();
   base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(GetRegistration(sync_options_1_));
 }
 
 TEST_F(BackgroundSyncManagerTest, WaitsFullDelayTime) {
   SetMaxSyncAttemptsAndRestartManager(2);
   InitFailedSyncEventTest();
 
   // The first run will fail but it will setup a timer to try again.
   EXPECT_TRUE(Register(sync_options_1_));
   EXPECT_TRUE(GetRegistration(sync_options_1_));
-  EXPECT_FALSE(test_background_sync_manager_->delayed_task().is_null());
+  EXPECT_TRUE(test_background_sync_manager_->IsDelayedTaskScheduled());
 
   // Fire again one second before it's ready to retry. Expect it to reschedule
   // the delay timer for one more second.
   test_clock_->Advance(test_background_sync_manager_->delayed_task_delta() -
                        base::TimeDelta::FromSeconds(1));
-  test_background_sync_manager_->delayed_task().Run();
+  test_background_sync_manager_->RunDelayedTask();
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(GetRegistration(sync_options_1_));
   EXPECT_EQ(base::TimeDelta::FromSeconds(1),
             test_background_sync_manager_->delayed_task_delta());
 
   // Fire one second later and it should fail permanently.
   test_clock_->Advance(base::TimeDelta::FromSeconds(1));
-  test_background_sync_manager_->delayed_task().Run();
+  test_background_sync_manager_->RunDelayedTask();
   base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(GetRegistration(sync_options_1_));
 }
 
 TEST_F(BackgroundSyncManagerTest, RetryOnBrowserRestart) {
   SetMaxSyncAttemptsAndRestartManager(2);
   InitFailedSyncEventTest();
 
   // The first run will fail but it will setup a timer to try again.
   EXPECT_TRUE(Register(sync_options_1_));
@@ skipping 48 matching lines @@
 
 TEST_F(BackgroundSyncManagerTest, AllTestsEventuallyFire) {
   SetMaxSyncAttemptsAndRestartManager(3);
   InitFailedSyncEventTest();
 
   // The first run will fail but it will setup a timer to try again.
   EXPECT_TRUE(Register(sync_options_1_));
 
   // Run it a second time.
   test_clock_->Advance(test_background_sync_manager_->delayed_task_delta());
-  test_background_sync_manager_->delayed_task().Run();
+  test_background_sync_manager_->RunDelayedTask();
   base::RunLoop().RunUntilIdle();
 
   base::TimeDelta delay_delta =
       test_background_sync_manager_->delayed_task_delta();
 
   // Create a second registration, which will fail and setup a timer.
   EXPECT_TRUE(Register(sync_options_2_));
   EXPECT_GT(delay_delta, test_background_sync_manager_->delayed_task_delta());
 
-  while (!test_background_sync_manager_->delayed_task().is_null()) {
+  while (test_background_sync_manager_->IsDelayedTaskScheduled()) {
     test_clock_->Advance(test_background_sync_manager_->delayed_task_delta());
-    test_background_sync_manager_->delayed_task().Run();
-    test_background_sync_manager_->ClearDelayedTask();
+    test_background_sync_manager_->RunDelayedTask();
+    EXPECT_FALSE(test_background_sync_manager_->IsDelayedTaskScheduled());
     base::RunLoop().RunUntilIdle();
   }
 
   EXPECT_FALSE(GetRegistration(sync_options_1_));
   EXPECT_FALSE(GetRegistration(sync_options_2_));
 }
 
 TEST_F(BackgroundSyncManagerTest, LastChance) {
   SetMaxSyncAttemptsAndRestartManager(2);
   InitFailedSyncEventTest();
 
   EXPECT_TRUE(Register(sync_options_1_));
   EXPECT_EQ(blink::mojom::BackgroundSyncEventLastChance::IS_NOT_LAST_CHANCE,
             test_background_sync_manager_->last_chance());
   EXPECT_TRUE(GetRegistration(sync_options_1_));
 
   // Run it again.
   test_clock_->Advance(test_background_sync_manager_->delayed_task_delta());
-  test_background_sync_manager_->delayed_task().Run();
+  test_background_sync_manager_->RunDelayedTask();
   base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(GetRegistration(sync_options_1_));
   EXPECT_EQ(blink::mojom::BackgroundSyncEventLastChance::IS_LAST_CHANCE,
             test_background_sync_manager_->last_chance());
 }
 
 }  // namespace content