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

content/browser/background_sync/background_sync_service_impl_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_service_impl.h"
 
 #include <stdint.h>
 
 #include <memory>
 #include <utility>
@@ skipping 146 matching lines @@
             ->GetNetworkObserverForTesting();
     network_observer->NotifyManagerIfNetworkChangedForTesting(
         net::NetworkChangeNotifier::CONNECTION_NONE);
     base::RunLoop().RunUntilIdle();
   }
 
   void CreateServiceWorkerRegistration() {
     bool called = false;
     embedded_worker_helper_->context()->RegisterServiceWorker(
         GURL(kServiceWorkerPattern), GURL(kServiceWorkerScript), NULL,
-        base::Bind(&RegisterServiceWorkerCallback, &called,
-                   &sw_registration_id_));
+        base::AdaptCallbackForRepeating(base::BindOnce(
+            &RegisterServiceWorkerCallback, &called, &sw_registration_id_)));
     base::RunLoop().RunUntilIdle();
     EXPECT_TRUE(called);
 
     embedded_worker_helper_->context_wrapper()->FindReadyRegistrationForId(
         sw_registration_id_, GURL(kServiceWorkerPattern).GetOrigin(),
-        base::Bind(FindServiceWorkerRegistrationCallback, &sw_registration_));
+        base::AdaptCallbackForRepeating(base::BindOnce(
+            FindServiceWorkerRegistrationCallback, &sw_registration_)));
     base::RunLoop().RunUntilIdle();
     EXPECT_TRUE(sw_registration_);
   }
 
   void CreateBackgroundSyncServiceImpl() {
     // Create a dummy mojo channel so that the BackgroundSyncServiceImpl can be
     // instantiated.
     mojo::InterfaceRequest<blink::mojom::BackgroundSyncService>
         service_request = mojo::MakeRequest(&service_ptr_);
     // Create a new BackgroundSyncServiceImpl bound to the dummy channel.
@@ skipping 32 matching lines @@
       service_impl_;  // Owned by background_sync_context_
   blink::mojom::SyncRegistrationPtr default_sync_registration_;
 };
 
 // Tests
 
 TEST_F(BackgroundSyncServiceImplTest, Register) {
   bool called = false;
   blink::mojom::BackgroundSyncError error;
   blink::mojom::SyncRegistrationPtr reg;
-  Register(default_sync_registration_.Clone(),
-           base::Bind(&ErrorAndRegistrationCallback, &called, &error, &reg));
+  Register(
+      default_sync_registration_.Clone(),
+      base::BindOnce(&ErrorAndRegistrationCallback, &called, &error, &reg));
   EXPECT_TRUE(called);
   EXPECT_EQ(blink::mojom::BackgroundSyncError::NONE, error);
   EXPECT_EQ("", reg->tag);
 }
 
 TEST_F(BackgroundSyncServiceImplTest, GetRegistrations) {
   bool called = false;
   blink::mojom::BackgroundSyncError error;
   unsigned long array_size = 0UL;
-  GetRegistrations(base::Bind(&ErrorAndRegistrationListCallback, &called,
-                              &error, &array_size));
+  GetRegistrations(base::BindOnce(&ErrorAndRegistrationListCallback, &called,
+                                  &error, &array_size));
   EXPECT_TRUE(called);
   EXPECT_EQ(blink::mojom::BackgroundSyncError::NONE, error);
   EXPECT_EQ(0UL, array_size);
 }
 
 TEST_F(BackgroundSyncServiceImplTest, GetRegistrationsWithRegisteredSync) {
   bool register_called = false;
-  bool getregistrations_called = false;
+  bool get_registrations_called = false;
   blink::mojom::BackgroundSyncError register_error;
   blink::mojom::BackgroundSyncError getregistrations_error;
   blink::mojom::SyncRegistrationPtr register_reg;
   unsigned long array_size = 0UL;
   Register(default_sync_registration_.Clone(),
-           base::Bind(&ErrorAndRegistrationCallback, &register_called,
-                      &register_error, &register_reg));
+           base::BindOnce(&ErrorAndRegistrationCallback, &register_called,
+                          &register_error, &register_reg));
   EXPECT_TRUE(register_called);
   EXPECT_EQ(blink::mojom::BackgroundSyncError::NONE, register_error);
-  GetRegistrations(base::Bind(&ErrorAndRegistrationListCallback,
-                              &getregistrations_called, &getregistrations_error,
-                              &array_size));
-  EXPECT_TRUE(getregistrations_called);
+  GetRegistrations(base::BindOnce(&ErrorAndRegistrationListCallback,
+                                  &get_registrations_called,
+                                  &getregistrations_error, &array_size));
+  EXPECT_TRUE(get_registrations_called);
   EXPECT_EQ(blink::mojom::BackgroundSyncError::NONE, getregistrations_error);
   EXPECT_EQ(1UL, array_size);
 }
 
 }  // namespace content