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

components/proximity_auth/remote_device_life_cycle_impl_unittest.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 <stddef.h>
+#include <utility>
 
 #include "base/callback.h"
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/test/test_simple_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "components/proximity_auth/authenticator.h"
 #include "components/proximity_auth/connection_finder.h"
 #include "components/proximity_auth/fake_connection.h"
 #include "components/proximity_auth/messenger.h"
@@ skipping 43 matching lines @@
  public:
   FakeConnectionFinder(const RemoteDevice& remote_device)
       : remote_device_(remote_device), connection_(nullptr) {}
   ~FakeConnectionFinder() override {}
 
   void OnConnectionFound() {
     ASSERT_FALSE(connection_callback_.is_null());
     scoped_ptr<FakeConnection> scoped_connection_(
         new FakeConnection(remote_device_));
     connection_ = scoped_connection_.get();
-    connection_callback_.Run(scoped_connection_.Pass());
+    connection_callback_.Run(std::move(scoped_connection_));
   }
 
   FakeConnection* connection() { return connection_; }
 
  private:
   // ConnectionFinder:
   void Find(const ConnectionCallback& connection_callback) override {
     ASSERT_TRUE(connection_callback_.is_null());
     connection_callback_ = connection_callback;
   }
@@ skipping 16 matching lines @@
     EXPECT_FALSE(callback_.is_null());
     EXPECT_EQ(kTestRemoteDevicePublicKey,
               connection_->remote_device().public_key);
   }
 
   void OnAuthenticationResult(Authenticator::Result result) {
     ASSERT_FALSE(callback_.is_null());
     scoped_ptr<SecureContext> secure_context;
     if (result == Authenticator::Result::SUCCESS)
       secure_context.reset(new StubSecureContext());
-    callback_.Run(result, secure_context.Pass());
+    callback_.Run(result, std::move(secure_context));
   }
 
  private:
   // Authenticator:
   void Authenticate(const AuthenticationCallback& callback) override {
     ASSERT_TRUE(callback_.is_null());
     callback_ = callback;
   }
 
   Connection* connection_;
@@ skipping 13 matching lines @@
   ~TestableRemoteDeviceLifeCycleImpl() override {}
 
   FakeConnectionFinder* connection_finder() { return connection_finder_; }
   FakeAuthenticator* authenticator() { return authenticator_; }
 
  private:
   scoped_ptr<ConnectionFinder> CreateConnectionFinder() override {
     scoped_ptr<FakeConnectionFinder> scoped_connection_finder(
         new FakeConnectionFinder(remote_device_));
     connection_finder_ = scoped_connection_finder.get();
-    return scoped_connection_finder.Pass();
+    return std::move(scoped_connection_finder);
   }
 
   scoped_ptr<Authenticator> CreateAuthenticator() override {
     EXPECT_TRUE(connection_finder_);
     scoped_ptr<FakeAuthenticator> scoped_authenticator(
         new FakeAuthenticator(connection_finder_->connection()));
     authenticator_ = scoped_authenticator.get();
-    return scoped_authenticator.Pass();
+    return std::move(scoped_authenticator);
   }
 
   const RemoteDevice remote_device_;
   FakeConnectionFinder* connection_finder_;
   FakeAuthenticator* authenticator_;
 
   DISALLOW_COPY_AND_ASSIGN(TestableRemoteDeviceLifeCycleImpl);
 };
 
 }  // namespace
@@ skipping 144 matching lines @@
 
   // Authentication succeeds on second pass.
   Connection* connection = OnConnectionFound();
   Authenticate(Authenticator::Result::SUCCESS);
   EXPECT_TRUE(life_cycle_.GetMessenger());
   EXPECT_CALL(*this, OnLifeCycleStateChanged(_, _));
   connection->Disconnect();
 }
 
 }  // namespace proximity_auth