Convert //components/sync_driver from scoped_ptr to std::unique_ptr

components/sync_driver/glue/sync_backend_registrar_unittest.cc

 // Copyright 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 "components/sync_driver/glue/sync_backend_registrar.h"
 
 #include "base/location.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "components/sync_driver/change_processor_mock.h"
@@ skipping 90 matching lines @@
 
   ~SyncBackendRegistrarTest() override {}
 
   void SetUp() override {
     db_thread_.StartAndWaitForTesting();
     file_thread_.StartAndWaitForTesting();
     test_user_share_.SetUp();
     sync_client_.reset(new RegistrarSyncClient(
         ui_task_runner(), db_task_runner(), file_task_runner()));
     registrar_.reset(new SyncBackendRegistrar(
-        "test", sync_client_.get(), scoped_ptr<base::Thread>(),
+        "test", sync_client_.get(), std::unique_ptr<base::Thread>(),
         ui_task_runner(), db_task_runner(), file_task_runner()));
     sync_thread_ = registrar_->sync_thread();
   }
 
   void TearDown() override {
     registrar_->RequestWorkerStopOnUIThread();
     test_user_share_.TearDown();
     sync_thread_->task_runner()->PostTask(
         FROM_HERE, base::Bind(&SyncBackendRegistrar::Shutdown,
                               base::Unretained(registrar_.release())));
@@ skipping 28 matching lines @@
 
   const scoped_refptr<base::SingleThreadTaskRunner> file_task_runner() {
     return db_thread_.task_runner();
   }
 
   base::MessageLoop message_loop_;
   base::Thread db_thread_;
   base::Thread file_thread_;
 
   syncer::TestUserShare test_user_share_;
-  scoped_ptr<RegistrarSyncClient> sync_client_;
-  scoped_ptr<SyncBackendRegistrar> registrar_;
+  std::unique_ptr<RegistrarSyncClient> sync_client_;
+  std::unique_ptr<SyncBackendRegistrar> registrar_;
 
   base::Thread* sync_thread_;
 };
 
 TEST_F(SyncBackendRegistrarTest, ConstructorEmpty) {
   registrar_->SetInitialTypes(ModelTypeSet());
   EXPECT_FALSE(registrar_->IsNigoriEnabled());
   {
     std::vector<scoped_refptr<syncer::ModelSafeWorker> > workers;
     registrar_->GetWorkers(&workers);
@@ skipping 179 matching lines @@
   }
 
   const scoped_refptr<base::SingleThreadTaskRunner> file_task_runner() {
     return file_thread_.task_runner();
   }
 
   base::MessageLoop message_loop_;
   base::Thread db_thread_;
   base::Thread file_thread_;
 
-  scoped_ptr<RegistrarSyncClient> sync_client_;
+  std::unique_ptr<RegistrarSyncClient> sync_client_;
   base::WaitableEvent db_thread_blocked_;
 
   base::Lock db_thread_lock_;
   base::RunLoop run_loop_;
   base::Closure quit_closure_;
 };
 
 // Wrap SyncBackendRegistrar so that we can monitor its lifetime.
 class TestRegistrar : public SyncBackendRegistrar {
  public:
   explicit TestRegistrar(
       sync_driver::SyncClient* sync_client,
       const scoped_refptr<base::SingleThreadTaskRunner>& ui_thread,
       const scoped_refptr<base::SingleThreadTaskRunner>& db_thread,
       const scoped_refptr<base::SingleThreadTaskRunner>& file_thread,
       SyncBackendRegistrarShutdownTest* test)
       : SyncBackendRegistrar("test",
                              sync_client,
-                             scoped_ptr<base::Thread>(),
+                             std::unique_ptr<base::Thread>(),
                              ui_thread,
                              db_thread,
                              file_thread),
         test_(test) {}
 
   ~TestRegistrar() override { test_->PostQuitOnUIMessageLoop(); }
 
  private:
   SyncBackendRegistrarShutdownTest* test_;
 };
 
 TEST_F(SyncBackendRegistrarShutdownTest, BlockingShutdown) {
   // Take ownership of |db_thread_lock_| so that the DB thread can't acquire it.
   db_thread_lock_.Acquire();
 
   // This will block the DB thread by waiting on |db_thread_lock_|.
   db_task_runner()->PostTask(
       FROM_HERE, base::Bind(&SyncBackendRegistrarShutdownTest::BlockDBThread,
                             base::Unretained(this)));
 
-  scoped_ptr<TestRegistrar> registrar(
+  std::unique_ptr<TestRegistrar> registrar(
       new TestRegistrar(sync_client_.get(), ui_task_runner(), db_task_runner(),
                         file_task_runner(), this));
   base::Thread* sync_thread = registrar->sync_thread();
 
   // Stop here until the DB thread gets a chance to run and block on the lock.
   // Please note that since the task above didn't finish, the task to
   // initialize the worker on the DB thread hasn't had a chance to run yet too.
   // Which means ModelSafeWorker::SetWorkingLoopToCurrent hasn't been called
   // for the DB worker.
   db_thread_blocked_.Wait();
@@ skipping 17 matching lines @@
   db_thread_lock_.Release();
 
   // Run the main thread loop until all workers have been removed and the
   // registrar destroyed.
   run_loop_.Run();
 }
 
 }  // namespace
 
 }  // namespace browser_sync