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

chrome/browser/sync_file_system/drive_backend/sync_engine_initializer.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_initializer.h"
 
 #include <stddef.h>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/logging.h"
 #include "chrome/browser/sync_file_system/drive_backend/drive_backend_constants.h"
 #include "chrome/browser/sync_file_system/drive_backend/drive_backend_util.h"
 #include "chrome/browser/sync_file_system/drive_backend/metadata_database.h"
 #include "chrome/browser/sync_file_system/drive_backend/sync_engine_context.h"
 #include "chrome/browser/sync_file_system/drive_backend/sync_task_manager.h"
 #include "chrome/browser/sync_file_system/drive_backend/sync_task_token.h"
@@ skipping 52 matching lines @@
 
 void SyncEngineInitializer::RunPreflight(scoped_ptr<SyncTaskToken> token) {
   util::Log(logging::LOG_VERBOSE, FROM_HERE, "[Initialize] Start.");
   DCHECK(sync_context_);
   DCHECK(sync_context_->GetDriveService());
 
   // The metadata seems to have been already initialized. Just return with OK.
   if (sync_context_->GetMetadataDatabase()) {
     util::Log(logging::LOG_VERBOSE, FROM_HERE,
               "[Initialize] Already initialized.");
-    SyncTaskManager::NotifyTaskDone(token.Pass(), SYNC_STATUS_OK);
+    SyncTaskManager::NotifyTaskDone(std::move(token), SYNC_STATUS_OK);
     return;
   }
 
   SyncStatusCode status = SYNC_STATUS_FAILED;
   scoped_ptr<MetadataDatabase> metadata_database =
       MetadataDatabase::Create(database_path_, env_override_, &status);
 
   if (status != SYNC_STATUS_OK) {
     util::Log(logging::LOG_VERBOSE, FROM_HERE,
               "[Initialize] Failed to initialize MetadataDatabase.");
-    SyncTaskManager::NotifyTaskDone(token.Pass(), status);
+    SyncTaskManager::NotifyTaskDone(std::move(token), status);
     return;
   }
 
   DCHECK(metadata_database);
-  metadata_database_ = metadata_database.Pass();
+  metadata_database_ = std::move(metadata_database);
   if (metadata_database_->HasSyncRoot() &&
       !metadata_database_->NeedsSyncRootRevalidation()) {
     util::Log(logging::LOG_VERBOSE, FROM_HERE,
               "[Initialize] Found local cache of sync-root.");
-    SyncTaskManager::NotifyTaskDone(token.Pass(), SYNC_STATUS_OK);
+    SyncTaskManager::NotifyTaskDone(std::move(token), SYNC_STATUS_OK);
     return;
   }
 
-  GetAboutResource(token.Pass());
+  GetAboutResource(std::move(token));
 }
 
 scoped_ptr<MetadataDatabase> SyncEngineInitializer::PassMetadataDatabase() {
-  return metadata_database_.Pass();
+  return std::move(metadata_database_);
 }
 
 void SyncEngineInitializer::GetAboutResource(
     scoped_ptr<SyncTaskToken> token) {
   set_used_network(true);
   sync_context_->GetDriveService()->GetAboutResource(
       base::Bind(&SyncEngineInitializer::DidGetAboutResource,
                  weak_ptr_factory_.GetWeakPtr(), base::Passed(&token)));
 }
 
 void SyncEngineInitializer::DidGetAboutResource(
     scoped_ptr<SyncTaskToken> token,
     google_apis::DriveApiErrorCode error,
     scoped_ptr<google_apis::AboutResource> about_resource) {
   cancel_callback_.Reset();
 
   SyncStatusCode status = DriveApiErrorCodeToSyncStatusCode(error);
   if (status != SYNC_STATUS_OK) {
     util::Log(logging::LOG_VERBOSE, FROM_HERE,
               "[Initialize] Failed to get AboutResource.");
-    SyncTaskManager::NotifyTaskDone(token.Pass(), status);
+    SyncTaskManager::NotifyTaskDone(std::move(token), status);
     return;
   }
 
   DCHECK(about_resource);
   root_folder_id_ = about_resource->root_folder_id();
   largest_change_id_ = about_resource->largest_change_id();
 
   DCHECK(!root_folder_id_.empty());
-  FindSyncRoot(token.Pass());
+  FindSyncRoot(std::move(token));
 }
 
 void SyncEngineInitializer::FindSyncRoot(scoped_ptr<SyncTaskToken> token) {
   if (find_sync_root_retry_count_++ >= kMaxRetry) {
     util::Log(logging::LOG_VERBOSE, FROM_HERE,
               "[Initialize] Reached max retry count.");
-    SyncTaskManager::NotifyTaskDone(token.Pass(), SYNC_STATUS_FAILED);
+    SyncTaskManager::NotifyTaskDone(std::move(token), SYNC_STATUS_FAILED);
     return;
   }
 
   set_used_network(true);
   cancel_callback_ = sync_context_->GetDriveService()->SearchByTitle(
       kSyncRootFolderTitle,
       std::string(),  // parent_folder_id
       base::Bind(&SyncEngineInitializer::DidFindSyncRoot,
                  weak_ptr_factory_.GetWeakPtr(),
                  base::Passed(&token)));
 }
 
 void SyncEngineInitializer::DidFindSyncRoot(
     scoped_ptr<SyncTaskToken> token,
     google_apis::DriveApiErrorCode error,
     scoped_ptr<google_apis::FileList> file_list) {
   cancel_callback_.Reset();
 
   SyncStatusCode status = DriveApiErrorCodeToSyncStatusCode(error);
   if (status != SYNC_STATUS_OK) {
     util::Log(logging::LOG_VERBOSE, FROM_HERE,
               "[Initialize] Failed to find sync root.");
-    SyncTaskManager::NotifyTaskDone(token.Pass(), status);
+    SyncTaskManager::NotifyTaskDone(std::move(token), status);
     return;
   }
 
   if (!file_list) {
     NOTREACHED();
     util::Log(logging::LOG_VERBOSE, FROM_HERE,
               "[Initialize] Got invalid resource list.");
-    SyncTaskManager::NotifyTaskDone(token.Pass(), SYNC_STATUS_FAILED);
+    SyncTaskManager::NotifyTaskDone(std::move(token), SYNC_STATUS_FAILED);
     return;
   }
 
   ScopedVector<google_apis::FileResource>* items = file_list->mutable_items();
   for (ScopedVector<google_apis::FileResource>::iterator itr = items->begin();
        itr != items->end(); ++itr) {
     google_apis::FileResource* entry = *itr;
 
     // Ignore deleted folder.
     if (entry->labels().is_trashed())
@@ skipping 19 matching lines @@
   if (!file_list->next_link().is_empty()) {
     cancel_callback_ = sync_context_->GetDriveService()->GetRemainingFileList(
         file_list->next_link(),
         base::Bind(&SyncEngineInitializer::DidFindSyncRoot,
                    weak_ptr_factory_.GetWeakPtr(),
                    base::Passed(&token)));
     return;
   }
 
   if (!sync_root_folder_) {
-    CreateSyncRoot(token.Pass());
+    CreateSyncRoot(std::move(token));
     return;
   }
 
   if (!HasNoParents(*sync_root_folder_)) {
-    DetachSyncRoot(token.Pass());
+    DetachSyncRoot(std::move(token));
     return;
   }
 
-  ListAppRootFolders(token.Pass());
+  ListAppRootFolders(std::move(token));
 }
 
 void SyncEngineInitializer::CreateSyncRoot(scoped_ptr<SyncTaskToken> token) {
   DCHECK(!sync_root_folder_);
   set_used_network(true);
   drive::AddNewDirectoryOptions options;
   options.visibility = google_apis::drive::FILE_VISIBILITY_PRIVATE;
   cancel_callback_ = sync_context_->GetDriveService()->AddNewDirectory(
       root_folder_id_, kSyncRootFolderTitle, options,
       base::Bind(&SyncEngineInitializer::DidCreateSyncRoot,
                  weak_ptr_factory_.GetWeakPtr(), base::Passed(&token)));
 }
 
 void SyncEngineInitializer::DidCreateSyncRoot(
     scoped_ptr<SyncTaskToken> token,
     google_apis::DriveApiErrorCode error,
     scoped_ptr<google_apis::FileResource> entry) {
   DCHECK(!sync_root_folder_);
   cancel_callback_.Reset();
 
   SyncStatusCode status = DriveApiErrorCodeToSyncStatusCode(error);
   if (status != SYNC_STATUS_OK) {
     util::Log(logging::LOG_VERBOSE, FROM_HERE,
               "[Initialize] Failed to create sync root.");
-    SyncTaskManager::NotifyTaskDone(token.Pass(), status);
+    SyncTaskManager::NotifyTaskDone(std::move(token), status);
     return;
   }
 
-  FindSyncRoot(token.Pass());
+  FindSyncRoot(std::move(token));
 }
 
 void SyncEngineInitializer::DetachSyncRoot(scoped_ptr<SyncTaskToken> token) {
   DCHECK(sync_root_folder_);
   set_used_network(true);
   cancel_callback_ =
       sync_context_->GetDriveService()->RemoveResourceFromDirectory(
           root_folder_id_,
           sync_root_folder_->file_id(),
           base::Bind(&SyncEngineInitializer::DidDetachSyncRoot,
                      weak_ptr_factory_.GetWeakPtr(),
                      base::Passed(&token)));
 }
 
 void SyncEngineInitializer::DidDetachSyncRoot(
     scoped_ptr<SyncTaskToken> token,
     google_apis::DriveApiErrorCode error) {
   cancel_callback_.Reset();
 
   SyncStatusCode status = DriveApiErrorCodeToSyncStatusCode(error);
   if (status != SYNC_STATUS_OK) {
     util::Log(logging::LOG_VERBOSE, FROM_HERE,
               "[Initialize] Failed to detach sync root.");
-    SyncTaskManager::NotifyTaskDone(token.Pass(), status);
+    SyncTaskManager::NotifyTaskDone(std::move(token), status);
     return;
   }
 
-  ListAppRootFolders(token.Pass());
+  ListAppRootFolders(std::move(token));
 }
 
 void SyncEngineInitializer::ListAppRootFolders(
     scoped_ptr<SyncTaskToken> token) {
   DCHECK(sync_root_folder_);
   set_used_network(true);
   cancel_callback_ =
       sync_context_->GetDriveService()->GetFileListInDirectory(
           sync_root_folder_->file_id(),
           base::Bind(&SyncEngineInitializer::DidListAppRootFolders,
                      weak_ptr_factory_.GetWeakPtr(),
                      base::Passed(&token)));
 }
 
 void SyncEngineInitializer::DidListAppRootFolders(
     scoped_ptr<SyncTaskToken> token,
     google_apis::DriveApiErrorCode error,
     scoped_ptr<google_apis::FileList> file_list) {
   cancel_callback_.Reset();
 
   SyncStatusCode status = DriveApiErrorCodeToSyncStatusCode(error);
   if (status != SYNC_STATUS_OK) {
     util::Log(logging::LOG_VERBOSE, FROM_HERE,
               "[Initialize] Failed to get initial app-root folders.");
-    SyncTaskManager::NotifyTaskDone(token.Pass(), status);
+    SyncTaskManager::NotifyTaskDone(std::move(token), status);
     return;
   }
 
   if (!file_list) {
     NOTREACHED();
     util::Log(logging::LOG_VERBOSE, FROM_HERE,
               "[Initialize] Got invalid initial app-root list.");
-    SyncTaskManager::NotifyTaskDone(token.Pass(), SYNC_STATUS_FAILED);
+    SyncTaskManager::NotifyTaskDone(std::move(token), SYNC_STATUS_FAILED);
     return;
   }
 
   ScopedVector<google_apis::FileResource>* new_entries =
       file_list->mutable_items();
   app_root_folders_.insert(app_root_folders_.end(),
                            new_entries->begin(), new_entries->end());
   new_entries->weak_clear();
 
   set_used_network(true);
   if (!file_list->next_link().is_empty()) {
     cancel_callback_ =
         sync_context_->GetDriveService()->GetRemainingFileList(
             file_list->next_link(),
             base::Bind(&SyncEngineInitializer::DidListAppRootFolders,
                        weak_ptr_factory_.GetWeakPtr(), base::Passed(&token)));
     return;
   }
 
-  PopulateDatabase(token.Pass());
+  PopulateDatabase(std::move(token));
 }
 
 void SyncEngineInitializer::PopulateDatabase(
     scoped_ptr<SyncTaskToken> token) {
   DCHECK(sync_root_folder_);
   SyncStatusCode status = metadata_database_->PopulateInitialData(
       largest_change_id_, *sync_root_folder_, app_root_folders_);
   if (status != SYNC_STATUS_OK) {
     util::Log(logging::LOG_VERBOSE, FROM_HERE,
               "[Initialize] Failed to populate initial data"
               " to MetadataDatabase.");
-    SyncTaskManager::NotifyTaskDone(token.Pass(), status);
+    SyncTaskManager::NotifyTaskDone(std::move(token), status);
     return;
   }
 
   util::Log(logging::LOG_VERBOSE, FROM_HERE,
             "[Initialize] Completed successfully.");
-  SyncTaskManager::NotifyTaskDone(token.Pass(), SYNC_STATUS_OK);
+  SyncTaskManager::NotifyTaskDone(std::move(token), SYNC_STATUS_OK);
 }
 
 }  // namespace drive_backend
 }  // namespace sync_file_system