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

components/browser_sync/browser/profile_sync_components_factory_impl.cc

 // Copyright (c) 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/browser_sync/browser/profile_sync_components_factory_impl.h"
 
 #include <utility>
 
 #include "base/command_line.h"
+#include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "build/build_config.h"
 #include "components/autofill/core/browser/autofill_wallet_data_type_controller.h"
 #include "components/autofill/core/browser/webdata/autofill_data_type_controller.h"
 #include "components/autofill/core/browser/webdata/autofill_profile_data_type_controller.h"
 #include "components/autofill/core/browser/webdata/autofill_webdata_service.h"
 #include "components/autofill/core/common/autofill_pref_names.h"
 #include "components/autofill/core/common/autofill_switches.h"
 #include "components/browser_sync/browser/profile_sync_service.h"
 #include "components/browser_sync/common/browser_sync_switches.h"
@@ skipping 251 matching lines @@
 browser_sync::SyncBackendHost*
 ProfileSyncComponentsFactoryImpl::CreateSyncBackendHost(
     const std::string& name,
     invalidation::InvalidationService* invalidator,
     const base::WeakPtr<sync_driver::SyncPrefs>& sync_prefs,
     const base::FilePath& sync_folder) {
   return new browser_sync::SyncBackendHostImpl(
       name, sync_client_, ui_thread_, invalidator, sync_prefs, sync_folder);
 }
 
-scoped_ptr<sync_driver::LocalDeviceInfoProvider>
+std::unique_ptr<sync_driver::LocalDeviceInfoProvider>
 ProfileSyncComponentsFactoryImpl::CreateLocalDeviceInfoProvider() {
-  return scoped_ptr<sync_driver::LocalDeviceInfoProvider>(
+  return base::WrapUnique(
       new browser_sync::LocalDeviceInfoProviderImpl(channel_, version_,
                                                     is_tablet_));
 }
 
 class TokenServiceProvider
     : public OAuth2TokenServiceRequest::TokenServiceProvider {
  public:
   TokenServiceProvider(
       const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
       OAuth2TokenService* token_service);
@@ skipping 19 matching lines @@
 
 scoped_refptr<base::SingleThreadTaskRunner>
 TokenServiceProvider::GetTokenServiceTaskRunner() {
   return task_runner_;
 }
 
 OAuth2TokenService* TokenServiceProvider::GetTokenService() {
   return token_service_;
 }
 
-scoped_ptr<syncer::AttachmentService>
+std::unique_ptr<syncer::AttachmentService>
 ProfileSyncComponentsFactoryImpl::CreateAttachmentService(
-    scoped_ptr<syncer::AttachmentStoreForSync> attachment_store,
+    std::unique_ptr<syncer::AttachmentStoreForSync> attachment_store,
     const syncer::UserShare& user_share,
     const std::string& store_birthday,
     syncer::ModelType model_type,
     syncer::AttachmentService::Delegate* delegate) {
-  scoped_ptr<syncer::AttachmentUploader> attachment_uploader;
-  scoped_ptr<syncer::AttachmentDownloader> attachment_downloader;
+  std::unique_ptr<syncer::AttachmentUploader> attachment_uploader;
+  std::unique_ptr<syncer::AttachmentDownloader> attachment_downloader;
   // Only construct an AttachmentUploader and AttachmentDownload if we have sync
   // credentials. We may not have sync credentials because there may not be a
   // signed in sync user.
   if (!user_share.sync_credentials.account_id.empty() &&
       !user_share.sync_credentials.scope_set.empty()) {
     scoped_refptr<OAuth2TokenServiceRequest::TokenServiceProvider>
         token_service_provider(
             new TokenServiceProvider(ui_thread_, token_service_));
     // TODO(maniscalco): Use shared (one per profile) thread-safe instances of
     // AttachmentUploader and AttachmentDownloader instead of creating a new one
@@ skipping 13 matching lines @@
         store_birthday, model_type);
   }
 
   // It is important that the initial backoff delay is relatively large.  For
   // whatever reason, the server may fail all requests for a short period of
   // time.  When this happens we don't want to overwhelm the server with
   // requests so we use a large initial backoff.
   const base::TimeDelta initial_backoff_delay =
       base::TimeDelta::FromMinutes(30);
   const base::TimeDelta max_backoff_delay = base::TimeDelta::FromHours(4);
-  scoped_ptr<syncer::AttachmentService> attachment_service(
+  std::unique_ptr<syncer::AttachmentService> attachment_service(
       new syncer::AttachmentServiceImpl(
           std::move(attachment_store), std::move(attachment_uploader),
           std::move(attachment_downloader), delegate, initial_backoff_delay,
           max_backoff_delay));
   return attachment_service;
 }
 
 sync_driver::SyncApiComponentFactory::SyncComponents
 ProfileSyncComponentsFactoryImpl::CreateBookmarkSyncComponents(
     sync_driver::SyncService* sync_service,
     sync_driver::DataTypeErrorHandler* error_handler) {
   BookmarkModel* bookmark_model =
       sync_service->GetSyncClient()->GetBookmarkModel();
   syncer::UserShare* user_share = sync_service->GetUserShare();
 // TODO(akalin): We may want to propagate this switch up eventually.
 #if defined(OS_ANDROID) || defined(OS_IOS)
   const bool kExpectMobileBookmarksFolder = true;
 #else
   const bool kExpectMobileBookmarksFolder = false;
 #endif
   BookmarkModelAssociator* model_associator = new BookmarkModelAssociator(
       bookmark_model, sync_service->GetSyncClient(), user_share, error_handler,
       kExpectMobileBookmarksFolder);
   BookmarkChangeProcessor* change_processor = new BookmarkChangeProcessor(
       sync_service->GetSyncClient(), model_associator, error_handler);
   return SyncComponents(model_associator, change_processor);
 }