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

net/socket/socket_test_util.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/socket_test_util.h"
 
 #include <algorithm>
+#include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
@@ skipping 685 matching lines @@
     const RandIntCallback& rand_int_cb,
     NetLog* net_log,
     const NetLog::Source& source) {
   SocketDataProvider* data_provider = mock_data_.GetNext();
   scoped_ptr<MockUDPClientSocket> socket(
       new MockUDPClientSocket(data_provider, net_log));
   if (bind_type == DatagramSocket::RANDOM_BIND)
     socket->set_source_port(
         static_cast<uint16_t>(rand_int_cb.Run(1025, 65535)));
   udp_client_socket_ports_.push_back(socket->source_port());
-  return socket.Pass();
+  return std::move(socket);
 }
 
 scoped_ptr<StreamSocket> MockClientSocketFactory::CreateTransportClientSocket(
     const AddressList& addresses,
     NetLog* net_log,
     const NetLog::Source& source) {
   SocketDataProvider* data_provider = mock_data_.GetNext();
   scoped_ptr<MockTCPClientSocket> socket(
       new MockTCPClientSocket(addresses, net_log, data_provider));
-  return socket.Pass();
+  return std::move(socket);
 }
 
 scoped_ptr<SSLClientSocket> MockClientSocketFactory::CreateSSLClientSocket(
     scoped_ptr<ClientSocketHandle> transport_socket,
     const HostPortPair& host_and_port,
     const SSLConfig& ssl_config,
     const SSLClientSocketContext& context) {
   SSLSocketDataProvider* next_ssl_data = mock_ssl_data_.GetNext();
   if (!next_ssl_data->next_protos_expected_in_ssl_config.empty()) {
     EXPECT_EQ(next_ssl_data->next_protos_expected_in_ssl_config.size(),
               ssl_config.alpn_protos.size());
     EXPECT_TRUE(
         std::equal(next_ssl_data->next_protos_expected_in_ssl_config.begin(),
                    next_ssl_data->next_protos_expected_in_ssl_config.end(),
                    ssl_config.alpn_protos.begin()));
   }
   return scoped_ptr<SSLClientSocket>(new MockSSLClientSocket(
-      transport_socket.Pass(), host_and_port, ssl_config, next_ssl_data));
+      std::move(transport_socket), host_and_port, ssl_config, next_ssl_data));
 }
 
 void MockClientSocketFactory::ClearSSLSessionCache() {
 }
 
 const char MockClientSocket::kTlsUnique[] = "MOCK_TLSUNIQ";
 
 MockClientSocket::MockClientSocket(const BoundNetLog& net_log)
     : connected_(false),
       net_log_(net_log),
@@ skipping 371 matching lines @@
 }
 
 MockSSLClientSocket::MockSSLClientSocket(
     scoped_ptr<ClientSocketHandle> transport_socket,
     const HostPortPair& host_port_pair,
     const SSLConfig& ssl_config,
     SSLSocketDataProvider* data)
     : MockClientSocket(
           // Have to use the right BoundNetLog for LoadTimingInfo regression
           // tests.
-          transport_socket->socket()->NetLog()),
-      transport_(transport_socket.Pass()),
+          transport_socket->socket()
+              ->NetLog()),
+      transport_(std::move(transport_socket)),
       data_(data) {
   DCHECK(data_);
   peer_addr_ = data->connect.peer_addr;
 }
 
 MockSSLClientSocket::~MockSSLClientSocket() {
   Disconnect();
 }
 
 int MockSSLClientSocket::Read(IOBuffer* buf, int buf_len,
@@ skipping 363 matching lines @@
   bool released_one;
   do {
     released_one = ReleaseOneConnection(keep_alive);
   } while (released_one);
 }
 
 MockTransportClientSocketPool::MockConnectJob::MockConnectJob(
     scoped_ptr<StreamSocket> socket,
     ClientSocketHandle* handle,
     const CompletionCallback& callback)
