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

chrome/browser/sync_file_system/drive_backend/metadata_database.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/sync_file_system/drive_backend/metadata_database.h"
 
 #include <algorithm>
 #include <stack>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/memory/scoped_vector.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
@@ skipping 97 matching lines @@
     int64_t change_id,
     const google_apis::FileResource& resource) {
   scoped_ptr<FileMetadata> file(new FileMetadata);
   file->set_file_id(resource.file_id());
 
   FileDetails* details = file->mutable_details();
   details->set_change_id(change_id);
 
   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(
     const google_apis::ChangeResource& change) {
   scoped_ptr<FileMetadata> file(new FileMetadata);
   file->set_file_id(change.file_id());
 
   FileDetails* details = file->mutable_details();
   details->set_change_id(change.change_id());
 
   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,
                                                    const std::string& file_id) {
   scoped_ptr<FileMetadata> file(new FileMetadata);
   file->set_file_id(file_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(
     int64_t tracker_id,
     const FileMetadata& sync_root_metadata) {
   scoped_ptr<FileTracker> sync_root_tracker(new FileTracker);
   sync_root_tracker->set_tracker_id(tracker_id);
   sync_root_tracker->set_file_id(sync_root_metadata.file_id());
   sync_root_tracker->set_parent_tracker_id(0);
   sync_root_tracker->set_tracker_kind(TRACKER_KIND_REGULAR);
   sync_root_tracker->set_dirty(false);
   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(
     int64_t tracker_id,
     int64_t parent_tracker_id,
     const FileMetadata& app_root_metadata) {
   scoped_ptr<FileTracker> app_root_tracker(new FileTracker);
   app_root_tracker->set_tracker_id(tracker_id);
   app_root_tracker->set_parent_tracker_id(parent_tracker_id);
   app_root_tracker->set_file_id(app_root_metadata.file_id());
   app_root_tracker->set_tracker_kind(TRACKER_KIND_REGULAR);
   app_root_tracker->set_dirty(false);
   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) {
   if (!obj)
     return nullptr;
   return scoped_ptr<FileTracker>(new FileTracker(*obj));
 }
 
 // Returns true if |db| has no content.
 bool IsDatabaseEmpty(LevelDBWrapper* db) {
@@ skipping 83 matching lines @@
 
 void MarkTrackerSetDirty(const TrackerIDSet& trackers,
                          MetadataDatabaseIndexInterface* index) {
   for (TrackerIDSet::const_iterator itr = trackers.begin();
        itr != trackers.end(); ++itr) {
     scoped_ptr<FileTracker> tracker(new FileTracker);
     index->GetFileTracker(*itr, tracker.get());
     if (tracker->dirty())
       continue;
     tracker->set_dirty(true);
-    index->StoreFileTracker(tracker.Pass());
+    index->StoreFileTracker(std::move(tracker));
   }
 }
 
 void MarkTrackersDirtyByPath(int64_t parent_tracker_id,
                              const std::string& title,
                              MetadataDatabaseIndexInterface* index) {
   if (parent_tracker_id == kInvalidTrackerID || title.empty())
     return;
   MarkTrackerSetDirty(
       index->GetFileTrackerIDsByParentAndTitle(parent_tracker_id, title),
@@ skipping 11 matching lines @@
   stack.push_back(root_tracker_id);
   while (!stack.empty()) {
     int64_t tracker_id = stack.back();
     stack.pop_back();
     AppendContents(index->GetFileTrackerIDsByParent(tracker_id), &stack);
 
     scoped_ptr<FileTracker> tracker(new FileTracker);
     index->GetFileTracker(tracker_id, tracker.get());
     tracker->set_dirty(true);
 
-    index->StoreFileTracker(tracker.Pass());
+    index->StoreFileTracker(std::move(tracker));
   }
 }
 
 void RemoveAllDescendantTrackers(int64_t root_tracker_id,
                                  MetadataDatabaseIndexInterface* index) {
   std::vector<int64_t> pending_trackers;
   AppendContents(index->GetFileTrackerIDsByParent(root_tracker_id),
                  &pending_trackers);
 
   std::vector<int64_t> to_be_removed;
@@ skipping 127 matching lines @@
   if (dirtying_options & MARK_ITSELF_DIRTY) {
     tracker->set_dirty(true);
     tracker->set_needs_folder_listing(
         tracker->has_synced_details() &&
         tracker->synced_details().file_kind() == FILE_KIND_FOLDER);
   } else {
     tracker->set_dirty(false);
     tracker->set_needs_folder_listing(false);
   }
 
-  index->StoreFileTracker(tracker.Pass());
+  index->StoreFileTracker(std::move(tracker));
 }
 
 void DeactivateFileTracker(int64_t tracker_id,
                            int dirtying_options,
                            MetadataDatabaseIndexInterface* index) {
   RemoveAllDescendantTrackers(tracker_id, index);
 
   scoped_ptr<FileTracker> tracker(new FileTracker);
   index->GetFileTracker(tracker_id, tracker.get());
 
   if (dirtying_options & MARK_SAME_FILE_ID_TRACKERS_DIRTY)
     MarkTrackersDirtyByFileID(tracker->file_id(), index);
   if (dirtying_options & MARK_SAME_PATH_TRACKERS_DIRTY) {
     MarkTrackersDirtyByPath(tracker->parent_tracker_id(),
                             GetTrackerTitle(*tracker), index);
   }
 
   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,
                        int dirtying_options,
                        MetadataDatabaseIndexInterface* index) {
   DCHECK(!(dirtying_options & MARK_ITSELF_DIRTY));
 
   FileTracker tracker;
   if (!index->GetFileTracker(tracker_id, &tracker))
     return;
@@ skipping 50 matching lines @@
         new MetadataDatabase(database_path,
                              enable_on_disk_index,
                              env_override));
     status = metadata_database->Initialize();
   }
 
   if (status != SYNC_STATUS_OK)
     metadata_database.reset();
 
   *status_out = status;
-  return metadata_database.Pass();
+  return metadata_database;
 }
 
 // static
 SyncStatusCode MetadataDatabase::CreateForTesting(
     scoped_ptr<LevelDBWrapper> db,
     bool enable_on_disk_index,
     scoped_ptr<MetadataDatabase>* metadata_database_out) {
   scoped_ptr<MetadataDatabase> metadata_database(
       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;
 }
 
 MetadataDatabase::~MetadataDatabase() {
 }
 
 // static
 void MetadataDatabase::ClearDatabase(
     scoped_ptr<MetadataDatabase> metadata_database) {
   DCHECK(metadata_database);
@@ skipping 91 matching lines @@
                                   sync_root_tracker_id, tracker.get())) {
     return SYNC_DATABASE_ERROR_NOT_FOUND;
   }
 
   tracker->set_app_id(app_id);
   tracker->set_tracker_kind(TRACKER_KIND_APP_ROOT);
   tracker->set_active(true);
   tracker->set_needs_folder_listing(true);
   tracker->set_dirty(true);
 
-  index_->StoreFileTracker(tracker.Pass());
+  index_->StoreFileTracker(std::move(tracker));
   return WriteToDatabase();
 }
 
 SyncStatusCode MetadataDatabase::DisableApp(const std::string& app_id) {
   int64_t tracker_id = index_->GetAppRootTracker(app_id);
   scoped_ptr<FileTracker> tracker(new FileTracker);
   if (!index_->GetFileTracker(tracker_id, tracker.get())) {
     return SYNC_DATABASE_ERROR_NOT_FOUND;
   }
 
   if (tracker->tracker_kind() == TRACKER_KIND_DISABLED_APP_ROOT) {
     return SYNC_STATUS_OK;
   }
 
   DCHECK_EQ(TRACKER_KIND_APP_ROOT, tracker->tracker_kind());
   DCHECK(tracker->active());
 
   // Keep the app-root tracker active (but change the tracker_kind) so that
   // 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();
 }
 
 SyncStatusCode MetadataDatabase::EnableApp(const std::string& app_id) {
   int64_t tracker_id = index_->GetAppRootTracker(app_id);
   scoped_ptr<FileTracker> tracker(new FileTracker);
   if (!index_->GetFileTracker(tracker_id, tracker.get())) {
     return SYNC_DATABASE_ERROR_NOT_FOUND;
   }
 
   if (tracker->tracker_kind() == TRACKER_KIND_APP_ROOT) {
     return SYNC_STATUS_OK;
   }
 
   DCHECK_EQ(TRACKER_KIND_DISABLED_APP_ROOT, tracker->tracker_kind());
   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();
 }
 
 SyncStatusCode MetadataDatabase::UnregisterApp(const std::string& app_id) {
   int64_t tracker_id = index_->GetAppRootTracker(app_id);
   scoped_ptr<FileTracker> tracker(new FileTracker);
   if (!index_->GetFileTracker(tracker_id, tracker.get()) ||
       tracker->tracker_kind() == TRACKER_KIND_REGULAR) {
     return SYNC_STATUS_OK;
   }
 
   RemoveAllDescendantTrackers(tracker_id, index_.get());
 
   tracker->clear_app_id();
   tracker->set_tracker_kind(TRACKER_KIND_REGULAR);
   tracker->set_active(false);
   tracker->set_dirty(true);
 
-  index_->StoreFileTracker(tracker.Pass());
+  index_->StoreFileTracker(std::move(tracker));
   return WriteToDatabase();
 }
 
 bool MetadataDatabase::FindAppRootTracker(const std::string& app_id,
                                           FileTracker* tracker_out) const {
   int64_t app_root_tracker_id = index_->GetAppRootTracker(app_id);
   if (!app_root_tracker_id)
     return false;
 
   if (tracker_out &&
@@ skipping 129 matching lines @@
     ScopedVector<google_apis::ChangeResource> changes) {
   DCHECK_LE(index_->GetLargestChangeID(), largest_change_id);
 
   for (size_t i = 0; i < changes.size(); ++i) {
     const google_apis::ChangeResource& change = *changes[i];
     if (HasNewerFileMetadata(change.file_id(), change.change_id()))
       continue;
 
     scoped_ptr<FileMetadata> metadata(
         CreateFileMetadataFromChangeResource(change));
-    UpdateByFileMetadata(FROM_HERE, metadata.Pass(),
+    UpdateByFileMetadata(FROM_HERE, std::move(metadata),
                          UPDATE_TRACKER_FOR_UNSYNCED_FILE);
   }
 
   UpdateLargestKnownChangeID(largest_change_id);
   index_->SetLargestChangeID(largest_change_id);
   return WriteToDatabase();
 }
 
 SyncStatusCode MetadataDatabase::UpdateByFileResource(
     const google_apis::FileResource& resource) {
   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();
 }
 
 SyncStatusCode MetadataDatabase::UpdateByFileResourceList(
     ScopedVector<google_apis::FileResource> resources) {
   for (size_t i = 0; i < resources.size(); ++i) {
     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();
 }
 
 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();
 }
 
 SyncStatusCode MetadataDatabase::UpdateByDeletedRemoteFileList(
     const FileIDList& file_ids) {
   for (FileIDList::const_iterator itr = file_ids.begin();
        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();
 }
 
 SyncStatusCode MetadataDatabase::ReplaceActiveTrackerWithNewResource(
     int64_t parent_tracker_id,
     const google_apis::FileResource& resource) {
   DCHECK(!index_->GetFileMetadata(resource.file_id(), nullptr));
   DCHECK(index_->GetFileTracker(parent_tracker_id, nullptr));
@@ skipping 58 matching lines @@
     }
     children.erase(tracker.file_id());
   }
 
   for (base::hash_set<std::string>::const_iterator itr = children.begin();
        itr != children.end(); ++itr)
     CreateTrackerForParentAndFileID(*folder_tracker, *itr);
   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();
 }
 
 SyncStatusCode MetadataDatabase::UpdateTracker(
     int64_t tracker_id,
     const FileDetails& updated_details) {
   FileTracker tracker;
   if (!index_->GetFileTracker(tracker_id, &tracker)) {
     return SYNC_DATABASE_ERROR_NOT_FOUND;
@@ skipping 72 matching lines @@
   //   - There is no active tracker that has the same |parent| and |title|.
   if (!tracker.active() && CanActivateTracker(tracker)) {
     updated_tracker->set_active(true);
     updated_tracker->set_dirty(true);
     updated_tracker->set_needs_folder_listing(
         tracker.synced_details().file_kind() == FILE_KIND_FOLDER);
     should_promote = true;
   } 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);
 
   return WriteToDatabase();
 }
 
 MetadataDatabase::ActivationStatus MetadataDatabase::TryActivateTracker(
     int64_t parent_tracker_id,
     const std::string& file_id,
     SyncStatusCode* status_out) {
@@ skipping 27 matching lines @@
         index_->GetFileTrackerIDsByParentAndTitle(parent_tracker_id, title);
     if (same_title_trackers.has_active()) {
       RemoveAllDescendantTrackers(same_title_trackers.active_tracker(),
                                   index_.get());
 
       scoped_ptr<FileTracker> tracker_to_be_deactivated(new FileTracker);
       if (index_->GetFileTracker(same_title_trackers.active_tracker(),
                                  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 {
         NOTREACHED();
       }
     }
   }
 
   tracker_to_be_activated->set_dirty(false);
   tracker_to_be_activated->set_active(true);
   *tracker_to_be_activated->mutable_synced_details() = metadata.details();
   if (tracker_to_be_activated->synced_details().file_kind() ==
       FILE_KIND_FOLDER) {
     tracker_to_be_activated->set_needs_folder_listing(true);
   }
   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;
 }
 
 void MetadataDatabase::DemoteTracker(int64_t tracker_id) {
   index_->DemoteDirtyTracker(tracker_id);
   WriteToDatabase();
 }
 
@@ skipping 97 matching lines @@
       tracker_ids.insert(*itr);
   }
 
   for (std::set<int64_t>::iterator itr = tracker_ids.begin();
        itr != tracker_ids.end(); ++itr) {
     scoped_ptr<FileTracker> tracker(new FileTracker);
     if (!index_->GetFileTracker(*itr, tracker.get()) ||
         !CanClearDirty(*tracker))
       continue;
     tracker->set_dirty(false);
-    index_->StoreFileTracker(tracker.Pass());
+    index_->StoreFileTracker(std::move(tracker));
   }
 
   return WriteToDatabase();
 }
 
 MetadataDatabase::MetadataDatabase(
     const base::FilePath& database_path,
     bool enable_on_disk_index,
     leveldb::Env* env_override)
     : database_path_(database_path),
@@ skipping 76 matching lines @@
   tracker->set_dirty(true);
   tracker->set_active(false);
   tracker->set_needs_folder_listing(false);
   if (details) {
     *tracker->mutable_synced_details() = *details;
     if (option == UPDATE_TRACKER_FOR_UNSYNCED_FILE) {
       tracker->mutable_synced_details()->set_missing(true);
       tracker->mutable_synced_details()->clear_md5();
     }
   }
-  index_->StoreFileTracker(tracker.Pass());
+  index_->StoreFileTracker(std::move(tracker));
 }
 
 void MetadataDatabase::MaybeAddTrackersForNewFile(
     const FileMetadata& metadata,
     UpdateOption option) {
   std::set<int64_t> parents_to_exclude;
   TrackerIDSet existing_trackers =
       index_->GetFileTrackerIDsByFileID(metadata.file_id());
   for (TrackerIDSet::const_iterator itr = existing_trackers.begin();
        itr != existing_trackers.end(); ++itr) {
@@ skipping 151 matching lines @@
            << (metadata->details().missing() ? " deleted" : "");
 
   std::string file_id = metadata->file_id();
   if (metadata->details().missing())
     RemoveUnneededTrackersForMissingFile(file_id);
   else
     MaybeAddTrackersForNewFile(*metadata, option);
 
   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());
   }
 }
 
 
 SyncStatusCode MetadataDatabase::WriteToDatabase() {
   return LevelDBStatusToSyncStatusCode(db_->Commit());
 }
 
 scoped_ptr<base::ListValue> MetadataDatabase::DumpFiles(
     const std::string& app_id) {
   scoped_ptr<base::ListValue> files(new base::ListValue);
 
   FileTracker app_root_tracker;
   if (!FindAppRootTracker(app_id, &app_root_tracker))
-    return files.Pass();
+    return files;
 
   std::vector<int64_t> stack;
   AppendContents(
       index_->GetFileTrackerIDsByParent(app_root_tracker.tracker_id()), &stack);
   while (!stack.empty()) {
     int64_t tracker_id = stack.back();
     stack.pop_back();
     AppendContents(index_->GetFileTrackerIDsByParent(tracker_id), &stack);
 
     FileTracker tracker;
@@ skipping 17 matching lines @@
         tracker.synced_details().file_kind() == FILE_KIND_FILE)
       details->SetString("md5", tracker.synced_details().md5());
     details->SetString("active", tracker.active() ? "true" : "false");
     details->SetString("dirty", tracker.dirty() ? "true" : "false");
 
     file->Set("details", details);
 
     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,
                                             int64_t change_id) {
   FileMetadata metadata;
   if (!index_->GetFileMetadata(file_id, &metadata))
     return false;
   DCHECK(metadata.has_details());
   return metadata.details().change_id() >= change_id;
 }
@@ skipping 51 matching lines @@
       const FileDetails& details = tracker.synced_details();
       dict->SetString("title", details.title());
       dict->SetString("kind", FileKindToString(details.file_kind()));
       dict->SetString("md5", details.md5());
       dict->SetString("etag", details.etag());
       dict->SetString("missing", details.missing() ? "true" : "false");
       dict->SetString("change_id", base::Int64ToString(details.change_id()));
     }
     trackers->Append(dict);
   }
