Convert Pass()→std::move() in //net

net/test/embedded_test_server/embedded_test_server.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/test/embedded_test_server/embedded_test_server.h"
 
+#include <utility>
+
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/path_service.h"
 #include "base/process/process_metrics.h"
 #include "base/run_loop.h"
 #include "base/stl_util.h"
@@ skipping 142 matching lines @@
       if (response)
         break;
     }
   }
 
   if (!response) {
     LOG(WARNING) << "Request not handled. Returning 404: "
                  << request->relative_url;
     scoped_ptr<BasicHttpResponse> not_found_response(new BasicHttpResponse);
     not_found_response->set_code(HTTP_NOT_FOUND);
-    response = not_found_response.Pass();
+    response = std::move(not_found_response);
   }
 
   response->SendResponse(
       base::Bind(&HttpConnection::SendResponseBytes, connection->GetWeakPtr()),
       base::Bind(&EmbeddedTestServer::DidClose, weak_factory_.GetWeakPtr(),
                  connection));
 }
 
 GURL EmbeddedTestServer::GetURL(const std::string& relative_url) const {
   DCHECK(Started()) << "You must start the server first.";
@@ skipping 103 matching lines @@
   std::vector<std::string> headers;
   headers.push_back("PRIVATE KEY");
   PEMTokenizer pem_tokenizer(key_string, headers);
   pem_tokenizer.GetNext();
   std::vector<uint8_t> key_vector;
   key_vector.assign(pem_tokenizer.data().begin(), pem_tokenizer.data().end());
 
   scoped_ptr<crypto::RSAPrivateKey> server_key(
       crypto::RSAPrivateKey::CreateFromPrivateKeyInfo(key_vector));
 
-  return CreateSSLServerSocket(connection.Pass(), GetCertificate().get(),
+  return CreateSSLServerSocket(std::move(connection), GetCertificate().get(),
                                server_key.get(), ssl_config_);
 }
 
 void EmbeddedTestServer::DoAcceptLoop() {
   int rv = OK;
   while (rv == OK) {
     rv = listen_socket_->Accept(
         &accepted_socket_, base::Bind(&EmbeddedTestServer::OnAcceptCompleted,
                                       base::Unretained(this)));
     if (rv == ERR_IO_PENDING)
       return;
-    HandleAcceptResult(accepted_socket_.Pass());
+    HandleAcceptResult(std::move(accepted_socket_));
   }
 }
 
 void EmbeddedTestServer::OnAcceptCompleted(int rv) {
   DCHECK_NE(ERR_IO_PENDING, rv);
-  HandleAcceptResult(accepted_socket_.Pass());
+  HandleAcceptResult(std::move(accepted_socket_));
   DoAcceptLoop();
 }
 
 void EmbeddedTestServer::OnHandshakeDone(HttpConnection* connection, int rv) {
   if (connection->socket_->IsConnected())
     ReadData(connection);
   else
     DidClose(connection);
 }
 
 void EmbeddedTestServer::HandleAcceptResult(scoped_ptr<StreamSocket> socket) {
   DCHECK(io_thread_->task_runner()->BelongsToCurrentThread());
   if (connection_listener_)
     connection_listener_->AcceptedSocket(*socket);
 
   if (is_using_ssl_)
-    socket = DoSSLUpgrade(socket.Pass());
+    socket = DoSSLUpgrade(std::move(socket));
 
   HttpConnection* http_connection = new HttpConnection(
-      socket.Pass(),
+      std::move(socket),
       base::Bind(&EmbeddedTestServer::HandleRequest, base::Unretained(this)));
   connections_[http_connection->socket_.get()] = http_connection;
 
   if (is_using_ssl_) {
     SSLServerSocket* ssl_socket =
         static_cast<SSLServerSocket*>(http_connection->socket_.get());
     int rv = ssl_socket->Handshake(
         base::Bind(&EmbeddedTestServer::OnHandshakeDone, base::Unretained(this),
                    http_connection));
     if (rv != ERR_IO_PENDING)
@@ skipping 78 matching lines @@
                                                    run_loop.QuitClosure())) {
     return false;
   }
   run_loop.Run();
 
   return true;
 }
 
 }  // namespace test_server
 }  // namespace net