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

chrome/browser/sync_file_system/drive_backend/sync_worker_unittest.cc

 // Copyright 2014 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/sync_worker.h"
 
 #include <utility>
 
 #include "base/files/scoped_temp_dir.h"
 #include "base/location.h"
@@ skipping 91 matching lines @@
                        public base::SupportsWeakPtr<SyncWorkerTest> {
  public:
   SyncWorkerTest() {}
   ~SyncWorkerTest() override {}
 
   void SetUp() override {
     ASSERT_TRUE(profile_dir_.CreateUniqueTempDir());
     in_memory_env_.reset(leveldb::NewMemEnv(leveldb::Env::Default()));
 
     extension_service_.reset(new MockExtensionService);
-    scoped_ptr<drive::DriveServiceInterface>
-        fake_drive_service(new drive::FakeDriveService);
+    std::unique_ptr<drive::DriveServiceInterface> fake_drive_service(
+        new drive::FakeDriveService);
 
-    scoped_ptr<SyncEngineContext> sync_engine_context(new SyncEngineContext(
-        std::move(fake_drive_service), nullptr /* drive_uploader */,
-        nullptr /* task_logger */,
-        base::ThreadTaskRunnerHandle::Get() /* ui_task_runner */,
-        base::ThreadTaskRunnerHandle::Get() /* worker_task_runner */,
-        nullptr /* worker_pool */));
+    std::unique_ptr<SyncEngineContext> sync_engine_context(
+        new SyncEngineContext(
+            std::move(fake_drive_service), nullptr /* drive_uploader */,
+            nullptr /* task_logger */,
+            base::ThreadTaskRunnerHandle::Get() /* ui_task_runner */,
+            base::ThreadTaskRunnerHandle::Get() /* worker_task_runner */,
+            nullptr /* worker_pool */));
 
     sync_worker_.reset(new SyncWorker(
         profile_dir_.path(),
         extension_service_->AsWeakPtr(),
         in_memory_env_.get()));
     sync_worker_->Initialize(std::move(sync_engine_context));
 
     sync_worker_->SetSyncEnabled(true);
     base::RunLoop().RunUntilIdle();
   }
@@ skipping 22 matching lines @@
     EXPECT_EQ(expected_service_status, sync_worker_->GetCurrentState());
   }
 
   MetadataDatabase* metadata_database() {
     return sync_worker_->GetMetadataDatabase();
   }
 
  private:
   content::TestBrowserThreadBundle browser_threads_;
   base::ScopedTempDir profile_dir_;
-  scoped_ptr<leveldb::Env> in_memory_env_;
+  std::unique_ptr<leveldb::Env> in_memory_env_;
 
-  scoped_ptr<MockExtensionService> extension_service_;
-  scoped_ptr<SyncWorker> sync_worker_;
+  std::unique_ptr<MockExtensionService> extension_service_;
+  std::unique_ptr<SyncWorker> sync_worker_;
 
   DISALLOW_COPY_AND_ASSIGN(SyncWorkerTest);
 };
 
 TEST_F(SyncWorkerTest, EnableOrigin) {
   FileTracker tracker;
   SyncStatusCode sync_status = SYNC_STATUS_UNKNOWN;
   GURL origin = extensions::Extension::GetBaseURLFromExtensionId(kAppID);
 
   sync_worker()->RegisterOrigin(origin, CreateResultReceiver(&sync_status));
@@ skipping 78 matching lines @@
   sync_worker()->RegisterOrigin(GURL("chrome-extension://app_0"),
                                 CreateResultReceiver(&sync_status));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(SYNC_STATUS_OK, sync_status);
 
   sync_worker()->RegisterOrigin(GURL("chrome-extension://app_1"),
                                 CreateResultReceiver(&sync_status));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(SYNC_STATUS_OK, sync_status);
 
-  scoped_ptr<RemoteFileSyncService::OriginStatusMap> status_map;
+  std::unique_ptr<RemoteFileSyncService::OriginStatusMap> status_map;
   sync_worker()->GetOriginStatusMap(CreateResultReceiver(&status_map));
   base::RunLoop().RunUntilIdle();
   ASSERT_EQ(2u, status_map->size());
   EXPECT_EQ("Enabled", (*status_map)[GURL("chrome-extension://app_0")]);
   EXPECT_EQ("Enabled", (*status_map)[GURL("chrome-extension://app_1")]);
 
   sync_worker()->DisableOrigin(GURL("chrome-extension://app_1"),
                                CreateResultReceiver(&sync_status));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(SYNC_STATUS_OK, sync_status);
@@ skipping 83 matching lines @@
   GetSyncTaskManager()->ScheduleTask(
       FROM_HERE,
       base::Bind(&EmptyTask, SYNC_DATABASE_ERROR_FAILED),
       SyncTaskManager::PRIORITY_MED,
       base::Bind(&SyncWorkerTest::CheckServiceState,
                  AsWeakPtr(),
                  SYNC_DATABASE_ERROR_FAILED,
                  REMOTE_SERVICE_DISABLED));
 
   GetSyncTaskManager()->ScheduleSyncTask(
-      FROM_HERE,
-      scoped_ptr<SyncTask>(new MockSyncTask(false)),
+      FROM_HERE, std::unique_ptr<SyncTask>(new MockSyncTask(false)),
       SyncTaskManager::PRIORITY_MED,
-      base::Bind(&SyncWorkerTest::CheckServiceState,
-                 AsWeakPtr(),
-                 SYNC_STATUS_OK,
-                 REMOTE_SERVICE_DISABLED));
+      base::Bind(&SyncWorkerTest::CheckServiceState, AsWeakPtr(),
+                 SYNC_STATUS_OK, REMOTE_SERVICE_DISABLED));
 
   GetSyncTaskManager()->ScheduleSyncTask(
-      FROM_HERE,
-      scoped_ptr<SyncTask>(new MockSyncTask(true)),
+      FROM_HERE, std::unique_ptr<SyncTask>(new MockSyncTask(true)),
       SyncTaskManager::PRIORITY_MED,
-      base::Bind(&SyncWorkerTest::CheckServiceState,
-                 AsWeakPtr(),
-                 SYNC_STATUS_OK,
-                 REMOTE_SERVICE_OK));
+      base::Bind(&SyncWorkerTest::CheckServiceState, AsWeakPtr(),
+                 SYNC_STATUS_OK, REMOTE_SERVICE_OK));
 
   base::RunLoop().RunUntilIdle();
 }
 
 }  // namespace drive_backend
 }  // namespace sync_file_system