Convert Pass()→std::move() in //chrome/browser/ui

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"
 #include "base/macros.h"
 #include "base/metrics/histogram.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "chrome/browser/drive/drive_notification_manager_factory.h"
@@ skipping 190 matching lines @@
                      task_logger,
                      notification_manager,
                      extension_service,
                      signin_manager,
                      token_service,
                      request_context.get(),
                      make_scoped_ptr(new DriveServiceFactory()),
                      nullptr /* env_override */));
 
   sync_engine->Initialize();
-  return sync_engine.Pass();
+  return sync_engine;
 }
 
 void SyncEngine::AppendDependsOnFactories(
     std::set<BrowserContextKeyedServiceFactory*>* factories) {
   DCHECK(factories);
   factories->insert(drive::DriveNotificationManagerFactory::GetInstance());
   factories->insert(SigninManagerFactory::GetInstance());
   factories->insert(
       extensions::ExtensionsBrowserClient::Get()->GetExtensionSystemFactory());
   factories->insert(ProfileOAuth2TokenServiceFactory::GetInstance());
@@ skipping 32 matching lines @@
   if (!signin_manager_ || !signin_manager_->IsAuthenticated())
     return;
 
   DCHECK(drive_service_factory_);
   scoped_ptr<drive::DriveServiceInterface> drive_service =
       drive_service_factory_->CreateDriveService(
           token_service_, request_context_.get(), drive_task_runner_.get());
   scoped_ptr<drive::DriveUploaderInterface> drive_uploader(
       new drive::DriveUploader(drive_service.get(), drive_task_runner_.get()));
 
-  InitializeInternal(drive_service.Pass(), drive_uploader.Pass(), nullptr);
+  InitializeInternal(std::move(drive_service), std::move(drive_uploader),
+                     nullptr);
 }
 
 void SyncEngine::InitializeForTesting(
     scoped_ptr<drive::DriveServiceInterface> drive_service,
     scoped_ptr<drive::DriveUploaderInterface> drive_uploader,
     scoped_ptr<SyncWorkerInterface> sync_worker) {
   Reset();
-  InitializeInternal(drive_service.Pass(), drive_uploader.Pass(),
-                     sync_worker.Pass());
+  InitializeInternal(std::move(drive_service), std::move(drive_uploader),
+                     std::move(sync_worker));
 }
 
 void SyncEngine::InitializeInternal(
     scoped_ptr<drive::DriveServiceInterface> drive_service,
     scoped_ptr<drive::DriveUploaderInterface> drive_uploader,
     scoped_ptr<SyncWorkerInterface> sync_worker) {
-  drive_service_ = drive_service.Pass();
+  drive_service_ = std::move(drive_service);
   drive_service_wrapper_.reset(new DriveServiceWrapper(drive_service_.get()));
 
   std::string account_id;
   if (signin_manager_)
     account_id = signin_manager_->GetAuthenticatedAccountId();
   drive_service_->Initialize(account_id);
 
-  drive_uploader_ = drive_uploader.Pass();
+  drive_uploader_ = std::move(drive_uploader);
   drive_uploader_wrapper_.reset(
       new DriveUploaderWrapper(drive_uploader_.get()));
 
   // DriveServiceWrapper and DriveServiceOnWorker relay communications
   // between DriveService and syncers in SyncWorker.
   scoped_ptr<drive::DriveServiceInterface> drive_service_on_worker(
       new DriveServiceOnWorker(drive_service_wrapper_->AsWeakPtr(),
                                ui_task_runner_.get(),
                                worker_task_runner_.get()));
   scoped_ptr<drive::DriveUploaderInterface> drive_uploader_on_worker(
       new DriveUploaderOnWorker(drive_uploader_wrapper_->AsWeakPtr(),
                                 ui_task_runner_.get(),
                                 worker_task_runner_.get()));
-  scoped_ptr<SyncEngineContext> sync_engine_context(
-      new SyncEngineContext(drive_service_on_worker.Pass(),
-                            drive_uploader_on_worker.Pass(),
-                            task_logger_,
-                            ui_task_runner_.get(),
-                            worker_task_runner_.get(),
-                            worker_pool_.get()));
+  scoped_ptr<SyncEngineContext> sync_engine_context(new SyncEngineContext(
+      std::move(drive_service_on_worker), std::move(drive_uploader_on_worker),
+      task_logger_, ui_task_runner_.get(), worker_task_runner_.get(),
+      worker_pool_.get()));
 
   worker_observer_.reset(new WorkerObserver(ui_task_runner_.get(),
                                             weak_ptr_factory_.GetWeakPtr()));
 
   base::WeakPtr<ExtensionServiceInterface> extension_service_weak_ptr;
   if (extension_service_)
     extension_service_weak_ptr = extension_service_->AsWeakPtr();
 
   if (!sync_worker) {
     sync_worker.reset(new SyncWorker(
         sync_file_system_dir_,
         extension_service_weak_ptr,
         env_override_));
   }
 
-  sync_worker_ = sync_worker.Pass();
+  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)));
   if (remote_change_processor_)
     SetRemoteChangeProcessor(remote_change_processor_);
 
@@ skipping 394 matching lines @@
       worker_task_runner_(worker_task_runner),
       drive_task_runner_(drive_task_runner),
       worker_pool_(worker_pool),
       sync_file_system_dir_(sync_file_system_dir),
       task_logger_(task_logger),
       notification_manager_(notification_manager),
       extension_service_(extension_service),
       signin_manager_(signin_manager),
       token_service_(token_service),
       request_context_(request_context),
-      drive_service_factory_(drive_service_factory.Pass()),
+      drive_service_factory_(std::move(drive_service_factory)),
       remote_change_processor_(nullptr),
       service_state_(REMOTE_SERVICE_TEMPORARY_UNAVAILABLE),
       has_refresh_token_(false),
       network_available_(false),
       sync_enabled_(false),
       env_override_(env_override),
       weak_ptr_factory_(this) {
   DCHECK(sync_file_system_dir_.IsAbsolute());
   if (notification_manager_)
     notification_manager_->AddObserver(this);
@@ skipping 31 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