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

chrome/browser/extensions/api/sync_file_system/sync_file_system_browsertest.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 <stdint.h>
 #include <utility>
 
 #include "base/json/json_reader.h"
 #include "base/macros.h"
 #include "base/run_loop.h"
@@ skipping 18 matching lines @@
 namespace {
 
 class FakeDriveServiceFactory
     : public drive_backend::SyncEngine::DriveServiceFactory {
  public:
   explicit FakeDriveServiceFactory(
       drive::FakeDriveService::ChangeObserver* change_observer)
       : change_observer_(change_observer) {}
   ~FakeDriveServiceFactory() override {}
 
-  scoped_ptr<drive::DriveServiceInterface> CreateDriveService(
+  std::unique_ptr<drive::DriveServiceInterface> CreateDriveService(
       OAuth2TokenService* oauth2_token_service,
       net::URLRequestContextGetter* url_request_context_getter,
       base::SequencedTaskRunner* blocking_task_runner) override {
-    scoped_ptr<drive::FakeDriveService> drive_service(
+    std::unique_ptr<drive::FakeDriveService> drive_service(
         new drive::FakeDriveService);
     drive_service->AddChangeObserver(change_observer_);
     return std::move(drive_service);
   }
 
  private:
   drive::FakeDriveService::ChangeObserver* change_observer_;
 
   DISALLOW_COPY_AND_ASSIGN(FakeDriveServiceFactory);
 };
@@ skipping 32 matching lines @@
   void SetUpOnMainThread() override {
     ASSERT_TRUE(base_dir_.CreateUniqueTempDir());
 
     SyncFileSystemServiceFactory* factory =
         SyncFileSystemServiceFactory::GetInstance();
 
     content::BrowserContext* context = browser()->profile();
     ExtensionServiceInterface* extension_service =
         extensions::ExtensionSystem::Get(context)->extension_service();
 
-    scoped_ptr<drive_backend::SyncEngine::DriveServiceFactory>
+    std::unique_ptr<drive_backend::SyncEngine::DriveServiceFactory>
         drive_service_factory(new FakeDriveServiceFactory(this));
 
     fake_signin_manager_.reset(new FakeSigninManagerForTesting(
         browser()->profile()));
 
     remote_service_ = new drive_backend::SyncEngine(
         base::ThreadTaskRunnerHandle::Get(),  // ui_task_runner
         MakeSequencedTaskRunner(), MakeSequencedTaskRunner(),
         content::BrowserThread::GetBlockingPool(), base_dir_.path(),
         NULL,  // task_logger
         NULL,  // notification_manager
         extension_service,
         fake_signin_manager_.get(),  // signin_manager
         NULL,                        // token_service
         NULL,                        // request_context
         std::move(drive_service_factory), in_memory_env_.get());
     remote_service_->SetSyncEnabled(true);
     factory->set_mock_remote_file_service(
-        scoped_ptr<RemoteFileSyncService>(remote_service_));
+        std::unique_ptr<RemoteFileSyncService>(remote_service_));
   }
 
   // drive::FakeDriveService::ChangeObserver override.
   void OnNewChangeAvailable() override {
     sync_engine()->OnNotificationReceived();
   }
 
   SyncFileSystemService* sync_file_system_service() {
     return SyncFileSystemServiceFactory::GetForProfile(browser()->profile());
   }
@@ skipping 17 matching lines @@
   }
 
   void WaitUntilIdle() {
     base::RunLoop run_loop;
     sync_file_system_service()->CallOnIdleForTesting(run_loop.QuitClosure());
     run_loop.Run();
   }
 
  private:
   base::ScopedTempDir base_dir_;
-  scoped_ptr<leveldb::Env> in_memory_env_;
+  std::unique_ptr<leveldb::Env> in_memory_env_;
 
-  scoped_ptr<FakeSigninManagerForTesting> fake_signin_manager_;
+  std::unique_ptr<FakeSigninManagerForTesting> fake_signin_manager_;
 
   drive_backend::SyncEngine* remote_service_;
 
   int64_t real_minimum_preserved_space_;
 
   DISALLOW_COPY_AND_ASSIGN(SyncFileSystemTest);
 };
 
 IN_PROC_BROWSER_TEST_F(SyncFileSystemTest, AuthorizationTest) {
   ExtensionTestMessageListener open_failure(
@@ skipping 37 matching lines @@
 
   sync_engine()->GoogleSigninSucceeded("test_account", "tester", "testing");
   WaitUntilIdle();
 
   bar_created.Reply("resume");
 
   EXPECT_TRUE(catcher.GetNextResult());
 }
 
 }  // namespace sync_file_system