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

chrome/browser/sync_file_system/drive_backend/register_app_task_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/register_app_task.h"
 
 #include <stddef.h>
 #include <stdint.h>
-
+#include <utility>
 #include <vector>
 
 #include "base/files/scoped_temp_dir.h"
 #include "base/format_macros.h"
 #include "base/macros.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/thread_task_runner_handle.h"
 #include "chrome/browser/sync_file_system/drive_backend/drive_backend_constants.h"
@@ skipping 35 matching lines @@
         fake_drive_service(new drive::FakeDriveService);
     scoped_ptr<drive::DriveUploaderInterface>
         drive_uploader(new drive::DriveUploader(
             fake_drive_service.get(),
             base::ThreadTaskRunnerHandle::Get()));
 
     fake_drive_service_helper_.reset(new FakeDriveServiceHelper(
         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(
                   kSyncRootFolderTitle, &sync_root_folder_id_));
   }
 
   void TearDown() override {
     context_.reset();
     base::RunLoop().RunUntilIdle();
   }
@@ skipping 38 matching lines @@
     PutServiceMetadataToDB(service_metadata, db);
     PutFileMetadataToDB(sync_root_metadata, db);
     PutFileTrackerToDB(sync_root_tracker, db);
     EXPECT_TRUE(db->Commit().ok());
   }
 
   void CreateMetadataDatabase(scoped_ptr<LevelDBWrapper> db) {
     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) {
     RegisterAppTask task(context_.get(), app_id);
     SyncStatusCode status = SYNC_STATUS_UNKNOWN;
     task.RunExclusive(CreateResultReceiver(&status));
     base::RunLoop().RunUntilIdle();
     return status;
   }
 
@@ skipping 135 matching lines @@
 };
 
 TEST_F(RegisterAppTaskTest, AlreadyRegistered) {
   scoped_ptr<LevelDBWrapper> db = OpenLevelDB();
   ASSERT_TRUE(db);
   SetUpInitialData(db.get());
 
   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());
   EXPECT_TRUE(IsAppRegistered(kAppID));
 }
 
 TEST_F(RegisterAppTaskTest, CreateAppFolder) {
   scoped_ptr<LevelDBWrapper> db = OpenLevelDB();
   ASSERT_TRUE(db);
   SetUpInitialData(db.get());
 
   const std::string kAppID = "app_id";
-  CreateMetadataDatabase(db.Pass());
+  CreateMetadataDatabase(std::move(db));
   RunRegisterAppTask(kAppID);
 
   EXPECT_EQ(1u, CountRegisteredAppRoot());
   EXPECT_TRUE(IsAppRegistered(kAppID));
 
   EXPECT_EQ(1u, CountRemoteFileInSyncRoot());
   EXPECT_TRUE(HasRemoteAppRoot(kAppID));
   EXPECT_TRUE(VerifyRemoteAppRootVisibility(kAppID));
 }
 
 TEST_F(RegisterAppTaskTest, RegisterExistingFolder) {
   scoped_ptr<LevelDBWrapper> db = OpenLevelDB();
   ASSERT_TRUE(db);
   SetUpInitialData(db.get());
 
   const std::string kAppID = "app_id";
   SetUpUnregisteredAppRoot(kAppID, db.get());
 
-  CreateMetadataDatabase(db.Pass());
+  CreateMetadataDatabase(std::move(db));
   RunRegisterAppTask(kAppID);
 
   EXPECT_EQ(1u, CountRegisteredAppRoot());
   EXPECT_TRUE(IsAppRegistered(kAppID));
 }
 
 TEST_F(RegisterAppTaskTest, RegisterExistingFolder_MultipleCandidate) {
   scoped_ptr<LevelDBWrapper> db = OpenLevelDB();
   ASSERT_TRUE(db);
   SetUpInitialData(db.get());
 
   const std::string kAppID = "app_id";
   SetUpUnregisteredAppRoot(kAppID, db.get());
   SetUpUnregisteredAppRoot(kAppID, db.get());
 
-  CreateMetadataDatabase(db.Pass());
+  CreateMetadataDatabase(std::move(db));
   RunRegisterAppTask(kAppID);
 
   EXPECT_EQ(1u, CountRegisteredAppRoot());
   EXPECT_TRUE(IsAppRegistered(kAppID));
 }
 
 }  // namespace drive_backend
 }  // namespace sync_file_system