-    : socket_(socket.Pass()),
-      handle_(handle),
-      user_callback_(callback) {
-}
+    : socket_(std::move(socket)), handle_(handle), user_callback_(callback) {}
 
 MockTransportClientSocketPool::MockConnectJob::~MockConnectJob() {}
 
 int MockTransportClientSocketPool::MockConnectJob::Connect() {
   int rv = socket_->Connect(base::Bind(&MockConnectJob::OnConnect,
                                        base::Unretained(this)));
   if (rv != ERR_IO_PENDING) {
     user_callback_.Reset();
     OnConnect(rv);
   }
   return rv;
 }
 
 bool MockTransportClientSocketPool::MockConnectJob::CancelHandle(
     const ClientSocketHandle* handle) {
   if (handle != handle_)
     return false;
   socket_.reset();
   handle_ = NULL;
   user_callback_.Reset();
   return true;
 }
 
 void MockTransportClientSocketPool::MockConnectJob::OnConnect(int rv) {
   if (!socket_.get())
     return;
   if (rv == OK) {
-    handle_->SetSocket(socket_.Pass());
+    handle_->SetSocket(std::move(socket_));
 
     // Needed for socket pool tests that layer other sockets on top of mock
     // sockets.
     LoadTimingInfo::ConnectTiming connect_timing;
     base::TimeTicks now = base::TimeTicks::Now();
     connect_timing.dns_start = now;
     connect_timing.dns_end = now;
     connect_timing.connect_start = now;
     connect_timing.connect_end = now;
     handle_->set_connect_timing(connect_timing);
@@ skipping 33 matching lines @@
 MockTransportClientSocketPool::~MockTransportClientSocketPool() {}
 
 int MockTransportClientSocketPool::RequestSocket(
     const std::string& group_name, const void* socket_params,
     RequestPriority priority, ClientSocketHandle* handle,
     const CompletionCallback& callback, const BoundNetLog& net_log) {
   last_request_priority_ = priority;
   scoped_ptr<StreamSocket> socket =
       client_socket_factory_->CreateTransportClientSocket(
           AddressList(), net_log.net_log(), NetLog::Source());
-  MockConnectJob* job = new MockConnectJob(socket.Pass(), handle, callback);
+  MockConnectJob* job = new MockConnectJob(std::move(socket), handle, callback);
   job_list_.push_back(make_scoped_ptr(job));
   handle->set_pool_id(1);
   return job->Connect();
 }
 
 void MockTransportClientSocketPool::CancelRequest(const std::string& group_name,
                                                   ClientSocketHandle* handle) {
   for (scoped_ptr<MockConnectJob>& it : job_list_) {
     if (it->CancelHandle(handle)) {
       cancel_count_++;
@@ skipping 34 matching lines @@
 
 void MockSOCKSClientSocketPool::CancelRequest(
     const std::string& group_name,
     ClientSocketHandle* handle) {
   return transport_pool_->CancelRequest(group_name, handle);
 }
 
 void MockSOCKSClientSocketPool::ReleaseSocket(const std::string& group_name,
                                               scoped_ptr<StreamSocket> socket,
                                               int id) {
-  return transport_pool_->ReleaseSocket(group_name, socket.Pass(), id);
+  return transport_pool_->ReleaseSocket(group_name, std::move(socket), id);
 }
 
 ScopedWebSocketEndpointZeroUnlockDelay::
     ScopedWebSocketEndpointZeroUnlockDelay() {
   old_delay_ =
       WebSocketEndpointLockManager::GetInstance()->SetUnlockDelayForTesting(
           base::TimeDelta());
 }
 
 ScopedWebSocketEndpointZeroUnlockDelay::
@@ skipping 26 matching lines @@
 }
 
 int64_t CountWriteBytes(const MockWrite writes[], size_t writes_size) {
   int64_t total = 0;
   for (const MockWrite* write = writes; write != writes + writes_size; ++write)
     total += write->data_len;
   return total;
 }
 
 }  // namespace net