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

chrome/browser/sync_file_system/drive_backend/sync_worker.cc

 // Copyright 2014 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_worker.h"
 
+#include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/sync_file_system/drive_backend/callback_helper.h"
 #include "chrome/browser/sync_file_system/drive_backend/conflict_resolver.h"
 #include "chrome/browser/sync_file_system/drive_backend/drive_backend_constants.h"
 #include "chrome/browser/sync_file_system/drive_backend/list_changes_task.h"
 #include "chrome/browser/sync_file_system/drive_backend/local_to_remote_syncer.h"
 #include "chrome/browser/sync_file_system/drive_backend/metadata_database.h"
@@ skipping 45 matching lines @@
 }
 
 SyncWorker::~SyncWorker() {
   observers_.Clear();
 }
 
 void SyncWorker::Initialize(scoped_ptr<SyncEngineContext> context) {
   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
   DCHECK(!task_manager_);
 
-  context_ = context.Pass();
+  context_ = std::move(context);
 
   task_manager_.reset(new SyncTaskManager(
       weak_ptr_factory_.GetWeakPtr(), 0 /* maximum_background_task */,
       context_->GetWorkerTaskRunner(),
       context_->GetWorkerPool()));
   task_manager_->Initialize(SYNC_STATUS_OK);
 
   PostInitializeTask();
 }
 
 void SyncWorker::RegisterOrigin(
     const GURL& origin,
     const SyncStatusCallback& callback) {
   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
 
   if (!GetMetadataDatabase())
     PostInitializeTask();
 
   scoped_ptr<RegisterAppTask> task(
       new RegisterAppTask(context_.get(), origin.host()));
   if (task->CanFinishImmediately()) {
     callback.Run(SYNC_STATUS_OK);
     return;
   }
 
-  task_manager_->ScheduleSyncTask(
-      FROM_HERE, task.Pass(), SyncTaskManager::PRIORITY_HIGH, callback);
+  task_manager_->ScheduleSyncTask(FROM_HERE, std::move(task),
+                                  SyncTaskManager::PRIORITY_HIGH, callback);
 }
 
 void SyncWorker::EnableOrigin(
     const GURL& origin,
     const SyncStatusCallback& callback) {
   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
 
   task_manager_->ScheduleTask(
       FROM_HERE,
       base::Bind(&SyncWorker::DoEnableApp,
@@ skipping 73 matching lines @@
   scoped_ptr<RemoteFileSyncService::OriginStatusMap>
       status_map(new RemoteFileSyncService::OriginStatusMap);
   for (std::vector<std::string>::const_iterator itr = app_ids.begin();
        itr != app_ids.end(); ++itr) {
     const std::string& app_id = *itr;
     GURL origin = extensions::Extension::GetBaseURLFromExtensionId(app_id);
     (*status_map)[origin] =
         GetMetadataDatabase()->IsAppEnabled(app_id) ? "Enabled" : "Disabled";
   }
 
-  callback.Run(status_map.Pass());
+  callback.Run(std::move(status_map));
 }
 
 scoped_ptr<base::ListValue> SyncWorker::DumpFiles(const GURL& origin) {
   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
 
   if (!GetMetadataDatabase())
     return scoped_ptr<base::ListValue>();
   return GetMetadataDatabase()->DumpFiles(origin.host());
 }
 
@@ skipping 184 matching lines @@
   }
   if (status != SYNC_STATUS_OK) {
     UpdateServiceState(REMOTE_SERVICE_TEMPORARY_UNAVAILABLE,
                        "Could not initialize remote service");
     return;
   }
 
   scoped_ptr<MetadataDatabase> metadata_database =
       initializer->PassMetadataDatabase();
   if (metadata_database) {
-    context_->SetMetadataDatabase(metadata_database.Pass());
+    context_->SetMetadataDatabase(std::move(metadata_database));
     return;
   }
 
   UpdateServiceState(REMOTE_SERVICE_OK, std::string());
   UpdateRegisteredApps();
 }
 
 void SyncWorker::UpdateRegisteredApps() {
   MetadataDatabase* metadata_db = GetMetadataDatabase();
   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
@@ skipping 306 matching lines @@
   return context_->GetDriveUploader();
 }
 
 MetadataDatabase* SyncWorker::GetMetadataDatabase() {
   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
   return context_->GetMetadataDatabase();
 }
 
 }  // namespace drive_backend
 }  // namespace sync_file_system