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

chrome/browser/sync_file_system/drive_backend/metadata_database_unittest.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 <stdint.h>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/thread_task_runner_handle.h"
 #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"
 #include "chrome/browser/sync_file_system/drive_backend/drive_backend_util.h"
@@ skipping 247 matching lines @@
     options.env = in_memory_env_.get();
     leveldb::Status status =
         leveldb::DB::Open(options, database_dir_.path().AsUTF8Unsafe(), &db);
     EXPECT_TRUE(status.ok());
 
     scoped_ptr<LevelDBWrapper> wrapper(new LevelDBWrapper(make_scoped_ptr(db)));
 
     wrapper->Put(kDatabaseVersionKey, base::Int64ToString(3));
     SetUpServiceMetadata(wrapper.get());
 
-    return wrapper.Pass();
+    return wrapper;
   }
 
   void SetUpServiceMetadata(LevelDBWrapper* db) {
     ServiceMetadata service_metadata;
     service_metadata.set_largest_change_id(kInitialChangeID);
     service_metadata.set_sync_root_tracker_id(kSyncRootTrackerID);
     service_metadata.set_next_tracker_id(next_tracker_id_);
     PutServiceMetadataToDB(service_metadata, db);
     EXPECT_TRUE(db->Commit().ok());
   }
@@ skipping 112 matching lines @@
     } else {
       file_resource->set_mime_type("application/vnd.google-apps.document");
     }
     file_resource->set_md5_checksum(file.details().md5());
     file_resource->set_etag(file.details().etag());
     file_resource->set_created_date(base::Time::FromInternalValue(
         file.details().creation_time()));
     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(
       const FileMetadata& file) {
     scoped_ptr<google_apis::ChangeResource> change(
         new google_apis::ChangeResource);
     change->set_change_id(file.details().change_id());
     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,
                                    FileMetadata* file) {
     FileDetails* details = file->mutable_details();
     details->set_title(new_title);
     details->set_change_id(++current_change_id_);
   }
 
   void ApplyReorganizeChangeToMetadata(const std::string& new_parent,
@@ skipping 76 matching lines @@
          itr1->Next(), itr2->Next()) {
       EXPECT_EQ(itr1->key().ToString(), itr2->key().ToString());
       EXPECT_EQ(itr1->value().ToString(), itr2->value().ToString());
     }
     EXPECT_TRUE(!itr1->Valid());
     EXPECT_TRUE(!itr2->Valid());
   }
 
   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();
     if (GetParam()) {
       VerifyReloadConsistencyForOnDisk(
           static_cast<MetadataDatabaseIndexOnDisk*>(index1),
           static_cast<MetadataDatabaseIndexOnDisk*>(index2));
     } else {
       VerifyReloadConsistencyForOnMemory(
           static_cast<MetadataDatabaseIndex*>(index1),
@@ skipping 32 matching lines @@
   SyncStatusCode EnableApp(const std::string& app_id) {
     return metadata_database_->EnableApp(app_id);
   }
 
   SyncStatusCode UnregisterApp(const std::string& app_id) {
     return metadata_database_->UnregisterApp(app_id);
   }
 
   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,
                                 const FileIDList& listed_children) {
     return metadata_database_->PopulateFolderByChildList(
         folder_id, listed_children);
   }
 
   SyncStatusCode UpdateTracker(const FileTracker& tracker) {
     return metadata_database_->UpdateTracker(
@@ skipping 317 matching lines @@
   PushToChangeList(
       CreateChangeResourceFromMetadata(renamed_file.metadata), &changes);
   PushToChangeList(
       CreateChangeResourceFromMetadata(reorganized_file.metadata), &changes);
   PushToChangeList(
       CreateChangeResourceFromMetadata(updated_file.metadata), &changes);
   PushToChangeList(
       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);
   updated_file.tracker.set_dirty(true);
   noop_file.tracker.set_dirty(true);
   new_file.tracker.mutable_synced_details()->set_missing(true);
   new_file.tracker.mutable_synced_details()->clear_md5();
   new_file.tracker.set_active(false);
   new_file.tracker.set_dirty(true);
   ResetTrackerID(&new_file.tracker);
@@ skipping 225 matching lines @@
   EXPECT_TRUE(file->HasKey("details"));
 
   ASSERT_TRUE(files->GetDictionary(1, &file));
   EXPECT_TRUE(file->GetString("title", &str) && str == "file_0");
   EXPECT_TRUE(file->GetString("type", &str) && str == "file");
   EXPECT_TRUE(file->HasKey("details"));
 }
 
 }  // namespace drive_backend
 }  // namespace sync_file_system