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

☃

BUG=557422
R=avi@chromium.org
TBR=kinuko@chromium.org

Review URL: https://codereview.chromium.org/1545283002

Cr-Commit-Position: refs/heads/master@{#366912}

47 files changed, 510 insertions, 505 deletions

diff --git a/chrome/browser/sync_file_system/drive_backend/callback_tracker_internal.cc b/chrome/browser/sync_file_system/drive_backend/callback_tracker_internal.cc
index 96276a9..09ef340 100644
--- a/chrome/browser/sync_file_system/drive_backend/callback_tracker_internal.cc
+++ b/chrome/browser/sync_file_system/drive_backend/callback_tracker_internal.cc
@@ -28,7 +28,7 @@ scoped_ptr<AbortHelper> AbortHelper::TakeOwnership(
   scoped_ptr<AbortHelper> result =
       abort_helper->tracker_->PassAbortHelper(abort_helper.get());
   abort_helper->weak_ptr_factory_.InvalidateWeakPtrs();
-  return result.Pass();
+  return result;
 }
 
 }  // namespace internal
diff --git a/chrome/browser/sync_file_system/drive_backend/conflict_resolver.cc b/chrome/browser/sync_file_system/drive_backend/conflict_resolver.cc
index 91c9c48..6e35474 100644
--- a/chrome/browser/sync_file_system/drive_backend/conflict_resolver.cc
+++ b/chrome/browser/sync_file_system/drive_backend/conflict_resolver.cc
@@ -5,6 +5,7 @@
 #include "chrome/browser/sync_file_system/drive_backend/conflict_resolver.h"
 
 #include <stdint.h>
+#include <utility>
 
 #include "base/callback.h"
 #include "base/format_macros.h"
