Global conversion of Pass()→std::move() on OS=android

net/socket/ssl_client_socket_openssl_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 "net/socket/ssl_client_socket.h"
 
 #include <errno.h>
-#include <string.h>
-
 #include <openssl/bio.h>
 #include <openssl/bn.h>
 #include <openssl/evp.h>
 #include <openssl/pem.h>
 #include <openssl/rsa.h>
+#include <string.h>
+#include <utility>
 
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/values.h"
 #include "crypto/openssl_util.h"
 #include "crypto/scoped_openssl_types.h"
 #include "net/base/address_list.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
@@ skipping 67 matching lines @@
   }
 
   ~SSLClientSocketOpenSSLClientAuthTest() override { key_store_->Flush(); }
 
  protected:
   scoped_ptr<SSLClientSocket> CreateSSLClientSocket(
       scoped_ptr<StreamSocket> transport_socket,
       const HostPortPair& host_and_port,
       const SSLConfig& ssl_config) {
     scoped_ptr<ClientSocketHandle> connection(new ClientSocketHandle);
-    connection->SetSocket(transport_socket.Pass());
-    return socket_factory_->CreateSSLClientSocket(connection.Pass(),
-                                                  host_and_port,
-                                                  ssl_config,
-                                                  context_);
+    connection->SetSocket(std::move(transport_socket));
+    return socket_factory_->CreateSSLClientSocket(
+        std::move(connection), host_and_port, ssl_config, context_);
   }
 
   // Connect to a HTTPS test server.
   bool ConnectToTestServer(SpawnedTestServer::SSLOptions& ssl_options) {
     test_server_.reset(new SpawnedTestServer(SpawnedTestServer::TYPE_HTTPS,
                                              ssl_options,
                                              base::FilePath()));
     if (!test_server_->Start()) {
       LOG(ERROR) << "Could not start SpawnedTestServer";
       return false;
@@ skipping 29 matching lines @@
   // Create an SSLClientSocket object and use it to connect to a test
   // server, then wait for connection results. This must be called after
   // a succesful ConnectToTestServer() call.
   // |ssl_config| the SSL configuration to use.
   // |result| will retrieve the ::Connect() result value.
   // Returns true on succes, false otherwise. Success means that the socket
   // could be created and its Connect() was called, not that the connection
   // itself was a success.
   bool CreateAndConnectSSLClientSocket(const SSLConfig& ssl_config,
                                        int* result) {
-    sock_ = CreateSSLClientSocket(transport_.Pass(),
-                                  test_server_->host_port_pair(),
-                                  ssl_config);
+    sock_ = CreateSSLClientSocket(std::move(transport_),
+                                  test_server_->host_port_pair(), ssl_config);
 
     if (sock_->IsConnected()) {
       LOG(ERROR) << "SSL Socket prematurely connected";
       return false;
     }
 
     *result = callback_.GetResult(sock_->Connect(callback_.callback()));
     return true;
   }
 
@@ skipping 92 matching lines @@
 
   EXPECT_TRUE(CheckSSLClientSocketSentCert());
 
   sock_->Disconnect();
   EXPECT_FALSE(sock_->IsConnected());
 }
 #endif  // defined(USE_OPENSSL_CERTS)
 
 }  // namespace
 }  // namespace net