-  return trackers.Pass();
+  return trackers;
 }
 
 scoped_ptr<base::ListValue> MetadataDatabase::DumpMetadata() {
   scoped_ptr<base::ListValue> files(new base::ListValue);
 
   // Append the first element for metadata.
   base::DictionaryValue* metadata = new base::DictionaryValue;
   const char *fileKeys[] = {
     "file_id", "title", "type", "md5", "etag", "missing",
     "change_id", "parents"
@@ skipping 28 matching lines @@
       dict->SetString("missing", details.missing() ? "true" : "false");
       dict->SetString("change_id", base::Int64ToString(details.change_id()));
 
       std::vector<std::string> parents;
       for (int i = 0; i < details.parent_folder_ids_size(); ++i)
         parents.push_back(details.parent_folder_ids(i));
       dict->SetString("parents", base::JoinString(parents, ","));
     }
     files->Append(dict);
   }
-  return files.Pass();
+  return files;
 }
 
 void MetadataDatabase::AttachSyncRoot(
     const google_apis::FileResource& sync_root_folder) {
   scoped_ptr<FileMetadata> sync_root_metadata =
       CreateFileMetadataFromFileResource(
           GetLargestKnownChangeID(), sync_root_folder);
   scoped_ptr<FileTracker> sync_root_tracker =
       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(
     const google_apis::FileResource& app_root_folder) {
   scoped_ptr<FileMetadata> app_root_metadata =
       CreateFileMetadataFromFileResource(
           GetLargestKnownChangeID(), app_root_folder);
   scoped_ptr<FileTracker> app_root_tracker =
       CreateInitialAppRootTracker(IncrementTrackerID(),
                                   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) {
   FileMetadata metadata;
   if (!index_->GetFileMetadata(tracker.file_id(), &metadata) ||
       !tracker.active() || !tracker.dirty() ||
       !tracker.has_synced_details() ||
       tracker.needs_folder_listing())
     return false;
 
@@ skipping 13 matching lines @@
       return false;
 
   if (!parents.empty())
     return false;
 
   return true;
 }
 
 }  // namespace drive_backend
 }  // namespace sync_file_system