Rewrite base::Bind to base::BindOnce with base_bind_rewriters in //chrome/browser/sync_file_system

chrome/browser/sync_file_system/drive_backend/sync_engine.cc

 // Copyright 2013 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 "chrome/browser/sync_file_system/drive_backend/sync_engine.h"
 
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 108 matching lines @@
 
   void OnPendingFileListUpdated(int item_count) override {
     if (ui_task_runner_->RunsTasksOnCurrentThread()) {
       if (sync_engine_)
         sync_engine_->OnPendingFileListUpdated(item_count);
       return;
     }
 
     DCHECK(sequence_checker_.CalledOnValidSequence());
     ui_task_runner_->PostTask(
-        FROM_HERE,
-        base::Bind(&SyncEngine::OnPendingFileListUpdated,
-                   sync_engine_,
-                   item_count));
+        FROM_HERE, base::BindOnce(&SyncEngine::OnPendingFileListUpdated,
+                                  sync_engine_, item_count));
   }
 
   void OnFileStatusChanged(const storage::FileSystemURL& url,
                            SyncFileType file_type,
                            SyncFileStatus file_status,
                            SyncAction sync_action,
                            SyncDirection direction) override {
     if (ui_task_runner_->RunsTasksOnCurrentThread()) {
       if (sync_engine_)
         sync_engine_->OnFileStatusChanged(
             url, file_type, file_status, sync_action, direction);
       return;
     }
 
     DCHECK(sequence_checker_.CalledOnValidSequence());
     ui_task_runner_->PostTask(
         FROM_HERE,
-        base::Bind(&SyncEngine::OnFileStatusChanged,
-                   sync_engine_,
-                   url, file_type, file_status, sync_action, direction));
+        base::BindOnce(&SyncEngine::OnFileStatusChanged, sync_engine_, url,
+                       file_type, file_status, sync_action, direction));
   }
 
   void UpdateServiceState(RemoteServiceState state,
                           const std::string& description) override {
     if (ui_task_runner_->RunsTasksOnCurrentThread()) {
       if (sync_engine_)
         sync_engine_->UpdateServiceState(state, description);
       return;
     }
 
     DCHECK(sequence_checker_.CalledOnValidSequence());
     ui_task_runner_->PostTask(
-        FROM_HERE,
-        base::Bind(&SyncEngine::UpdateServiceState,
-                   sync_engine_, state, description));
+        FROM_HERE, base::BindOnce(&SyncEngine::UpdateServiceState, sync_engine_,
+                                  state, description));
   }
 
   void DetachFromSequence() {
     sequence_checker_.DetachFromSequence();
   }
 
  private:
   scoped_refptr<base::SequencedTaskRunner> ui_task_runner_;
   base::WeakPtr<SyncEngine> sync_engine_;
 
@@ skipping 160 matching lines @@
     sync_worker.reset(new SyncWorker(
         sync_file_system_dir_,
         extension_service_weak_ptr,
         env_override_));
   }
 
   sync_worker_ = std::move(sync_worker);
   sync_worker_->AddObserver(worker_observer_.get());
 
   worker_task_runner_->PostTask(
-      FROM_HERE,
-      base::Bind(&SyncWorkerInterface::Initialize,
-                 base::Unretained(sync_worker_.get()),
-                 base::Passed(&sync_engine_context)));
+      FROM_HERE, base::BindOnce(&SyncWorkerInterface::Initialize,
+                                base::Unretained(sync_worker_.get()),
+                                base::Passed(&sync_engine_context)));
   if (remote_change_processor_)
     SetRemoteChangeProcessor(remote_change_processor_);
 
   drive_service_->AddObserver(this);
 
   service_state_ = REMOTE_SERVICE_TEMPORARY_UNAVAILABLE;
   OnNetworkChanged(net::NetworkChangeNotifier::GetConnectionType());
   if (drive_service_->HasRefreshToken())
     OnReadyToSendRequests();
   else
