Convert //chrome/browser/sync_file_system from scoped_ptr to std::unique_ptr

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/memory/ptr_util.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"
 #include "chrome/browser/sync_file_system/drive_backend/drive_backend_util.h"
 #include "chrome/browser/sync_file_system/drive_backend/fake_drive_service_helper.h"
 #include "chrome/browser/sync_file_system/drive_backend/leveldb_wrapper.h"
 #include "chrome/browser/sync_file_system/drive_backend/metadata_database.h"
 #include "chrome/browser/sync_file_system/drive_backend/metadata_database.pb.h"
@@ skipping 19 matching lines @@
  public:
   RegisterAppTaskTest()
       : next_file_id_(1000),
         next_tracker_id_(10000) {}
   ~RegisterAppTaskTest() override {}
 
   void SetUp() override {
     ASSERT_TRUE(database_dir_.CreateUniqueTempDir());
     in_memory_env_.reset(leveldb::NewMemEnv(leveldb::Env::Default()));
 
-    scoped_ptr<drive::FakeDriveService>
-        fake_drive_service(new drive::FakeDriveService);
-    scoped_ptr<drive::DriveUploaderInterface>
-        drive_uploader(new drive::DriveUploader(
-            fake_drive_service.get(),
-            base::ThreadTaskRunnerHandle::Get()));
+    std::unique_ptr<drive::FakeDriveService> fake_drive_service(
+        new drive::FakeDriveService);
+    std::unique_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(
         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();
   }
 
  protected:
-  scoped_ptr<LevelDBWrapper> OpenLevelDB() {
+  std::unique_ptr<LevelDBWrapper> OpenLevelDB() {
     leveldb::DB* db = nullptr;
     leveldb::Options options;
     options.create_if_missing = true;
     options.env = in_memory_env_.get();
     leveldb::Status status =
         leveldb::DB::Open(options, database_dir_.path().AsUTF8Unsafe(), &db);
     EXPECT_TRUE(status.ok());
-    return make_scoped_ptr(new LevelDBWrapper(make_scoped_ptr(db)));
+    return base::WrapUnique(new LevelDBWrapper(base::WrapUnique(db)));
   }
 
   void SetUpInitialData(LevelDBWrapper* db) {
     ServiceMetadata service_metadata;
     service_metadata.set_largest_change_id(100);
     service_metadata.set_sync_root_tracker_id(kSyncRootTrackerID);
     service_metadata.set_next_tracker_id(next_tracker_id_);
 
     FileDetails sync_root_details;
     sync_root_details.set_title(kSyncRootFolderTitle);
@@ skipping 13 matching lines @@
     sync_root_tracker.set_active(true);
 
     db->Put(kDatabaseVersionKey,
             base::Int64ToString(kCurrentDatabaseVersion));
     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) {
+  void CreateMetadataDatabase(std::unique_ptr<LevelDBWrapper> db) {
     ASSERT_TRUE(db);
     ASSERT_FALSE(context_->GetMetadataDatabase());
-    scoped_ptr<MetadataDatabase> metadata_db;
+    std::unique_ptr<MetadataDatabase> metadata_db;
     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;
@@ skipping 87 matching lines @@
         files.active_tracker(), &app_root_tracker));
     *app_root_folder_id = app_root_tracker.file_id();
     return true;
   }
 
   bool HasRemoteAppRoot(const std::string& app_id) {
     std::string app_root_folder_id;
     if (!GetAppRootFolderID(app_id, &app_root_folder_id))
       return false;
 
-    scoped_ptr<google_apis::FileResource> entry;
+    std::unique_ptr<google_apis::FileResource> entry;
     if (google_apis::HTTP_SUCCESS !=
         fake_drive_service_helper_->GetFileResource(app_root_folder_id, &entry))
       return false;
 
     return !entry->labels().is_trashed();
   }
 
   bool VerifyRemoteAppRootVisibility(const std::string& app_id) {
     std::string app_root_folder_id;
     if (!GetAppRootFolderID(app_id, &app_root_folder_id))
       return false;
 
     google_apis::drive::FileVisibility visibility;
     if (google_apis::HTTP_SUCCESS !=
         fake_drive_service_helper_->GetFileVisibility(
             app_root_folder_id, &visibility))
       return false;
     if (visibility != google_apis::drive::FILE_VISIBILITY_PRIVATE)
       return false;
 
     return true;
   }
 
  private:
   std::string GenerateFileID() {
     return base::StringPrintf("file_id_%" PRId64, next_file_id_++);
   }
 
-  scoped_ptr<leveldb::Env> in_memory_env_;
+  std::unique_ptr<leveldb::Env> in_memory_env_;
 
   std::string sync_root_folder_id_;
 
   int64_t next_file_id_;
   int64_t next_tracker_id_;
 
   content::TestBrowserThreadBundle browser_threads_;
   base::ScopedTempDir database_dir_;
 
-  scoped_ptr<SyncEngineContext> context_;
-  scoped_ptr<FakeDriveServiceHelper> fake_drive_service_helper_;
+  std::unique_ptr<SyncEngineContext> context_;
+  std::unique_ptr<FakeDriveServiceHelper> fake_drive_service_helper_;
 
   DISALLOW_COPY_AND_ASSIGN(RegisterAppTaskTest);
 };
 
 TEST_F(RegisterAppTaskTest, AlreadyRegistered) {
-  scoped_ptr<LevelDBWrapper> db = OpenLevelDB();
+  std::unique_ptr<LevelDBWrapper> db = OpenLevelDB();
   ASSERT_TRUE(db);
   SetUpInitialData(db.get());
 
   const std::string kAppID = "app_id";
   SetUpRegisteredAppRoot(kAppID, db.get());
 
   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();
+  std::unique_ptr<LevelDBWrapper> db = OpenLevelDB();
   ASSERT_TRUE(db);
   SetUpInitialData(db.get());
 
   const std::string kAppID = "app_id";
   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();
+  std::unique_ptr<LevelDBWrapper> db = OpenLevelDB();
   ASSERT_TRUE(db);
   SetUpInitialData(db.get());
 
   const std::string kAppID = "app_id";
   SetUpUnregisteredAppRoot(kAppID, db.get());
 
   CreateMetadataDatabase(std::move(db));
   RunRegisterAppTask(kAppID);
 
   EXPECT_EQ(1u, CountRegisteredAppRoot());
   EXPECT_TRUE(IsAppRegistered(kAppID));
 }
 
 TEST_F(RegisterAppTaskTest, RegisterExistingFolder_MultipleCandidate) {
-  scoped_ptr<LevelDBWrapper> db = OpenLevelDB();
+  std::unique_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(std::move(db));
   RunRegisterAppTask(kAppID);
 
   EXPECT_EQ(1u, CountRegisteredAppRoot());
   EXPECT_TRUE(IsAppRegistered(kAppID));
 }
 
 }  // namespace drive_backend
 }  // namespace sync_file_system