Convert Pass()→std::move() in //components/[n-z]*

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 <utility>
+
 #include "base/command_line.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/single_thread_task_runner.h"
 #include "components/invalidation/public/invalidation_service.h"
 #include "components/invalidation/public/object_id_invalidation_map.h"
 #include "components/signin/core/browser/signin_client.h"
 #include "components/sync_driver/glue/sync_backend_host_core.h"
 #include "components/sync_driver/glue/sync_backend_registrar.h"
 #include "components/sync_driver/invalidation_helper.h"
@@ skipping 61 matching lines @@
     const std::string& sync_user_agent,
     const syncer::SyncCredentials& credentials,
     bool delete_sync_data_folder,
     scoped_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) {
   registrar_.reset(new browser_sync::SyncBackendRegistrar(
-      name_, sync_client_, sync_thread.Pass(), ui_thread_, db_thread,
+      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;
   registrar_->GetModelSafeRoutingInfo(&routing_info);
   registrar_->GetWorkers(&workers);
@@ skipping 20 matching lines @@
   std::map<syncer::ModelType, int64_t> invalidation_versions;
   sync_prefs_->GetInvalidationVersions(&invalidation_versions);
 
   scoped_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() : "",
-      sync_manager_factory.Pass(), delete_sync_data_folder,
+      std::move(sync_manager_factory), delete_sync_data_folder,
       sync_prefs_->GetEncryptionBootstrapToken(),
       sync_prefs_->GetKeystoreEncryptionBootstrapToken(),
       scoped_ptr<InternalComponentsFactory>(
-          new syncer::InternalComponentsFactoryImpl(factory_switches))
-          .Pass(),
+          new syncer::InternalComponentsFactoryImpl(factory_switches)),
       unrecoverable_error_handler, report_unrecoverable_error_function,
-      saved_nigori_state.Pass(), clear_data_option, invalidation_versions));
-  InitCore(init_opts.Pass());
+      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,
       base::Bind(&SyncBackendHostCore::DoRefreshTypes, core_.get(), types));
 }
 
 void SyncBackendHostImpl::UpdateCredentials(
@@ skipping 283 matching lines @@
   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) {
-  sync_context_proxy_->ConnectTypeToSync(type, activation_context.Pass());
+  sync_context_proxy_->ConnectTypeToSync(type, std::move(activation_context));
 }
 
 void SyncBackendHostImpl::DeactivateNonBlockingDataType(
     syncer::ModelType type) {
   sync_context_proxy_->Disconnect(type);
 }
 
 syncer::UserShare* SyncBackendHostImpl::GetUserShare() const {
   return core_->sync_manager()->GetUserShare();
 }
@@ skipping 404 matching lines @@
     const syncer::SyncManager::ClearServerDataCallback& frontend_callback) {
   DCHECK(ui_thread_->BelongsToCurrentThread());
   frontend_callback.Run();
 }
 
 }  // namespace browser_sync
 
 #undef SDVLOG
 
 #undef SLOG