@@ skipping 18 matching lines @@
     else
       callback.Run(SYNC_STATUS_ABORT);
     return;
   }
 
   SyncStatusCallback relayed_callback = RelayCallbackToCurrentThread(
       FROM_HERE, base::Bind(&DidRegisterOrigin, base::TimeTicks::Now(),
                             TrackCallback(callback)));
 
   worker_task_runner_->PostTask(
-      FROM_HERE,
-      base::Bind(&SyncWorkerInterface::RegisterOrigin,
-                 base::Unretained(sync_worker_.get()),
-                 origin, relayed_callback));
+      FROM_HERE, base::BindOnce(&SyncWorkerInterface::RegisterOrigin,
+                                base::Unretained(sync_worker_.get()), origin,
+                                relayed_callback));
 }
 
 void SyncEngine::EnableOrigin(
     const GURL& origin, const SyncStatusCallback& callback) {
   if (!sync_worker_) {
     // It's safe to return OK immediately since this is also checked in
     // SyncWorker initialization.
     callback.Run(SYNC_STATUS_OK);
     return;
   }
 
   SyncStatusCallback relayed_callback = RelayCallbackToCurrentThread(
       FROM_HERE, TrackCallback(callback));
 
   worker_task_runner_->PostTask(
-      FROM_HERE,
-      base::Bind(&SyncWorkerInterface::EnableOrigin,
-                 base::Unretained(sync_worker_.get()),
-                 origin, relayed_callback));
+      FROM_HERE, base::BindOnce(&SyncWorkerInterface::EnableOrigin,
+                                base::Unretained(sync_worker_.get()), origin,
+                                relayed_callback));
 }
 
 void SyncEngine::DisableOrigin(
     const GURL& origin, const SyncStatusCallback& callback) {
   if (!sync_worker_) {
     // It's safe to return OK immediately since this is also checked in
     // SyncWorker initialization.
     callback.Run(SYNC_STATUS_OK);
     return;
   }
 
   SyncStatusCallback relayed_callback = RelayCallbackToCurrentThread(
       FROM_HERE, TrackCallback(callback));
 
   worker_task_runner_->PostTask(
-      FROM_HERE,
-      base::Bind(&SyncWorkerInterface::DisableOrigin,
-                 base::Unretained(sync_worker_.get()),
-                 origin,
-                 relayed_callback));
+      FROM_HERE, base::BindOnce(&SyncWorkerInterface::DisableOrigin,
+                                base::Unretained(sync_worker_.get()), origin,
+                                relayed_callback));
 }
 
 void SyncEngine::UninstallOrigin(
     const GURL& origin,
     UninstallFlag flag,
     const SyncStatusCallback& callback) {
   if (!sync_worker_) {
     // It's safe to return OK immediately since this is also checked in
     // SyncWorker initialization.
     callback.Run(SYNC_STATUS_OK);
     return;
   }
 
   SyncStatusCallback relayed_callback = RelayCallbackToCurrentThread(
       FROM_HERE, TrackCallback(callback));
   worker_task_runner_->PostTask(
-      FROM_HERE,
-      base::Bind(&SyncWorkerInterface::UninstallOrigin,
-                 base::Unretained(sync_worker_.get()),
-                 origin, flag, relayed_callback));
+      FROM_HERE, base::BindOnce(&SyncWorkerInterface::UninstallOrigin,
+                                base::Unretained(sync_worker_.get()), origin,
+                                flag, relayed_callback));
 }
 
 void SyncEngine::ProcessRemoteChange(const SyncFileCallback& callback) {
   if (GetCurrentState() == REMOTE_SERVICE_DISABLED) {
     callback.Run(SYNC_STATUS_SYNC_DISABLED, storage::FileSystemURL());
     return;
   }
 
   base::Closure abort_closure =
       base::Bind(callback, SYNC_STATUS_ABORT, storage::FileSystemURL());
 
   if (!sync_worker_) {
     abort_closure.Run();
     return;
   }
 
   SyncFileCallback tracked_callback = callback_tracker_.Register(
       abort_closure, callback);
   SyncFileCallback relayed_callback = RelayCallbackToCurrentThread(
       FROM_HERE, tracked_callback);
   worker_task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&SyncWorkerInterface::ProcessRemoteChange,
-                 base::Unretained(sync_worker_.get()),
-                 relayed_callback));
+      base::BindOnce(&SyncWorkerInterface::ProcessRemoteChange,
+                     base::Unretained(sync_worker_.get()), relayed_callback));
 }
 
 void SyncEngine::SetRemoteChangeProcessor(RemoteChangeProcessor* processor) {
   remote_change_processor_ = processor;
 
   if (!sync_worker_)
     return;
 
   remote_change_processor_wrapper_.reset(
       new RemoteChangeProcessorWrapper(processor));
 
   remote_change_processor_on_worker_.reset(new RemoteChangeProcessorOnWorker(
       remote_change_processor_wrapper_->AsWeakPtr(),
       ui_task_runner_.get(),
       worker_task_runner_.get()));
 
   worker_task_runner_->PostTask(
-      FROM_HERE,
-      base::Bind(&SyncWorkerInterface::SetRemoteChangeProcessor,
-                 base::Unretained(sync_worker_.get()),
-                 remote_change_processor_on_worker_.get()));
+      FROM_HERE, base::BindOnce(&SyncWorkerInterface::SetRemoteChangeProcessor,
+                                base::Unretained(sync_worker_.get()),
+                                remote_change_processor_on_worker_.get()));
 }
 
 LocalChangeProcessor* SyncEngine::GetLocalChangeProcessor() {
   return this;
 }
 
 RemoteServiceState SyncEngine::GetCurrentState() const {
   if (!sync_enabled_)
     return REMOTE_SERVICE_DISABLED;
   if (!has_refresh_token_)
@@ skipping 10 matching lines @@
     return;
   }
 
   StatusMapCallback tracked_callback =
       callback_tracker_.Register(abort_closure, callback);
   StatusMapCallback relayed_callback =
       RelayCallbackToCurrentThread(FROM_HERE, tracked_callback);
 
   worker_task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&SyncWorkerInterface::GetOriginStatusMap,
