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

components/sync_driver/glue/sync_backend_host_impl.h

 // 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.
 
 #ifndef COMPONENTS_SYNC_DRIVER_GLUE_SYNC_BACKEND_HOST_IMPL_H_
 #define COMPONENTS_SYNC_DRIVER_GLUE_SYNC_BACKEND_HOST_IMPL_H_
 
 #include <stdint.h>
 
 #include <map>
+#include <memory>
 #include <string>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/threading/thread.h"
 #include "components/invalidation/public/invalidation_handler.h"
 #include "components/sync_driver/backend_data_type_configurer.h"
 #include "components/sync_driver/glue/sync_backend_host.h"
 #include "sync/internal_api/public/base/model_type.h"
 #include "sync/internal_api/public/configure_reason.h"
 #include "sync/internal_api/public/sessions/sync_session_snapshot.h"
 #include "sync/internal_api/public/sessions/type_debug_info_observer.h"
 #include "sync/internal_api/public/sync_manager.h"
@@ skipping 46 matching lines @@
       sync_driver::SyncClient* sync_client,
       const scoped_refptr<base::SingleThreadTaskRunner>& ui_thread,
       invalidation::InvalidationService* invalidator,
       const base::WeakPtr<sync_driver::SyncPrefs>& sync_prefs,
       const base::FilePath& sync_folder);
   ~SyncBackendHostImpl() override;
 
   // SyncBackendHost implementation.
   void 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& 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)
-      override;
+      std::unique_ptr<syncer::SyncEncryptionHandler::NigoriState>
+          saved_nigori_state) override;
   void TriggerRefresh(const syncer::ModelTypeSet& types) override;
   void UpdateCredentials(const syncer::SyncCredentials& credentials) override;
   void StartSyncingWithServer() override;
   void SetEncryptionPassphrase(const std::string& passphrase,
                                bool is_explicit) override;
   bool SetDecryptionPassphrase(const std::string& passphrase) override
       WARN_UNUSED_RESULT;
   void StopSyncingForShutdown() override;
-  scoped_ptr<base::Thread> Shutdown(syncer::ShutdownReason reason) override;
+  std::unique_ptr<base::Thread> Shutdown(
+      syncer::ShutdownReason reason) override;
   void UnregisterInvalidationIds() override;
   syncer::ModelTypeSet ConfigureDataTypes(
       syncer::ConfigureReason reason,
       const DataTypeConfigStateMap& config_state_map,
       const base::Callback<void(syncer::ModelTypeSet, syncer::ModelTypeSet)>&
           ready_task,
       const base::Callback<void()>& retry_callback) override;
   void ActivateDirectoryDataType(
       syncer::ModelType type,
       syncer::ModelSafeGroup group,
       sync_driver::ChangeProcessor* change_processor) override;
   void DeactivateDirectoryDataType(syncer::ModelType type) override;
   void ActivateNonBlockingDataType(
       syncer::ModelType type,
-      scoped_ptr<syncer_v2::ActivationContext>) override;
+      std::unique_ptr<syncer_v2::ActivationContext>) override;
   void DeactivateNonBlockingDataType(syncer::ModelType type) override;
   void EnableEncryptEverything() override;
   syncer::UserShare* GetUserShare() const override;
   Status GetDetailedStatus() override;
   syncer::sessions::SyncSessionSnapshot GetLastSessionSnapshot() const override;
   bool HasUnsyncedItems() const override;
   bool IsNigoriEnabled() const override;
   syncer::PassphraseType GetPassphraseType() const override;
   base::Time GetExplicitPassphraseTime() const override;
   bool IsCryptographerReady(
@@ skipping 19 matching lines @@
   void OnInvalidatorStateChange(syncer::InvalidatorState state) override;
   void OnIncomingInvalidation(
       const syncer::ObjectIdInvalidationMap& invalidation_map) override;
   std::string GetOwnerName() const override;
 
  protected:
   // The types and functions below are protected so that test
   // subclasses can use them.
 
   // Allows tests to perform alternate core initialization work.
-  virtual void InitCore(scoped_ptr<DoInitializeOptions> options);
+  virtual void InitCore(std::unique_ptr<DoInitializeOptions> options);
 
   // Request the syncer to reconfigure with the specfied params.
   // Virtual for testing.
   virtual void RequestConfigureSyncer(
       syncer::ConfigureReason reason,
       syncer::ModelTypeSet to_download,
       syncer::ModelTypeSet to_purge,
       syncer::ModelTypeSet to_journal,
       syncer::ModelTypeSet to_unapply,
       syncer::ModelTypeSet to_ignore,
@@ skipping 12 matching lines @@
 
   // Reports backend initialization success.  Includes some objects from sync
   // manager initialization to be passed back to the UI thread.
   //
   // |model_type_connector| is our ModelTypeConnector, which is owned because in
   // production it is a proxy object to the real ModelTypeConnector.
   virtual void 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);
 
   // Forwards a ProtocolEvent to the frontend.  Will not be called unless a
   // call to SetForwardProtocolEvents() explicitly requested that we start
   // forwarding these events.
   void HandleProtocolEventOnFrontendLoop(syncer::ProtocolEvent* event);
 
   // Forwards a directory commit counter update to the frontend loop.  Will not
   // be called unless a call to EnableDirectoryTypeDebugInfoForwarding()
   // explicitly requested that we start forwarding these events.
@@ skipping 123 matching lines @@
   // Name used for debugging (set from profile_->GetDebugName()).
   const std::string name_;
 
   // Our core, which communicates directly to the syncapi. Use refptr instead
   // of WeakHandle because |core_| is created on UI loop but released on
   // sync loop.
   scoped_refptr<SyncBackendHostCore> core_;
 
   // A handle referencing the main interface for non-blocking sync types. This
   // object is owned because in production code it is a proxy object.
-  scoped_ptr<syncer_v2::ModelTypeConnector> model_type_connector_;
+  std::unique_ptr<syncer_v2::ModelTypeConnector> model_type_connector_;
 
   bool initialized_;
 
   const base::WeakPtr<sync_driver::SyncPrefs> sync_prefs_;
 
-  scoped_ptr<SyncBackendRegistrar> registrar_;
+  std::unique_ptr<SyncBackendRegistrar> registrar_;
 
   // The frontend which we serve (and are owned by).
   sync_driver::SyncFrontend* frontend_;
 
   // We cache the cryptographer's pending keys whenever NotifyPassphraseRequired
   // is called. This way, before the UI calls SetDecryptionPassphrase on the
   // syncer, it can avoid the overhead of an asynchronous decryption call and
   // give the user immediate feedback about the passphrase entered by first
   // trying to decrypt the cached pending keys on the UI thread. Note that
   // SetDecryptionPassphrase can still fail after the cached pending keys are
@@ skipping 18 matching lines @@
   bool invalidation_handler_registered_;
 
   base::WeakPtrFactory<SyncBackendHostImpl> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(SyncBackendHostImpl);
 };
 
 }  // namespace browser_sync
 
 #endif  // COMPONENTS_SYNC_DRIVER_GLUE_SYNC_BACKEND_HOST_IMPL_H_