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

components/sync_driver/glue/sync_backend_registrar.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 <cstddef>
 #include <utility>
 
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "components/sync_driver/change_processor.h"
 #include "components/sync_driver/sync_client.h"
 #include "sync/internal_api/public/user_share.h"
 
 namespace browser_sync {
 
 SyncBackendRegistrar::SyncBackendRegistrar(
     const std::string& name,
     sync_driver::SyncClient* sync_client,
-    scoped_ptr<base::Thread> sync_thread,
+    std::unique_ptr<base::Thread> sync_thread,
     const scoped_refptr<base::SingleThreadTaskRunner>& ui_thread,
     const scoped_refptr<base::SingleThreadTaskRunner>& db_thread,
     const scoped_refptr<base::SingleThreadTaskRunner>& file_thread)
     : name_(name),
       sync_client_(sync_client),
       ui_thread_(ui_thread),
       db_thread_(db_thread),
       file_thread_(file_thread) {
   DCHECK(ui_thread_->BelongsToCurrentThread());
   DCHECK(sync_client_);
@@ skipping 298 matching lines @@
   }
 
   if (last_worker) {
     // Self-destruction after last worker.
     DVLOG(1) << "Destroy registrar on loop of "
              << ModelSafeGroupToString(group);
     delete this;
   }
 }
 
-scoped_ptr<base::Thread> SyncBackendRegistrar::ReleaseSyncThread() {
+std::unique_ptr<base::Thread> SyncBackendRegistrar::ReleaseSyncThread() {
   return std::move(sync_thread_);
 }
 
 void SyncBackendRegistrar::Shutdown() {
   // All data types should have been deactivated by now.
   DCHECK(processors_.empty());
 
   // Unregister worker from observing loop destruction.
   base::AutoLock al(lock_);
   for (WorkerMap::iterator it = workers_.begin(); it != workers_.end(); ++it) {
     it->second->UnregisterForLoopDestruction(
         base::Bind(&SyncBackendRegistrar::OnWorkerUnregistrationDone,
                    base::Unretained(this)));
   }
 }
 
 base::Thread* SyncBackendRegistrar::sync_thread() {
   return sync_thread_.get();
 }
 
 syncer::ModelSafeGroup SyncBackendRegistrar::GetInitialGroupForType(
     syncer::ModelType type) const {
   if (non_blocking_types_.Has(type))
     return syncer::GROUP_NON_BLOCKING;
   else
     return syncer::GROUP_PASSIVE;
 }
 
 }  // namespace browser_sync