-                 base::Unretained(sync_worker_.get()),
-                 relayed_callback));
+      base::BindOnce(&SyncWorkerInterface::GetOriginStatusMap,
+                     base::Unretained(sync_worker_.get()), relayed_callback));
 }
 
 void SyncEngine::DumpFiles(const GURL& origin,
                            const ListCallback& callback) {
   base::Closure abort_closure =
       base::Bind(callback, base::Passed(std::unique_ptr<base::ListValue>()));
 
   if (!sync_worker_) {
     abort_closure.Run();
     return;
@@ skipping 37 matching lines @@
   if (sync_enabled_) {
     if (!sync_worker_)
       Initialize();
 
     // Have no login credential.
     if (!sync_worker_)
       return;
 
     worker_task_runner_->PostTask(
         FROM_HERE,
-        base::Bind(&SyncWorkerInterface::SetSyncEnabled,
-                   base::Unretained(sync_worker_.get()),
-                   sync_enabled_));
+        base::BindOnce(&SyncWorkerInterface::SetSyncEnabled,
+                       base::Unretained(sync_worker_.get()), sync_enabled_));
     return;
   }
 
   if (!sync_worker_)
     return;
 
   // TODO(tzik): Consider removing SyncWorkerInterface::SetSyncEnabled and
   // let SyncEngine handle the flag.
   worker_task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&SyncWorkerInterface::SetSyncEnabled,
-                 base::Unretained(sync_worker_.get()),
-                 sync_enabled_));
+      base::BindOnce(&SyncWorkerInterface::SetSyncEnabled,
+                     base::Unretained(sync_worker_.get()), sync_enabled_));
   Reset();
 }
 
 void SyncEngine::PromoteDemotedChanges(const base::Closure& callback) {
   if (!sync_worker_) {
     callback.Run();
     return;
   }
 
   base::Closure relayed_callback = RelayCallbackToCurrentThread(
       FROM_HERE, callback_tracker_.Register(callback, callback));
 
   worker_task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&SyncWorkerInterface::PromoteDemotedChanges,
-                 base::Unretained(sync_worker_.get()),
-                 relayed_callback));
+      base::BindOnce(&SyncWorkerInterface::PromoteDemotedChanges,
+                     base::Unretained(sync_worker_.get()), relayed_callback));
 }
 
 void SyncEngine::ApplyLocalChange(const FileChange& local_change,
                                   const base::FilePath& local_path,
                                   const SyncFileMetadata& local_metadata,
                                   const storage::FileSystemURL& url,
                                   const SyncStatusCallback& callback) {
   if (GetCurrentState() == REMOTE_SERVICE_DISABLED) {
     callback.Run(SYNC_STATUS_SYNC_DISABLED);
     return;
   }
 
   if (!sync_worker_) {
     callback.Run(SYNC_STATUS_ABORT);
     return;
   }
 
   SyncStatusCallback relayed_callback = RelayCallbackToCurrentThread(
       FROM_HERE, TrackCallback(callback));
   worker_task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&SyncWorkerInterface::ApplyLocalChange,
-                 base::Unretained(sync_worker_.get()),
-                 local_change,
-                 local_path,
-                 local_metadata,
-                 url,
-                 relayed_callback));
+      base::BindOnce(&SyncWorkerInterface::ApplyLocalChange,
+                     base::Unretained(sync_worker_.get()), local_change,
+                     local_path, local_metadata, url, relayed_callback));
 }
 
 void SyncEngine::OnNotificationReceived() {
   if (!sync_worker_)
     return;
 
   worker_task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&SyncWorkerInterface::ActivateService,
-                 base::Unretained(sync_worker_.get()),
-                 REMOTE_SERVICE_OK,
-                 "Got push notification for Drive"));
+      base::BindOnce(&SyncWorkerInterface::ActivateService,
+                     base::Unretained(sync_worker_.get()), REMOTE_SERVICE_OK,
+                     "Got push notification for Drive"));
 }
 
 void SyncEngine::OnPushNotificationEnabled(bool /* enabled */) {}
 
 void SyncEngine::OnReadyToSendRequests() {
   has_refresh_token_ = true;
   if (!sync_worker_)
     return;
 
   worker_task_runner_->PostTask(
-      FROM_HERE,
-      base::Bind(&SyncWorkerInterface::ActivateService,
-                 base::Unretained(sync_worker_.get()),
-                 REMOTE_SERVICE_OK,
-                 "Authenticated"));
+      FROM_HERE, base::BindOnce(&SyncWorkerInterface::ActivateService,
+                                base::Unretained(sync_worker_.get()),
+                                REMOTE_SERVICE_OK, "Authenticated"));
 }
 
 void SyncEngine::OnRefreshTokenInvalid() {
   has_refresh_token_ = false;
   if (!sync_worker_)
     return;
 
   worker_task_runner_->PostTask(
-      FROM_HERE,
-      base::Bind(&SyncWorkerInterface::DeactivateService,
-                 base::Unretained(sync_worker_.get()),
-                 "Found invalid refresh token."));
+      FROM_HERE, base::BindOnce(&SyncWorkerInterface::DeactivateService,
+                                base::Unretained(sync_worker_.get()),
+                                "Found invalid refresh token."));
 }
 
 void SyncEngine::OnNetworkChanged(
     net::NetworkChangeNotifier::ConnectionType type) {
   if (!sync_worker_)
     return;
 
   bool network_available_old = network_available_;
   network_available_ = (type != net::NetworkChangeNotifier::CONNECTION_NONE);
 
   if (!network_available_old && network_available_) {
     worker_task_runner_->PostTask(
-        FROM_HERE,
-        base::Bind(&SyncWorkerInterface::ActivateService,
-                   base::Unretained(sync_worker_.get()),
-                   REMOTE_SERVICE_OK,
-                   "Connected"));
+        FROM_HERE, base::BindOnce(&SyncWorkerInterface::ActivateService,
+                                  base::Unretained(sync_worker_.get()),
+                                  REMOTE_SERVICE_OK, "Connected"));
   } else if (network_available_old && !network_available_) {
     worker_task_runner_->PostTask(
         FROM_HERE,
-        base::Bind(&SyncWorkerInterface::DeactivateService,
-                   base::Unretained(sync_worker_.get()),
-                   "Disconnected"));
+        base::BindOnce(&SyncWorkerInterface::DeactivateService,
+                       base::Unretained(sync_worker_.get()), "Disconnected"));
   }
 }
 
 void SyncEngine::GoogleSigninFailed(const GoogleServiceAuthError& error) {
   Reset();
   UpdateServiceState(REMOTE_SERVICE_AUTHENTICATION_REQUIRED,
                      "Failed to sign in.");
 }
 
 void SyncEngine::GoogleSigninSucceeded(const std::string& account_id,
@@ skipping 76 matching lines @@
 
 SyncStatusCallback SyncEngine::TrackCallback(
     const SyncStatusCallback& callback) {
   return callback_tracker_.Register(
       base::Bind(callback, SYNC_STATUS_ABORT),
       callback);
 }
 
 }  // namespace drive_backend
 }  // namespace sync_file_system