@@ -38,20 +39,20 @@ void ConflictResolver::RunPreflight(scoped_ptr<SyncTaskToken> token) {
   scoped_ptr<TaskBlocker> task_blocker(new TaskBlocker);
   task_blocker->exclusive = true;
   SyncTaskManager::UpdateTaskBlocker(
-      token.Pass(), task_blocker.Pass(),
+      std::move(token), std::move(task_blocker),
       base::Bind(&ConflictResolver::RunExclusive,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 void ConflictResolver::RunExclusive(scoped_ptr<SyncTaskToken> token) {
   if (!IsContextReady()) {
-    SyncTaskManager::NotifyTaskDone(token.Pass(), SYNC_STATUS_FAILED);
+    SyncTaskManager::NotifyTaskDone(std::move(token), SYNC_STATUS_FAILED);
     return;
   }
 
   // Conflict resolution should be invoked on clean tree.
   if (metadata_database()->HasDirtyTracker()) {
-    SyncTaskManager::NotifyTaskDone(token.Pass(), SYNC_STATUS_RETRY);
+    SyncTaskManager::NotifyTaskDone(std::move(token), SYNC_STATUS_RETRY);
     return;
   }
 
@@ -61,7 +62,7 @@ void ConflictResolver::RunExclusive(scoped_ptr<SyncTaskToken> token) {
     DCHECK_LT(1u, trackers.size());
     if (!trackers.has_active()) {
       NOTREACHED();
-      SyncTaskManager::NotifyTaskDone(token.Pass(), SYNC_STATUS_FAILED);
+      SyncTaskManager::NotifyTaskDone(std::move(token), SYNC_STATUS_FAILED);
       return;
     }
 
@@ -86,12 +87,12 @@ void ConflictResolver::RunExclusive(scoped_ptr<SyncTaskToken> token) {
           tracker.parent_tracker_id(), &parent_tracker);
       if (!should_success) {
         NOTREACHED();
-        SyncTaskManager::NotifyTaskDone(token.Pass(), SYNC_STATUS_FAILED);
+        SyncTaskManager::NotifyTaskDone(std::move(token), SYNC_STATUS_FAILED);
         return;
       }
       parents_to_remove_.push_back(parent_tracker.file_id());
     }
-    DetachFromNonPrimaryParents(token.Pass());
+    DetachFromNonPrimaryParents(std::move(token));
     return;
   }
 
@@ -119,11 +120,11 @@ void ConflictResolver::RunExclusive(scoped_ptr<SyncTaskToken> token) {
         "(primary tracker_id=%" PRId64 ")",
         non_primary_file_ids_.size(), primary_tracker_id));
 
-    RemoveNonPrimaryFiles(token.Pass());
+    RemoveNonPrimaryFiles(std::move(token));
     return;
   }
 
-  SyncTaskManager::NotifyTaskDone(token.Pass(), SYNC_STATUS_NO_CONFLICT);
+  SyncTaskManager::NotifyTaskDone(std::move(token), SYNC_STATUS_NO_CONFLICT);
 }
 
 void ConflictResolver::DetachFromNonPrimaryParents(
@@ -151,16 +152,16 @@ void ConflictResolver::DidDetachFromParent(
     google_apis::DriveApiErrorCode error) {
   SyncStatusCode status = DriveApiErrorCodeToSyncStatusCode(error);
   if (status != SYNC_STATUS_OK) {
-    SyncTaskManager::NotifyTaskDone(token.Pass(), status);
+    SyncTaskManager::NotifyTaskDone(std::move(token), status);
     return;
   }
 
   if (!parents_to_remove_.empty()) {
-    DetachFromNonPrimaryParents(token.Pass());
+    DetachFromNonPrimaryParents(std::move(token));
     return;
   }
 
-  SyncTaskManager::NotifyTaskDone(token.Pass(), SYNC_STATUS_OK);
+  SyncTaskManager::NotifyTaskDone(std::move(token), SYNC_STATUS_OK);
 }
 
 std::string ConflictResolver::PickPrimaryFile(const TrackerIDSet& trackers) {
@@ -181,7 +182,7 @@ std::string ConflictResolver::PickPrimaryFile(const TrackerIDSet& trackers) {
     }
 
     if (!primary) {
-      primary = file_metadata.Pass();
+      primary = std::move(file_metadata);
       continue;
     }
 
@@ -193,7 +194,7 @@ std::string ConflictResolver::PickPrimaryFile(const TrackerIDSet& trackers) {
     if (primary->details().file_kind() == FILE_KIND_FILE) {
       if (file_metadata->details().file_kind() == FILE_KIND_FOLDER) {
         // Prioritize folders over regular files.
-        primary = file_metadata.Pass();
+        primary = std::move(file_metadata);
         continue;
       }
 
@@ -201,7 +202,7 @@ std::string ConflictResolver::PickPrimaryFile(const TrackerIDSet& trackers) {
       if (primary->details().modification_time() <
           file_metadata->details().modification_time()) {
         // Prioritize last write for regular files.
-        primary = file_metadata.Pass();
+        primary = std::move(file_metadata);
         continue;
       }
 
@@ -218,7 +219,7 @@ std::string ConflictResolver::PickPrimaryFile(const TrackerIDSet& trackers) {
     if (primary->details().creation_time() >
         file_metadata->details().creation_time()) {
       // Prioritize first create for folders.
-      primary = file_metadata.Pass();
+      primary = std::move(file_metadata);
       continue;
     }
   }
@@ -254,25 +255,25 @@ void ConflictResolver::DidRemoveFile(scoped_ptr<SyncTaskToken> token,
                                      google_apis::DriveApiErrorCode error) {
   if (error == google_apis::HTTP_PRECONDITION ||
       error == google_apis::HTTP_CONFLICT) {
-    UpdateFileMetadata(file_id, token.Pass());
+    UpdateFileMetadata(file_id, std::move(token));
     return;
   }
 
   SyncStatusCode status = DriveApiErrorCodeToSyncStatusCode(error);
   if (status != SYNC_STATUS_OK && error != google_apis::HTTP_NOT_FOUND) {
-    SyncTaskManager::NotifyTaskDone(token.Pass(), status);
+    SyncTaskManager::NotifyTaskDone(std::move(token), status);
     return;
   }
 
   deleted_file_ids_.push_back(file_id);
   if (!non_primary_file_ids_.empty()) {
-    RemoveNonPrimaryFiles(token.Pass());
+    RemoveNonPrimaryFiles(std::move(token));
     return;
   }
 
   status = metadata_database()->UpdateByDeletedRemoteFileList(
       deleted_file_ids_);
-  SyncTaskManager::NotifyTaskDone(token.Pass(), status);
+  SyncTaskManager::NotifyTaskDone(std::move(token), status);
 }
 
 bool ConflictResolver::IsContextReady() {
@@ -297,24 +298,24 @@ void ConflictResolver::DidGetRemoteMetadata(
     scoped_ptr<google_apis::FileResource> entry) {
   SyncStatusCode status = DriveApiErrorCodeToSyncStatusCode(error);
   if (status != SYNC_STATUS_OK && error != google_apis::HTTP_NOT_FOUND) {
-    SyncTaskManager::NotifyTaskDone(token.Pass(), status);
+    SyncTaskManager::NotifyTaskDone(std::move(token), status);
     return;
   }
 
   if (error != google_apis::HTTP_NOT_FOUND) {
     status = metadata_database()->UpdateByDeletedRemoteFile(file_id);
-    SyncTaskManager::NotifyTaskDone(token.Pass(), status);
+    SyncTaskManager::NotifyTaskDone(std::move(token), status);
     return;
   }
 
   if (!entry) {
     NOTREACHED();
-    SyncTaskManager::NotifyTaskDone(token.Pass(), SYNC_STATUS_FAILED);
+    SyncTaskManager::NotifyTaskDone(std::move(token), SYNC_STATUS_FAILED);
     return;
   }
 
   status = metadata_database()->UpdateByFileResource(*entry);
-  SyncTaskManager::NotifyTaskDone(token.Pass(), status);
+  SyncTaskManager::NotifyTaskDone(std::move(token), status);
 }
 
 drive::DriveServiceInterface* ConflictResolver::drive_service() {
diff --git a/chrome/browser/sync_file_system/drive_backend/conflict_resolver_unittest.cc b/chrome/browser/sync_file_system/drive_backend/conflict_resolver_unittest.cc
index dec53c9..fe54bdc 100644
--- a/chrome/browser/sync_file_system/drive_backend/conflict_resolver_unittest.cc
+++ b/chrome/browser/sync_file_system/drive_backend/conflict_resolver_unittest.cc
@@ -4,6 +4,8 @@
 
 #include "chrome/browser/sync_file_system/drive_backend/conflict_resolver.h"
 
+#include <utility>
+
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/files/file_util.h"
@@ -69,12 +71,10 @@ class ConflictResolverTest : public testing::Test {
                                    kSyncRootFolderTitle));
     remote_change_processor_.reset(new FakeRemoteChangeProcessor);
 
-    context_.reset(new SyncEngineContext(fake_drive_service.Pass(),
-                                         drive_uploader.Pass(),
-                                         nullptr /* task_logger */,
-                                         base::ThreadTaskRunnerHandle::Get(),
-                                         base::ThreadTaskRunnerHandle::Get(),
-                                         nullptr /* worker_pool */));
+    context_.reset(new SyncEngineContext(
+        std::move(fake_drive_service), std::move(drive_uploader),
+        nullptr /* task_logger */, base::ThreadTaskRunnerHandle::Get(),
+        base::ThreadTaskRunnerHandle::Get(), nullptr /* worker_pool */));
     context_->SetRemoteChangeProcessor(remote_change_processor_.get());
 
     RegisterSyncableFileSystem();
@@ -248,7 +248,7 @@ class ConflictResolverTest : public testing::Test {
     EXPECT_EQ(google_apis::HTTP_SUCCESS,
               fake_drive_helper_->SearchByTitle(
                   parent_folder_id, title, &entries));
-    return entries.Pass();
+    return entries;
   }
 
   void VerifyConflictResolution(
diff --git a/chrome/browser/sync_file_system/drive_backend/drive_backend_sync_unittest.cc b/chrome/browser/sync_file_system/drive_backend/drive_backend_sync_unittest.cc
index b2589ca..006c681 100644
--- a/chrome/browser/sync_file_system/drive_backend/drive_backend_sync_unittest.cc
+++ b/chrome/browser/sync_file_system/drive_backend/drive_backend_sync_unittest.cc
@@ -4,9 +4,9 @@
 
 #include <stddef.h>
 #include <stdint.h>
-
 #include <algorithm>
 #include <stack>
+#include <utility>
 
 #include "base/files/file_util.h"
 #include "base/macros.h"
@@ -133,8 +133,9 @@ class DriveBackendSyncTest : public testing::Test,
                        nullptr,  // drive_service
                        in_memory_env_.get()));
     remote_sync_service_->AddServiceObserver(this);
-    remote_sync_service_->InitializeForTesting(
-        drive_service.Pass(), uploader.Pass(), nullptr /* sync_worker */);
+    remote_sync_service_->InitializeForTesting(std::move(drive_service),
+                                               std::move(uploader),
+                                               nullptr /* sync_worker */);
     remote_sync_service_->SetSyncEnabled(true);
 
     local_sync_service_->SetLocalChangeProcessor(remote_sync_service_.get());
diff --git a/chrome/browser/sync_file_system/drive_backend/drive_backend_test_util.cc b/chrome/browser/sync_file_system/drive_backend/drive_backend_test_util.cc
index 4f13ff0..234465d 100644
--- a/chrome/browser/sync_file_system/drive_backend/drive_backend_test_util.cc
+++ b/chrome/browser/sync_file_system/drive_backend/drive_backend_test_util.cc
@@ -68,7 +68,7 @@ scoped_ptr<FileMetadata> CreateFolderMetadata(const std::string& file_id,
   metadata->set_file_id(file_id);
   *metadata->mutable_details() = details;
 
-  return metadata.Pass();
+  return metadata;
 }
 
 scoped_ptr<FileMetadata> CreateFileMetadata(const std::string& file_id,
@@ -84,7 +84,7 @@ scoped_ptr<FileMetadata> CreateFileMetadata(const std::string& file_id,
   metadata->set_file_id(file_id);
   *metadata->mutable_details() = details;
 
-  return metadata.Pass();
+  return metadata;
 }
 
 scoped_ptr<FileTracker> CreateTracker(const FileMetadata& metadata,
@@ -103,7 +103,7 @@ scoped_ptr<FileTracker> CreateTracker(const FileMetadata& metadata,
   tracker->set_dirty(false);
   tracker->set_active(true);
   tracker->set_needs_folder_listing(false);
-  return tracker.Pass();
+  return tracker;
 }
 
 scoped_ptr<FileTracker> CreatePlaceholderTracker(
@@ -121,7 +121,7 @@ scoped_ptr<FileTracker> CreatePlaceholderTracker(
   tracker->set_dirty(true);
   tracker->set_active(false);
   tracker->set_needs_folder_listing(false);
-  return tracker.Pass();
+  return tracker;
 }
 
 FileResourceKind GetFileResourceKind(
diff --git a/chrome/browser/sync_file_system/drive_backend/drive_backend_util.cc b/chrome/browser/sync_file_system/drive_backend/drive_backend_util.cc
index 40c25e3..dda088a 100644
--- a/chrome/browser/sync_file_system/drive_backend/drive_backend_util.cc
+++ b/chrome/browser/sync_file_system/drive_backend/drive_backend_util.cc
@@ -171,7 +171,7 @@ scoped_ptr<ServiceMetadata> InitializeServiceMetadata(LevelDBWrapper* db) {
     service_metadata->set_next_tracker_id(1);
   }
 
-  return service_metadata.Pass();
+  return service_metadata;
 }
 
 }  // namespace drive_backend
diff --git a/chrome/browser/sync_file_system/drive_backend/fake_drive_service_helper.cc b/chrome/browser/sync_file_system/drive_backend/fake_drive_service_helper.cc
index ab18a35..c0c085e 100644
--- a/chrome/browser/sync_file_system/drive_backend/fake_drive_service_helper.cc
+++ b/chrome/browser/sync_file_system/drive_backend/fake_drive_service_helper.cc
@@ -4,6 +4,8 @@
 
 #include "chrome/browser/sync_file_system/drive_backend/fake_drive_service_helper.h"
 
+#include <utility>
+
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/message_loop/message_loop.h"
@@ -35,7 +37,7 @@ void UploadResultCallback(DriveApiErrorCode* error_out,
   ASSERT_TRUE(error_out);
   ASSERT_TRUE(entry_out);
   *error_out = error;
-  *entry_out = entry.Pass();
+  *entry_out = std::move(entry);
 }
 
 void DownloadResultCallback(DriveApiErrorCode* error_out,
@@ -239,7 +241,7 @@ DriveApiErrorCode FakeDriveServiceHelper::ListFilesInFolder(
   if (error != google_apis::HTTP_SUCCESS)
     return error;
 
-  return CompleteListing(list.Pass(), entries);
+  return CompleteListing(std::move(list), entries);
 }
 
 DriveApiErrorCode FakeDriveServiceHelper::SearchByTitle(
@@ -255,7 +257,7 @@ DriveApiErrorCode FakeDriveServiceHelper::SearchByTitle(
   if (error != google_apis::HTTP_SUCCESS)
     return error;
 
-  return CompleteListing(list.Pass(), entries);
+  return CompleteListing(std::move(list), entries);
 }
 
 DriveApiErrorCode FakeDriveServiceHelper::GetFileResource(
diff --git a/chrome/browser/sync_file_system/drive_backend/fake_sync_worker.cc b/chrome/browser/sync_file_system/drive_backend/fake_sync_worker.cc
index 4dbcce8..f447e11 100644
--- a/chrome/browser/sync_file_system/drive_backend/fake_sync_worker.cc
+++ b/chrome/browser/sync_file_system/drive_backend/fake_sync_worker.cc
@@ -4,6 +4,8 @@
 
 #include "chrome/browser/sync_file_system/drive_backend/fake_sync_worker.h"
 
+#include <utility>
+
 #include "base/values.h"
 #include "chrome/browser/sync_file_system/drive_backend/drive_backend_constants.h"
 #include "chrome/browser/sync_file_system/drive_backend/sync_engine_context.h"
@@ -25,7 +27,7 @@ void FakeSyncWorker::Initialize(
     scoped_ptr<SyncEngineContext> sync_engine_context) {
   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
 
-  sync_engine_context_ = sync_engine_context.Pass();
+  sync_engine_context_ = std::move(sync_engine_context);
   status_map_.clear();
   // TODO(peria): Set |status_map_| as a fake metadata database.
 }
@@ -105,7 +107,7 @@ void FakeSyncWorker::GetOriginStatusMap(
       break;
     }
   }
-  callback.Run(status_map.Pass());
+  callback.Run(std::move(status_map));
 }
 
 scoped_ptr<base::ListValue> FakeSyncWorker::DumpFiles(const GURL& origin) {
diff --git a/chrome/browser/sync_file_system/drive_backend/folder_creator.cc b/chrome/browser/sync_file_system/drive_backend/folder_creator.cc
index 40baec3..cfa9f8d 100644
--- a/chrome/browser/sync_file_system/drive_backend/folder_creator.cc
+++ b/chrome/browser/sync_file_system/drive_backend/folder_creator.cc
@@ -5,6 +5,7 @@
 #include "chrome/browser/sync_file_system/drive_backend/folder_creator.h"
 
 #include <stddef.h>
+#include <utility>
 
 #include "chrome/browser/sync_file_system/drive_backend/drive_backend_util.h"
 #include "chrome/browser/sync_file_system/drive_backend/metadata_database.h"
@@ -109,7 +110,7 @@ void FolderCreator::DidListFolders(
 
   std::string file_id = oldest->file_id();
 
-  status = metadata_database_->UpdateByFileResourceList(candidates.Pass());
+  status = metadata_database_->UpdateByFileResourceList(std::move(candidates));
   if (status != SYNC_STATUS_OK) {
     callback.Run(std::string(), status);
     return;
diff --git a/chrome/browser/sync_file_system/drive_backend/leveldb_wrapper.cc b/chrome/browser/sync_file_system/drive_backend/leveldb_wrapper.cc
index 29a54a6..9131c5c 100644
--- a/chrome/browser/sync_file_system/drive_backend/leveldb_wrapper.cc
+++ b/chrome/browser/sync_file_system/drive_backend/leveldb_wrapper.cc
@@ -7,6 +7,7 @@
 #include <map>
 #include <set>
 #include <string>
+#include <utility>
 
 #include "base/logging.h"
 #include "third_party/leveldatabase/src/include/leveldb/db.h"
@@ -144,7 +145,7 @@ void LevelDBWrapper::Iterator::AdvanceIterators() {
 // LevelDBWrapper class
 // ---------------------------------------------------------------------------
 LevelDBWrapper::LevelDBWrapper(scoped_ptr<leveldb::DB> db)
-    : db_(db.Pass()), num_puts_(0), num_deletes_(0) {
+    : db_(std::move(db)), num_puts_(0), num_deletes_(0) {
   DCHECK(db_);
 }
 
diff --git a/chrome/browser/sync_file_system/drive_backend/list_changes_task.cc b/chrome/browser/sync_file_system/drive_backend/list_changes_task.cc
index de9b3cc..bf8b86a 100644
--- a/chrome/browser/sync_file_system/drive_backend/list_changes_task.cc
+++ b/chrome/browser/sync_file_system/drive_backend/list_changes_task.cc
@@ -5,7 +5,7 @@
 #include "chrome/browser/sync_file_system/drive_backend/list_changes_task.h"
 
 #include <stddef.h>
-
+#include <utility>
 #include <vector>
 
 #include "base/bind.h"
@@ -39,13 +39,12 @@ void ListChangesTask::RunPreflight(scoped_ptr<SyncTaskToken> token) {
 
   if (!IsContextReady()) {
     token->RecordLog("Failed to get required service.");
-    SyncTaskManager::NotifyTaskDone(token.Pass(), SYNC_STATUS_FAILED);
+    SyncTaskManager::NotifyTaskDone(std::move(token), SYNC_STATUS_FAILED);
     return;
   }
 
   SyncTaskManager::UpdateTaskBlocker(
-      token.Pass(),
-      scoped_ptr<TaskBlocker>(new TaskBlocker),
+      std::move(token), scoped_ptr<TaskBlocker>(new TaskBlocker),
       base::Bind(&ListChangesTask::StartListing,
                  weak_ptr_factory_.GetWeakPtr()));
 }
@@ -64,15 +63,15 @@ void ListChangesTask::DidListChanges(
   SyncStatusCode status = DriveApiErrorCodeToSyncStatusCode(error);
   if (status != SYNC_STATUS_OK) {
     token->RecordLog("Failed to fetch change list.");
-    SyncTaskManager::NotifyTaskDone(
-        token.Pass(), SYNC_STATUS_NETWORK_ERROR);
+    SyncTaskManager::NotifyTaskDone(std::move(token),
+                                    SYNC_STATUS_NETWORK_ERROR);
     return;
   }
 
   if (!change_list) {
     NOTREACHED();
     token->RecordLog("Got invalid change list.");
-    SyncTaskManager::NotifyTaskDone(token.Pass(), SYNC_STATUS_FAILED);
+    SyncTaskManager::NotifyTaskDone(std::move(token), SYNC_STATUS_FAILED);
     return;
   }
 
@@ -95,16 +94,15 @@ void ListChangesTask::DidListChanges(
 
   if (change_list_.empty()) {
     token->RecordLog("Got no change.");
-    SyncTaskManager::NotifyTaskDone(
-        token.Pass(), SYNC_STATUS_NO_CHANGE_TO_SYNC);
+    SyncTaskManager::NotifyTaskDone(std::move(token),
+                                    SYNC_STATUS_NO_CHANGE_TO_SYNC);
     return;
   }
 
   scoped_ptr<TaskBlocker> task_blocker(new TaskBlocker);
   task_blocker->exclusive = true;
   SyncTaskManager::UpdateTaskBlocker(
-      token.Pass(),
-      task_blocker.Pass(),
+      std::move(token), std::move(task_blocker),
       base::Bind(&ListChangesTask::CheckInChangeList,
                  weak_ptr_factory_.GetWeakPtr(),
                  change_list->largest_change_id()));
@@ -121,16 +119,15 @@ void ListChangesTask::CheckInChangeList(int64_t largest_change_id,
   for (size_t i = 0; i < change_list_.size(); ++i)
     file_ids_.push_back(change_list_[i]->file_id());
 
-  SyncStatusCode status =
-      metadata_database()->UpdateByChangeList(
-          largest_change_id, change_list_.Pass());
+  SyncStatusCode status = metadata_database()->UpdateByChangeList(
+      largest_change_id, std::move(change_list_));
   if (status != SYNC_STATUS_OK) {
-    SyncTaskManager::NotifyTaskDone(token.Pass(), status);
+    SyncTaskManager::NotifyTaskDone(std::move(token), status);
     return;
   }
 
   status = metadata_database()->SweepDirtyTrackers(file_ids_);
-  SyncTaskManager::NotifyTaskDone(token.Pass(), status);
+  SyncTaskManager::NotifyTaskDone(std::move(token), status);
 }
 
 bool ListChangesTask::IsContextReady() {
diff --git a/chrome/browser/sync_file_system/drive_backend/list_changes_task_unittest.cc b/chrome/browser/sync_file_system/drive_backend/list_changes_task_unittest.cc
index 0c7e1f3..44584d6 100644
--- a/chrome/browser/sync_file_system/drive_backend/list_changes_task_unittest.cc
+++ b/chrome/browser/sync_file_system/drive_backend/list_changes_task_unittest.cc
@@ -5,8 +5,8 @@
 #include "chrome/browser/sync_file_system/drive_backend/list_changes_task.h"
 
 #include <stddef.h>
-
 #include <string>
+#include <utility>
 
 #include "base/files/scoped_temp_dir.h"
 #include "base/format_macros.h"
@@ -67,12 +67,10 @@ class ListChangesTaskTest : public testing::Test {
         nullptr /* worker_pool */));
     sync_task_manager_->Initialize(SYNC_STATUS_OK);
 
-    context_.reset(new SyncEngineContext(fake_drive_service.Pass(),
-                                         drive_uploader.Pass(),
-                                         nullptr /* task_logger */,
-                                         base::ThreadTaskRunnerHandle::Get(),
-                                         base::ThreadTaskRunnerHandle::Get(),
-                                         nullptr /* worker_pool */));
+    context_.reset(new SyncEngineContext(
+        std::move(fake_drive_service), std::move(drive_uploader),
+        nullptr /* task_logger */, base::ThreadTaskRunnerHandle::Get(),
+        base::ThreadTaskRunnerHandle::Get(), nullptr /* worker_pool */));
 
     SetUpRemoteFolders();
 
@@ -89,10 +87,9 @@ class ListChangesTaskTest : public testing::Test {
  protected:
   SyncStatusCode RunTask(scoped_ptr<SyncTask> sync_task) {
     SyncStatusCode status = SYNC_STATUS_UNKNOWN;
-    sync_task_manager_->ScheduleSyncTask(
-        FROM_HERE, sync_task.Pass(),
-        SyncTaskManager::PRIORITY_MED,
-        CreateResultReceiver(&status));
+    sync_task_manager_->ScheduleSyncTask(FROM_HERE, std::move(sync_task),
+                                         SyncTaskManager::PRIORITY_MED,
+                                         CreateResultReceiver(&status));
     base::RunLoop().RunUntilIdle();
     return status;
   }
diff --git a/chrome/browser/sync_file_system/drive_backend/local_to_remote_syncer.cc b/chrome/browser/sync_file_system/drive_backend/local_to_remote_syncer.cc
index f205186..fc15f12 100644
--- a/chrome/browser/sync_file_system/drive_backend/local_to_remote_syncer.cc
+++ b/chrome/browser/sync_file_system/drive_backend/local_to_remote_syncer.cc
@@ -5,6 +5,7 @@
 #include "chrome/browser/sync_file_system/drive_backend/local_to_remote_syncer.h"
 
 #include <string>
+#include <utility>
 #include <vector>
 
 #include "base/callback.h"
@@ -40,7 +41,7 @@ scoped_ptr<FileTracker> FindTrackerByID(MetadataDatabase* metadata_database,
                                         int64_t tracker_id) {
   scoped_ptr<FileTracker> tracker(new FileTracker);
   if (metadata_database->FindTrackerByTrackerID(tracker_id, tracker.get()))
-    return tracker.Pass();
+    return tracker;
   return scoped_ptr<FileTracker>();
 }
 
@@ -100,7 +101,7 @@ void LocalToRemoteSyncer::RunPreflight(scoped_ptr<SyncTaskToken> token) {
 
   if (!IsContextReady()) {
     token->RecordLog("Context not ready.");
-    SyncTaskManager::NotifyTaskDone(token.Pass(), SYNC_STATUS_FAILED);
+    SyncTaskManager::NotifyTaskDone(std::move(token), SYNC_STATUS_FAILED);
     return;
   }
 
@@ -114,7 +115,7 @@ void LocalToRemoteSyncer::RunPreflight(scoped_ptr<SyncTaskToken> token) {
   if (local_is_missing_ && !local_change_.IsDelete()) {
     // Stray file, we can just return.
     token->RecordLog("Missing file for non-delete change.");
-    SyncTaskManager::NotifyTaskDone(token.Pass(), SYNC_STATUS_OK);
+    SyncTaskManager::NotifyTaskDone(std::move(token), SYNC_STATUS_OK);
     return;
   }
 
@@ -128,7 +129,8 @@ void LocalToRemoteSyncer::RunPreflight(scoped_ptr<SyncTaskToken> token) {
           active_ancestor_tracker.get(), &active_ancestor_path)) {
     // The app is disabled or not registered.
     token->RecordLog("App is disabled or not registered");
-    SyncTaskManager::NotifyTaskDone(token.Pass(), SYNC_STATUS_UNKNOWN_ORIGIN);
+    SyncTaskManager::NotifyTaskDone(std::move(token),
+                                    SYNC_STATUS_UNKNOWN_ORIGIN);
     return;
   }
   DCHECK(active_ancestor_tracker->active());
@@ -151,7 +153,7 @@ void LocalToRemoteSyncer::RunPreflight(scoped_ptr<SyncTaskToken> token) {
       token->RecordLog(
           base::StringPrintf("Detected invalid ancestor: %" PRIsFP,
                              active_ancestor_path.value().c_str()));
-      SyncTaskManager::NotifyTaskDone(token.Pass(), SYNC_STATUS_FAILED);
+      SyncTaskManager::NotifyTaskDone(std::move(token), SYNC_STATUS_FAILED);
       return;
     }
   }
@@ -168,7 +170,7 @@ void LocalToRemoteSyncer::RunPreflight(scoped_ptr<SyncTaskToken> token) {
 
       // Local file is deleted and remote file is missing, already deleted or
       // not yet synced.  There is nothing to do for the file.
-      SyncTaskManager::NotifyTaskDone(token.Pass(), SYNC_STATUS_OK);
+      SyncTaskManager::NotifyTaskDone(std::move(token), SYNC_STATUS_OK);
       return;
     }
   }
@@ -177,14 +179,14 @@ void LocalToRemoteSyncer::RunPreflight(scoped_ptr<SyncTaskToken> token) {
     // The original target doesn't have remote file and parent.
     // Try creating the parent first.
     if (active_ancestor_details.file_kind() == FILE_KIND_FOLDER) {
-      remote_parent_folder_tracker_ = active_ancestor_tracker.Pass();
+      remote_parent_folder_tracker_ = std::move(active_ancestor_tracker);
       target_path_ = active_ancestor_path.Append(missing_components[0]);
       token->RecordLog("Detected missing parent folder.");
 
       retry_on_success_ = true;
       MoveToBackground(base::Bind(&LocalToRemoteSyncer::CreateRemoteFolder,
                                   weak_ptr_factory_.GetWeakPtr()),
-                       token.Pass());
+                       std::move(token));
       return;
     }
 
@@ -192,14 +194,14 @@ void LocalToRemoteSyncer::RunPreflight(scoped_ptr<SyncTaskToken> token) {
     remote_parent_folder_tracker_ =
         FindTrackerByID(metadata_database(),
                         active_ancestor_tracker->parent_tracker_id());
-    remote_file_tracker_ = active_ancestor_tracker.Pass();
+    remote_file_tracker_ = std::move(active_ancestor_tracker);
     target_path_ = active_ancestor_path;
     token->RecordLog("Detected non-folder file in its path.");
 
     retry_on_success_ = true;
     MoveToBackground(base::Bind(&LocalToRemoteSyncer::DeleteRemoteFile,
                                 weak_ptr_factory_.GetWeakPtr()),
-                     token.Pass());
+                     std::move(token));
     return;
   }
 
@@ -208,7 +210,7 @@ void LocalToRemoteSyncer::RunPreflight(scoped_ptr<SyncTaskToken> token) {
     remote_parent_folder_tracker_ =
         FindTrackerByID(metadata_database(),
                         active_ancestor_tracker->parent_tracker_id());
-    remote_file_tracker_ = active_ancestor_tracker.Pass();
+    remote_file_tracker_ = std::move(active_ancestor_tracker);
     target_path_ = url_.path();
     DCHECK(target_path_ == active_ancestor_path);
 
@@ -217,12 +219,12 @@ void LocalToRemoteSyncer::RunPreflight(scoped_ptr<SyncTaskToken> token) {
           "Detected conflicting dirty tracker:%" PRId64,
            remote_file_tracker_->tracker_id()));
       // Both local and remote file has pending modification.
-      HandleConflict(token.Pass());
+      HandleConflict(std::move(token));
       return;
     }
 
     // Non-conflicting file/folder update case.
-    HandleExistingRemoteFile(token.Pass());
+    HandleExistingRemoteFile(std::move(token));
     return;
   }
 
@@ -231,21 +233,21 @@ void LocalToRemoteSyncer::RunPreflight(scoped_ptr<SyncTaskToken> token) {
   // The original target has remote parent folder and doesn't have remote active
   // file.
   // Upload the file as a new file or create a folder.
-  remote_parent_folder_tracker_ = active_ancestor_tracker.Pass();
+  remote_parent_folder_tracker_ = std::move(active_ancestor_tracker);
   target_path_ = url_.path();
   DCHECK(target_path_ == active_ancestor_path.Append(missing_components[0]));
   if (local_change_.file_type() == SYNC_FILE_TYPE_FILE) {
     token->RecordLog("Detected a new file.");
     MoveToBackground(base::Bind(&LocalToRemoteSyncer::UploadNewFile,
                                 weak_ptr_factory_.GetWeakPtr()),
-                     token.Pass());
+                     std::move(token));
     return;
   }
 
   token->RecordLog("Detected a new folder.");
   MoveToBackground(base::Bind(&LocalToRemoteSyncer::CreateRemoteFolder,
                               weak_ptr_factory_.GetWeakPtr()),
-                   token.Pass());
+                   std::move(token));
 }
 
 void LocalToRemoteSyncer::MoveToBackground(const Continuation& continuation,
@@ -259,7 +261,7 @@ void LocalToRemoteSyncer::MoveToBackground(const Continuation& continuation,
                           remote_file_tracker_->file_id(),
                           &remote_file_change_id_)) {
       NOTREACHED();
-      SyncCompleted(token.Pass(), SYNC_STATUS_FAILED);
+      SyncCompleted(std::move(token), SYNC_STATUS_FAILED);
       return;
     }
 
@@ -270,10 +272,9 @@ void LocalToRemoteSyncer::MoveToBackground(const Continuation& continuation,
   // Run current task as a background task with |blocker|.
   // After the invocation of ContinueAsBackgroundTask
   SyncTaskManager::UpdateTaskBlocker(
-      token.Pass(), blocker.Pass(),
+      std::move(token), std::move(blocker),
       base::Bind(&LocalToRemoteSyncer::ContinueAsBackgroundTask,
-                 weak_ptr_factory_.GetWeakPtr(),
-                 continuation));
+                 weak_ptr_factory_.GetWeakPtr(), continuation));
 }
 
 void LocalToRemoteSyncer::ContinueAsBackgroundTask(
@@ -300,18 +301,18 @@ void LocalToRemoteSyncer::ContinueAsBackgroundTask(
                           remote_file_tracker_->file_id(),
                           &latest_change_id) ||
         latest_change_id > remote_file_change_id_) {
-      SyncCompleted(token.Pass(), SYNC_STATUS_RETRY);
+      SyncCompleted(std::move(token), SYNC_STATUS_RETRY);
       return;
     }
 
     if (!metadata_database()->FindTrackerByTrackerID(
             remote_file_tracker_->tracker_id(), nullptr)) {
-      SyncCompleted(token.Pass(), SYNC_STATUS_RETRY);
+      SyncCompleted(std::move(token), SYNC_STATUS_RETRY);
       return;
     }
   }
 
-  continuation.Run(token.Pass());
+  continuation.Run(std::move(token));
 }
 
 void LocalToRemoteSyncer::SyncCompleted(scoped_ptr<SyncTaskToken> token,
@@ -329,7 +330,7 @@ void LocalToRemoteSyncer::SyncCompleted(scoped_ptr<SyncTaskToken> token,
       target_path_.AsUTF8Unsafe().c_str(),
       url_.origin().host().c_str()));
 
-  SyncTaskManager::NotifyTaskDone(token.Pass(), status);
+  SyncTaskManager::NotifyTaskDone(std::move(token), status);
 }
 
 void LocalToRemoteSyncer::HandleConflict(scoped_ptr<SyncTaskToken> token) {
@@ -339,7 +340,7 @@ void LocalToRemoteSyncer::HandleConflict(scoped_ptr<SyncTaskToken> token) {
   DCHECK(remote_file_tracker_->dirty());
 
   if (local_is_missing_) {
-    SyncCompleted(token.Pass(), SYNC_STATUS_OK);
+    SyncCompleted(std::move(token), SYNC_STATUS_OK);
     return;
   }
 
@@ -348,7 +349,7 @@ void LocalToRemoteSyncer::HandleConflict(scoped_ptr<SyncTaskToken> token) {
     // resolve it.
     MoveToBackground(base::Bind(&LocalToRemoteSyncer::UploadNewFile,
                                 weak_ptr_factory_.GetWeakPtr()),
-                     token.Pass());
+                     std::move(token));
     return;
   }
 
@@ -360,7 +361,7 @@ void LocalToRemoteSyncer::HandleConflict(scoped_ptr<SyncTaskToken> token) {
     NOTREACHED();
     MoveToBackground(base::Bind(&LocalToRemoteSyncer::CreateRemoteFolder,
                                 weak_ptr_factory_.GetWeakPtr()),
-                     token.Pass());
+                     std::move(token));
     return;
   }
 
@@ -373,15 +374,14 @@ void LocalToRemoteSyncer::HandleConflict(scoped_ptr<SyncTaskToken> token) {
                       remote_parent_folder_tracker_->file_id())) {
     MoveToBackground(
         base::Bind(&LocalToRemoteSyncer::UpdateTrackerForReusedFolder,
-                   weak_ptr_factory_.GetWeakPtr(),
-                   remote_details),
-        token.Pass());
+                   weak_ptr_factory_.GetWeakPtr(), remote_details),
+        std::move(token));
     return;
   }
 
   MoveToBackground(base::Bind(&LocalToRemoteSyncer::CreateRemoteFolder,
                               weak_ptr_factory_.GetWeakPtr()),
-                   token.Pass());
+                   std::move(token));
 }
 
 void LocalToRemoteSyncer::UpdateTrackerForReusedFolder(
@@ -389,7 +389,7 @@ void LocalToRemoteSyncer::UpdateTrackerForReusedFolder(
     scoped_ptr<SyncTaskToken> token) {
   SyncStatusCode status = metadata_database()->UpdateTracker(
       remote_file_tracker_->tracker_id(), details);
-  SyncCompleted(token.Pass(), status);
+  SyncCompleted(std::move(token), status);
 }
 
 void LocalToRemoteSyncer::HandleExistingRemoteFile(
@@ -403,7 +403,7 @@ void LocalToRemoteSyncer::HandleExistingRemoteFile(
     // Local file deletion for existing remote file.
     MoveToBackground(base::Bind(&LocalToRemoteSyncer::DeleteRemoteFile,
                                 weak_ptr_factory_.GetWeakPtr()),
-                     token.Pass());
+                     std::move(token));
     return;
   }
 
@@ -418,7 +418,7 @@ void LocalToRemoteSyncer::HandleExistingRemoteFile(
       // Non-conflicting local file update to existing remote regular file.
       MoveToBackground(base::Bind(&LocalToRemoteSyncer::UploadExistingFile,
                                   weak_ptr_factory_.GetWeakPtr()),
-                       token.Pass());
+                       std::move(token));
       return;
     }
 
@@ -429,7 +429,7 @@ void LocalToRemoteSyncer::HandleExistingRemoteFile(
     retry_on_success_ = true;
     MoveToBackground(base::Bind(&LocalToRemoteSyncer::DeleteRemoteFile,
                                 weak_ptr_factory_.GetWeakPtr()),
-                     token.Pass());
+                     std::move(token));
     return;
   }
 
@@ -441,13 +441,13 @@ void LocalToRemoteSyncer::HandleExistingRemoteFile(
     retry_on_success_ = true;
     MoveToBackground(base::Bind(&LocalToRemoteSyncer::DeleteRemoteFile,
                                 weak_ptr_factory_.GetWeakPtr()),
-                     token.Pass());
+                     std::move(token));
     return;
   }
 
   // Non-conflicting local folder creation to existing remote folder.
   DCHECK_EQ(FILE_KIND_FOLDER, synced_details.file_kind());
