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

content/browser/background_sync/background_sync_browsertest.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 <stdint.h>
 
 #include <memory>
 #include <set>
 #include <string>
 #include <vector>
@@ skipping 54 matching lines @@
     const base::Closure& quit,
     const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
     bool* result_out,
     bool result) {
   *result_out = result;
   task_runner->PostTask(FROM_HERE, quit);
 }
 
 void RegistrationPendingDidGetSyncRegistration(
     const std::string& tag,
-    const base::Callback<void(bool)>& callback,
+    base::OnceCallback<void(bool)> callback,
     BackgroundSyncStatus error_type,
     std::vector<std::unique_ptr<BackgroundSyncRegistration>> registrations) {
   ASSERT_EQ(BACKGROUND_SYNC_STATUS_OK, error_type);
   // Find the right registration in the list and check its status.
   for (const auto& registration : registrations) {
     if (registration->options()->tag == tag) {
-      callback.Run(registration->sync_state() ==
-                   blink::mojom::BackgroundSyncState::PENDING);
+      std::move(callback).Run(registration->sync_state() ==
+                              blink::mojom::BackgroundSyncState::PENDING);
       return;
     }
   }
   ADD_FAILURE() << "Registration should exist";
 }
 
 void RegistrationPendingDidGetSWRegistration(
     const scoped_refptr<BackgroundSyncContext> sync_context,
     const std::string& tag,
-    const base::Callback<void(bool)>& callback,
+    base::OnceCallback<void(bool)> callback,
     ServiceWorkerStatusCode status,
     scoped_refptr<ServiceWorkerRegistration> registration) {
   ASSERT_EQ(SERVICE_WORKER_OK, status);
   int64_t service_worker_id = registration->id();
   BackgroundSyncManager* sync_manager = sync_context->background_sync_manager();
   sync_manager->GetRegistrations(
       service_worker_id,
-      base::Bind(&RegistrationPendingDidGetSyncRegistration, tag, callback));
+      base::BindOnce(&RegistrationPendingDidGetSyncRegistration, tag,
+                     std::move(callback)));
 }
 
 void RegistrationPendingOnIOThread(
     const scoped_refptr<BackgroundSyncContext> sync_context,
     const scoped_refptr<ServiceWorkerContextWrapper> sw_context,
     const std::string& tag,
     const GURL& url,
-    const base::Callback<void(bool)>& callback) {
+    base::OnceCallback<void(bool)> callback) {
   sw_context->FindReadyRegistrationForDocument(
-      url, base::Bind(&RegistrationPendingDidGetSWRegistration, sync_context,
-                      tag, callback));
+      url, base::AdaptCallbackForRepeating(
+               base::BindOnce(&RegistrationPendingDidGetSWRegistration,
+                              sync_context, tag, std::move(callback))));
 }
 
 void SetMaxSyncAttemptsOnIOThread(
     const scoped_refptr<BackgroundSyncContext>& sync_context,
     int max_sync_attempts) {
   BackgroundSyncManager* background_sync_manager =
       sync_context->background_sync_manager();
   background_sync_manager->SetMaxSyncAttemptsForTesting(max_sync_attempts);
 }
 
@@ skipping 96 matching lines @@
 bool BackgroundSyncBrowserTest::RegistrationPending(const std::string& tag) {
   bool is_pending;
   base::RunLoop run_loop;
 
   StoragePartitionImpl* storage = GetStorage();
   BackgroundSyncContext* sync_context = storage->GetBackgroundSyncContext();
   ServiceWorkerContextWrapper* service_worker_context =
       static_cast<ServiceWorkerContextWrapper*>(
           storage->GetServiceWorkerContext());
 
-  base::Callback<void(bool)> callback =
-      base::Bind(&RegistrationPendingCallback, run_loop.QuitClosure(),
-                 base::ThreadTaskRunnerHandle::Get(), &is_pending);
+  auto callback =
+      base::BindOnce(&RegistrationPendingCallback, run_loop.QuitClosure(),
+                     base::ThreadTaskRunnerHandle::Get(), &is_pending);
 
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      base::Bind(&RegistrationPendingOnIOThread,
-                 make_scoped_refptr(sync_context),
-                 make_scoped_refptr(service_worker_context), tag,
-                 https_server_->GetURL(kDefaultTestURL), callback));
+      base::BindOnce(
+          &RegistrationPendingOnIOThread, make_scoped_refptr(sync_context),
+          make_scoped_refptr(service_worker_context), tag,
+          https_server_->GetURL(kDefaultTestURL), std::move(callback)));
 
   run_loop.Run();
 
   return is_pending;
 }
 
 void BackgroundSyncBrowserTest::SetMaxSyncAttempts(int max_sync_attempts) {
   base::RunLoop run_loop;
 
   StoragePartitionImpl* storage = GetStorage();
   BackgroundSyncContext* sync_context = storage->GetBackgroundSyncContext();
 
   BrowserThread::PostTaskAndReply(
       BrowserThread::IO, FROM_HERE,
-      base::Bind(&SetMaxSyncAttemptsOnIOThread,
-                 make_scoped_refptr(sync_context), max_sync_attempts),
+      base::BindOnce(&SetMaxSyncAttemptsOnIOThread,
+                     make_scoped_refptr(sync_context), max_sync_attempts),
       run_loop.QuitClosure());
 
   run_loop.Run();
 }
 
 void BackgroundSyncBrowserTest::ClearStoragePartitionData() {
   // Clear data from the storage partition.  Parameters are set to clear data
   // for service workers, for all origins, for an unbounded time range.
   StoragePartitionImpl* storage = GetStorage();
 
@@ skipping 417 matching lines @@
 IN_PROC_BROWSER_TEST_F(BackgroundSyncBrowserTest,
                        RegisterFromServiceWorkerWithoutMainFrameHost) {
   std::string script_result;
   EXPECT_TRUE(
       RegisterFromCrossOriginFrame(kRegisterSyncFromSWURL, &script_result));
   EXPECT_EQ(BuildExpectedResult("frame", "failed to register sync"),
             script_result);
 }
 
 }  // namespace content