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

components/sync_driver/glue/sync_backend_host_core.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_core.h"
 
 #include <map>
 #include <string>
 #include <utility>
 #include <vector>
@@ skipping 59 matching lines @@
 
 DoInitializeOptions::DoInitializeOptions(
     base::MessageLoop* sync_loop,
     SyncBackendRegistrar* registrar,
     const syncer::ModelSafeRoutingInfo& routing_info,
     const std::vector<scoped_refptr<syncer::ModelSafeWorker>>& workers,
     const scoped_refptr<syncer::ExtensionsActivity>& extensions_activity,
     const syncer::WeakHandle<syncer::JsEventHandler>& event_handler,
     const GURL& service_url,
     const std::string& sync_user_agent,
-    scoped_ptr<syncer::HttpPostProviderFactory> http_bridge_factory,
+    std::unique_ptr<syncer::HttpPostProviderFactory> http_bridge_factory,
     const syncer::SyncCredentials& credentials,
     const std::string& invalidator_client_id,
-    scoped_ptr<syncer::SyncManagerFactory> sync_manager_factory,
+    std::unique_ptr<syncer::SyncManagerFactory> sync_manager_factory,
     bool delete_sync_data_folder,
     const std::string& restored_key_for_bootstrapping,
     const std::string& restored_keystore_key_for_bootstrapping,
-    scoped_ptr<syncer::InternalComponentsFactory> internal_components_factory,
+    std::unique_ptr<syncer::InternalComponentsFactory>
+        internal_components_factory,
     const syncer::WeakHandle<syncer::UnrecoverableErrorHandler>&
         unrecoverable_error_handler,
     const base::Closure& report_unrecoverable_error_function,
-    scoped_ptr<syncer::SyncEncryptionHandler::NigoriState> saved_nigori_state,
+    std::unique_ptr<syncer::SyncEncryptionHandler::NigoriState>
+        saved_nigori_state,
     syncer::PassphraseTransitionClearDataOption clear_data_option,
     const std::map<syncer::ModelType, int64_t>& invalidation_versions)
     : sync_loop(sync_loop),
       registrar(registrar),
       routing_info(routing_info),
       workers(workers),
       extensions_activity(extensions_activity),
       event_handler(event_handler),
       service_url(service_url),
       sync_user_agent(sync_user_agent),
@@ skipping 273 matching lines @@
   host_.Call(
       FROM_HERE,
       &SyncBackendHostImpl::HandleMigrationRequestedOnFrontendLoop,
       types);
 }
 
 void SyncBackendHostCore::OnProtocolEvent(
     const syncer::ProtocolEvent& event) {
   // TODO(rlarocque): Find a way to pass event_clone as a scoped_ptr.
   if (forward_protocol_events_) {
-    scoped_ptr<syncer::ProtocolEvent> event_clone(event.Clone());
+    std::unique_ptr<syncer::ProtocolEvent> event_clone(event.Clone());
     host_.Call(
         FROM_HERE,
         &SyncBackendHostImpl::HandleProtocolEventOnFrontendLoop,
         event_clone.release());
   }
 }
 
 void SyncBackendHostCore::DoOnInvalidatorStateChange(
     syncer::InvalidatorState state) {
   DCHECK_EQ(base::MessageLoop::current(), sync_loop_);
@@ skipping 17 matching lines @@
         auto last_invalidation = last_invalidation_versions_.find(type);
         if (!invalidation.is_unknown_version() &&
             last_invalidation != last_invalidation_versions_.end() &&
             invalidation.version() <= last_invalidation->second) {
           DVLOG(1) << "Ignoring redundant invalidation for "
                    << syncer::ModelTypeToString(type) << " with version "
                    << invalidation.version() << ", last seen version was "
                    << last_invalidation->second;
           continue;
         }
-        scoped_ptr<syncer::InvalidationInterface> inv_adapter(
+        std::unique_ptr<syncer::InvalidationInterface> inv_adapter(
             new InvalidationAdapter(invalidation));
         sync_manager_->OnIncomingInvalidation(type, std::move(inv_adapter));
         if (!invalidation.is_unknown_version())
           last_invalidation_versions_[type] = invalidation.version();
       }
     }
   }
 
   host_.Call(
       FROM_HERE,
       &SyncBackendHostImpl::UpdateInvalidationVersions,
       last_invalidation_versions_);
 }
 
 void SyncBackendHostCore::DoInitialize(
-    scoped_ptr<DoInitializeOptions> options) {
+    std::unique_ptr<DoInitializeOptions> options) {
   DCHECK(!sync_loop_);
   sync_loop_ = options->sync_loop;
   DCHECK(sync_loop_);
 
   // Finish initializing the HttpBridgeFactory.  We do this here because
   // building the user agent may block on some platforms.
   options->http_bridge_factory->Init(options->sync_user_agent,
                                      base::Bind(&BindFetcherToDataTracker));
 
   // Blow away the partial or corrupt sync data folder before doing any more
@@ skipping 343 matching lines @@
 
 void SyncBackendHostCore::ClearServerDataDone(
     const base::Closure& frontend_callback) {
   DCHECK_EQ(base::MessageLoop::current(), sync_loop_);
   host_.Call(FROM_HERE, &SyncBackendHostImpl::ClearServerDataDoneOnFrontendLoop,
              frontend_callback);
 }
 
 
 }  // namespace browser_sync