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

chrome/browser/sync_file_system/drive_backend/conflict_resolver_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/conflict_resolver.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 43 matching lines @@
   typedef FakeRemoteChangeProcessor::URLToFileChangesMap URLToFileChangesMap;
 
   ConflictResolverTest()
       : thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP) {}
   ~ConflictResolverTest() override {}
 
   void SetUp() override {
     ASSERT_TRUE(database_dir_.CreateUniqueTempDir());
     in_memory_env_.reset(leveldb::NewMemEnv(leveldb::Env::Default()));
 
-    scoped_ptr<FakeDriveServiceWrapper>
-        fake_drive_service(new FakeDriveServiceWrapper);
-    scoped_ptr<drive::DriveUploaderInterface>
-        drive_uploader(new FakeDriveUploader(fake_drive_service.get()));
+    std::unique_ptr<FakeDriveServiceWrapper> fake_drive_service(
+        new FakeDriveServiceWrapper);
+    std::unique_ptr<drive::DriveUploaderInterface> drive_uploader(
+        new FakeDriveUploader(fake_drive_service.get()));
     fake_drive_helper_.reset(
         new FakeDriveServiceHelper(fake_drive_service.get(),
                                    drive_uploader.get(),
                                    kSyncRootFolderTitle));
     remote_change_processor_.reset(new FakeRemoteChangeProcessor);
 
     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 */));
