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

chrome/browser/sync_file_system/drive_backend/sync_engine_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/sync_engine.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/files/scoped_temp_dir.h"
@@ skipping 20 matching lines @@
                        public base::SupportsWeakPtr<SyncEngineTest> {
  public:
   typedef RemoteFileSyncService::OriginStatusMap RemoteOriginStatusMap;
 
   SyncEngineTest() : worker_pool_owner_(1, "Worker") {}
   ~SyncEngineTest() override {}
 
   void SetUp() override {
     ASSERT_TRUE(profile_dir_.CreateUniqueTempDir());
 
-    scoped_ptr<drive::DriveServiceInterface>
-        fake_drive_service(new drive::FakeDriveService);
+    std::unique_ptr<drive::DriveServiceInterface> fake_drive_service(
+        new drive::FakeDriveService);
 
     scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner =
         base::ThreadTaskRunnerHandle::Get();
     worker_task_runner_ =
         worker_pool_owner_.pool()->GetSequencedTaskRunnerWithShutdownBehavior(
             worker_pool_owner_.pool()->GetSequenceToken(),
             base::SequencedWorkerPool::SKIP_ON_SHUTDOWN);
 
     sync_engine_.reset(new drive_backend::SyncEngine(
         ui_task_runner.get(), worker_task_runner_.get(),
         nullptr,  // drive_task_runner
         worker_pool_owner_.pool().get(), profile_dir_.path(),
         nullptr,    // task_logger
         nullptr,    // notification_manager
         nullptr,    // extension_service
         nullptr,    // signin_manager
         nullptr,    // token_service
         nullptr,    // request_context
         nullptr,    // drive_service_factory
         nullptr));  // in_memory_env
 
     sync_engine_->InitializeForTesting(
         std::move(fake_drive_service),
         nullptr,  // drive_uploader
-        scoped_ptr<SyncWorkerInterface>(new FakeSyncWorker));
+        std::unique_ptr<SyncWorkerInterface>(new FakeSyncWorker));
     sync_engine_->SetSyncEnabled(true);
     sync_engine_->OnReadyToSendRequests();
 
     WaitForWorkerTaskRunner();
   }
 
   void TearDown() override {
     sync_engine_.reset();
     WaitForWorkerTaskRunner();
 
     worker_task_runner_ = nullptr;
   }
 
   bool FindOriginStatus(const GURL& origin, std::string* status) {
-    scoped_ptr<RemoteOriginStatusMap> status_map;
+    std::unique_ptr<RemoteOriginStatusMap> status_map;
     sync_engine()->GetOriginStatusMap(CreateResultReceiver(&status_map));
     WaitForWorkerTaskRunner();
 
     RemoteOriginStatusMap::const_iterator itr = status_map->find(origin);
     if (itr == status_map->end())
       return false;
 
     *status = itr->second;
     // If an origin is uninstalled, it should not be found actually.
     if (*status == "Uninstalled")
@@ skipping 26 matching lines @@
   // Accessors
   SyncEngine* sync_engine() { return sync_engine_.get(); }
 
   FakeSyncWorker* fake_sync_worker() {
     return static_cast<FakeSyncWorker*>(sync_engine_->sync_worker_.get());
   }
 
  private:
   content::TestBrowserThreadBundle browser_threads_;
   base::ScopedTempDir profile_dir_;
-  scoped_ptr<drive_backend::SyncEngine> sync_engine_;
+  std::unique_ptr<drive_backend::SyncEngine> sync_engine_;
 
   base::SequencedWorkerPoolOwner worker_pool_owner_;
   scoped_refptr<base::SequencedTaskRunner> worker_task_runner_;
 
   DISALLOW_COPY_AND_ASSIGN(SyncEngineTest);
 };
 
 TEST_F(SyncEngineTest, OriginTest) {
   GURL origin("chrome-extension://app_0");
 
@@ skipping 40 matching lines @@
   sync_engine()->RegisterOrigin(GURL("chrome-extension://app_0"),
                                 CreateResultReceiver(&sync_status));
   WaitForWorkerTaskRunner();
   EXPECT_EQ(SYNC_STATUS_OK, sync_status);
 
   sync_engine()->RegisterOrigin(GURL("chrome-extension://app_1"),
                                 CreateResultReceiver(&sync_status));
   WaitForWorkerTaskRunner();
   EXPECT_EQ(SYNC_STATUS_OK, sync_status);
 
-  scoped_ptr<RemoteOriginStatusMap> status_map;
+  std::unique_ptr<RemoteOriginStatusMap> status_map;
   sync_engine()->GetOriginStatusMap(CreateResultReceiver(&status_map));
   WaitForWorkerTaskRunner();
   ASSERT_EQ(2u, status_map->size());
   EXPECT_EQ("Registered", (*status_map)[GURL("chrome-extension://app_0")]);
   EXPECT_EQ("Registered", (*status_map)[GURL("chrome-extension://app_1")]);
 
   sync_engine()->DisableOrigin(GURL("chrome-extension://app_1"),
                                CreateResultReceiver(&sync_status));
   WaitForWorkerTaskRunner();
   EXPECT_EQ(SYNC_STATUS_OK, sync_status);
@@ skipping 26 matching lines @@
 TEST_F(SyncEngineTest, ProcessRemoteChange) {
   SyncStatusCode sync_status;
   storage::FileSystemURL url;
   sync_engine()->ProcessRemoteChange(CreateResultReceiver(&sync_status, &url));
   WaitForWorkerTaskRunner();
   EXPECT_EQ(SYNC_STATUS_OK, sync_status);
 }
 
 }  // namespace drive_backend
 }  // namespace sync_file_system