Convert Pass()→std::move() in sync/

sync/internal_api/sync_manager_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 "sync/internal_api/sync_manager_impl.h"
 
 #include <stddef.h>
 #include <stdint.h>
-
 #include <string>
+#include <utility>
 
 #include "base/base64.h"
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/json/json_writer.h"
 #include "base/memory/ref_counted.h"
 #include "base/metrics/histogram.h"
 #include "base/observer_list.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 235 matching lines @@
   sync_encryption_handler_->AddObserver(this);
   sync_encryption_handler_->AddObserver(&debug_info_event_listener_);
   sync_encryption_handler_->AddObserver(&js_sync_encryption_handler_observer_);
 
   base::FilePath absolute_db_path = database_path_;
   DCHECK(absolute_db_path.IsAbsolute());
 
   scoped_ptr<syncable::DirectoryBackingStore> backing_store =
       args->internal_components_factory->BuildDirectoryBackingStore(
           InternalComponentsFactory::STORAGE_ON_DISK,
-          args->credentials.account_id, absolute_db_path).Pass();
+          args->credentials.account_id, absolute_db_path);
 
   DCHECK(backing_store.get());
   share_.directory.reset(
       new syncable::Directory(
           backing_store.release(),
           args->unrecoverable_error_handler,
           report_unrecoverable_error_function_,
           sync_encryption_handler_.get(),
           sync_encryption_handler_->GetCryptographerUnsafe()));
   share_.sync_credentials = args->credentials;
@@ skipping 43 matching lines @@
   weak_core.get();
 
   sync_context_proxy_.reset(new syncer_v2::SyncContextProxyImpl(
       base::ThreadTaskRunnerHandle::Get(), weak_core));
 
   // Build a SyncSessionContext and store the worker in it.
   DVLOG(1) << "Sync is bringing up SyncSessionContext.";
   std::vector<SyncEngineEventListener*> listeners;
   listeners.push_back(&allstatus_);
   listeners.push_back(this);
-  session_context_ =
-      args->internal_components_factory->BuildContext(
-                                             connection_manager_.get(),
-                                             directory(),
-                                             args->extensions_activity,
-                                             listeners,
-                                             &debug_info_event_listener_,
-                                             model_type_registry_.get(),
-                                             args->invalidator_client_id)
-          .Pass();
+  session_context_ = args->internal_components_factory->BuildContext(
+      connection_manager_.get(), directory(), args->extensions_activity,
+      listeners, &debug_info_event_listener_, model_type_registry_.get(),
+      args->invalidator_client_id);
   scheduler_ = args->internal_components_factory->BuildScheduler(
-      name_, session_context_.get(), args->cancelation_signal).Pass();
+      name_, session_context_.get(), args->cancelation_signal);
 
   scheduler_->Start(SyncScheduler::CONFIGURATION_MODE, base::Time());
 
   initialized_ = true;
 
   net::NetworkChangeNotifier::AddIPAddressObserver(this);
   net::NetworkChangeNotifier::AddConnectionTypeObserver(this);
   observing_network_connectivity_changes_ = true;
 
   UpdateCredentials(args->credentials);
@@ skipping 558 matching lines @@
   allstatus_.SetNotificationsEnabled(invalidator_enabled);
   scheduler_->SetNotificationsEnabled(invalidator_enabled);
 }
 
 void SyncManagerImpl::OnIncomingInvalidation(
     syncer::ModelType type,
     scoped_ptr<InvalidationInterface> invalidation) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   allstatus_.IncrementNotificationsReceived();
-  scheduler_->ScheduleInvalidationNudge(
-      type,
-      invalidation.Pass(),
-      FROM_HERE);
+  scheduler_->ScheduleInvalidationNudge(type, std::move(invalidation),
+                                        FROM_HERE);
 }
 
 void SyncManagerImpl::RefreshTypes(ModelTypeSet types) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (types.Empty()) {
     LOG(WARNING) << "Sync received refresh request with no types specified.";
   } else {
     scheduler_->ScheduleLocalRefreshRequest(
         types, FROM_HERE);
   }
@@ skipping 112 matching lines @@
 }
 
 void SyncManagerImpl::ClearServerData(const ClearServerDataCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   scheduler_->Start(SyncScheduler::CLEAR_SERVER_DATA_MODE, base::Time());
   ClearParams params(callback);
   scheduler_->ScheduleClearServerData(params);
 }
 
 }  // namespace syncer