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

net/socket/socks_client_socket_pool.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/socks_client_socket_pool.h"
 
+#include <utility>
+
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "net/base/net_errors.h"
 #include "net/socket/client_socket_factory.h"
 #include "net/socket/client_socket_handle.h"
 #include "net/socket/client_socket_pool_base.h"
 #include "net/socket/socks5_client_socket.h"
 #include "net/socket/socks_client_socket.h"
@@ skipping 117 matching lines @@
   ResetTimer(base::TimeDelta::FromSeconds(kSOCKSConnectJobTimeoutInSeconds));
   next_state_ = STATE_SOCKS_CONNECT;
   return result;
 }
 
 int SOCKSConnectJob::DoSOCKSConnect() {
   next_state_ = STATE_SOCKS_CONNECT_COMPLETE;
 
   // Add a SOCKS connection on top of the tcp socket.
   if (socks_params_->is_socks_v5()) {
-    socket_.reset(new SOCKS5ClientSocket(transport_socket_handle_.Pass(),
+    socket_.reset(new SOCKS5ClientSocket(std::move(transport_socket_handle_),
                                          socks_params_->destination()));
   } else {
-    socket_.reset(new SOCKSClientSocket(transport_socket_handle_.Pass(),
+    socket_.reset(new SOCKSClientSocket(std::move(transport_socket_handle_),
                                         socks_params_->destination(),
-                                        priority(),
-                                        resolver_));
+                                        priority(), resolver_));
   }
   return socket_->Connect(
       base::Bind(&SOCKSConnectJob::OnIOComplete, base::Unretained(this)));
 }
 
 int SOCKSConnectJob::DoSOCKSConnectComplete(int result) {
   if (result != OK) {
     socket_->Disconnect();
     return result;
   }
 
-  SetSocket(socket_.Pass());
+  SetSocket(std::move(socket_));
   return result;
 }
 
 int SOCKSConnectJob::ConnectInternal() {
   next_state_ = STATE_TRANSPORT_CONNECT;
   return DoLoop(OK);
 }
 
 scoped_ptr<ConnectJob>
 SOCKSClientSocketPool::SOCKSConnectJobFactory::NewConnectJob(
@@ skipping 61 matching lines @@
 }
 
 void SOCKSClientSocketPool::CancelRequest(const std::string& group_name,
                                           ClientSocketHandle* handle) {
   base_.CancelRequest(group_name, handle);
 }
 
 void SOCKSClientSocketPool::ReleaseSocket(const std::string& group_name,
                                           scoped_ptr<StreamSocket> socket,
                                           int id) {
-  base_.ReleaseSocket(group_name, socket.Pass(), id);
+  base_.ReleaseSocket(group_name, std::move(socket), id);
 }
 
 void SOCKSClientSocketPool::FlushWithError(int error) {
   base_.FlushWithError(error);
 }
 
 void SOCKSClientSocketPool::CloseIdleSockets() {
   base_.CloseIdleSockets();
 }
 
@@ skipping 14 matching lines @@
 scoped_ptr<base::DictionaryValue> SOCKSClientSocketPool::GetInfoAsValue(
     const std::string& name,
     const std::string& type,
     bool include_nested_pools) const {
   scoped_ptr<base::DictionaryValue> dict(base_.GetInfoAsValue(name, type));
   if (include_nested_pools) {
     scoped_ptr<base::ListValue> list(new base::ListValue());
     list->Append(transport_pool_->GetInfoAsValue("transport_socket_pool",
                                                  "transport_socket_pool",
                                                  false));
-    dict->Set("nested_pools", list.Pass());
+    dict->Set("nested_pools", std::move(list));
   }
-  return dict.Pass();
+  return dict;
 }
 
 base::TimeDelta SOCKSClientSocketPool::ConnectionTimeout() const {
   return base_.ConnectionTimeout();
 }
 
 bool SOCKSClientSocketPool::IsStalled() const {
   return base_.IsStalled();
 }
 
 void SOCKSClientSocketPool::AddHigherLayeredPool(
     HigherLayeredPool* higher_pool) {
   base_.AddHigherLayeredPool(higher_pool);
 }
 
 void SOCKSClientSocketPool::RemoveHigherLayeredPool(
     HigherLayeredPool* higher_pool) {
   base_.RemoveHigherLayeredPool(higher_pool);
 }
 
 bool SOCKSClientSocketPool::CloseOneIdleConnection() {
   if (base_.CloseOneIdleSocket())
     return true;
   return base_.CloseOneIdleConnectionInHigherLayeredPool();
 }
 
 }  // namespace net