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

chrome/browser/sync_file_system/sync_file_system_service_unittest.cc

 // Copyright (c) 2012 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/sync_file_system_service.h"
 
 #include <stddef.h>
 #include <utility>
 #include <vector>
 
@@ skipping 123 matching lines @@
                        content::TestBrowserThreadBundle::REAL_IO_THREAD) {}
 
   void SetUp() override {
     in_memory_env_.reset(leveldb::NewMemEnv(leveldb::Env::Default()));
     file_system_.reset(new CannedSyncableFileSystem(
         GURL(kOrigin),
         in_memory_env_.get(),
         BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO),
         BrowserThread::GetMessageLoopProxyForThread(BrowserThread::FILE)));
 
-    scoped_ptr<LocalFileSyncService> local_service =
+    std::unique_ptr<LocalFileSyncService> local_service =
         LocalFileSyncService::CreateForTesting(&profile_, in_memory_env_.get());
     remote_service_ = new StrictMock<MockRemoteFileSyncService>;
     sync_service_.reset(new SyncFileSystemService(&profile_));
 
     EXPECT_CALL(*mock_remote_service(),
                 AddServiceObserver(_)).Times(1);
     EXPECT_CALL(*mock_remote_service(),
                 AddFileStatusObserver(sync_service_.get())).Times(1);
     EXPECT_CALL(*mock_remote_service(),
                 GetLocalChangeProcessor())
         .WillRepeatedly(Return(&local_change_processor_));
     EXPECT_CALL(*mock_remote_service(),
                 SetRemoteChangeProcessor(local_service.get())).Times(1);
 
     sync_service_->Initialize(
         std::move(local_service),
-        scoped_ptr<RemoteFileSyncService>(remote_service_));
+        std::unique_ptr<RemoteFileSyncService>(remote_service_));
 
     // Disable auto sync by default.
     EXPECT_CALL(*mock_remote_service(), SetSyncEnabled(false)).Times(1);
     sync_service_->SetSyncEnabledForTesting(false);
 
     file_system_->SetUp(CannedSyncableFileSystem::QUOTA_ENABLED);
   }
 
   void TearDown() override {
     sync_service_->Shutdown();
@@ skipping 85 matching lines @@
   StrictMock<MockLocalChangeProcessor>* mock_local_change_processor() {
     return &local_change_processor_;
   }
 
   void EnableSync() {
     EXPECT_CALL(*mock_remote_service(), SetSyncEnabled(true)).Times(1);
     sync_service_->SetSyncEnabledForTesting(true);
   }
 
   content::TestBrowserThreadBundle thread_bundle_;
-  scoped_ptr<leveldb::Env> in_memory_env_;
+  std::unique_ptr<leveldb::Env> in_memory_env_;
   TestingProfile profile_;
-  scoped_ptr<CannedSyncableFileSystem> file_system_;
+  std::unique_ptr<CannedSyncableFileSystem> file_system_;
 
   // Their ownerships are transferred to SyncFileSystemService.
   StrictMock<MockRemoteFileSyncService>* remote_service_;
   StrictMock<MockLocalChangeProcessor> local_change_processor_;
 
-  scoped_ptr<SyncFileSystemService> sync_service_;
+  std::unique_ptr<SyncFileSystemService> sync_service_;
 };
 
 TEST_F(SyncFileSystemServiceTest, InitializeForApp) {
   InitializeApp();
 }
 
 TEST_F(SyncFileSystemServiceTest, InitializeForAppSuccess) {
   std::vector<SyncServiceState> expected_states;
   expected_states.push_back(SYNC_SERVICE_RUNNING);
 
@@ skipping 197 matching lines @@
         base::Bind(&AssignValueAndQuit<SyncFileStatus>,
                    &run_loop, &status, &sync_file_status));
     run_loop.Run();
 
     EXPECT_EQ(SYNC_STATUS_OK, status);
     EXPECT_EQ(SYNC_FILE_STATUS_HAS_PENDING_CHANGES, sync_file_status);
   }
 }
 
 }  // namespace sync_file_system