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

components/proximity_auth/remote_device_life_cycle_impl.cc

 // Copyright 2015 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/proximity_auth/remote_device_life_cycle_impl.h"
 
+#include <utility>
+
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/time/default_tick_clock.h"
 #include "components/proximity_auth/ble/bluetooth_low_energy_connection.h"
 #include "components/proximity_auth/ble/bluetooth_low_energy_connection_finder.h"
 #include "components/proximity_auth/bluetooth_connection.h"
 #include "components/proximity_auth/bluetooth_connection_finder.h"
 #include "components/proximity_auth/bluetooth_throttler_impl.h"
 #include "components/proximity_auth/cryptauth/secure_message_delegate.h"
@@ skipping 94 matching lines @@
   connection_finder_ = CreateConnectionFinder();
   connection_finder_->Find(
       base::Bind(&RemoteDeviceLifeCycleImpl::OnConnectionFound,
                  weak_ptr_factory_.GetWeakPtr()));
   TransitionToState(RemoteDeviceLifeCycle::State::FINDING_CONNECTION);
 }
 
 void RemoteDeviceLifeCycleImpl::OnConnectionFound(
     scoped_ptr<Connection> connection) {
   DCHECK(state_ == RemoteDeviceLifeCycle::State::FINDING_CONNECTION);
-  connection_ = connection.Pass();
+  connection_ = std::move(connection);
   authenticator_ = CreateAuthenticator();
   authenticator_->Authenticate(
       base::Bind(&RemoteDeviceLifeCycleImpl::OnAuthenticationResult,
                  weak_ptr_factory_.GetWeakPtr()));
   TransitionToState(RemoteDeviceLifeCycle::State::AUTHENTICATING);
 }
 
 void RemoteDeviceLifeCycleImpl::OnAuthenticationResult(
     Authenticator::Result result,
     scoped_ptr<SecureContext> secure_context) {
   DCHECK(state_ == RemoteDeviceLifeCycle::State::AUTHENTICATING);
   authenticator_.reset();
   if (result != Authenticator::Result::SUCCESS) {
     PA_LOG(WARNING) << "Waiting " << kAuthenticationRecoveryTimeSeconds
                     << " seconds to retry after authentication failure.";
     connection_->Disconnect();
     authentication_recovery_timer_.Start(
         FROM_HERE,
         base::TimeDelta::FromSeconds(kAuthenticationRecoveryTimeSeconds), this,
         &RemoteDeviceLifeCycleImpl::FindConnection);
     TransitionToState(RemoteDeviceLifeCycle::State::AUTHENTICATION_FAILED);
     return;
   }
 
   // Create the MessengerImpl asynchronously. |messenger_| registers itself as
   // an observer of |connection_|, so creating it synchronously would trigger
   // |OnSendCompleted()| as an observer call for |messenger_|.
-  secure_context_ = secure_context.Pass();
+  secure_context_ = std::move(secure_context);
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(&RemoteDeviceLifeCycleImpl::CreateMessenger,
                             weak_ptr_factory_.GetWeakPtr()));
 }
 
 void RemoteDeviceLifeCycleImpl::CreateMessenger() {
   DCHECK(state_ == RemoteDeviceLifeCycle::State::AUTHENTICATING);
   DCHECK(secure_context_);
   messenger_.reset(
-      new MessengerImpl(connection_.Pass(), secure_context_.Pass()));
+      new MessengerImpl(std::move(connection_), std::move(secure_context_)));
   messenger_->AddObserver(this);
 
   TransitionToState(RemoteDeviceLifeCycle::State::SECURE_CHANNEL_ESTABLISHED);
 }
 
 void RemoteDeviceLifeCycleImpl::OnDisconnected() {
   DCHECK(state_ == RemoteDeviceLifeCycle::State::SECURE_CHANNEL_ESTABLISHED);
   messenger_.reset();
   FindConnection();
 }
 
 }  // namespace proximity_auth