-  SyncCompleted(token.Pass(), SYNC_STATUS_OK);
+  SyncCompleted(std::move(token), SYNC_STATUS_OK);
 }
 
 void LocalToRemoteSyncer::DeleteRemoteFile(scoped_ptr<SyncTaskToken> token) {
@@ -482,7 +482,7 @@ void LocalToRemoteSyncer::DidDeleteRemoteFile(
       error != google_apis::HTTP_NOT_FOUND &&
       error != google_apis::HTTP_PRECONDITION &&
       error != google_apis::HTTP_CONFLICT) {
-    SyncCompleted(token.Pass(), status);
+    SyncCompleted(std::move(token), status);
     return;
   }
 
@@ -494,11 +494,11 @@ void LocalToRemoteSyncer::DidDeleteRemoteFile(
       error == google_apis::HTTP_NOT_FOUND) {
     SyncStatusCode status = metadata_database()->UpdateByDeletedRemoteFile(
         remote_file_tracker_->file_id());
-    SyncCompleted(token.Pass(), status);
+    SyncCompleted(std::move(token), status);
     return;
   }
 
-  SyncCompleted(token.Pass(), SYNC_STATUS_OK);
+  SyncCompleted(std::move(token), SYNC_STATUS_OK);
 }
 
 void LocalToRemoteSyncer::UploadExistingFile(scoped_ptr<SyncTaskToken> token) {
@@ -510,7 +510,7 @@ void LocalToRemoteSyncer::UploadExistingFile(scoped_ptr<SyncTaskToken> token) {
                                                                nullptr);
   if (local_file_md5 == remote_file_tracker_->synced_details().md5()) {
     // Local file is not changed.
-    SyncCompleted(token.Pass(), SYNC_STATUS_OK);
+    SyncCompleted(std::move(token), SYNC_STATUS_OK);
     return;
   }
 
@@ -543,28 +543,26 @@ void LocalToRemoteSyncer::DidUploadExistingFile(
     // handle this as ListChangesTask.
 
     needs_remote_change_listing_ = true;
-    UpdateRemoteMetadata(
-        remote_file_tracker_->file_id(),
-        token.Pass());
+    UpdateRemoteMetadata(remote_file_tracker_->file_id(), std::move(token));
     return;
   }
 
   SyncStatusCode status = DriveApiErrorCodeToSyncStatusCode(error);
   if (status != SYNC_STATUS_OK) {
-    SyncCompleted(token.Pass(), status);
+    SyncCompleted(std::move(token), status);
     return;
   }
 
   if (!entry) {
     NOTREACHED();
-    SyncCompleted(token.Pass(), SYNC_STATUS_FAILED);
+    SyncCompleted(std::move(token), SYNC_STATUS_FAILED);
     return;
   }
 
   DCHECK(entry);
   status = metadata_database()->UpdateByFileResource(*entry);
   if (status != SYNC_STATUS_OK) {
-    SyncCompleted(token.Pass(), status);
+    SyncCompleted(std::move(token), status);
     return;
   }
 
@@ -572,7 +570,7 @@ void LocalToRemoteSyncer::DidUploadExistingFile(
   if (!metadata_database()->FindFileByFileID(
           remote_file_tracker_->file_id(), &file)) {
     NOTREACHED();
-    SyncCompleted(token.Pass(), SYNC_STATUS_FAILED);
+    SyncCompleted(std::move(token), SYNC_STATUS_FAILED);
     return;
   }
 
@@ -585,11 +583,11 @@ void LocalToRemoteSyncer::DidUploadExistingFile(
                       remote_parent_folder_tracker_->file_id())) {
     SyncStatusCode status = metadata_database()->UpdateTracker(
         remote_file_tracker_->tracker_id(), file.details());
-    SyncCompleted(token.Pass(), status);
+    SyncCompleted(std::move(token), status);
     return;
   }
 
-  SyncCompleted(token.Pass(), SYNC_STATUS_RETRY);
+  SyncCompleted(std::move(token), SYNC_STATUS_RETRY);
 }
 
 void LocalToRemoteSyncer::UpdateRemoteMetadata(
@@ -615,25 +613,25 @@ void LocalToRemoteSyncer::DidGetRemoteMetadata(
     retry_on_success_ = true;
     SyncStatusCode status =
         metadata_database()->UpdateByDeletedRemoteFile(file_id);
-    SyncCompleted(token.Pass(), status);
+    SyncCompleted(std::move(token), status);
     return;
   }
 
   SyncStatusCode status = DriveApiErrorCodeToSyncStatusCode(error);
   if (status != SYNC_STATUS_OK) {
-    SyncCompleted(token.Pass(), status);
+    SyncCompleted(std::move(token), status);
     return;
   }
 
   if (!entry) {
     NOTREACHED();
-    SyncCompleted(token.Pass(), SYNC_STATUS_FAILED);
+    SyncCompleted(std::move(token), SYNC_STATUS_FAILED);
     return;
   }
 
   retry_on_success_ = true;
   status = metadata_database()->UpdateByFileResource(*entry);
-  SyncCompleted(token.Pass(), status);
+  SyncCompleted(std::move(token), status);
 }
 
 void LocalToRemoteSyncer::UploadNewFile(scoped_ptr<SyncTaskToken> token) {
@@ -661,19 +659,19 @@ void LocalToRemoteSyncer::DidUploadNewFile(
 
   SyncStatusCode status = DriveApiErrorCodeToSyncStatusCode(error);
   if (status != SYNC_STATUS_OK) {
-    SyncCompleted(token.Pass(), status);
+    SyncCompleted(std::move(token), status);
     return;
   }
 
   if (!entry) {
     NOTREACHED();
-    SyncCompleted(token.Pass(), SYNC_STATUS_FAILED);
+    SyncCompleted(std::move(token), SYNC_STATUS_FAILED);
     return;
   }
 
   status = metadata_database()->ReplaceActiveTrackerWithNewResource(
       remote_parent_folder_tracker_->tracker_id(), *entry);
-  SyncCompleted(token.Pass(), status);
+  SyncCompleted(std::move(token), status);
 }
 
 void LocalToRemoteSyncer::CreateRemoteFolder(scoped_ptr<SyncTaskToken> token) {
@@ -701,9 +699,9 @@ void LocalToRemoteSyncer::DidCreateRemoteFolder(
   if (status == SYNC_FILE_ERROR_NOT_FOUND)
     needs_remote_change_listing_ = true;
 
-  scoped_ptr<FolderCreator> deleter = folder_creator_.Pass();
+  scoped_ptr<FolderCreator> deleter = std::move(folder_creator_);
   if (status != SYNC_STATUS_OK) {
-    SyncCompleted(token.Pass(), status);
+    SyncCompleted(std::move(token), status);
     return;
   }
 
@@ -714,7 +712,7 @@ void LocalToRemoteSyncer::DidCreateRemoteFolder(
           file_id, &status);
   switch (activation_status) {
     case MetadataDatabase::ACTIVATION_PENDING:
-      SyncCompleted(token.Pass(), status);
+      SyncCompleted(std::move(token), status);
       return;
     case MetadataDatabase::ACTIVATION_FAILED_ANOTHER_ACTIVE_TRACKER:
       // The activation failed due to another tracker that has another parent.
@@ -728,7 +726,7 @@ void LocalToRemoteSyncer::DidCreateRemoteFolder(
   }
 
   NOTREACHED();
-  SyncCompleted(token.Pass(), SYNC_STATUS_FAILED);
+  SyncCompleted(std::move(token), SYNC_STATUS_FAILED);
   return;
 }
 
@@ -737,11 +735,11 @@ void LocalToRemoteSyncer::DidDetachResourceForCreationConflict(
     google_apis::DriveApiErrorCode error) {
   SyncStatusCode status = DriveApiErrorCodeToSyncStatusCode(error);
   if (status != SYNC_STATUS_OK) {
-    SyncCompleted(token.Pass(), status);
+    SyncCompleted(std::move(token), status);
     return;
   }
 
-  SyncCompleted(token.Pass(), SYNC_STATUS_RETRY);
+  SyncCompleted(std::move(token), SYNC_STATUS_RETRY);
 }
 
 bool LocalToRemoteSyncer::IsContextReady() {
diff --git a/chrome/browser/sync_file_system/drive_backend/local_to_remote_syncer_unittest.cc b/chrome/browser/sync_file_system/drive_backend/local_to_remote_syncer_unittest.cc
index c0804d1..edfdd1f 100644
--- a/chrome/browser/sync_file_system/drive_backend/local_to_remote_syncer_unittest.cc
+++ b/chrome/browser/sync_file_system/drive_backend/local_to_remote_syncer_unittest.cc
@@ -4,6 +4,8 @@
 
 #include "chrome/browser/sync_file_system/drive_backend/local_to_remote_syncer.h"
 
+#include <utility>
+
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/files/scoped_temp_dir.h"
@@ -70,12 +72,10 @@ class LocalToRemoteSyncerTest : public testing::Test {
         kSyncRootFolderTitle));
     remote_change_processor_.reset(new FakeRemoteChangeProcessor);
 
-    context_.reset(new SyncEngineContext(fake_drive_service.Pass(),
-                                         drive_uploader.Pass(),
-                                         nullptr /* task_logger */,
-                                         base::ThreadTaskRunnerHandle::Get(),
-                                         base::ThreadTaskRunnerHandle::Get(),
-                                         nullptr /* worker_pool */));
+    context_.reset(new SyncEngineContext(
+        std::move(fake_drive_service), std::move(drive_uploader),
+        nullptr /* task_logger */, base::ThreadTaskRunnerHandle::Get(),
+        base::ThreadTaskRunnerHandle::Get(), nullptr /* worker_pool */));
     context_->SetRemoteChangeProcessor(remote_change_processor_.get());
 
     RegisterSyncableFileSystem();
@@ -221,7 +221,7 @@ class LocalToRemoteSyncerTest : public testing::Test {
     EXPECT_EQ(google_apis::HTTP_SUCCESS,
               fake_drive_helper_->SearchByTitle(
                   parent_folder_id, title, &entries));
-    return entries.Pass();
+    return entries;
   }
 
   std::string GetFileIDForParentAndTitle(const std::string& parent_folder_id,
diff --git a/chrome/browser/sync_file_system/drive_backend/metadata_database.cc b/chrome/browser/sync_file_system/drive_backend/metadata_database.cc
index 02561d0..cf97ac8 100644
--- a/chrome/browser/sync_file_system/drive_backend/metadata_database.cc
+++ b/chrome/browser/sync_file_system/drive_backend/metadata_database.cc
@@ -6,6 +6,7 @@
 
 #include <algorithm>
 #include <stack>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ -123,11 +124,11 @@ scoped_ptr<FileMetadata> CreateFileMetadataFromFileResource(
 
   if (resource.labels().is_trashed()) {
     details->set_missing(true);
-    return file.Pass();
+    return file;
   }
 
   PopulateFileDetailsByFileResource(resource, details);
-  return file.Pass();
+  return file;
 }
 
 scoped_ptr<FileMetadata> CreateFileMetadataFromChangeResource(
@@ -140,11 +141,11 @@ scoped_ptr<FileMetadata> CreateFileMetadataFromChangeResource(
 
   if (change.is_deleted()) {
     details->set_missing(true);
-    return file.Pass();
+    return file;
   }
 
   PopulateFileDetailsByFileResource(*change.file(), details);
-  return file.Pass();
+  return file;
 }
 
 scoped_ptr<FileMetadata> CreateDeletedFileMetadata(int64_t change_id,
@@ -155,7 +156,7 @@ scoped_ptr<FileMetadata> CreateDeletedFileMetadata(int64_t change_id,
   FileDetails* details = file->mutable_details();
   details->set_change_id(change_id);
   details->set_missing(true);
-  return file.Pass();
+  return file;
 }
 
 scoped_ptr<FileTracker> CreateSyncRootTracker(
@@ -170,7 +171,7 @@ scoped_ptr<FileTracker> CreateSyncRootTracker(
   sync_root_tracker->set_active(true);
   sync_root_tracker->set_needs_folder_listing(false);
   *sync_root_tracker->mutable_synced_details() = sync_root_metadata.details();
-  return sync_root_tracker.Pass();
+  return sync_root_tracker;
 }
 
 scoped_ptr<FileTracker> CreateInitialAppRootTracker(
@@ -186,7 +187,7 @@ scoped_ptr<FileTracker> CreateInitialAppRootTracker(
   app_root_tracker->set_active(false);
   app_root_tracker->set_needs_folder_listing(false);
   *app_root_tracker->mutable_synced_details() = app_root_metadata.details();
-  return app_root_tracker.Pass();
+  return app_root_tracker;
 }
 
 scoped_ptr<FileTracker> CloneFileTracker(const FileTracker* obj) {
@@ -290,7 +291,7 @@ void MarkTrackerSetDirty(const TrackerIDSet& trackers,
     if (tracker->dirty())
       continue;
     tracker->set_dirty(true);
-    index->StoreFileTracker(tracker.Pass());
+    index->StoreFileTracker(std::move(tracker));
   }
 }
 
@@ -322,7 +323,7 @@ void MarkTrackersDirtyRecursively(int64_t root_tracker_id,
     index->GetFileTracker(tracker_id, tracker.get());
     tracker->set_dirty(true);
 
-    index->StoreFileTracker(tracker.Pass());
+    index->StoreFileTracker(std::move(tracker));
   }
 }
 
@@ -470,7 +471,7 @@ void ActivateFileTracker(int64_t tracker_id,
     tracker->set_needs_folder_listing(false);
   }
 
-  index->StoreFileTracker(tracker.Pass());
+  index->StoreFileTracker(std::move(tracker));
 }
 
 void DeactivateFileTracker(int64_t tracker_id,
@@ -490,7 +491,7 @@ void DeactivateFileTracker(int64_t tracker_id,
 
   tracker->set_dirty(dirtying_options & MARK_ITSELF_DIRTY);
   tracker->set_active(false);
-  index->StoreFileTracker(tracker.Pass());
+  index->StoreFileTracker(std::move(tracker));
 }
 
 void RemoveFileTracker(int64_t tracker_id,
@@ -561,7 +562,7 @@ scoped_ptr<MetadataDatabase> MetadataDatabase::CreateInternal(
     metadata_database.reset();
 
   *status_out = status;
-  return metadata_database.Pass();
+  return metadata_database;
 }
 
 // static
@@ -573,10 +574,10 @@ SyncStatusCode MetadataDatabase::CreateForTesting(
       new MetadataDatabase(base::FilePath(),
                            enable_on_disk_index,
                            nullptr));
-  metadata_database->db_ = db.Pass();
+  metadata_database->db_ = std::move(db);
   SyncStatusCode status = metadata_database->Initialize();
   if (status == SYNC_STATUS_OK)
-    *metadata_database_out = metadata_database.Pass();
+    *metadata_database_out = std::move(metadata_database);
   return status;
 }
 
@@ -688,7 +689,7 @@ SyncStatusCode MetadataDatabase::RegisterApp(const std::string& app_id,
   tracker->set_needs_folder_listing(true);
   tracker->set_dirty(true);
 
-  index_->StoreFileTracker(tracker.Pass());
+  index_->StoreFileTracker(std::move(tracker));
   return WriteToDatabase();
 }
 
@@ -710,7 +711,7 @@ SyncStatusCode MetadataDatabase::DisableApp(const std::string& app_id) {
   // other conflicting trackers won't become active.
   tracker->set_tracker_kind(TRACKER_KIND_DISABLED_APP_ROOT);
 
-  index_->StoreFileTracker(tracker.Pass());
+  index_->StoreFileTracker(std::move(tracker));
   return WriteToDatabase();
 }
 
@@ -729,7 +730,7 @@ SyncStatusCode MetadataDatabase::EnableApp(const std::string& app_id) {
   DCHECK(tracker->active());
 
   tracker->set_tracker_kind(TRACKER_KIND_APP_ROOT);
-  index_->StoreFileTracker(tracker.Pass());
+  index_->StoreFileTracker(std::move(tracker));
 
   MarkTrackersDirtyRecursively(tracker_id, index_.get());
   return WriteToDatabase();
@@ -750,7 +751,7 @@ SyncStatusCode MetadataDatabase::UnregisterApp(const std::string& app_id) {
   tracker->set_active(false);
   tracker->set_dirty(true);
 
-  index_->StoreFileTracker(tracker.Pass());
+  index_->StoreFileTracker(std::move(tracker));
   return WriteToDatabase();
 }
 
@@ -900,7 +901,7 @@ SyncStatusCode MetadataDatabase::UpdateByChangeList(
 
     scoped_ptr<FileMetadata> metadata(
         CreateFileMetadataFromChangeResource(change));
-    UpdateByFileMetadata(FROM_HERE, metadata.Pass(),
+    UpdateByFileMetadata(FROM_HERE, std::move(metadata),
                          UPDATE_TRACKER_FOR_UNSYNCED_FILE);
   }
 
@@ -914,7 +915,7 @@ SyncStatusCode MetadataDatabase::UpdateByFileResource(
   scoped_ptr<FileMetadata> metadata(
       CreateFileMetadataFromFileResource(
           GetLargestKnownChangeID(), resource));
-  UpdateByFileMetadata(FROM_HERE, metadata.Pass(),
+  UpdateByFileMetadata(FROM_HERE, std::move(metadata),
                        UPDATE_TRACKER_FOR_UNSYNCED_FILE);
   return WriteToDatabase();
 }
@@ -925,7 +926,7 @@ SyncStatusCode MetadataDatabase::UpdateByFileResourceList(
     scoped_ptr<FileMetadata> metadata(
         CreateFileMetadataFromFileResource(
             GetLargestKnownChangeID(), *resources[i]));
-    UpdateByFileMetadata(FROM_HERE, metadata.Pass(),
+    UpdateByFileMetadata(FROM_HERE, std::move(metadata),
                          UPDATE_TRACKER_FOR_UNSYNCED_FILE);
   }
   return WriteToDatabase();
@@ -935,7 +936,7 @@ SyncStatusCode MetadataDatabase::UpdateByDeletedRemoteFile(
     const std::string& file_id) {
   scoped_ptr<FileMetadata> metadata(
       CreateDeletedFileMetadata(GetLargestKnownChangeID(), file_id));
-  UpdateByFileMetadata(FROM_HERE, metadata.Pass(),
+  UpdateByFileMetadata(FROM_HERE, std::move(metadata),
                        UPDATE_TRACKER_FOR_UNSYNCED_FILE);
   return WriteToDatabase();
 }
@@ -946,7 +947,7 @@ SyncStatusCode MetadataDatabase::UpdateByDeletedRemoteFileList(
        itr != file_ids.end(); ++itr) {
     scoped_ptr<FileMetadata> metadata(
         CreateDeletedFileMetadata(GetLargestKnownChangeID(), *itr));
-    UpdateByFileMetadata(FROM_HERE, metadata.Pass(),
+    UpdateByFileMetadata(FROM_HERE, std::move(metadata),
                          UPDATE_TRACKER_FOR_UNSYNCED_FILE);
   }
   return WriteToDatabase();
@@ -1025,7 +1026,7 @@ SyncStatusCode MetadataDatabase::PopulateFolderByChildList(
   folder_tracker->set_needs_folder_listing(false);
   if (folder_tracker->dirty() && !ShouldKeepDirty(*folder_tracker))
     folder_tracker->set_dirty(false);
-  index_->StoreFileTracker(folder_tracker.Pass());
+  index_->StoreFileTracker(std::move(folder_tracker));
 
   return WriteToDatabase();
 }
@@ -1118,7 +1119,7 @@ SyncStatusCode MetadataDatabase::UpdateTracker(
   } else if (tracker.dirty() && !ShouldKeepDirty(tracker)) {
     updated_tracker->set_dirty(false);
   }
-  index_->StoreFileTracker(updated_tracker.Pass());
+  index_->StoreFileTracker(std::move(updated_tracker));
   if (should_promote)
     index_->PromoteDemotedDirtyTracker(tracker_id);
 
@@ -1166,7 +1167,7 @@ MetadataDatabase::ActivationStatus MetadataDatabase::TryActivateTracker(
                                  tracker_to_be_deactivated.get())) {
         const std::string file_id = tracker_to_be_deactivated->file_id();
         tracker_to_be_deactivated->set_active(false);
-        index_->StoreFileTracker(tracker_to_be_deactivated.Pass());
+        index_->StoreFileTracker(std::move(tracker_to_be_deactivated));
 
         MarkTrackersDirtyByFileID(file_id, index_.get());
       } else {
@@ -1184,7 +1185,7 @@ MetadataDatabase::ActivationStatus MetadataDatabase::TryActivateTracker(
   }
   tracker_to_be_activated->set_dirty(false);
 
-  index_->StoreFileTracker(tracker_to_be_activated.Pass());
+  index_->StoreFileTracker(std::move(tracker_to_be_activated));
 
   *status_out = WriteToDatabase();
   return ACTIVATION_PENDING;
@@ -1302,7 +1303,7 @@ SyncStatusCode MetadataDatabase::SweepDirtyTrackers(
         !CanClearDirty(*tracker))
       continue;
     tracker->set_dirty(false);
-    index_->StoreFileTracker(tracker.Pass());
+    index_->StoreFileTracker(std::move(tracker));
   }
 
   return WriteToDatabase();
@@ -1399,7 +1400,7 @@ void MetadataDatabase::CreateTrackerInternal(const FileTracker& parent_tracker,
       tracker->mutable_synced_details()->clear_md5();
     }
   }
-  index_->StoreFileTracker(tracker.Pass());
+  index_->StoreFileTracker(std::move(tracker));
 }
 
 void MetadataDatabase::MaybeAddTrackersForNewFile(
@@ -1571,7 +1572,7 @@ void MetadataDatabase::UpdateByFileMetadata(
 
   TrackerIDSet trackers = index_->GetFileTrackerIDsByFileID(file_id);
   if (!trackers.empty()) {
-    index_->StoreFileMetadata(metadata.Pass());
+    index_->StoreFileMetadata(std::move(metadata));
 
     if (option != UPDATE_TRACKER_FOR_SYNCED_FILE)
       MarkTrackerSetDirty(trackers, index_.get());
@@ -1589,7 +1590,7 @@ scoped_ptr<base::ListValue> MetadataDatabase::DumpFiles(
 
   FileTracker app_root_tracker;
   if (!FindAppRootTracker(app_id, &app_root_tracker))
-    return files.Pass();
+    return files;
 
   std::vector<int64_t> stack;
   AppendContents(
@@ -1627,14 +1628,14 @@ scoped_ptr<base::ListValue> MetadataDatabase::DumpFiles(
     files->Append(file);
   }
 
-  return files.Pass();
+  return files;
 }
 
 scoped_ptr<base::ListValue> MetadataDatabase::DumpDatabase() {
   scoped_ptr<base::ListValue> list(new base::ListValue);
   list->Append(DumpTrackers().release());
   list->Append(DumpMetadata().release());
-  return list.Pass();
+  return list;
 }
 
 bool MetadataDatabase::HasNewerFileMetadata(const std::string& file_id,
@@ -1706,7 +1707,7 @@ scoped_ptr<base::ListValue> MetadataDatabase::DumpTrackers() {
     }
     trackers->Append(dict);
   }
-  return trackers.Pass();
+  return trackers;
 }
 
 scoped_ptr<base::ListValue> MetadataDatabase::DumpMetadata() {
@@ -1755,7 +1756,7 @@ scoped_ptr<base::ListValue> MetadataDatabase::DumpMetadata() {
     }
     files->Append(dict);
   }
-  return files.Pass();
+  return files;
 }
 
 void MetadataDatabase::AttachSyncRoot(
@@ -1767,8 +1768,8 @@ void MetadataDatabase::AttachSyncRoot(
       CreateSyncRootTracker(IncrementTrackerID(), *sync_root_metadata);
 
   index_->SetSyncRootTrackerID(sync_root_tracker->tracker_id());
-  index_->StoreFileMetadata(sync_root_metadata.Pass());
-  index_->StoreFileTracker(sync_root_tracker.Pass());
+  index_->StoreFileMetadata(std::move(sync_root_metadata));
+  index_->StoreFileTracker(std::move(sync_root_tracker));
 }
 
 void MetadataDatabase::AttachInitialAppRoot(
@@ -1781,8 +1782,8 @@ void MetadataDatabase::AttachInitialAppRoot(
                                   GetSyncRootTrackerID(),
                                   *app_root_metadata);
 
-  index_->StoreFileMetadata(app_root_metadata.Pass());
-  index_->StoreFileTracker(app_root_tracker.Pass());
+  index_->StoreFileMetadata(std::move(app_root_metadata));
+  index_->StoreFileTracker(std::move(app_root_tracker));
 }
 
 bool MetadataDatabase::CanClearDirty(const FileTracker& tracker) {
diff --git a/chrome/browser/sync_file_system/drive_backend/metadata_database_index.cc b/chrome/browser/sync_file_system/drive_backend/metadata_database_index.cc
index df4dcf6..75836da 100644
--- a/chrome/browser/sync_file_system/drive_backend/metadata_database_index.cc
+++ b/chrome/browser/sync_file_system/drive_backend/metadata_database_index.cc
@@ -5,6 +5,7 @@
 #include "chrome/browser/sync_file_system/drive_backend/metadata_database_index.h"
 
 #include <tuple>
+#include <utility>
 
 #include "base/metrics/histogram.h"
 #include "base/strings/string_number_conversions.h"
@@ -175,7 +176,7 @@ void RemoveUnreachableItemsFromDB(DatabaseContents* contents,
       PutFileTrackerDeletionToDB(tracker->tracker_id(), db);
     }
   }
-  contents->file_trackers = reachable_trackers.Pass();
+  contents->file_trackers = std::move(reachable_trackers);
 
   // List all |file_id| referred by a tracker.
   base::hash_set<std::string> referred_file_ids;
@@ -193,7 +194,7 @@ void RemoveUnreachableItemsFromDB(DatabaseContents* contents,
       PutFileMetadataDeletionToDB(metadata->file_id(), db);
     }
   }
-  contents->file_metadata = referred_file_metadata.Pass();
+  contents->file_metadata = std::move(referred_file_metadata);
 }
 
 }  // namespace
@@ -215,8 +216,8 @@ MetadataDatabaseIndex::Create(LevelDBWrapper* db) {
                                db);
 
   scoped_ptr<MetadataDatabaseIndex> index(new MetadataDatabaseIndex(db));
-  index->Initialize(service_metadata.Pass(), &contents);
-  return index.Pass();
+  index->Initialize(std::move(service_metadata), &contents);
+  return index;
 }
 
 // static
@@ -225,13 +226,13 @@ MetadataDatabaseIndex::CreateForTesting(DatabaseContents* contents,
                                         LevelDBWrapper* db) {
   scoped_ptr<MetadataDatabaseIndex> index(new MetadataDatabaseIndex(db));
   index->Initialize(make_scoped_ptr(new ServiceMetadata), contents);
-  return index.Pass();
+  return index;
 }
 
 void MetadataDatabaseIndex::Initialize(
     scoped_ptr<ServiceMetadata> service_metadata,
     DatabaseContents* contents) {
-  service_metadata_ = service_metadata.Pass();
+  service_metadata_ = std::move(service_metadata);
 
   for (size_t i = 0; i < contents->file_metadata.size(); ++i)
     StoreFileMetadata(make_scoped_ptr(contents->file_metadata[i]));
@@ -285,7 +286,7 @@ void MetadataDatabaseIndex::StoreFileMetadata(
   }
 
   std::string file_id = metadata->file_id();
-  metadata_by_id_.set(file_id, metadata.Pass());
+  metadata_by_id_.set(file_id, std::move(metadata));
 }
 
 void MetadataDatabaseIndex::StoreFileTracker(
@@ -317,7 +318,7 @@ void MetadataDatabaseIndex::StoreFileTracker(
     UpdateInDirtyTrackerIndexes(*old_tracker, *tracker);
   }
 
-  tracker_by_id_.set(tracker_id, tracker.Pass());
+  tracker_by_id_.set(tracker_id, std::move(tracker));
 }
 
 void MetadataDatabaseIndex::RemoveFileMetadata(const std::string& file_id) {
diff --git a/chrome/browser/sync_file_system/drive_backend/metadata_database_index_on_disk.cc b/chrome/browser/sync_file_system/drive_backend/metadata_database_index_on_disk.cc
index 2587acb..e57584c 100644
--- a/chrome/browser/sync_file_system/drive_backend/metadata_database_index_on_disk.cc
+++ b/chrome/browser/sync_file_system/drive_backend/metadata_database_index_on_disk.cc
@@ -267,7 +267,7 @@ MetadataDatabaseIndexOnDisk::Create(LevelDBWrapper* db) {
   scoped_ptr<MetadataDatabaseIndexOnDisk>
       index(new MetadataDatabaseIndexOnDisk(db));
 
-  return index.Pass();
+  return index;
 }
 
 MetadataDatabaseIndexOnDisk::~MetadataDatabaseIndexOnDisk() {}
diff --git a/chrome/browser/sync_file_system/drive_backend/metadata_database_index_on_disk_unittest.cc b/chrome/browser/sync_file_system/drive_backend/metadata_database_index_on_disk_unittest.cc
index 55442a0..48ef87f 100644
--- a/chrome/browser/sync_file_system/drive_backend/metadata_database_index_on_disk_unittest.cc
+++ b/chrome/browser/sync_file_system/drive_backend/metadata_database_index_on_disk_unittest.cc
@@ -5,8 +5,8 @@
 #include "chrome/browser/sync_file_system/drive_backend/metadata_database_index_on_disk.h"
 
 #include <stdint.h>
-
 #include <algorithm>
+#include <utility>
 
 #include "base/files/scoped_temp_dir.h"
 #include "base/strings/string_number_conversions.h"
@@ -92,13 +92,13 @@ class MetadataDatabaseIndexOnDiskTest : public testing::Test {
     if (build_index) {
       DCHECK(index());
 
-      index()->StoreFileMetadata(sync_root_metadata.Pass());
-      index()->StoreFileTracker(sync_root_tracker.Pass());
-      index()->StoreFileMetadata(app_root_metadata.Pass());
-      index()->StoreFileTracker(app_root_tracker.Pass());
-      index()->StoreFileMetadata(file_metadata.Pass());
-      index()->StoreFileTracker(file_tracker.Pass());
-      index()->StoreFileTracker(placeholder_tracker.Pass());
+      index()->StoreFileMetadata(std::move(sync_root_metadata));
+      index()->StoreFileTracker(std::move(sync_root_tracker));
+      index()->StoreFileMetadata(std::move(app_root_metadata));
+      index()->StoreFileTracker(std::move(app_root_tracker));
+      index()->StoreFileMetadata(std::move(file_metadata));
+      index()->StoreFileTracker(std::move(file_tracker));
+      index()->StoreFileTracker(std::move(placeholder_tracker));
     } else {
       PutFileMetadataToDB(*sync_root_metadata, db);
       PutFileTrackerToDB(*sync_root_tracker, db);
@@ -164,8 +164,8 @@ TEST_F(MetadataDatabaseIndexOnDiskTest, SetEntryTest) {
   scoped_ptr<FileTracker> tracker =
       test_util::CreateTracker(*metadata, tracker_id, &root_tracker);
 
-  index()->StoreFileMetadata(metadata.Pass());
-  index()->StoreFileTracker(tracker.Pass());
+  index()->StoreFileMetadata(std::move(metadata));
+  index()->StoreFileTracker(std::move(tracker));
 
   EXPECT_TRUE(index()->GetFileMetadata("test_file_id", nullptr));
   EXPECT_TRUE(index()->GetFileTracker(tracker_id, nullptr));
@@ -241,8 +241,8 @@ TEST_F(MetadataDatabaseIndexOnDiskTest, SyncRootInvalidation) {
                                nullptr);
 
   // Override SyncRoot with a new one.
-  index()->StoreFileMetadata(new_sync_root_metadata.Pass());
-  index()->StoreFileTracker(new_sync_root_tracker.Pass());
+  index()->StoreFileMetadata(std::move(new_sync_root_metadata));
+  index()->StoreFileTracker(std::move(new_sync_root_tracker));
   index()->SetSyncRootTrackerID(kNewSyncRootTrackerID);
 
   // Drop trees under the old SyncRoot.
@@ -335,7 +335,7 @@ TEST_F(MetadataDatabaseIndexOnDiskTest, IndexAppRootIDByAppIDTest) {
   app_root_tracker->set_app_id("app_id_2");
   app_root_tracker->set_tracker_kind(TRACKER_KIND_APP_ROOT);
 
-  index()->StoreFileTracker(app_root_tracker.Pass());
+  index()->StoreFileTracker(std::move(app_root_tracker));
   WriteToDB();
   EXPECT_EQ(kAppRootTrackerID, index()->GetAppRootTracker("app_id"));
   EXPECT_EQ(kAppRootTrackerID2, index()->GetAppRootTracker("app_id_2"));
@@ -347,7 +347,7 @@ TEST_F(MetadataDatabaseIndexOnDiskTest, IndexAppRootIDByAppIDTest) {
   app_root_tracker->set_app_id("app_id_3");
   app_root_tracker->set_active(false);
 
-  index()->StoreFileTracker(app_root_tracker.Pass());
+  index()->StoreFileTracker(std::move(app_root_tracker));
   WriteToDB();
   EXPECT_EQ(kAppRootTrackerID, index()->GetAppRootTracker("app_id"));
   EXPECT_EQ(kInvalidTrackerID, index()->GetAppRootTracker("app_id_2"));
@@ -359,7 +359,7 @@ TEST_F(MetadataDatabaseIndexOnDiskTest, IndexAppRootIDByAppIDTest) {
   app_root_tracker->set_app_id("app_id_3");
   app_root_tracker->set_tracker_kind(TRACKER_KIND_APP_ROOT);
 
-  index()->StoreFileTracker(app_root_tracker.Pass());
+  index()->StoreFileTracker(std::move(app_root_tracker));
   WriteToDB();
   EXPECT_EQ(kAppRootTrackerID, index()->GetAppRootTracker("app_id"));
   EXPECT_EQ(kInvalidTrackerID, index()->GetAppRootTracker("app_id_2"));
@@ -390,7 +390,7 @@ TEST_F(MetadataDatabaseIndexOnDiskTest, TrackerIDSetByFileIDTest) {
   scoped_ptr<FileTracker> file_tracker =
       test_util::CreateTracker(metadata, tracker_id, &app_root_tracker);
 
-  index()->StoreFileTracker(file_tracker.Pass());
+  index()->StoreFileTracker(std::move(file_tracker));
   WriteToDB();
   tracker_ids = index()->GetFileTrackerIDsByFileID("file_id");
   EXPECT_EQ(2U, tracker_ids.size());
@@ -404,7 +404,7 @@ TEST_F(MetadataDatabaseIndexOnDiskTest, TrackerIDSetByFileIDTest) {
       test_util::CreateTracker(metadata, tracker_id, &app_root_tracker);
   file_tracker->set_active(false);
 
-  index()->StoreFileTracker(file_tracker.Pass());
+  index()->StoreFileTracker(std::move(file_tracker));
   WriteToDB();
   tracker_ids = index()->GetFileTrackerIDsByFileID("file_id");
   EXPECT_EQ(2U, tracker_ids.size());
@@ -416,7 +416,7 @@ TEST_F(MetadataDatabaseIndexOnDiskTest, TrackerIDSetByFileIDTest) {
   file_tracker =
       test_util::CreateTracker(metadata, tracker_id, &app_root_tracker);
 
-  index()->StoreFileTracker(file_tracker.Pass());
+  index()->StoreFileTracker(std::move(file_tracker));
   WriteToDB();
   tracker_ids = index()->GetFileTrackerIDsByFileID("file_id");
   EXPECT_EQ(2U, tracker_ids.size());
@@ -459,7 +459,7 @@ TEST_F(MetadataDatabaseIndexOnDiskTest, TrackerIDSetByParentIDAndTitleTest) {
   scoped_ptr<FileTracker> file_tracker =
       test_util::CreateTracker(metadata, tracker_id, &app_root_tracker);
 
-  index()->StoreFileTracker(file_tracker.Pass());
+  index()->StoreFileTracker(std::move(file_tracker));
   WriteToDB();
   tracker_ids = index()->GetFileTrackerIDsByParentAndTitle(
       kAppRootTrackerID, "file");
@@ -475,7 +475,7 @@ TEST_F(MetadataDatabaseIndexOnDiskTest, TrackerIDSetByParentIDAndTitleTest) {
       test_util::CreateTracker(metadata, tracker_id, &app_root_tracker);
   file_tracker->set_active(false);
 
-  index()->StoreFileTracker(file_tracker.Pass());
+  index()->StoreFileTracker(std::move(file_tracker));
   WriteToDB();
   tracker_ids = index()->GetFileTrackerIDsByParentAndTitle(
       kAppRootTrackerID, "file");
@@ -489,7 +489,7 @@ TEST_F(MetadataDatabaseIndexOnDiskTest, TrackerIDSetByParentIDAndTitleTest) {
   file_tracker =
       test_util::CreateTracker(metadata, tracker_id, &app_root_tracker);
 
-  index()->StoreFileTracker(file_tracker.Pass());
+  index()->StoreFileTracker(std::move(file_tracker));
   WriteToDB();
   tracker_ids = index()->GetFileTrackerIDsByParentAndTitle(
       kAppRootTrackerID, "file");
@@ -527,8 +527,8 @@ TEST_F(MetadataDatabaseIndexOnDiskTest,
     scoped_ptr<FileTracker> folder_tracker =
         test_util::CreateTracker(*folder_metadata, kFolderTrackerID,
                                  &app_root_tracker);
-    index()->StoreFileMetadata(folder_metadata.Pass());
-    index()->StoreFileTracker(folder_tracker.Pass());
+    index()->StoreFileMetadata(std::move(folder_metadata));
+    index()->StoreFileTracker(std::move(folder_tracker));
     WriteToDB();
   }
 
@@ -546,7 +546,7 @@ TEST_F(MetadataDatabaseIndexOnDiskTest,
   scoped_ptr<FileTracker> file_tracker =
       test_util::CreateTracker(*metadata, kNewFileTrackerID, &folder_tracker);
 
-  index()->StoreFileTracker(file_tracker.Pass());
+  index()->StoreFileTracker(std::move(file_tracker));
   WriteToDB();
   tracker_ids = index()->GetFileTrackerIDsByParentAndTitle(
       kFolderTrackerID, std::string());
@@ -560,7 +560,7 @@ TEST_F(MetadataDatabaseIndexOnDiskTest,
   file_tracker =
       test_util::CreateTracker(*metadata, kNewFileTrackerID, &folder_tracker);
 
-  index()->StoreFileTracker(file_tracker.Pass());
+  index()->StoreFileTracker(std::move(file_tracker));
   WriteToDB();
   tracker_ids = index()->GetFileTrackerIDsByParentAndTitle(
       kFolderTrackerID, std::string());
@@ -589,9 +589,9 @@ TEST_F(MetadataDatabaseIndexOnDiskTest, TrackerIDSetDetailsTest) {
   file_tracker2->set_active(false);
 
   // Add 2 trackers related to one file metadata.
-  index()->StoreFileMetadata(file_metadata.Pass());
-  index()->StoreFileTracker(file_tracker.Pass());
-  index()->StoreFileTracker(file_tracker2.Pass());
+  index()->StoreFileMetadata(std::move(file_metadata));
+  index()->StoreFileTracker(std::move(file_tracker));
+  index()->StoreFileTracker(std::move(file_tracker2));
 
   TrackerIDSet idset = index()->GetFileTrackerIDsByFileID("file_id2");
   EXPECT_EQ(2U, idset.size());
@@ -601,7 +601,7 @@ TEST_F(MetadataDatabaseIndexOnDiskTest, TrackerIDSetDetailsTest) {
   file_tracker.reset(new FileTracker);
   index()->GetFileTracker(kFileTrackerID2, file_tracker.get());
   file_tracker->set_active(true);
-  index()->StoreFileTracker(file_tracker.Pass());
+  index()->StoreFileTracker(std::move(file_tracker));
 
   idset = index()->GetFileTrackerIDsByFileID("file_id2");
   EXPECT_EQ(2U, idset.size());
@@ -630,7 +630,7 @@ TEST_F(MetadataDatabaseIndexOnDiskTest, DirtyTrackersTest) {
       test_util::CreatePlaceholderTracker("placeholder",
                                           tracker_id,
                                           app_root_tracker.get());
-  index()->StoreFileTracker(tracker.Pass());
+  index()->StoreFileTracker(std::move(tracker));
   WriteToDB();
   EXPECT_EQ(1U, index()->CountDirtyTracker());
   EXPECT_EQ(tracker_id, index()->PickDirtyTracker());
@@ -640,7 +640,7 @@ TEST_F(MetadataDatabaseIndexOnDiskTest, DirtyTrackersTest) {
                                                 tracker_id,
                                                 app_root_tracker.get());
   tracker->set_dirty(false);
-  index()->StoreFileTracker(tracker.Pass());
+  index()->StoreFileTracker(std::move(tracker));
   WriteToDB();
   EXPECT_EQ(0U, index()->CountDirtyTracker());
   EXPECT_EQ(kInvalidTrackerID, index()->PickDirtyTracker());
@@ -648,7 +648,7 @@ TEST_F(MetadataDatabaseIndexOnDiskTest, DirtyTrackersTest) {
   tracker = test_util::CreatePlaceholderTracker("placeholder",
                                                 tracker_id,
                                                 app_root_tracker.get());
-  index()->StoreFileTracker(tracker.Pass());
+  index()->StoreFileTracker(std::move(tracker));
   WriteToDB();
   EXPECT_EQ(1U, index()->CountDirtyTracker());
   EXPECT_EQ(tracker_id, index()->PickDirtyTracker());
diff --git a/chrome/browser/sync_file_system/drive_backend/metadata_database_index_unittest.cc b/chrome/browser/sync_file_system/drive_backend/metadata_database_index_unittest.cc
index dc0e596..839c5fa 100644
--- a/chrome/browser/sync_file_system/drive_backend/metadata_database_index_unittest.cc
+++ b/chrome/browser/sync_file_system/drive_backend/metadata_database_index_unittest.cc
@@ -5,6 +5,7 @@
 #include "chrome/browser/sync_file_system/drive_backend/metadata_database_index.h"
 
 #include <stdint.h>
+#include <utility>
 
 #include "chrome/browser/sync_file_system/drive_backend/drive_backend_constants.h"
 #include "chrome/browser/sync_file_system/drive_backend/drive_backend_test_util.h"
@@ -62,7 +63,7 @@ scoped_ptr<DatabaseContents> CreateTestDatabaseContents() {
   contents->file_metadata.push_back(file_metadata.release());
   contents->file_trackers.push_back(file_tracker.release());
   contents->file_trackers.push_back(placeholder_tracker.release());
-  return contents.Pass();
+  return contents;
 }
 
 }  // namespace
@@ -151,7 +152,7 @@ TEST_F(MetadataDatabaseIndexTest, UpdateTest) {
   scoped_ptr<FileTracker> new_tracker =
       test_util::CreateTracker(metadata, new_tracker_id, &app_root_tracker);
   new_tracker->set_active(false);
-  index()->StoreFileTracker(new_tracker.Pass());
+  index()->StoreFileTracker(std::move(new_tracker));
 
   EXPECT_EQ("file_id", index()->PickMultiTrackerFileID());
   EXPECT_EQ(ParentIDAndTitle(kAppRootTrackerID, std::string("file")),
diff --git a/chrome/browser/sync_file_system/drive_backend/metadata_database_unittest.cc b/chrome/browser/sync_file_system/drive_backend/metadata_database_unittest.cc
index cd7af78..ea11a52 100644
--- a/chrome/browser/sync_file_system/drive_backend/metadata_database_unittest.cc
+++ b/chrome/browser/sync_file_system/drive_backend/metadata_database_unittest.cc
@@ -5,6 +5,7 @@
 #include "chrome/browser/sync_file_system/drive_backend/metadata_database.h"
 
 #include <stdint.h>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/files/scoped_temp_dir.h"
@@ -272,7 +273,7 @@ class MetadataDatabaseTest : public testing::TestWithParam<bool> {
     wrapper->Put(kDatabaseVersionKey, base::Int64ToString(3));
     SetUpServiceMetadata(wrapper.get());
 
-    return wrapper.Pass();
+    return wrapper;
   }
 
   void SetUpServiceMetadata(LevelDBWrapper* db) {
@@ -405,7 +406,7 @@ class MetadataDatabaseTest : public testing::TestWithParam<bool> {
     file_resource->set_modified_date(base::Time::FromInternalValue(
         file.details().modification_time()));
 
-    return file_resource.Pass();
+    return file_resource;
   }
 
   scoped_ptr<google_apis::ChangeResource> CreateChangeResourceFromMetadata(
@@ -416,10 +417,10 @@ class MetadataDatabaseTest : public testing::TestWithParam<bool> {
     change->set_file_id(file.file_id());
     change->set_deleted(file.details().missing());
     if (change->is_deleted())
-      return change.Pass();
+      return change;
 
     change->set_file(CreateFileResourceFromMetadata(file));
-    return change.Pass();
+    return change;
   }
 
   void ApplyRenameChangeToMetadata(const std::string& new_title,
@@ -516,12 +517,11 @@ class MetadataDatabaseTest : public testing::TestWithParam<bool> {
 
   void VerifyReloadConsistency() {
     scoped_ptr<MetadataDatabase> metadata_database_2;
-    ASSERT_EQ(SYNC_STATUS_OK,
-              MetadataDatabase::CreateForTesting(
-                  metadata_database_->db_.Pass(),
-                  metadata_database_->enable_on_disk_index_,
-                  &metadata_database_2));
-    metadata_database_->db_ = metadata_database_2->db_.Pass();
+    ASSERT_EQ(SYNC_STATUS_OK, MetadataDatabase::CreateForTesting(
+                                  std::move(metadata_database_->db_),
+                                  metadata_database_->enable_on_disk_index_,
+                                  &metadata_database_2));
+    metadata_database_->db_ = std::move(metadata_database_2->db_);
 
     MetadataDatabaseIndexInterface* index1 = metadata_database_->index_.get();
     MetadataDatabaseIndexInterface* index2 = metadata_database_2->index_.get();
@@ -574,8 +574,8 @@ class MetadataDatabaseTest : public testing::TestWithParam<bool> {
 
   SyncStatusCode UpdateByChangeList(
       ScopedVector<google_apis::ChangeResource> changes) {
-    return metadata_database_->UpdateByChangeList(
-        current_change_id_, changes.Pass());
+    return metadata_database_->UpdateByChangeList(current_change_id_,
+                                                  std::move(changes));
   }
 
   SyncStatusCode PopulateFolder(const std::string& folder_id,
@@ -913,7 +913,7 @@ TEST_P(MetadataDatabaseTest, UpdateByChangeListTest) {
       CreateChangeResourceFromMetadata(noop_file.metadata), &changes);
   PushToChangeList(
       CreateChangeResourceFromMetadata(new_file.metadata), &changes);
-  EXPECT_EQ(SYNC_STATUS_OK, UpdateByChangeList(changes.Pass()));
+  EXPECT_EQ(SYNC_STATUS_OK, UpdateByChangeList(std::move(changes)));
 
   renamed_file.tracker.set_dirty(true);
   reorganized_file.tracker.set_dirty(true);
diff --git a/chrome/browser/sync_file_system/drive_backend/register_app_task.cc b/chrome/browser/sync_file_system/drive_backend/register_app_task.cc
index 594df14..168f853 100644
--- a/chrome/browser/sync_file_system/drive_backend/register_app_task.cc
+++ b/chrome/browser/sync_file_system/drive_backend/register_app_task.cc
@@ -5,6 +5,7 @@
 #include "chrome/browser/sync_file_system/drive_backend/register_app_task.h"
 
 #include <stdint.h>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/location.h"
@@ -104,7 +105,7 @@ void RegisterAppTask::DidCreateAppRootFolder(
     const SyncStatusCallback& callback,
     const std::string& folder_id,
     SyncStatusCode status) {
-  scoped_ptr<FolderCreator> deleter = folder_creator_.Pass();
+  scoped_ptr<FolderCreator> deleter = std::move(folder_creator_);
   if (status != SYNC_STATUS_OK) {
     callback.Run(status);
     return;
@@ -156,7 +157,7 @@ bool RegisterAppTask::FilterCandidates(const TrackerIDSet& trackers,
     if (oldest_tracker && CompareOnCTime(*oldest_tracker, *tracker))
       continue;
 
-    oldest_tracker = tracker.Pass();
+    oldest_tracker = std::move(tracker);
   }
 
   if (!oldest_tracker)
diff --git a/chrome/browser/sync_file_system/drive_backend/register_app_task_unittest.cc b/chrome/browser/sync_file_system/drive_backend/register_app_task_unittest.cc
index c6efe8d..08dcb77 100644
--- a/chrome/browser/sync_file_system/drive_backend/register_app_task_unittest.cc
+++ b/chrome/browser/sync_file_system/drive_backend/register_app_task_unittest.cc
@@ -6,7 +6,7 @@
 
 #include <stddef.h>
 #include <stdint.h>
-
+#include <utility>
 #include <vector>
 
 #include "base/files/scoped_temp_dir.h"
@@ -62,12 +62,10 @@ class RegisterAppTaskTest : public testing::Test {
         fake_drive_service.get(), drive_uploader.get(),
         kSyncRootFolderTitle));
 
-    context_.reset(new SyncEngineContext(fake_drive_service.Pass(),
-                                         drive_uploader.Pass(),
-                                         nullptr /* task_logger */,
-                                         base::ThreadTaskRunnerHandle::Get(),
-                                         base::ThreadTaskRunnerHandle::Get(),
-                                         nullptr /* worker_pool */));
+    context_.reset(new SyncEngineContext(
+        std::move(fake_drive_service), std::move(drive_uploader),
+        nullptr /* task_logger */, base::ThreadTaskRunnerHandle::Get(),
+        base::ThreadTaskRunnerHandle::Get(), nullptr /* worker_pool */));
 
     ASSERT_EQ(google_apis::HTTP_CREATED,
               fake_drive_service_helper_->AddOrphanedFolder(
@@ -126,10 +124,11 @@ class RegisterAppTaskTest : public testing::Test {
     ASSERT_TRUE(db);
     ASSERT_FALSE(context_->GetMetadataDatabase());
     scoped_ptr<MetadataDatabase> metadata_db;
-    ASSERT_EQ(SYNC_STATUS_OK,
-              MetadataDatabase::CreateForTesting(
-                  db.Pass(), true /* enable_on_disk_index */, &metadata_db));
-    context_->SetMetadataDatabase(metadata_db.Pass());
+    ASSERT_EQ(
+        SYNC_STATUS_OK,
+        MetadataDatabase::CreateForTesting(
+            std::move(db), true /* enable_on_disk_index */, &metadata_db));
+    context_->SetMetadataDatabase(std::move(metadata_db));
   }
 
   SyncStatusCode RunRegisterAppTask(const std::string& app_id) {
@@ -285,7 +284,7 @@ TEST_F(RegisterAppTaskTest, AlreadyRegistered) {
   const std::string kAppID = "app_id";
   SetUpRegisteredAppRoot(kAppID, db.get());
 
-  CreateMetadataDatabase(db.Pass());
+  CreateMetadataDatabase(std::move(db));
   EXPECT_EQ(SYNC_STATUS_OK, RunRegisterAppTask(kAppID));
 
   EXPECT_EQ(1u, CountRegisteredAppRoot());
@@ -298,7 +297,7 @@ TEST_F(RegisterAppTaskTest, CreateAppFolder) {
   SetUpInitialData(db.get());
 
   const std::string kAppID = "app_id";
-  CreateMetadataDatabase(db.Pass());
+  CreateMetadataDatabase(std::move(db));
   RunRegisterAppTask(kAppID);
 
   EXPECT_EQ(1u, CountRegisteredAppRoot());
@@ -317,7 +316,7 @@ TEST_F(RegisterAppTaskTest, RegisterExistingFolder) {
   const std::string kAppID = "app_id";
   SetUpUnregisteredAppRoot(kAppID, db.get());
 
-  CreateMetadataDatabase(db.Pass());
+  CreateMetadataDatabase(std::move(db));
   RunRegisterAppTask(kAppID);
 
   EXPECT_EQ(1u, CountRegisteredAppRoot());
@@ -333,7 +332,7 @@ TEST_F(RegisterAppTaskTest, RegisterExistingFolder_MultipleCandidate) {
   SetUpUnregisteredAppRoot(kAppID, db.get());
   SetUpUnregisteredAppRoot(kAppID, db.get());
 
-  CreateMetadataDatabase(db.Pass());
+  CreateMetadataDatabase(std::move(db));
   RunRegisterAppTask(kAppID);
 
   EXPECT_EQ(1u, CountRegisteredAppRoot());
diff --git a/chrome/browser/sync_file_system/drive_backend/remote_to_local_syncer.cc b/chrome/browser/sync_file_system/drive_backend/remote_to_local_syncer.cc
index 8ebcb42..2cf1e63 100644
--- a/chrome/browser/sync_file_system/drive_backend/remote_to_local_syncer.cc
+++ b/chrome/browser/sync_file_system/drive_backend/remote_to_local_syncer.cc
@@ -5,8 +5,8 @@
 #include "chrome/browser/sync_file_system/drive_backend/remote_to_local_syncer.h"
 
 #include <stdint.h>
-
 #include <limits>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ -77,7 +77,7 @@ scoped_ptr<FileMetadata> GetFileMetadata(MetadataDatabase* database,
   scoped_ptr<FileMetadata> metadata(new FileMetadata);
   if (!database->FindFileByFileID(file_id, metadata.get()))
     metadata.reset();
-  return metadata.Pass();
+  return metadata;
 }
 
 // Creates a temporary file in |dir_path|.  This must be called on an
@@ -112,7 +112,7 @@ void RemoteToLocalSyncer::RunPreflight(scoped_ptr<SyncTaskToken> token) {
 
   if (!drive_service() || !metadata_database() || !remote_change_processor()) {
     token->RecordLog("Context not ready.");
-    SyncTaskManager::NotifyTaskDone(token.Pass(), SYNC_STATUS_FAILED);
+    SyncTaskManager::NotifyTaskDone(std::move(token), SYNC_STATUS_FAILED);
     return;
   }
 
@@ -121,12 +121,13 @@ void RemoteToLocalSyncer::RunPreflight(scoped_ptr<SyncTaskToken> token) {
     token->RecordLog(base::StringPrintf(
         "Start: tracker_id=%" PRId64, dirty_tracker_->tracker_id()));
     metadata_database()->DemoteTracker(dirty_tracker_->tracker_id());
-    ResolveRemoteChange(token.Pass());
+    ResolveRemoteChange(std::move(token));
     return;
   }
 
   token->RecordLog("Nothing to do.");
-  SyncTaskManager::NotifyTaskDone(token.Pass(), SYNC_STATUS_NO_CHANGE_TO_SYNC);
+  SyncTaskManager::NotifyTaskDone(std::move(token),
+                                  SYNC_STATUS_NO_CHANGE_TO_SYNC);
 }
 
 void RemoteToLocalSyncer::ResolveRemoteChange(scoped_ptr<SyncTaskToken> token) {
@@ -143,7 +144,7 @@ void RemoteToLocalSyncer::ResolveRemoteChange(scoped_ptr<SyncTaskToken> token) {
     token->RecordLog("Missing remote metadata case.");
 
     MoveToBackground(
-        token.Pass(),
+        std::move(token),
         base::Bind(&RemoteToLocalSyncer::HandleMissingRemoteMetadata,
                    weak_ptr_factory_.GetWeakPtr()));
     return;
@@ -157,7 +158,7 @@ void RemoteToLocalSyncer::ResolveRemoteChange(scoped_ptr<SyncTaskToken> token) {
       HasDisabledAppRoot(metadata_database(), *dirty_tracker_)) {
     // Handle inactive tracker in SyncCompleted.
     token->RecordLog("Inactive tracker case.");
-    SyncCompleted(token.Pass(), SYNC_STATUS_OK);
+    SyncCompleted(std::move(token), SYNC_STATUS_OK);
     return;
   }
 
@@ -169,7 +170,7 @@ void RemoteToLocalSyncer::ResolveRemoteChange(scoped_ptr<SyncTaskToken> token) {
         "Missing synced_details of an active tracker: %" PRId64,
         dirty_tracker_->tracker_id()));
     NOTREACHED();
-    SyncCompleted(token.Pass(), SYNC_STATUS_FAILED);
+    SyncCompleted(std::move(token), SYNC_STATUS_FAILED);
     return;
   }
 
@@ -183,11 +184,11 @@ void RemoteToLocalSyncer::ResolveRemoteChange(scoped_ptr<SyncTaskToken> token) {
         remote_details.parent_folder_ids_size()) {
       token->RecordLog("Sync-root deletion.");
       sync_root_deletion_ = true;
-      SyncCompleted(token.Pass(), SYNC_STATUS_OK);
+      SyncCompleted(std::move(token), SYNC_STATUS_OK);
       return;
     }
     token->RecordLog("Trivial sync-root change.");
-    SyncCompleted(token.Pass(), SYNC_STATUS_OK);
+    SyncCompleted(std::move(token), SYNC_STATUS_OK);
     return;
   }
 
@@ -196,7 +197,7 @@ void RemoteToLocalSyncer::ResolveRemoteChange(scoped_ptr<SyncTaskToken> token) {
 
   if (!BuildFileSystemURL(metadata_database(), *dirty_tracker_, &url_)) {
     NOTREACHED();
-    SyncCompleted(token.Pass(), SYNC_STATUS_FAILED);
+    SyncCompleted(std::move(token), SYNC_STATUS_FAILED);
     return;
   }
 
@@ -205,7 +206,7 @@ void RemoteToLocalSyncer::ResolveRemoteChange(scoped_ptr<SyncTaskToken> token) {
   if (remote_details.missing()) {
     if (!synced_details.missing()) {
       token->RecordLog("Remote file deletion.");
-      MoveToBackground(token.Pass(),
+      MoveToBackground(std::move(token),
                        base::Bind(&RemoteToLocalSyncer::HandleDeletion,
                                   weak_ptr_factory_.GetWeakPtr()));
       return;
@@ -215,7 +216,7 @@ void RemoteToLocalSyncer::ResolveRemoteChange(scoped_ptr<SyncTaskToken> token) {
     token->RecordLog("Found a stray missing tracker: " +
                      dirty_tracker_->file_id());
     NOTREACHED();
-    SyncCompleted(token.Pass(), SYNC_STATUS_OK);
+    SyncCompleted(std::move(token), SYNC_STATUS_OK);
     return;
   }
 
@@ -230,7 +231,7 @@ void RemoteToLocalSyncer::ResolveRemoteChange(scoped_ptr<SyncTaskToken> token) {
         synced_details.file_kind(),
         remote_details.file_kind()));
     NOTREACHED();
-    SyncCompleted(token.Pass(), SYNC_STATUS_FAILED);
+    SyncCompleted(std::move(token), SYNC_STATUS_FAILED);
     return;
   }
   DCHECK_EQ(synced_details.file_kind(), remote_details.file_kind());
@@ -239,7 +240,7 @@ void RemoteToLocalSyncer::ResolveRemoteChange(scoped_ptr<SyncTaskToken> token) {
     token->RecordLog("Found an unsupported active file: " +
                      remote_metadata_->file_id());
     NOTREACHED();
-    SyncCompleted(token.Pass(), SYNC_STATUS_FAILED);
+    SyncCompleted(std::move(token), SYNC_STATUS_FAILED);
     return;
   }
   DCHECK(remote_details.file_kind() == FILE_KIND_FILE ||
@@ -249,7 +250,7 @@ void RemoteToLocalSyncer::ResolveRemoteChange(scoped_ptr<SyncTaskToken> token) {
     // Handle rename as deletion + addition.
     token->RecordLog("Detected file rename.");
 
-    MoveToBackground(token.Pass(),
+    MoveToBackground(std::move(token),
                      base::Bind(&RemoteToLocalSyncer::HandleFileMove,
                                 weak_ptr_factory_.GetWeakPtr()));
     return;
@@ -262,7 +263,7 @@ void RemoteToLocalSyncer::ResolveRemoteChange(scoped_ptr<SyncTaskToken> token) {
     token->RecordLog("Missing parent tracker for a non sync-root tracker: "
                      + dirty_tracker_->file_id());
     NOTREACHED();
-    SyncCompleted(token.Pass(), SYNC_STATUS_FAILED);
+    SyncCompleted(std::move(token), SYNC_STATUS_FAILED);
     return;
   }
 
@@ -270,7 +271,7 @@ void RemoteToLocalSyncer::ResolveRemoteChange(scoped_ptr<SyncTaskToken> token) {
     // Handle reorganize as deletion + addition.
     token->RecordLog("Detected file reorganize.");
 
-    MoveToBackground(token.Pass(),
+    MoveToBackground(std::move(token),
                      base::Bind(&RemoteToLocalSyncer::HandleFileMove,
                                 weak_ptr_factory_.GetWeakPtr()));
     return;
@@ -279,7 +280,7 @@ void RemoteToLocalSyncer::ResolveRemoteChange(scoped_ptr<SyncTaskToken> token) {
   if (synced_details.file_kind() == FILE_KIND_FILE) {
     if (synced_details.md5() != remote_details.md5()) {
       token->RecordLog("Detected file content update.");
-      MoveToBackground(token.Pass(),
+      MoveToBackground(std::move(token),
                        base::Bind(&RemoteToLocalSyncer::HandleContentUpdate,
                                   weak_ptr_factory_.GetWeakPtr()));
       return;
@@ -288,24 +289,24 @@ void RemoteToLocalSyncer::ResolveRemoteChange(scoped_ptr<SyncTaskToken> token) {
     DCHECK_EQ(FILE_KIND_FOLDER, synced_details.file_kind());
     if (synced_details.missing()) {
       token->RecordLog("Detected folder update.");
-      MoveToBackground(token.Pass(),
+      MoveToBackground(std::move(token),
                        base::Bind(&RemoteToLocalSyncer::HandleFolderUpdate,
                                   weak_ptr_factory_.GetWeakPtr()));
       return;
     }
     if (dirty_tracker_->needs_folder_listing()) {
       token->RecordLog("Needs listing folder.");
-      MoveToBackground(token.Pass(),
+      MoveToBackground(std::move(token),
                        base::Bind(&RemoteToLocalSyncer::ListFolderContent,
                                   weak_ptr_factory_.GetWeakPtr()));
       return;
     }
-    SyncCompleted(token.Pass(), SYNC_STATUS_OK);
+    SyncCompleted(std::move(token), SYNC_STATUS_OK);
     return;
   }
 
   token->RecordLog("Trivial file change.");
-  SyncCompleted(token.Pass(), SYNC_STATUS_OK);
+  SyncCompleted(std::move(token), SYNC_STATUS_OK);
 }
 
 void RemoteToLocalSyncer::MoveToBackground(scoped_ptr<SyncTaskToken> token,
@@ -320,7 +321,7 @@ void RemoteToLocalSyncer::MoveToBackground(scoped_ptr<SyncTaskToken> token,
   blocker->tracker_ids.push_back(dirty_tracker_->tracker_id());
 
   SyncTaskManager::UpdateTaskBlocker(
-      token.Pass(), blocker.Pass(),
+      std::move(token), std::move(blocker),
       base::Bind(&RemoteToLocalSyncer::ContinueAsBackgroundTask,
                  weak_ptr_factory_.GetWeakPtr(), continuation));
 }
@@ -353,7 +354,7 @@ void RemoteToLocalSyncer::ContinueAsBackgroundTask(
           dirty_tracker_->tracker_id(), &latest_dirty_tracker) ||
       dirty_tracker_->active() != latest_dirty_tracker.active() ||
       !latest_dirty_tracker.dirty()) {
-    SyncCompleted(token.Pass(), SYNC_STATUS_RETRY);
+    SyncCompleted(std::move(token), SYNC_STATUS_RETRY);
     return;
   }
 
@@ -364,7 +365,7 @@ void RemoteToLocalSyncer::ContinueAsBackgroundTask(
   if (latest_dirty_tracker.has_synced_details())
     latest_change_id = latest_dirty_tracker.synced_details().change_id();
   if (current_change_id != latest_change_id) {
-    SyncCompleted(token.Pass(), SYNC_STATUS_RETRY);
+    SyncCompleted(std::move(token), SYNC_STATUS_RETRY);
     return;
   }
 
@@ -372,23 +373,23 @@ void RemoteToLocalSyncer::ContinueAsBackgroundTask(
   if (metadata_database()->FindFileByFileID(dirty_tracker_->file_id(),
                                             &latest_file_metadata)) {
     if (!remote_metadata_) {
-      SyncCompleted(token.Pass(), SYNC_STATUS_RETRY);
+      SyncCompleted(std::move(token), SYNC_STATUS_RETRY);
       return;
     }
 
     int64_t change_id = remote_metadata_->details().change_id();
     int64_t latest_change_id = latest_file_metadata.details().change_id();
     if (change_id != latest_change_id) {
-      SyncCompleted(token.Pass(), SYNC_STATUS_RETRY);
+      SyncCompleted(std::move(token), SYNC_STATUS_RETRY);
       return;
     }
   } else {
     if (remote_metadata_) {
-      SyncCompleted(token.Pass(), SYNC_STATUS_RETRY);
+      SyncCompleted(std::move(token), SYNC_STATUS_RETRY);
       return;
     }
   }
-  continuation.Run(token.Pass());
+  continuation.Run(std::move(token));
 }
 
 void RemoteToLocalSyncer::HandleMissingRemoteMetadata(
@@ -411,40 +412,40 @@ void RemoteToLocalSyncer::DidGetRemoteMetadata(
   SyncStatusCode status = DriveApiErrorCodeToSyncStatusCode(error);
   if (status != SYNC_STATUS_OK &&
       error != google_apis::HTTP_NOT_FOUND) {
-    SyncCompleted(token.Pass(), status);
+    SyncCompleted(std::move(token), status);
     return;
   }
 
   if (error == google_apis::HTTP_NOT_FOUND) {
     status = metadata_database()->UpdateByDeletedRemoteFile(
         dirty_tracker_->file_id());
-    SyncCompleted(token.Pass(), status);
+    SyncCompleted(std::move(token), status);
     return;
   }
 
   if (!entry) {
     NOTREACHED();
-    SyncCompleted(token.Pass(), SYNC_STATUS_FAILED);
+    SyncCompleted(std::move(token), SYNC_STATUS_FAILED);
     return;
   }
 
   status = metadata_database()->UpdateByFileResource(*entry);
   if (status != SYNC_STATUS_OK) {
-    SyncCompleted(token.Pass(), status);
+    SyncCompleted(std::move(token), status);
     return;
   }
 
   metadata_database()->PromoteDemotedTracker(dirty_tracker_->tracker_id());
 
   // Do not update |dirty_tracker_|.
-  SyncCompleted(token.Pass(), SYNC_STATUS_RETRY);
+  SyncCompleted(std::move(token), SYNC_STATUS_RETRY);
 }
 
 void RemoteToLocalSyncer::DidPrepareForAddOrUpdateFile(
     scoped_ptr<SyncTaskToken> token,
     SyncStatusCode status) {
   if (status != SYNC_STATUS_OK) {
-    SyncCompleted(token.Pass(), status);
+    SyncCompleted(std::move(token), status);
     return;
   }
 
@@ -459,7 +460,7 @@ void RemoteToLocalSyncer::DidPrepareForAddOrUpdateFile(
     sync_action_ = SYNC_ACTION_ADDED;
     // Missing local file case.
     // Download the file and add it to local as a new file.
-    DownloadFile(token.Pass());
+    DownloadFile(std::move(token));
     return;
   }
 
@@ -469,7 +470,7 @@ void RemoteToLocalSyncer::DidPrepareForAddOrUpdateFile(
       file_type_ = SYNC_FILE_TYPE_FILE;
       sync_action_ = SYNC_ACTION_UPDATED;
       // Download the file and overwrite the existing local file.
-      DownloadFile(token.Pass());
+      DownloadFile(std::move(token));
       return;
     }
 
@@ -479,17 +480,16 @@ void RemoteToLocalSyncer::DidPrepareForAddOrUpdateFile(
     // Our policy prioritize folders in this case.
     // Let local-to-remote sync phase process this change.
     remote_change_processor()->RecordFakeLocalChange(
-        url_,
-        FileChange(FileChange::FILE_CHANGE_ADD_OR_UPDATE,
-                   local_metadata_->file_type),
-        SyncCompletedCallback(token.Pass()));
+        url_, FileChange(FileChange::FILE_CHANGE_ADD_OR_UPDATE,
+                         local_metadata_->file_type),
+        SyncCompletedCallback(std::move(token)));
     return;
   }
 
   DCHECK(local_changes_->back().IsAddOrUpdate());
   // Conflict case.
   // Do nothing for the change now, and handle this in LocalToRemoteSync phase.
-  SyncCompleted(token.Pass(), SYNC_STATUS_RETRY);
+  SyncCompleted(std::move(token), SYNC_STATUS_RETRY);
 }
 
 void RemoteToLocalSyncer::HandleFolderUpdate(
@@ -512,7 +512,7 @@ void RemoteToLocalSyncer::DidPrepareForFolderUpdate(
     scoped_ptr<SyncTaskToken> token,
     SyncStatusCode status) {
   if (status != SYNC_STATUS_OK) {
-    SyncCompleted(token.Pass(), status);
+    SyncCompleted(std::move(token), status);
     return;
   }
 
@@ -526,7 +526,7 @@ void RemoteToLocalSyncer::DidPrepareForFolderUpdate(
     file_type_ = SYNC_FILE_TYPE_DIRECTORY;
     sync_action_ = SYNC_ACTION_ADDED;
     // No local file exists at the path.
-    CreateFolder(token.Pass());
+    CreateFolder(std::move(token));
     return;
   }
 
@@ -534,9 +534,9 @@ void RemoteToLocalSyncer::DidPrepareForFolderUpdate(
     // There already exists a folder, nothing left to do.
     if (dirty_tracker_->needs_folder_listing() &&
         !dirty_tracker_->synced_details().missing()) {
-      ListFolderContent(token.Pass());
+      ListFolderContent(std::move(token));
     } else {
-      SyncCompleted(token.Pass(), SYNC_STATUS_OK);
+      SyncCompleted(std::move(token), SYNC_STATUS_OK);
     }
     return;
   }
@@ -546,7 +546,7 @@ void RemoteToLocalSyncer::DidPrepareForFolderUpdate(
   sync_action_ = SYNC_ACTION_ADDED;
   // Got a remote folder for existing local file.
   // Our policy prioritize folders in this case.
-  CreateFolder(token.Pass());
+  CreateFolder(std::move(token));
 }
 
 void RemoteToLocalSyncer::HandleDeletion(
@@ -585,7 +585,7 @@ void RemoteToLocalSyncer::DidPrepareForDeletion(
     scoped_ptr<SyncTaskToken> token,
     SyncStatusCode status) {
   if (status != SYNC_STATUS_OK) {
-    SyncCompleted(token.Pass(), status);
+    SyncCompleted(std::move(token), status);
     return;
   }
 
@@ -597,7 +597,7 @@ void RemoteToLocalSyncer::DidPrepareForDeletion(
   if (local_metadata_->file_type == SYNC_FILE_TYPE_UNKNOWN ||
       (!local_changes_->empty() && local_changes_->back().IsDelete())) {
     // No local file exists at the path.
-    SyncCompleted(token.Pass(), SYNC_STATUS_OK);
+    SyncCompleted(std::move(token), SYNC_STATUS_OK);
     return;
   }
 
@@ -605,14 +605,14 @@ void RemoteToLocalSyncer::DidPrepareForDeletion(
   if (local_changes_->empty()) {
     file_type_ = local_metadata_->file_type;
     sync_action_ = SYNC_ACTION_DELETED;
-    DeleteLocalFile(token.Pass());
+    DeleteLocalFile(std::move(token));
     return;
   }
 
   DCHECK(local_changes_->back().IsAddOrUpdate());
   // File is remotely deleted and locally updated.
   // Ignore the remote deletion and handle it as if applied successfully.
-  SyncCompleted(token.Pass(), SYNC_STATUS_OK);
+  SyncCompleted(std::move(token), SYNC_STATUS_OK);
 }
 
 void RemoteToLocalSyncer::HandleContentUpdate(
@@ -664,13 +664,13 @@ void RemoteToLocalSyncer::DidListFolderContent(
     scoped_ptr<google_apis::FileList> file_list) {
   SyncStatusCode status = DriveApiErrorCodeToSyncStatusCode(error);
   if (status != SYNC_STATUS_OK) {
-    SyncCompleted(token.Pass(), status);
+    SyncCompleted(std::move(token), status);
     return;
   }
 
   if (!file_list) {
     NOTREACHED();
-    SyncCompleted(token.Pass(), SYNC_STATUS_FAILED);
+    SyncCompleted(std::move(token), SYNC_STATUS_FAILED);
     return;
   }
 
@@ -693,7 +693,7 @@ void RemoteToLocalSyncer::DidListFolderContent(
 
   status = metadata_database()->PopulateFolderByChildList(
       dirty_tracker_->file_id(), *children);
-  SyncCompleted(token.Pass(), status);
+  SyncCompleted(std::move(token), status);
 }
 
 void RemoteToLocalSyncer::SyncCompleted(scoped_ptr<SyncTaskToken> token,
@@ -704,17 +704,17 @@ void RemoteToLocalSyncer::SyncCompleted(scoped_ptr<SyncTaskToken> token,
       SyncStatusCodeToString(status)));
 
   if (sync_root_deletion_) {
-    FinalizeSync(token.Pass(), SYNC_STATUS_OK);
+    FinalizeSync(std::move(token), SYNC_STATUS_OK);
     return;
   }
 
   if (status == SYNC_STATUS_RETRY) {
-    FinalizeSync(token.Pass(), SYNC_STATUS_OK);
+    FinalizeSync(std::move(token), SYNC_STATUS_OK);
     return;
   }
 
   if (status != SYNC_STATUS_OK) {
-    FinalizeSync(token.Pass(), status);
+    FinalizeSync(std::move(token), status);
     return;
   }
 
@@ -737,7 +737,7 @@ void RemoteToLocalSyncer::SyncCompleted(scoped_ptr<SyncTaskToken> token,
 
   status = metadata_database()->UpdateTracker(
       dirty_tracker_->tracker_id(), updated_details);
-  FinalizeSync(token.Pass(), status);
+  FinalizeSync(std::move(token), status);
 }
 
 void RemoteToLocalSyncer::FinalizeSync(scoped_ptr<SyncTaskToken> token,
@@ -750,7 +750,7 @@ void RemoteToLocalSyncer::FinalizeSync(scoped_ptr<SyncTaskToken> token,
     return;
   }
 
-  SyncTaskManager::NotifyTaskDone(token.Pass(), status);
+  SyncTaskManager::NotifyTaskDone(std::move(token), status);
 }
 
 void RemoteToLocalSyncer::Prepare(const SyncStatusCallback& callback) {
@@ -781,9 +781,7 @@ void RemoteToLocalSyncer::DidPrepare(const SyncStatusCallback& callback,
 void RemoteToLocalSyncer::DeleteLocalFile(scoped_ptr<SyncTaskToken> token) {
   remote_change_processor()->ApplyRemoteChange(
       FileChange(FileChange::FILE_CHANGE_DELETE, SYNC_FILE_TYPE_UNKNOWN),
-      base::FilePath(),
-      url_,
-      SyncCompletedCallback(token.Pass()));
+      base::FilePath(), url_, SyncCompletedCallback(std::move(token)));
 }
 
 void RemoteToLocalSyncer::DownloadFile(scoped_ptr<SyncTaskToken> token) {
@@ -810,20 +808,20 @@ void RemoteToLocalSyncer::DidDownloadFile(scoped_ptr<SyncTaskToken> token,
 
   SyncStatusCode status = DriveApiErrorCodeToSyncStatusCode(error);
   if (status != SYNC_STATUS_OK) {
-    SyncCompleted(token.Pass(), status);
+    SyncCompleted(std::move(token), status);
     return;
   }
 
   base::FilePath path = file.path();
   const std::string md5 = drive::util::GetMd5Digest(path, nullptr);
   if (md5.empty()) {
-    SyncCompleted(token.Pass(), SYNC_FILE_ERROR_NOT_FOUND);
+    SyncCompleted(std::move(token), SYNC_FILE_ERROR_NOT_FOUND);
     return;
   }
 
   if (md5 != remote_metadata_->details().md5()) {
     // File has been modified since last metadata retrieval.
-    SyncCompleted(token.Pass(), SYNC_STATUS_RETRY);
+    SyncCompleted(std::move(token), SYNC_STATUS_RETRY);
     return;
   }
 
@@ -838,15 +836,14 @@ void RemoteToLocalSyncer::DidDownloadFile(scoped_ptr<SyncTaskToken> token,
 void RemoteToLocalSyncer::DidApplyDownload(scoped_ptr<SyncTaskToken> token,
                                            storage::ScopedFile,
                                            SyncStatusCode status) {
-  SyncCompleted(token.Pass(), status);
+  SyncCompleted(std::move(token), status);
 }
 
 void RemoteToLocalSyncer::CreateFolder(scoped_ptr<SyncTaskToken> token) {
   remote_change_processor()->ApplyRemoteChange(
       FileChange(FileChange::FILE_CHANGE_ADD_OR_UPDATE,
                  SYNC_FILE_TYPE_DIRECTORY),
-      base::FilePath(), url_,
-      SyncCompletedCallback(token.Pass()));
+      base::FilePath(), url_, SyncCompletedCallback(std::move(token)));
 }
 
 drive::DriveServiceInterface* RemoteToLocalSyncer::drive_service() {
diff --git a/chrome/browser/sync_file_system/drive_backend/remote_to_local_syncer_unittest.cc b/chrome/browser/sync_file_system/drive_backend/remote_to_local_syncer_unittest.cc
index 4d1d0da..27a3995 100644
--- a/chrome/browser/sync_file_system/drive_backend/remote_to_local_syncer_unittest.cc
+++ b/chrome/browser/sync_file_system/drive_backend/remote_to_local_syncer_unittest.cc
@@ -5,6 +5,7 @@
 #include "chrome/browser/sync_file_system/drive_backend/remote_to_local_syncer.h"
 
 #include <map>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ -70,12 +71,10 @@ class RemoteToLocalSyncerTest : public testing::Test {
                                    kSyncRootFolderTitle));
     remote_change_processor_.reset(new FakeRemoteChangeProcessor);
 
-    context_.reset(new SyncEngineContext(fake_drive_service.Pass(),
-                                         drive_uploader.Pass(),
-                                         nullptr /* task_logger */,
-                                         base::ThreadTaskRunnerHandle::Get(),
-                                         base::ThreadTaskRunnerHandle::Get(),
-                                         nullptr /* worker_pool*/));
+    context_.reset(new SyncEngineContext(
+        std::move(fake_drive_service), std::move(drive_uploader),
+        nullptr /* task_logger */, base::ThreadTaskRunnerHandle::Get(),
+        base::ThreadTaskRunnerHandle::Get(), nullptr /* worker_pool*/));
     context_->SetRemoteChangeProcessor(remote_change_processor_.get());
 
     RegisterSyncableFileSystem();
diff --git a/chrome/browser/sync_file_system/drive_backend/sync_engine.cc b/chrome/browser/sync_file_system/drive_backend/sync_engine.cc
index 0e496cd..e718282 100644
--- a/chrome/browser/sync_file_system/drive_backend/sync_engine.cc
+++ b/chrome/browser/sync_file_system/drive_backend/sync_engine.cc
@@ -4,6 +4,7 @@
 
 #include "chrome/browser/sync_file_system/drive_backend/sync_engine.h"
 
+#include <utility>
 #include <vector>
 
 #include "base/bind.h"
@@ -214,7 +215,7 @@ scoped_ptr<SyncEngine> SyncEngine::CreateForBrowserContext(
                      nullptr /* env_override */));
 
   sync_engine->Initialize();
-  return sync_engine.Pass();
+  return sync_engine;
 }
 
 void SyncEngine::AppendDependsOnFactories(
@@ -267,7 +268,8 @@ void SyncEngine::Initialize() {
   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(
@@ -275,15 +277,15 @@ void SyncEngine::InitializeForTesting(
     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;
@@ -291,7 +293,7 @@ void SyncEngine::InitializeInternal(
     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()));
 
@@ -305,13 +307,10 @@ void SyncEngine::InitializeInternal(
       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()));
@@ -327,7 +326,7 @@ void SyncEngine::InitializeInternal(
         env_override_));
   }
 
-  sync_worker_ = sync_worker.Pass();
+  sync_worker_ = std::move(sync_worker);
   sync_worker_->AddObserver(worker_observer_.get());
 
   worker_task_runner_->PostTask(
@@ -742,7 +741,7 @@ SyncEngine::SyncEngine(
       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),
diff --git a/chrome/browser/sync_file_system/drive_backend/sync_engine_context.cc b/chrome/browser/sync_file_system/drive_backend/sync_engine_context.cc
index e26a0eb..10752a9 100644
--- a/chrome/browser/sync_file_system/drive_backend/sync_engine_context.cc
+++ b/chrome/browser/sync_file_system/drive_backend/sync_engine_context.cc
@@ -4,6 +4,8 @@
 
 #include "chrome/browser/sync_file_system/drive_backend/sync_engine_context.h"
 
+#include <utility>
+
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/sequenced_task_runner.h"
@@ -24,8 +26,8 @@ SyncEngineContext::SyncEngineContext(
     const scoped_refptr<base::SingleThreadTaskRunner>& ui_task_runner,
     const scoped_refptr<base::SequencedTaskRunner>& worker_task_runner,
     const scoped_refptr<base::SequencedWorkerPool>& worker_pool)
-    : drive_service_(drive_service.Pass()),
-      drive_uploader_(drive_uploader.Pass()),
+    : drive_service_(std::move(drive_service)),
+      drive_uploader_(std::move(drive_uploader)),
       task_logger_(task_logger ? task_logger->AsWeakPtr()
                                : base::WeakPtr<TaskLogger>()),
       remote_change_processor_(nullptr),
@@ -61,7 +63,7 @@ MetadataDatabase* SyncEngineContext::GetMetadataDatabase() {
 
 scoped_ptr<MetadataDatabase> SyncEngineContext::PassMetadataDatabase() {
   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
-  return metadata_database_.Pass();
+  return std::move(metadata_database_);
 }
 
 RemoteChangeProcessor* SyncEngineContext::GetRemoteChangeProcessor() {
@@ -88,7 +90,7 @@ void SyncEngineContext::SetMetadataDatabase(
     scoped_ptr<MetadataDatabase> metadata_database) {
   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
   if (metadata_database)
-    metadata_database_ = metadata_database.Pass();
+    metadata_database_ = std::move(metadata_database);
 }
 
 void SyncEngineContext::SetRemoteChangeProcessor(
diff --git a/chrome/browser/sync_file_system/drive_backend/sync_engine_initializer.cc b/chrome/browser/sync_file_system/drive_backend/sync_engine_initializer.cc
index 26dfd07..3153beb 100644
--- a/chrome/browser/sync_file_system/drive_backend/sync_engine_initializer.cc
+++ b/chrome/browser/sync_file_system/drive_backend/sync_engine_initializer.cc
@@ -5,6 +5,7 @@
 #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"
@@ -77,7 +78,7 @@ void SyncEngineInitializer::RunPreflight(scoped_ptr<SyncTaskToken> token) {
   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;
   }
 
@@ -88,25 +89,25 @@ void SyncEngineInitializer::RunPreflight(scoped_ptr<SyncTaskToken> token) {
   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(
@@ -127,7 +128,7 @@ void SyncEngineInitializer::DidGetAboutResource(
   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;
   }
 
@@ -136,14 +137,14 @@ void SyncEngineInitializer::DidGetAboutResource(
   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;
   }
 
@@ -166,7 +167,7 @@ void SyncEngineInitializer::DidFindSyncRoot(
   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;
   }
 
@@ -174,7 +175,7 @@ void SyncEngineInitializer::DidFindSyncRoot(
     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;
   }
 
@@ -214,16 +215,16 @@ void SyncEngineInitializer::DidFindSyncRoot(
   }
 
   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) {
@@ -248,11 +249,11 @@ void SyncEngineInitializer::DidCreateSyncRoot(
   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) {
@@ -276,11 +277,11 @@ void SyncEngineInitializer::DidDetachSyncRoot(
   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(
@@ -305,7 +306,7 @@ void SyncEngineInitializer::DidListAppRootFolders(
   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;
   }
 
@@ -313,7 +314,7 @@ void SyncEngineInitializer::DidListAppRootFolders(
     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;
   }
 
@@ -333,7 +334,7 @@ void SyncEngineInitializer::DidListAppRootFolders(
     return;
   }
 
-  PopulateDatabase(token.Pass());
+  PopulateDatabase(std::move(token));
 }
 
 void SyncEngineInitializer::PopulateDatabase(
@@ -345,13 +346,13 @@ void SyncEngineInitializer::PopulateDatabase(
     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
diff --git a/chrome/browser/sync_file_system/drive_backend/sync_engine_initializer_unittest.cc b/chrome/browser/sync_file_system/drive_backend/sync_engine_initializer_unittest.cc
index aac13d8..2ac8321 100644
--- a/chrome/browser/sync_file_system/drive_backend/sync_engine_initializer_unittest.cc
+++ b/chrome/browser/sync_file_system/drive_backend/sync_engine_initializer_unittest.cc
@@ -6,6 +6,7 @@
 
 #include <stddef.h>
 #include <stdint.h>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/files/scoped_temp_dir.h"
@@ -57,12 +58,10 @@ class SyncEngineInitializerTest : public testing::Test {
     fake_drive_service_ = fake_drive_service.get();
 
     sync_context_.reset(new SyncEngineContext(
-        fake_drive_service.Pass(),
-        scoped_ptr<drive::DriveUploaderInterface>(),
-        nullptr /* task_logger */,
+        std::move(fake_drive_service),
+        scoped_ptr<drive::DriveUploaderInterface>(), nullptr /* task_logger */,
         base::ThreadTaskRunnerHandle::Get(),
-        base::ThreadTaskRunnerHandle::Get(),
-        nullptr /* worker_pool */));
+        base::ThreadTaskRunnerHandle::Get(), nullptr /* worker_pool */));
 
     sync_task_manager_.reset(new SyncTaskManager(
         base::WeakPtr<SyncTaskManager::Client>(),
@@ -146,7 +145,7 @@ class SyncEngineInitializerTest : public testing::Test {
     base::RunLoop().RunUntilIdle();
 
     EXPECT_EQ(google_apis::HTTP_CREATED, error);
-    return entry.Pass();
+    return entry;
   }
 
   scoped_ptr<google_apis::FileResource> CreateRemoteSyncRoot() {
@@ -163,7 +162,7 @@ class SyncEngineInitializerTest : public testing::Test {
       EXPECT_EQ(google_apis::HTTP_NO_CONTENT, error);
     }
 
-    return sync_root.Pass();
+    return sync_root;
   }
 
   std::string GetSyncRootFolderID() {
diff --git a/chrome/browser/sync_file_system/drive_backend/sync_engine_unittest.cc b/chrome/browser/sync_file_system/drive_backend/sync_engine_unittest.cc
index 84b47b7..445a1eb 100644
--- a/chrome/browser/sync_file_system/drive_backend/sync_engine_unittest.cc
+++ b/chrome/browser/sync_file_system/drive_backend/sync_engine_unittest.cc
@@ -5,6 +5,7 @@
 #include "chrome/browser/sync_file_system/drive_backend/sync_engine.h"
 
 #include <stddef.h>
+#include <utility>
 
 #include "base/files/scoped_temp_dir.h"
 #include "base/macros.h"
@@ -61,7 +62,7 @@ class SyncEngineTest : public testing::Test,
         nullptr));  // in_memory_env
 
     sync_engine_->InitializeForTesting(
-        fake_drive_service.Pass(),
+        std::move(fake_drive_service),
         nullptr,  // drive_uploader
         scoped_ptr<SyncWorkerInterface>(new FakeSyncWorker));
     sync_engine_->SetSyncEnabled(true);
diff --git a/chrome/browser/sync_file_system/drive_backend/sync_task.cc b/chrome/browser/sync_file_system/drive_backend/sync_task.cc
index f5f7dac..a9727af 100644
--- a/chrome/browser/sync_file_system/drive_backend/sync_task.cc
+++ b/chrome/browser/sync_file_system/drive_backend/sync_task.cc
@@ -4,6 +4,8 @@
 
 #include "chrome/browser/sync_file_system/drive_backend/sync_task.h"
 
+#include <utility>
+
 #include "base/bind.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"
@@ -17,7 +19,7 @@ namespace {
 void CallRunExclusive(const base::WeakPtr<ExclusiveTask>& task,
                       scoped_ptr<SyncTaskToken> token) {
   if (task)
-    task->RunExclusive(SyncTaskToken::WrapToCallback(token.Pass()));
+    task->RunExclusive(SyncTaskToken::WrapToCallback(std::move(token)));
 }
 
 }  // namespace
@@ -30,7 +32,7 @@ void ExclusiveTask::RunPreflight(scoped_ptr<SyncTaskToken> token) {
   task_blocker->exclusive = true;
 
   SyncTaskManager::UpdateTaskBlocker(
-      token.Pass(), task_blocker.Pass(),
+      std::move(token), std::move(task_blocker),
       base::Bind(&CallRunExclusive, weak_ptr_factory_.GetWeakPtr()));
 }
 
diff --git a/chrome/browser/sync_file_system/drive_backend/sync_task_manager.cc b/chrome/browser/sync_file_system/drive_backend/sync_task_manager.cc
index a576262..785f9a0 100644
--- a/chrome/browser/sync_file_system/drive_backend/sync_task_manager.cc
+++ b/chrome/browser/sync_file_system/drive_backend/sync_task_manager.cc
@@ -4,6 +4,8 @@
 
 #include "chrome/browser/sync_file_system/drive_backend/sync_task_manager.h"
 
+#include <utility>
+
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/macros.h"
@@ -112,7 +114,7 @@ void SyncTaskManager::ScheduleSyncTask(
         priority);
     return;
   }
-  RunTask(token.Pass(), task.Pass());
+  RunTask(std::move(token), std::move(task));
 }
 
 bool SyncTaskManager::ScheduleTaskIfIdle(
@@ -136,7 +138,7 @@ bool SyncTaskManager::ScheduleSyncTaskIfIdle(
   scoped_ptr<SyncTaskToken> token(GetToken(from_here, callback));
   if (!token)
     return false;
-  RunTask(token.Pass(), task.Pass());
+  RunTask(std::move(token), std::move(task));
   return true;
 }
 
@@ -155,7 +157,7 @@ void SyncTaskManager::NotifyTaskDone(scoped_ptr<SyncTaskToken> token,
   }
 
   if (manager)
-    manager->NotifyTaskDoneBody(token.Pass(), status);
+    manager->NotifyTaskDoneBody(std::move(token), status);
 }
 
 // static
@@ -168,7 +170,7 @@ void SyncTaskManager::UpdateTaskBlocker(
   SyncTaskManager* manager = current_task_token->manager();
   if (current_task_token->token_id() == SyncTaskToken::kTestingTaskTokenID) {
     DCHECK(!manager);
-    continuation.Run(current_task_token.Pass());
+    continuation.Run(std::move(current_task_token));
     return;
   }
 
@@ -179,15 +181,13 @@ void SyncTaskManager::UpdateTaskBlocker(
   scoped_ptr<SyncTaskToken> background_task_token;
   scoped_ptr<TaskLogger::TaskLog> task_log = current_task_token->PassTaskLog();
   if (current_task_token->token_id() == SyncTaskToken::kForegroundTaskTokenID)
-    foreground_task_token = current_task_token.Pass();
+    foreground_task_token = std::move(current_task_token);
   else
-    background_task_token = current_task_token.Pass();
+    background_task_token = std::move(current_task_token);
 
-  manager->UpdateTaskBlockerBody(foreground_task_token.Pass(),
-                                 background_task_token.Pass(),
-                                 task_log.Pass(),
-                                 task_blocker.Pass(),
-                                 continuation);
+  manager->UpdateTaskBlockerBody(
+      std::move(foreground_task_token), std::move(background_task_token),
+      std::move(task_log), std::move(task_blocker), continuation);
 }
 
 bool SyncTaskManager::IsRunningTask(int64_t token_id) const {
@@ -236,14 +236,14 @@ void SyncTaskManager::NotifyTaskDoneBody(scoped_ptr<SyncTaskToken> token,
   SyncStatusCallback callback = token->callback();
   token->clear_callback();
   if (token->token_id() == SyncTaskToken::kForegroundTaskTokenID) {
-    token_ = token.Pass();
-    task = running_foreground_task_.Pass();
+    token_ = std::move(token);
+    task = std::move(running_foreground_task_);
   } else {
     task = running_background_tasks_.take_and_erase(token->token_id());
   }
 
   // Acquire the token to prevent a new task to jump into the queue.
-  token = token_.Pass();
+  token = std::move(token_);
 
   bool task_used_network = false;
   if (task)
@@ -275,8 +275,8 @@ void SyncTaskManager::UpdateTaskBlockerBody(
   if (!maximum_background_task_) {
     DCHECK(foreground_task_token);
     DCHECK(!background_task_token);
-    foreground_task_token->SetTaskLog(task_log.Pass());
-    continuation.Run(foreground_task_token.Pass());
+    foreground_task_token->SetTaskLog(std::move(task_log));
+    continuation.Run(std::move(foreground_task_token));
     return;
   }
 
@@ -332,26 +332,24 @@ void SyncTaskManager::UpdateTaskBlockerBody(
   }
 
   if (background_task_token) {
-    background_task_token->set_task_blocker(task_blocker.Pass());
+    background_task_token->set_task_blocker(std::move(task_blocker));
   } else {
     tracked_objects::Location from_here = foreground_task_token->location();
     SyncStatusCallback callback = foreground_task_token->callback();
     foreground_task_token->clear_callback();
 
-    background_task_token =
-        SyncTaskToken::CreateForBackgroundTask(weak_ptr_factory_.GetWeakPtr(),
-                                               task_runner_.get(),
-                                               task_token_seq_++,
-                                               task_blocker.Pass());
+    background_task_token = SyncTaskToken::CreateForBackgroundTask(
+        weak_ptr_factory_.GetWeakPtr(), task_runner_.get(), task_token_seq_++,
+        std::move(task_blocker));
     background_task_token->UpdateTask(from_here, callback);
     running_background_tasks_.set(background_task_token->token_id(),
-                                  running_foreground_task_.Pass());
+                                  std::move(running_foreground_task_));
   }
 
-  token_ = foreground_task_token.Pass();
+  token_ = std::move(foreground_task_token);
   MaybeStartNextForegroundTask(nullptr);
-  background_task_token->SetTaskLog(task_log.Pass());
-  continuation.Run(background_task_token.Pass());
+  background_task_token->SetTaskLog(std::move(task_log));
+  continuation.Run(std::move(background_task_token));
 }
 
 scoped_ptr<SyncTaskToken> SyncTaskManager::GetToken(
@@ -362,7 +360,7 @@ scoped_ptr<SyncTaskToken> SyncTaskManager::GetToken(
   if (!token_)
     return nullptr;
   token_->UpdateTask(from_here, callback);
-  return token_.Pass();
+  return std::move(token_);
 }
 
 void SyncTaskManager::PushPendingTask(
@@ -377,8 +375,8 @@ void SyncTaskManager::RunTask(scoped_ptr<SyncTaskToken> token,
   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
   DCHECK(!running_foreground_task_);
 
-  running_foreground_task_ = task.Pass();
-  running_foreground_task_->RunPreflight(token.Pass());
+  running_foreground_task_ = std::move(task);
+  running_foreground_task_->RunPreflight(std::move(token));
 }
 
 void SyncTaskManager::MaybeStartNextForegroundTask(
@@ -387,7 +385,7 @@ void SyncTaskManager::MaybeStartNextForegroundTask(
 
   if (token) {
     DCHECK(!token_);
-    token_ = token.Pass();
+    token_ = std::move(token);
   }
 
   if (!pending_backgrounding_task_.is_null()) {
diff --git a/chrome/browser/sync_file_system/drive_backend/sync_task_manager_unittest.cc b/chrome/browser/sync_file_system/drive_backend/sync_task_manager_unittest.cc
index c7ee44e..ccf3616 100644
--- a/chrome/browser/sync_file_system/drive_backend/sync_task_manager_unittest.cc
+++ b/chrome/browser/sync_file_system/drive_backend/sync_task_manager_unittest.cc
@@ -2,10 +2,12 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include <stdint.h>
+#include "chrome/browser/sync_file_system/drive_backend/sync_task_manager.h"
 
+#include <stdint.h>
 #include <deque>
 #include <string>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/location.h"
@@ -16,7 +18,6 @@
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "chrome/browser/sync_file_system/drive_backend/sync_task.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"
 #include "chrome/browser/sync_file_system/sync_file_system_test_util.h"
 #include "storage/common/fileapi/file_system_util.h"
@@ -198,7 +199,7 @@ class BackgroundTask : public SyncTask {
     task_blocker->paths.push_back(path_);
 
     SyncTaskManager::UpdateTaskBlocker(
-        token.Pass(), task_blocker.Pass(),
+        std::move(token), std::move(task_blocker),
         base::Bind(&BackgroundTask::RunAsBackgroundTask,
                    weak_ptr_factory_.GetWeakPtr()));
   }
@@ -218,7 +219,7 @@ class BackgroundTask : public SyncTask {
   void CompleteTask(scoped_ptr<SyncTaskToken> token) {
     ++(stats_->finished_task);
     --(stats_->running_background_task);
-    SyncTaskManager::NotifyTaskDone(token.Pass(), SYNC_STATUS_OK);
+    SyncTaskManager::NotifyTaskDone(std::move(token), SYNC_STATUS_OK);
   }
 
   std::string app_id_;
@@ -248,14 +249,14 @@ class BlockerUpdateTestHelper : public SyncTask {
   ~BlockerUpdateTestHelper() override {}
 
   void RunPreflight(scoped_ptr<SyncTaskToken> token) override {
-    UpdateBlocker(token.Pass());
+    UpdateBlocker(std::move(token));
   }
 
  private:
   void UpdateBlocker(scoped_ptr<SyncTaskToken> token) {
     if (paths_.empty()) {
       log_->push_back(name_ + ": finished");
-      SyncTaskManager::NotifyTaskDone(token.Pass(), SYNC_STATUS_OK);
+      SyncTaskManager::NotifyTaskDone(std::move(token), SYNC_STATUS_OK);
       return;
     }
 
@@ -271,10 +272,9 @@ class BlockerUpdateTestHelper : public SyncTask {
             base::FilePath::FromUTF8Unsafe(updating_to))));
 
     SyncTaskManager::UpdateTaskBlocker(
-        token.Pass(), task_blocker.Pass(),
+        std::move(token), std::move(task_blocker),
         base::Bind(&BlockerUpdateTestHelper::UpdateBlockerSoon,
-                   weak_ptr_factory_.GetWeakPtr(),
-                   updating_to));
+                   weak_ptr_factory_.GetWeakPtr(), updating_to));
   }
 
   void UpdateBlockerSoon(const std::string& updated_to,
diff --git a/chrome/browser/sync_file_system/drive_backend/sync_task_token.cc b/chrome/browser/sync_file_system/drive_backend/sync_task_token.cc
index 32cb4e4..b7f730a 100644
--- a/chrome/browser/sync_file_system/drive_backend/sync_task_token.cc
+++ b/chrome/browser/sync_file_system/drive_backend/sync_task_token.cc
@@ -4,6 +4,8 @@
 
 #include "chrome/browser/sync_file_system/drive_backend/sync_task_token.h"
 
+#include <utility>
+
 #include "base/bind.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/trace_event/trace_event.h"
@@ -46,12 +48,9 @@ scoped_ptr<SyncTaskToken> SyncTaskToken::CreateForBackgroundTask(
     base::SequencedTaskRunner* task_runner,
     int64_t token_id,
     scoped_ptr<TaskBlocker> task_blocker) {
-  return make_scoped_ptr(new SyncTaskToken(
-      manager,
-      task_runner,
-      token_id,
-      task_blocker.Pass(),
-      SyncStatusCallback()));
+  return make_scoped_ptr(new SyncTaskToken(manager, task_runner, token_id,
+                                           std::move(task_blocker),
+                                           SyncStatusCallback()));
 }
 
 void SyncTaskToken::UpdateTask(const tracked_objects::Location& location,
@@ -78,10 +77,8 @@ SyncTaskToken::~SyncTaskToken() {
 
     // Reinitializes the token.
     SyncTaskManager::NotifyTaskDone(
-        make_scoped_ptr(new SyncTaskToken(manager_,
-                                          task_runner_.get(),
-                                          token_id_,
-                                          task_blocker_.Pass(),
+        make_scoped_ptr(new SyncTaskToken(manager_, task_runner_.get(),
+                                          token_id_, std::move(task_blocker_),
                                           SyncStatusCallback())),
         SYNC_STATUS_OK);
   }
@@ -95,7 +92,7 @@ SyncStatusCallback SyncTaskToken::WrapToCallback(
 
 void SyncTaskToken::set_task_blocker(
     scoped_ptr<TaskBlocker> task_blocker) {
-  task_blocker_ = task_blocker.Pass();
+  task_blocker_ = std::move(task_blocker);
 }
 
 const TaskBlocker* SyncTaskToken::task_blocker() const {
@@ -134,11 +131,11 @@ void SyncTaskToken::RecordLog(const std::string& message) {
 }
 
 void SyncTaskToken::SetTaskLog(scoped_ptr<TaskLogger::TaskLog> task_log) {
-  task_log_ = task_log.Pass();
+  task_log_ = std::move(task_log);
 }
 
 scoped_ptr<TaskLogger::TaskLog> SyncTaskToken::PassTaskLog() {
-  return task_log_.Pass();
+  return std::move(task_log_);
 }
 
 SyncTaskToken::SyncTaskToken(
@@ -151,7 +148,7 @@ SyncTaskToken::SyncTaskToken(
       task_runner_(task_runner),
       token_id_(token_id),
       callback_(callback),
-      task_blocker_(task_blocker.Pass()) {}
+      task_blocker_(std::move(task_blocker)) {}
 
 }  // namespace drive_backend
 }  // namespace sync_file_system
diff --git a/chrome/browser/sync_file_system/drive_backend/sync_worker.cc b/chrome/browser/sync_file_system/drive_backend/sync_worker.cc
index 1cb1c4e..f7b67b2 100644
--- a/chrome/browser/sync_file_system/drive_backend/sync_worker.cc
+++ b/chrome/browser/sync_file_system/drive_backend/sync_worker.cc
@@ -4,6 +4,7 @@
 
 #include "chrome/browser/sync_file_system/drive_backend/sync_worker.h"
 
+#include <utility>
 #include <vector>
 
 #include "base/bind.h"
@@ -69,7 +70,7 @@ 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 */,
@@ -95,8 +96,8 @@ void SyncWorker::RegisterOrigin(
     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(
@@ -190,7 +191,7 @@ void SyncWorker::GetOriginStatusMap(
         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) {
@@ -395,7 +396,7 @@ void SyncWorker::DidInitialize(SyncEngineInitializer* initializer,
   scoped_ptr<MetadataDatabase> metadata_database =
       initializer->PassMetadataDatabase();
   if (metadata_database) {
-    context_->SetMetadataDatabase(metadata_database.Pass());
+    context_->SetMetadataDatabase(std::move(metadata_database));
     return;
   }
 
diff --git a/chrome/browser/sync_file_system/drive_backend/sync_worker_unittest.cc b/chrome/browser/sync_file_system/drive_backend/sync_worker_unittest.cc
index a8754d2..8555077 100644
--- a/chrome/browser/sync_file_system/drive_backend/sync_worker_unittest.cc
+++ b/chrome/browser/sync_file_system/drive_backend/sync_worker_unittest.cc
@@ -4,6 +4,8 @@
 
 #include "chrome/browser/sync_file_system/drive_backend/sync_worker.h"
 
+#include <utility>
+
 #include "base/files/scoped_temp_dir.h"
 #include "base/location.h"
 #include "base/macros.h"
@@ -110,20 +112,18 @@ class SyncWorkerTest : public testing::Test,
     scoped_ptr<drive::DriveServiceInterface>
         fake_drive_service(new drive::FakeDriveService);
 
-    scoped_ptr<SyncEngineContext>
-        sync_engine_context(new SyncEngineContext(
-            fake_drive_service.Pass(),
-            nullptr /* drive_uploader */,
-            nullptr /* task_logger */,
-            base::ThreadTaskRunnerHandle::Get() /* ui_task_runner */,
-            base::ThreadTaskRunnerHandle::Get() /* worker_task_runner */,
-            nullptr /* worker_pool */));
+    scoped_ptr<SyncEngineContext> sync_engine_context(new SyncEngineContext(
+        std::move(fake_drive_service), nullptr /* drive_uploader */,
+        nullptr /* task_logger */,
+        base::ThreadTaskRunnerHandle::Get() /* ui_task_runner */,
+        base::ThreadTaskRunnerHandle::Get() /* worker_task_runner */,
+        nullptr /* worker_pool */));
 
     sync_worker_.reset(new SyncWorker(
         profile_dir_.path(),
         extension_service_->AsWeakPtr(),
         in_memory_env_.get()));
-    sync_worker_->Initialize(sync_engine_context.Pass());
+    sync_worker_->Initialize(std::move(sync_engine_context));
 
     sync_worker_->SetSyncEnabled(true);
     base::RunLoop().RunUntilIdle();
diff --git a/chrome/browser/sync_file_system/local/canned_syncable_file_system.cc b/chrome/browser/sync_file_system/local/canned_syncable_file_system.cc
index efe1107..309a53a 100644
--- a/chrome/browser/sync_file_system/local/canned_syncable_file_system.cc
+++ b/chrome/browser/sync_file_system/local/canned_syncable_file_system.cc
@@ -5,9 +5,9 @@
 #include "chrome/browser/sync_file_system/local/canned_syncable_file_system.h"
 
 #include <stddef.h>
-
 #include <algorithm>
 #include <iterator>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ -258,14 +258,12 @@ void CannedSyncableFileSystem::SetUp(QuotaMode quota_mode) {
   additional_backends.push_back(SyncFileSystemBackend::CreateForTesting());
 
   file_system_context_ = new FileSystemContext(
-      io_task_runner_.get(),
-      file_task_runner_.get(),
+      io_task_runner_.get(), file_task_runner_.get(),
       storage::ExternalMountPoints::CreateRefCounted().get(),
       storage_policy.get(),
       quota_manager_.get() ? quota_manager_->proxy() : nullptr,
-      additional_backends.Pass(),
-      std::vector<storage::URLRequestAutoMountHandler>(),
-      data_dir_.path(),
+      std::move(additional_backends),
+      std::vector<storage::URLRequestAutoMountHandler>(), data_dir_.path(),
       options);
 
   is_filesystem_set_up_ = true;
@@ -692,10 +690,9 @@ void CannedSyncableFileSystem::DoWrite(
   EXPECT_TRUE(io_task_runner_->RunsTasksOnCurrentThread());
   EXPECT_TRUE(is_filesystem_opened_);
   WriteHelper* helper = new WriteHelper;
-  operation_runner()->Write(url_request_context, url,
-                            blob_data_handle.Pass(), 0,
-                            base::Bind(&WriteHelper::DidWrite,
-                                       base::Owned(helper), callback));
+  operation_runner()->Write(
+      url_request_context, url, std::move(blob_data_handle), 0,
+      base::Bind(&WriteHelper::DidWrite, base::Owned(helper), callback));
 }
 
 void CannedSyncableFileSystem::DoWriteString(
diff --git a/chrome/browser/sync_file_system/local/local_file_change_tracker.cc b/chrome/browser/sync_file_system/local/local_file_change_tracker.cc
index e67d97b..8333430 100644
--- a/chrome/browser/sync_file_system/local/local_file_change_tracker.cc
+++ b/chrome/browser/sync_file_system/local/local_file_change_tracker.cc
@@ -5,8 +5,8 @@
 #include "chrome/browser/sync_file_system/local/local_file_change_tracker.h"
 
 #include <stddef.h>
-
 #include <queue>
+#include <utility>
 
 #include "base/location.h"
 #include "base/logging.h"
@@ -302,7 +302,7 @@ void LocalFileChangeTracker::ResetForFileSystem(const GURL& origin,
 
   // Fail to apply batch to database wouldn't have critical effect, they'll be
   // just marked deleted on next relaunch.
-  tracker_db_->WriteBatch(batch.Pass());
+  tracker_db_->WriteBatch(std::move(batch));
   UpdateNumChanges();
 }
 
diff --git a/chrome/browser/sync_file_system/local/local_file_sync_context.cc b/chrome/browser/sync_file_system/local/local_file_sync_context.cc
index 2d3cfbb..d0b9aa6 100644
--- a/chrome/browser/sync_file_system/local/local_file_sync_context.cc
+++ b/chrome/browser/sync_file_system/local/local_file_sync_context.cc
@@ -4,6 +4,8 @@
 
 #include "chrome/browser/sync_file_system/local/local_file_sync_context.h"
 
+#include <utility>
+
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/location.h"
@@ -739,7 +741,7 @@ void LocalFileSyncContext::DidInitializeChangeTrackerOnIOThread(
   SyncFileSystemBackend* backend =
       SyncFileSystemBackend::GetBackend(file_system_context);
   DCHECK(backend);
-  backend->SetLocalFileChangeTracker(tracker_ptr->Pass());
+  backend->SetLocalFileChangeTracker(std::move(*tracker_ptr));
 
   origins_with_pending_changes_.insert(origins_with_changes->begin(),
                                        origins_with_changes->end());
@@ -799,7 +801,7 @@ LocalFileSyncContext::GetNextURLsForSyncOnFileThread(
        iter != urls->end(); ++iter)
     backend->change_tracker()->DemoteChangesForURL(*iter);
 
-  return urls.Pass();
+  return urls;
 }
 
 void LocalFileSyncContext::TryPrepareForLocalSync(
@@ -841,15 +843,16 @@ void LocalFileSyncContext::DidTryPrepareForLocalSync(
   DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
   if (status != SYNC_STATUS_FILE_BUSY) {
     PromoteDemotedChangesForURLs(file_system_context,
-                                 remaining_urls.Pass());
-    callback.Run(status, sync_file_info, snapshot.Pass());
+                                 std::move(remaining_urls));
+    callback.Run(status, sync_file_info, std::move(snapshot));
     return;
   }
 
   PromoteDemotedChangesForURL(file_system_context, sync_file_info.url);
 
   // Recursively call TryPrepareForLocalSync with remaining_urls.
-  TryPrepareForLocalSync(file_system_context, callback, remaining_urls.Pass());
+  TryPrepareForLocalSync(file_system_context, callback,
+                         std::move(remaining_urls));
 }
 
 void LocalFileSyncContext::PromoteDemotedChangesForURL(
diff --git a/chrome/browser/sync_file_system/local/local_file_sync_context_unittest.cc b/chrome/browser/sync_file_system/local/local_file_sync_context_unittest.cc
index bcca037..e09596e 100644
--- a/chrome/browser/sync_file_system/local/local_file_sync_context_unittest.cc
+++ b/chrome/browser/sync_file_system/local/local_file_sync_context_unittest.cc
@@ -5,7 +5,7 @@
 #include "chrome/browser/sync_file_system/local/local_file_sync_context.h"
 
 #include <stdint.h>
-
+#include <utility>
 #include <vector>
 
 #include "base/bind.h"
@@ -134,7 +134,7 @@ class LocalFileSyncContextTest : public testing::Test {
     *metadata_out = sync_file_info.metadata;
     *changes_out = sync_file_info.changes;
     if (snapshot_out)
-      *snapshot_out = snapshot.Pass();
+      *snapshot_out = std::move(snapshot);
     base::MessageLoop::current()->QuitWhenIdle();
   }
 
diff --git a/chrome/browser/sync_file_system/local/local_file_sync_service.cc b/chrome/browser/sync_file_system/local/local_file_sync_service.cc
index d28c141..d9904fb 100644
--- a/chrome/browser/sync_file_system/local/local_file_sync_service.cc
+++ b/chrome/browser/sync_file_system/local/local_file_sync_service.cc
@@ -117,7 +117,7 @@ scoped_ptr<LocalFileSyncService> LocalFileSyncService::CreateForTesting(
   scoped_ptr<LocalFileSyncService> sync_service(
       new LocalFileSyncService(profile, env));
   sync_service->sync_context_->set_mock_notify_changes_duration_in_sec(0);
-  return sync_service.Pass();
+  return sync_service;
 }
 
 LocalFileSyncService::~LocalFileSyncService() {
diff --git a/chrome/browser/sync_file_system/local/sync_file_system_backend.cc b/chrome/browser/sync_file_system/local/sync_file_system_backend.cc
index fbb9444..cd67ac1 100644
--- a/chrome/browser/sync_file_system/local/sync_file_system_backend.cc
+++ b/chrome/browser/sync_file_system/local/sync_file_system_backend.cc
@@ -5,6 +5,7 @@
 #include "chrome/browser/sync_file_system/local/sync_file_system_backend.h"
 
 #include <string>
+#include <utility>
 
 #include "base/logging.h"
 #include "chrome/browser/chrome_notification_types.h"
@@ -168,12 +169,12 @@ storage::FileSystemOperation* SyncFileSystemBackend::CreateFileSystemOperation(
     return nullptr;
 
   if (url.type() == storage::kFileSystemTypeSyncableForInternalSync) {
-    return storage::FileSystemOperation::Create(
-        url, context, operation_context.Pass());
+    return storage::FileSystemOperation::Create(url, context,
+                                                std::move(operation_context));
   }
 
-  return new SyncableFileSystemOperation(
-      url, context, operation_context.Pass());
+  return new SyncableFileSystemOperation(url, context,
+                                         std::move(operation_context));
 }
 
 bool SyncFileSystemBackend::SupportsStreaming(
@@ -240,7 +241,7 @@ void SyncFileSystemBackend::SetLocalFileChangeTracker(
     scoped_ptr<LocalFileChangeTracker> tracker) {
   DCHECK(!change_tracker_);
   DCHECK(tracker);
-  change_tracker_ = tracker.Pass();
+  change_tracker_ = std::move(tracker);
 
   storage::SandboxFileSystemBackendDelegate* delegate = GetDelegate();
   delegate->AddFileUpdateObserver(storage::kFileSystemTypeSyncable,
diff --git a/chrome/browser/sync_file_system/local/syncable_file_system_operation.cc b/chrome/browser/sync_file_system/local/syncable_file_system_operation.cc
index 56243ee..d7ebcb4 100644
--- a/chrome/browser/sync_file_system/local/syncable_file_system_operation.cc
+++ b/chrome/browser/sync_file_system/local/syncable_file_system_operation.cc
@@ -4,6 +4,8 @@
 
 #include "chrome/browser/sync_file_system/local/syncable_file_system_operation.h"
 
+#include <utility>
+
 #include "base/logging.h"
 #include "base/macros.h"
 #include "chrome/browser/sync_file_system/local/local_file_sync_context.h"
@@ -90,7 +92,7 @@ void SyncableFileSystemOperation::CreateFile(
                  base::Unretained(impl_.get()),
                  url, exclusive,
                  base::Bind(&self::DidFinish, weak_factory_.GetWeakPtr()))));
-  operation_runner_->PostOperationTask(task.Pass());
+  operation_runner_->PostOperationTask(std::move(task));
 }
 
 void SyncableFileSystemOperation::CreateDirectory(
@@ -112,7 +114,7 @@ void SyncableFileSystemOperation::CreateDirectory(
                  base::Unretained(impl_.get()),
                  url, exclusive, recursive,
                  base::Bind(&self::DidFinish, weak_factory_.GetWeakPtr()))));
-  operation_runner_->PostOperationTask(task.Pass());
+  operation_runner_->PostOperationTask(std::move(task));
 }
 
 void SyncableFileSystemOperation::Copy(
@@ -135,7 +137,7 @@ void SyncableFileSystemOperation::Copy(
       base::Bind(&FileSystemOperation::Copy, base::Unretained(impl_.get()),
                  src_url, dest_url, option, error_behavior, progress_callback,
                  base::Bind(&self::DidFinish, weak_factory_.GetWeakPtr()))));
-  operation_runner_->PostOperationTask(task.Pass());
+  operation_runner_->PostOperationTask(std::move(task));
 }
 
 void SyncableFileSystemOperation::Move(
@@ -158,7 +160,7 @@ void SyncableFileSystemOperation::Move(
                  base::Unretained(impl_.get()),
                  src_url, dest_url, option,
                  base::Bind(&self::DidFinish, weak_factory_.GetWeakPtr()))));
-  operation_runner_->PostOperationTask(task.Pass());
+  operation_runner_->PostOperationTask(std::move(task));
 }
 
 void SyncableFileSystemOperation::DirectoryExists(
@@ -210,7 +212,7 @@ void SyncableFileSystemOperation::Remove(
                  base::Unretained(impl_.get()),
                  url, recursive,
                  base::Bind(&self::DidFinish, weak_factory_.GetWeakPtr()))));
-  operation_runner_->PostOperationTask(task.Pass());
+  operation_runner_->PostOperationTask(std::move(task));
 }
 
 void SyncableFileSystemOperation::Write(
@@ -235,7 +237,7 @@ void SyncableFileSystemOperation::Write(
                  base::Passed(&blob_request),
                  base::Bind(&self::DidWrite, weak_factory_.GetWeakPtr(),
                             callback))));
-  operation_runner_->PostOperationTask(task.Pass());
+  operation_runner_->PostOperationTask(std::move(task));
 }
 
 void SyncableFileSystemOperation::Truncate(const FileSystemURL& url,
@@ -255,7 +257,7 @@ void SyncableFileSystemOperation::Truncate(const FileSystemURL& url,
                  base::Unretained(impl_.get()),
                  url, length,
                  base::Bind(&self::DidFinish, weak_factory_.GetWeakPtr()))));
-  operation_runner_->PostOperationTask(task.Pass());
+  operation_runner_->PostOperationTask(std::move(task));
 }
 
 void SyncableFileSystemOperation::TouchFile(
@@ -305,7 +307,7 @@ void SyncableFileSystemOperation::CopyInForeignFile(
                  base::Unretained(impl_.get()),
                  src_local_disk_path, dest_url,
                  base::Bind(&self::DidFinish, weak_factory_.GetWeakPtr()))));
-  operation_runner_->PostOperationTask(task.Pass());
+  operation_runner_->PostOperationTask(std::move(task));
 }
 
 void SyncableFileSystemOperation::RemoveFile(
@@ -363,7 +365,7 @@ SyncableFileSystemOperation::SyncableFileSystemOperation(
     return;
   }
   impl_.reset(storage::FileSystemOperation::Create(
-      url_, file_system_context, operation_context.Pass()));
+      url_, file_system_context, std::move(operation_context)));
   operation_runner_ = backend->sync_context()->operation_runner();
 }
 
diff --git a/chrome/browser/sync_file_system/sync_file_system_service.cc b/chrome/browser/sync_file_system/sync_file_system_service.cc
index 8a74b0a..85d6f33 100644
--- a/chrome/browser/sync_file_system/sync_file_system_service.cc
+++ b/chrome/browser/sync_file_system/sync_file_system_service.cc
@@ -6,8 +6,8 @@
 
 #include <stddef.h>
 #include <stdint.h>
-
 #include <string>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/format_macros.h"
@@ -455,8 +455,8 @@ void SyncFileSystemService::Initialize(
   DCHECK(remote_service);
   DCHECK(profile_);
 
-  local_service_ = local_service.Pass();
-  remote_service_ = remote_service.Pass();
+  local_service_ = std::move(local_service);
+  remote_service_ = std::move(remote_service);
 
   scoped_ptr<LocalSyncRunner> local_syncer(
       new LocalSyncRunner(kLocalSyncName, this));
diff --git a/chrome/browser/sync_file_system/sync_file_system_service_factory.cc b/chrome/browser/sync_file_system/sync_file_system_service_factory.cc
index 410f7d1..0730652 100644
--- a/chrome/browser/sync_file_system/sync_file_system_service_factory.cc
+++ b/chrome/browser/sync_file_system/sync_file_system_service_factory.cc
@@ -5,6 +5,7 @@
 #include "chrome/browser/sync_file_system/sync_file_system_service_factory.h"
 
 #include <set>
+#include <utility>
 
 #include "base/command_line.h"
 #include "chrome/browser/profiles/profile.h"
@@ -30,12 +31,12 @@ SyncFileSystemServiceFactory* SyncFileSystemServiceFactory::GetInstance() {
 
 void SyncFileSystemServiceFactory::set_mock_local_file_service(
     scoped_ptr<LocalFileSyncService> mock_local_service) {
-  mock_local_file_service_ = mock_local_service.Pass();
+  mock_local_file_service_ = std::move(mock_local_service);
 }
 
 void SyncFileSystemServiceFactory::set_mock_remote_file_service(
     scoped_ptr<RemoteFileSyncService> mock_remote_service) {
-  mock_remote_file_service_ = mock_remote_service.Pass();
+  mock_remote_file_service_ = std::move(mock_remote_service);
 }
 
 SyncFileSystemServiceFactory::SyncFileSystemServiceFactory()
@@ -63,20 +64,20 @@ KeyedService* SyncFileSystemServiceFactory::BuildServiceInstanceFor(
 
   scoped_ptr<LocalFileSyncService> local_file_service;
   if (mock_local_file_service_)
-    local_file_service = mock_local_file_service_.Pass();
+    local_file_service = std::move(mock_local_file_service_);
   else
     local_file_service = LocalFileSyncService::Create(profile);
 
   scoped_ptr<RemoteFileSyncService> remote_file_service;
   if (mock_remote_file_service_) {
-    remote_file_service = mock_remote_file_service_.Pass();
+    remote_file_service = std::move(mock_remote_file_service_);
   } else {
     remote_file_service = RemoteFileSyncService::CreateForBrowserContext(
         context, service->task_logger());
   }
 
-  service->Initialize(local_file_service.Pass(),
-                      remote_file_service.Pass());
+  service->Initialize(std::move(local_file_service),
+                      std::move(remote_file_service));
   return service;
 }
 
diff --git a/chrome/browser/sync_file_system/sync_file_system_service_unittest.cc b/chrome/browser/sync_file_system/sync_file_system_service_unittest.cc
index 5c61fe1..6cb5911 100644
--- a/chrome/browser/sync_file_system/sync_file_system_service_unittest.cc
+++ b/chrome/browser/sync_file_system/sync_file_system_service_unittest.cc
@@ -2,8 +2,10 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include <stddef.h>
+#include "chrome/browser/sync_file_system/sync_file_system_service.h"
 
+#include <stddef.h>
+#include <utility>
 #include <vector>
 
 #include "base/bind.h"
@@ -21,7 +23,6 @@
 #include "chrome/browser/sync_file_system/sync_callbacks.h"
 #include "chrome/browser/sync_file_system/sync_event_observer.h"
 #include "chrome/browser/sync_file_system/sync_file_metadata.h"
-#include "chrome/browser/sync_file_system/sync_file_system_service.h"
 #include "chrome/browser/sync_file_system/sync_file_system_test_util.h"
 #include "chrome/browser/sync_file_system/sync_status_code.h"
 #include "chrome/browser/sync_file_system/syncable_file_system_util.h"
@@ -156,7 +157,7 @@ class SyncFileSystemServiceTest : public testing::Test {
                 SetRemoteChangeProcessor(local_service.get())).Times(1);
 
     sync_service_->Initialize(
-        local_service.Pass(),
+        std::move(local_service),
         scoped_ptr<RemoteFileSyncService>(remote_service_));
 
     // Disable auto sync by default.
diff --git a/chrome/browser/sync_file_system/sync_process_runner.cc b/chrome/browser/sync_file_system/sync_process_runner.cc
index 42078fd..39de004 100644
--- a/chrome/browser/sync_file_system/sync_process_runner.cc
+++ b/chrome/browser/sync_file_system/sync_process_runner.cc
@@ -4,6 +4,8 @@
 
 #include "chrome/browser/sync_file_system/sync_process_runner.h"
 
+#include <utility>
+
 #include "base/format_macros.h"
 #include "base/macros.h"
 #include "chrome/browser/sync_file_system/logger.h"
@@ -56,16 +58,15 @@ bool WasSuccessfulSync(SyncStatusCode status) {
 
 }  // namespace
 
-SyncProcessRunner::SyncProcessRunner(
-    const std::string& name,
-    Client* client,
-    scoped_ptr<TimerHelper> timer_helper,
-    size_t max_parallel_task)
+SyncProcessRunner::SyncProcessRunner(const std::string& name,
+                                     Client* client,
+                                     scoped_ptr<TimerHelper> timer_helper,
+                                     size_t max_parallel_task)
     : name_(name),
       client_(client),
       max_parallel_task_(max_parallel_task),
       running_tasks_(0),
-      timer_helper_(timer_helper.Pass()),
+      timer_helper_(std::move(timer_helper)),
       service_state_(SYNC_SERVICE_RUNNING),
       pending_changes_(0),
       factory_(this) {
diff --git a/chrome/browser/sync_file_system/sync_process_runner_unittest.cc b/chrome/browser/sync_file_system/sync_process_runner_unittest.cc
index d123142..3f73df8 100644
--- a/chrome/browser/sync_file_system/sync_process_runner_unittest.cc
+++ b/chrome/browser/sync_file_system/sync_process_runner_unittest.cc
@@ -6,8 +6,8 @@
 
 #include <stddef.h>
 #include <stdint.h>
-
 #include <queue>
+#include <utility>
 
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
@@ -85,10 +85,10 @@ class FakeSyncProcessRunner : public SyncProcessRunner {
                         scoped_ptr<TimerHelper> timer_helper,
                         size_t max_parallel_task)
       : SyncProcessRunner("FakeSyncProcess",
-                          client, timer_helper.Pass(),
+                          client,
+                          std::move(timer_helper),
                           max_parallel_task),
-        max_parallel_task_(max_parallel_task) {
-  }
+        max_parallel_task_(max_parallel_task) {}
 
   void StartSync(const SyncStatusCallback& callback) override {
     EXPECT_LT(running_tasks_.size(), max_parallel_task_);