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

components/sync_driver/glue/sync_backend_host_impl.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 "components/sync_driver/glue/sync_backend_host_impl.h"
 
 #include <map>
 #include <utility>
 #include <vector>
 
@@ skipping 56 matching lines @@
                                   weak_ptr_factory_.GetWeakPtr());
 }
 
 SyncBackendHostImpl::~SyncBackendHostImpl() {
   DCHECK(!core_.get() && !frontend_) << "Must call Shutdown before destructor.";
   DCHECK(!registrar_.get());
 }
 
 void SyncBackendHostImpl::Initialize(
     sync_driver::SyncFrontend* frontend,
-    scoped_ptr<base::Thread> sync_thread,
+    std::unique_ptr<base::Thread> sync_thread,
     const scoped_refptr<base::SingleThreadTaskRunner>& db_thread,
     const scoped_refptr<base::SingleThreadTaskRunner>& file_thread,
     const syncer::WeakHandle<syncer::JsEventHandler>& event_handler,
     const GURL& sync_service_url,
     const std::string& sync_user_agent,
     const syncer::SyncCredentials& credentials,
     bool delete_sync_data_folder,
-    scoped_ptr<syncer::SyncManagerFactory> sync_manager_factory,
+    std::unique_ptr<syncer::SyncManagerFactory> sync_manager_factory,
     const syncer::WeakHandle<syncer::UnrecoverableErrorHandler>&
         unrecoverable_error_handler,
     const base::Closure& report_unrecoverable_error_function,
     const HttpPostProviderFactoryGetter& http_post_provider_factory_getter,
-    scoped_ptr<syncer::SyncEncryptionHandler::NigoriState> saved_nigori_state) {
+    std::unique_ptr<syncer::SyncEncryptionHandler::NigoriState>
+        saved_nigori_state) {
   registrar_.reset(new browser_sync::SyncBackendRegistrar(
       name_, sync_client_, std::move(sync_thread), ui_thread_, db_thread,
       file_thread));
   CHECK(registrar_->sync_thread());
 
   frontend_ = frontend;
   DCHECK(frontend);
 
   syncer::ModelSafeRoutingInfo routing_info;
   std::vector<scoped_refptr<syncer::ModelSafeWorker> > workers;
@@ skipping 15 matching lines @@
         InternalComponentsFactory::FORCE_ENABLE_PRE_COMMIT_UPDATE_AVOIDANCE;
   }
   syncer::PassphraseTransitionClearDataOption clear_data_option =
       syncer::PASSPHRASE_TRANSITION_DO_NOT_CLEAR_DATA;
   if (cl->HasSwitch(switches::kSyncEnableClearDataOnPassphraseEncryption))
     clear_data_option = syncer::PASSPHRASE_TRANSITION_CLEAR_DATA;
 
   std::map<syncer::ModelType, int64_t> invalidation_versions;
   sync_prefs_->GetInvalidationVersions(&invalidation_versions);
 
