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

remoting/protocol/ssl_hmac_channel_authenticator.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/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback_helpers.h"
 #include "base/logging.h"
@@ skipping 45 matching lines @@
     verify_result->cert_status = net::CERT_STATUS_INVALID;
     return net::ERR_CERT_INVALID;
   }
 };
 
 // Implements net::StreamSocket interface on top of P2PStreamSocket to be passed
 // to net::SSLClientSocket and net::SSLServerSocket.
 class NetStreamSocketAdapter : public net::StreamSocket {
  public:
   NetStreamSocketAdapter(scoped_ptr<P2PStreamSocket> socket)
-      : socket_(socket.Pass()) {}
+      : socket_(std::move(socket)) {}
   ~NetStreamSocketAdapter() override {}
 
   int Read(net::IOBuffer* buf, int buf_len,
            const net::CompletionCallback& callback) override {
     return socket_->Read(buf, buf_len, callback);
   }
   int Write(net::IOBuffer* buf, int buf_len,
             const net::CompletionCallback& callback) override {
     return socket_->Write(buf, buf_len, callback);
   }
@@ skipping 63 matching lines @@
 
  private:
   scoped_ptr<P2PStreamSocket> socket_;
   net::BoundNetLog net_log_;
 };
 
 // Implements P2PStreamSocket interface on top of net::StreamSocket.
 class P2PStreamSocketAdapter : public P2PStreamSocket {
  public:
   P2PStreamSocketAdapter(scoped_ptr<net::StreamSocket> socket)
-      : socket_(socket.Pass()) {}
+      : socket_(std::move(socket)) {}
   ~P2PStreamSocketAdapter() override {}
 
   int Read(const scoped_refptr<net::IOBuffer>& buf, int buf_len,
            const net::CompletionCallback& callback) override {
     return socket_->Read(buf.get(), buf_len, callback);
   }
   int Write(const scoped_refptr<net::IOBuffer>& buf, int buf_len,
             const net::CompletionCallback& callback) override {
     return socket_->Write(buf.get(), buf_len, callback);
   }
 
  private:
   scoped_ptr<net::StreamSocket> socket_;
 };
 
 }  // namespace
 
 // static
 scoped_ptr<SslHmacChannelAuthenticator>
 SslHmacChannelAuthenticator::CreateForClient(
       const std::string& remote_cert,
       const std::string& auth_key) {
   scoped_ptr<SslHmacChannelAuthenticator> result(
       new SslHmacChannelAuthenticator(auth_key));
   result->remote_cert_ = remote_cert;
-  return result.Pass();
+  return result;
 }
 
 scoped_ptr<SslHmacChannelAuthenticator>
 SslHmacChannelAuthenticator::CreateForHost(
     const std::string& local_cert,
     scoped_refptr<RsaKeyPair> key_pair,
     const std::string& auth_key) {
   scoped_ptr<SslHmacChannelAuthenticator> result(
       new SslHmacChannelAuthenticator(auth_key));
   result->local_cert_ = local_cert;
   result->local_key_pair_ = key_pair;
-  return result.Pass();
+  return result;
 }
 
 SslHmacChannelAuthenticator::SslHmacChannelAuthenticator(
     const std::string& auth_key)
     : auth_key_(auth_key) {
 }
 
 SslHmacChannelAuthenticator::~SslHmacChannelAuthenticator() {
 }
 
@@ skipping 18 matching lines @@
     if (!cert.get()) {
       LOG(ERROR) << "Failed to parse X509Certificate";
       NotifyError(net::ERR_FAILED);
       return;
     }
 
     net::SSLServerConfig ssl_config;
     ssl_config.require_ecdhe = true;
 
     scoped_ptr<net::SSLServerSocket> server_socket = net::CreateSSLServerSocket(
-        make_scoped_ptr(new NetStreamSocketAdapter(socket.Pass())), cert.get(),
-        local_key_pair_->private_key(), ssl_config);
+        make_scoped_ptr(new NetStreamSocketAdapter(std::move(socket))),
+        cert.get(), local_key_pair_->private_key(), ssl_config);
     net::SSLServerSocket* raw_server_socket = server_socket.get();
-    socket_ = server_socket.Pass();
+    socket_ = std::move(server_socket);
     result = raw_server_socket->Handshake(
         base::Bind(&SslHmacChannelAuthenticator::OnConnected,
                    base::Unretained(this)));
 #endif
   } else {
     transport_security_state_.reset(new net::TransportSecurityState);
     cert_verifier_.reset(new FailingCertVerifier);
 
     net::SSLConfig::CertAndStatus cert_and_status;
     cert_and_status.cert_status = net::CERT_STATUS_AUTHORITY_INVALID;
     cert_and_status.der_cert = remote_cert_;
 
     net::SSLConfig ssl_config;
     // Certificate verification and revocation checking are not needed
     // because we use self-signed certs. Disable it so that the SSL
     // layer doesn't try to initialize OCSP (OCSP works only on the IO
     // thread).
     ssl_config.cert_io_enabled = false;
     ssl_config.rev_checking_enabled = false;
     ssl_config.allowed_bad_certs.push_back(cert_and_status);
     ssl_config.require_ecdhe = true;
 
     net::HostPortPair host_and_port(kSslFakeHostName, 0);
     net::SSLClientSocketContext context;
     context.transport_security_state = transport_security_state_.get();
     context.cert_verifier = cert_verifier_.get();
     scoped_ptr<net::ClientSocketHandle> socket_handle(
         new net::ClientSocketHandle);
     socket_handle->SetSocket(
-        make_scoped_ptr(new NetStreamSocketAdapter(socket.Pass())));
+        make_scoped_ptr(new NetStreamSocketAdapter(std::move(socket))));
 
 #if defined(OS_NACL)
     // net_nacl doesn't include ClientSocketFactory.
     socket_.reset(new net::SSLClientSocketOpenSSL(
-        socket_handle.Pass(), host_and_port, ssl_config, context));
+        std::move(socket_handle), host_and_port, ssl_config, context));
 #else
     socket_ =
         net::ClientSocketFactory::GetDefaultFactory()->CreateSSLClientSocket(
-            socket_handle.Pass(), host_and_port, ssl_config, context);
+            std::move(socket_handle), host_and_port, ssl_config, context);
 #endif
 
     result = socket_->Connect(
         base::Bind(&SslHmacChannelAuthenticator::OnConnected,
                    base::Unretained(this)));
   }
 
   if (result == net::ERR_IO_PENDING)
     return;
 
@@ skipping 139 matching lines @@
 }
 
 void SslHmacChannelAuthenticator::CheckDone(bool* callback_called) {
   if (auth_write_buf_.get() == nullptr && auth_read_buf_.get() == nullptr) {
     DCHECK(socket_.get() != nullptr);
     if (callback_called)
       *callback_called = true;
 
     base::ResetAndReturn(&done_callback_)
         .Run(net::OK,
-             make_scoped_ptr(new P2PStreamSocketAdapter(socket_.Pass())));
+             make_scoped_ptr(new P2PStreamSocketAdapter(std::move(socket_))));
   }
 }
 
 void SslHmacChannelAuthenticator::NotifyError(int error) {
   base::ResetAndReturn(&done_callback_).Run(error, nullptr);
 }
 
 }  // namespace protocol
 }  // namespace remoting