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

content/browser/background_sync/background_sync_service_impl.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 <utility>
 
 #include "base/memory/weak_ptr.h"
 #include "base/stl_util.h"
@@ skipping 65 matching lines @@
 
 BackgroundSyncServiceImpl::BackgroundSyncServiceImpl(
     BackgroundSyncContext* background_sync_context,
     mojo::InterfaceRequest<blink::mojom::BackgroundSyncService> request)
     : background_sync_context_(background_sync_context),
       binding_(this, std::move(request)),
       weak_ptr_factory_(this) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(background_sync_context);
 
-  binding_.set_connection_error_handler(
-      base::Bind(&BackgroundSyncServiceImpl::OnConnectionError,
-                 base::Unretained(this) /* the channel is owned by this */));
+  binding_.set_connection_error_handler(base::BindOnce(
+      &BackgroundSyncServiceImpl::OnConnectionError,
+      base::Unretained(this) /* the channel is owned by this */));
 }
 
 void BackgroundSyncServiceImpl::OnConnectionError() {
   background_sync_context_->ServiceHadConnectionError(this);
   // |this| is now deleted.
 }
 
 void BackgroundSyncServiceImpl::Register(
     blink::mojom::SyncRegistrationPtr options,
     int64_t sw_registration_id,
     RegisterCallback callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   BackgroundSyncRegistrationOptions manager_options =
       ToBackgroundSyncRegistrationOptions(options);
 
   BackgroundSyncManager* background_sync_manager =
       background_sync_context_->background_sync_manager();
   DCHECK(background_sync_manager);
   background_sync_manager->Register(
       sw_registration_id, manager_options,
-      base::Bind(&BackgroundSyncServiceImpl::OnRegisterResult,
-                 weak_ptr_factory_.GetWeakPtr(), base::Passed(&callback)));
+      base::BindOnce(&BackgroundSyncServiceImpl::OnRegisterResult,
+                     weak_ptr_factory_.GetWeakPtr(), std::move(callback)));
 }
 
 void BackgroundSyncServiceImpl::GetRegistrations(
     int64_t sw_registration_id,
     GetRegistrationsCallback callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   BackgroundSyncManager* background_sync_manager =
       background_sync_context_->background_sync_manager();
   DCHECK(background_sync_manager);
   background_sync_manager->GetRegistrations(
       sw_registration_id,
-      base::Bind(&BackgroundSyncServiceImpl::OnGetRegistrationsResult,
-                 weak_ptr_factory_.GetWeakPtr(), base::Passed(&callback)));
+      base::BindOnce(&BackgroundSyncServiceImpl::OnGetRegistrationsResult,
+                     weak_ptr_factory_.GetWeakPtr(), std::move(callback)));
 }
 
 void BackgroundSyncServiceImpl::OnRegisterResult(
     RegisterCallback callback,
     BackgroundSyncStatus status,
     std::unique_ptr<BackgroundSyncRegistration> result) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (status != BACKGROUND_SYNC_STATUS_OK) {
     std::move(callback).Run(
@@ skipping 20 matching lines @@
   std::vector<blink::mojom::SyncRegistrationPtr> mojo_registrations;
   for (const auto& registration : result_registrations)
     mojo_registrations.push_back(ToMojoRegistration(*registration));
 
   std::move(callback).Run(
       static_cast<blink::mojom::BackgroundSyncError>(status),
       std::move(mojo_registrations));
 }
 
 }  // namespace content