-  scoped_ptr<DoInitializeOptions> init_opts(new DoInitializeOptions(
+  std::unique_ptr<DoInitializeOptions> init_opts(new DoInitializeOptions(
       registrar_->sync_thread()->message_loop(), registrar_.get(), routing_info,
       workers, sync_client_->GetExtensionsActivity(), event_handler,
       sync_service_url, sync_user_agent,
       http_post_provider_factory_getter.Run(
           core_->GetRequestContextCancelationSignal()),
       credentials, invalidator_ ? invalidator_->GetInvalidatorClientId() : "",
       std::move(sync_manager_factory), delete_sync_data_folder,
       sync_prefs_->GetEncryptionBootstrapToken(),
       sync_prefs_->GetKeystoreEncryptionBootstrapToken(),
-      scoped_ptr<InternalComponentsFactory>(
+      std::unique_ptr<InternalComponentsFactory>(
           new syncer::InternalComponentsFactoryImpl(factory_switches)),
       unrecoverable_error_handler, report_unrecoverable_error_function,
       std::move(saved_nigori_state), clear_data_option, invalidation_versions));
   InitCore(std::move(init_opts));
 }
 
 void SyncBackendHostImpl::TriggerRefresh(const syncer::ModelTypeSet& types) {
   DCHECK(ui_thread_->BelongsToCurrentThread());
   registrar_->sync_thread()->task_runner()->PostTask(
       FROM_HERE,
@@ skipping 95 matching lines @@
   // Stop non-blocking sync types from sending any more requests to the syncer.
   model_type_connector_.reset();
 
   DCHECK(registrar_->sync_thread()->IsRunning());
 
   registrar_->RequestWorkerStopOnUIThread();
 
   core_->ShutdownOnUIThread();
 }
 
-scoped_ptr<base::Thread> SyncBackendHostImpl::Shutdown(
+std::unique_ptr<base::Thread> SyncBackendHostImpl::Shutdown(
     syncer::ShutdownReason reason) {
   // StopSyncingForShutdown() (which nulls out |frontend_|) should be
   // called first.
   DCHECK(!frontend_);
   DCHECK(registrar_->sync_thread()->IsRunning());
 
   bool sync_thread_claimed = (reason != syncer::BROWSER_SHUTDOWN);
 
   if (invalidation_handler_registered_) {
     if (reason == syncer::DISABLE_SYNC) {
@@ skipping 12 matching lines @@
 
   // Worker cleanup.
   SyncBackendRegistrar* detached_registrar = registrar_.release();
   detached_registrar->sync_thread()->task_runner()->PostTask(
       FROM_HERE, base::Bind(&SyncBackendRegistrar::Shutdown,
                             base::Unretained(detached_registrar)));
 
   if (sync_thread_claimed)
     return detached_registrar->ReleaseSyncThread();
   else
-    return scoped_ptr<base::Thread>();
+    return std::unique_ptr<base::Thread>();
 }
 
 void SyncBackendHostImpl::UnregisterInvalidationIds() {
   if (invalidation_handler_registered_) {
     CHECK(invalidator_->UpdateRegisteredInvalidationIds(this,
                                                         syncer::ObjectIdSet()));
   }
 }
 
 syncer::ModelTypeSet SyncBackendHostImpl::ConfigureDataTypes(
@@ skipping 137 matching lines @@
     sync_driver::ChangeProcessor* change_processor) {
   registrar_->ActivateDataType(type, group, change_processor, GetUserShare());
 }
 
 void SyncBackendHostImpl::DeactivateDirectoryDataType(syncer::ModelType type) {
   registrar_->DeactivateDataType(type);
 }
 
 void SyncBackendHostImpl::ActivateNonBlockingDataType(
     syncer::ModelType type,
-    scoped_ptr<syncer_v2::ActivationContext> activation_context) {
+    std::unique_ptr<syncer_v2::ActivationContext> activation_context) {
   registrar_->RegisterNonBlockingType(type);
   model_type_connector_->ConnectType(type, std::move(activation_context));
 }
 
 void SyncBackendHostImpl::DeactivateNonBlockingDataType(
     syncer::ModelType type) {
   model_type_connector_->DisconnectType(type);
 }
 
 syncer::UserShare* SyncBackendHostImpl::GetUserShare() const {
@@ skipping 82 matching lines @@
 void SyncBackendHostImpl::GetAllNodesForTypes(
     syncer::ModelTypeSet types,
     base::Callback<void(const std::vector<syncer::ModelType>&,
                         ScopedVector<base::ListValue>)> callback) {
   DCHECK(initialized());
   registrar_->sync_thread()->task_runner()->PostTask(
       FROM_HERE, base::Bind(&SyncBackendHostCore::GetAllNodesForTypes, core_,
                             types, frontend_loop_->task_runner(), callback));
 }
 
-void SyncBackendHostImpl::InitCore(scoped_ptr<DoInitializeOptions> options) {
+void SyncBackendHostImpl::InitCore(
+    std::unique_ptr<DoInitializeOptions> options) {
   registrar_->sync_thread()->task_runner()->PostTask(
       FROM_HERE, base::Bind(&SyncBackendHostCore::DoInitialize, core_.get(),
                             base::Passed(&options)));
 }
 
 void SyncBackendHostImpl::RequestConfigureSyncer(
     syncer::ConfigureReason reason,
     syncer::ModelTypeSet to_download,
     syncer::ModelTypeSet to_purge,
     syncer::ModelTypeSet to_journal,
@@ skipping 36 matching lines @@
   CHECK(initialized());
   syncer::Experiments experiments;
   if (core_->sync_manager()->ReceivedExperiment(&experiments))
     frontend_->OnExperimentsChanged(experiments);
 }
 
 void SyncBackendHostImpl::HandleInitializationSuccessOnFrontendLoop(
     const syncer::WeakHandle<syncer::JsBackend> js_backend,
     const syncer::WeakHandle<syncer::DataTypeDebugInfoListener>
         debug_info_listener,
-    scoped_ptr<syncer_v2::ModelTypeConnector> model_type_connector,
+    std::unique_ptr<syncer_v2::ModelTypeConnector> model_type_connector,
     const std::string& cache_guid) {
   DCHECK_EQ(base::MessageLoop::current(), frontend_loop_);
 
   model_type_connector_ = std::move(model_type_connector);
 
   if (!frontend_)
     return;
 
   initialized_ = true;
 
@@ skipping 179 matching lines @@
 
   DCHECK_EQ(base::MessageLoop::current(), frontend_loop_);
 
   DVLOG(1) << "Connection status changed: "
            << syncer::ConnectionStatusToString(status);
   frontend_->OnConnectionStatusChange(status);
 }
 
 void SyncBackendHostImpl::HandleProtocolEventOnFrontendLoop(
     syncer::ProtocolEvent* event) {
-  scoped_ptr<syncer::ProtocolEvent> scoped_event(event);
+  std::unique_ptr<syncer::ProtocolEvent> scoped_event(event);
   if (!frontend_)
     return;
   frontend_->OnProtocolEvent(*scoped_event);
 }
 
 void SyncBackendHostImpl::HandleDirectoryCommitCountersUpdatedOnFrontendLoop(
     syncer::ModelType type,
     const syncer::CommitCounters& counters) {
   if (!frontend_)
     return;
@@ skipping 52 matching lines @@
     const syncer::SyncManager::ClearServerDataCallback& frontend_callback) {
   DCHECK(ui_thread_->BelongsToCurrentThread());
   frontend_callback.Run();
 }
 
 }  // namespace browser_sync
 
 #undef SDVLOG
 
 #undef SLOG