@@ skipping 17 matching lines @@
     base::RunLoop().RunUntilIdle();
   }
 
   void InitializeMetadataDatabase() {
     SyncEngineInitializer* initializer =
         new SyncEngineInitializer(context_.get(),
                                   database_dir_.path(),
                                   in_memory_env_.get());
     SyncStatusCode status = SYNC_STATUS_UNKNOWN;
     sync_task_manager_->ScheduleSyncTask(
-        FROM_HERE,
-        scoped_ptr<SyncTask>(initializer),
+        FROM_HERE, std::unique_ptr<SyncTask>(initializer),
         SyncTaskManager::PRIORITY_MED,
         base::Bind(&ConflictResolverTest::DidInitializeMetadataDatabase,
                    base::Unretained(this), initializer, &status));
 
     base::RunLoop().RunUntilIdle();
     EXPECT_EQ(SYNC_STATUS_OK, status);
   }
 
   void DidInitializeMetadataDatabase(SyncEngineInitializer* initializer,
                                      SyncStatusCode* status_out,
@@ skipping 48 matching lines @@
       const std::string& file_id) {
     google_apis::DriveApiErrorCode error = google_apis::DRIVE_OTHER_ERROR;
     context_->GetDriveService()->AddResourceToDirectory(
         parent_folder_id, file_id,
         CreateResultReceiver(&error));
     base::RunLoop().RunUntilIdle();
     return error;
   }
 
   int CountParents(const std::string& file_id) {
-    scoped_ptr<google_apis::FileResource> entry;
+    std::unique_ptr<google_apis::FileResource> entry;
     EXPECT_EQ(google_apis::HTTP_SUCCESS,
               fake_drive_helper_->GetFileResource(file_id, &entry));
     return entry->parents().size();
   }
 
   SyncStatusCode RunRemoteToLocalSyncer() {
     SyncStatusCode status = SYNC_STATUS_UNKNOWN;
-    scoped_ptr<RemoteToLocalSyncer> syncer(
+    std::unique_ptr<RemoteToLocalSyncer> syncer(
         new RemoteToLocalSyncer(context_.get()));
     syncer->RunPreflight(SyncTaskToken::CreateForTesting(
         CreateResultReceiver(&status)));
     base::RunLoop().RunUntilIdle();
     return status;
   }
 
   SyncStatusCode RunLocalToRemoteSyncer(const storage::FileSystemURL& url,
                                         const FileChange& file_change) {
     SyncStatusCode status = SYNC_STATUS_UNKNOWN;
     base::FilePath local_path = base::FilePath(FILE_PATH_LITERAL("dummy"));
     if (file_change.IsAddOrUpdate())
       CreateTemporaryFileInDir(database_dir_.path(), &local_path);
-    scoped_ptr<LocalToRemoteSyncer> syncer(new LocalToRemoteSyncer(
+    std::unique_ptr<LocalToRemoteSyncer> syncer(new LocalToRemoteSyncer(
         context_.get(),
-        SyncFileMetadata(file_change.file_type(), 0, base::Time()),
-        file_change, local_path, url));
+        SyncFileMetadata(file_change.file_type(), 0, base::Time()), file_change,
+        local_path, url));
     syncer->RunPreflight(SyncTaskToken::CreateForTesting(
         CreateResultReceiver(&status)));
     base::RunLoop().RunUntilIdle();
     if (status == SYNC_STATUS_OK)
       remote_change_processor_->ClearLocalChanges(url);
     return status;
   }
 
   void RunRemoteToLocalSyncerUntilIdle() {
     const int kRetryLimit = 100;
@@ skipping 16 matching lines @@
     resolver.RunPreflight(SyncTaskToken::CreateForTesting(
         CreateResultReceiver(&status)));
     base::RunLoop().RunUntilIdle();
     return status;
   }
 
   SyncStatusCode ListChanges() {
     SyncStatusCode status = SYNC_STATUS_UNKNOWN;
     sync_task_manager_->ScheduleSyncTask(
         FROM_HERE,
-        scoped_ptr<SyncTask>(new ListChangesTask(context_.get())),
-        SyncTaskManager::PRIORITY_MED,
-        CreateResultReceiver(&status));
+        std::unique_ptr<SyncTask>(new ListChangesTask(context_.get())),
+        SyncTaskManager::PRIORITY_MED, CreateResultReceiver(&status));
     base::RunLoop().RunUntilIdle();
     return status;
   }
 
   ScopedVector<google_apis::FileResource>
   GetResourceEntriesForParentAndTitle(const std::string& parent_folder_id,
                                       const std::string& title) {
     ScopedVector<google_apis::FileResource> entries;
     EXPECT_EQ(google_apis::HTTP_SUCCESS,
               fake_drive_helper_->SearchByTitle(
@@ skipping 16 matching lines @@
   }
 
   void VerifyLocalChangeConsistency(
       const URLToFileChangesMap& expected_changes) {
     remote_change_processor_->VerifyConsistency(expected_changes);
   }
 
  private:
   content::TestBrowserThreadBundle thread_bundle_;
   base::ScopedTempDir database_dir_;
-  scoped_ptr<leveldb::Env> in_memory_env_;
+  std::unique_ptr<leveldb::Env> in_memory_env_;
 
-  scoped_ptr<SyncEngineContext> context_;
-  scoped_ptr<FakeDriveServiceHelper> fake_drive_helper_;
-  scoped_ptr<FakeRemoteChangeProcessor> remote_change_processor_;
+  std::unique_ptr<SyncEngineContext> context_;
+  std::unique_ptr<FakeDriveServiceHelper> fake_drive_helper_;
+  std::unique_ptr<FakeRemoteChangeProcessor> remote_change_processor_;
 
-  scoped_ptr<SyncTaskManager> sync_task_manager_;
+  std::unique_ptr<SyncTaskManager> sync_task_manager_;
 
   DISALLOW_COPY_AND_ASSIGN(ConflictResolverTest);
 };
 
 TEST_F(ConflictResolverTest, NoFileToBeResolved) {
   const GURL kOrigin("chrome-extension://example");
   const std::string sync_root = CreateSyncRoot();
   const std::string app_root = CreateRemoteFolder(sync_root, kOrigin.host());
   InitializeMetadataDatabase();
   RegisterApp(kOrigin.host(), app_root);
@@ skipping 227 matching lines @@
 
   EXPECT_EQ(4, CountParents(file));
 
   EXPECT_EQ(SYNC_STATUS_OK, RunConflictResolver());
 
   EXPECT_EQ(1, CountParents(file));
 }
 
 }  // namespace drive_backend
 }  // namespace sync_file_system