Use std::move() instead of scoped_ptr<>::Pass().

remoting/protocol/ssl_hmac_channel_authenticator_unittest.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 "remoting/protocol/ssl_hmac_channel_authenticator.h"
 
 #include "base/base64.h"
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
@@ skipping 58 matching lines @@
     key_pair_ = RsaKeyPair::FromString(key_base64);
     ASSERT_TRUE(key_pair_.get());
   }
 
   void RunChannelAuth(int expected_client_error, int expected_host_error) {
     client_fake_socket_.reset(new FakeStreamSocket());
     host_fake_socket_.reset(new FakeStreamSocket());
     client_fake_socket_->PairWith(host_fake_socket_.get());
 
     client_auth_->SecureAndAuthenticate(
-        client_fake_socket_.Pass(),
+        std::move(client_fake_socket_),
         base::Bind(&SslHmacChannelAuthenticatorTest::OnClientConnected,
                    base::Unretained(this)));
 
     host_auth_->SecureAndAuthenticate(
-        host_fake_socket_.Pass(),
+        std::move(host_fake_socket_),
         base::Bind(&SslHmacChannelAuthenticatorTest::OnHostConnected,
                    base::Unretained(this), std::string("ref argument value")));
 
     // Expect two callbacks to be called - the client callback and the host
     // callback.
     int callback_counter = 2;
 
     if (expected_client_error != net::OK) {
       EXPECT_CALL(client_callback_, OnDone(expected_client_error, nullptr))
           .WillOnce(QuitThreadOnCounter(&callback_counter));
@@ skipping 20 matching lines @@
 
   void OnHostConnected(const std::string& ref_argument,
                        int error,
                        scoped_ptr<P2PStreamSocket> socket) {
     // Try deleting the authenticator and verify that this doesn't destroy
     // reference parameters.
     host_auth_.reset();
     DCHECK_EQ(ref_argument, "ref argument value");
 
     host_callback_.OnDone(error, socket.get());
-    host_socket_ = socket.Pass();
+    host_socket_ = std::move(socket);
   }
 
   void OnClientConnected(int error, scoped_ptr<P2PStreamSocket> socket) {
     client_auth_.reset();
     client_callback_.OnDone(error, socket.get());
-    client_socket_ = socket.Pass();
+    client_socket_ = std::move(socket);
   }
 
   base::MessageLoop message_loop_;
 
   scoped_refptr<RsaKeyPair> key_pair_;
   std::string host_cert_;
   scoped_ptr<FakeStreamSocket> client_fake_socket_;
   scoped_ptr<FakeStreamSocket> host_fake_socket_;
   scoped_ptr<ChannelAuthenticator> client_auth_;
   scoped_ptr<ChannelAuthenticator> host_auth_;
@@ skipping 51 matching lines @@
   host_auth_ = SslHmacChannelAuthenticator::CreateForHost(
       host_cert_, key_pair_, kTestSharedSecret);
 
   RunChannelAuth(net::ERR_CERT_INVALID, net::ERR_CONNECTION_CLOSED);
 
   ASSERT_TRUE(host_socket_.get() == nullptr);
 }
 
 }  // namespace protocol
 }  // namespace remoting