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

net/socket/websocket_transport_client_socket_pool.cc

 // Copyright 2014 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/websocket_transport_client_socket_pool.h"
 
 #include <algorithm>
+#include <utility>
 
 #include "base/compiler_specific.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_util.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "base/values.h"
@@ skipping 307 matching lines @@
       NetLog::TYPE_SOCKET_POOL_BOUND_TO_CONNECT_JOB,
       connect_job->net_log().source().ToEventParametersCallback());
   if (rv == OK) {
     HandOutSocket(connect_job->PassSocket(),
                   connect_job->connect_timing(),
                   handle,
                   request_net_log);
     request_net_log.EndEvent(NetLog::TYPE_SOCKET_POOL);
   } else if (rv == ERR_IO_PENDING) {
     // TODO(ricea): Implement backup job timer?
-    AddJob(handle, connect_job.Pass());
+    AddJob(handle, std::move(connect_job));
   } else {
     scoped_ptr<StreamSocket> error_socket;
     connect_job->GetAdditionalErrorState(handle);
     error_socket = connect_job->PassSocket();
     if (error_socket) {
-      HandOutSocket(error_socket.Pass(),
-                    connect_job->connect_timing(),
-                    handle,
-                    request_net_log);
+      HandOutSocket(std::move(error_socket), connect_job->connect_timing(),
+                    handle, request_net_log);
     }
   }
 
   if (rv != ERR_IO_PENDING) {
     request_net_log.EndEventWithNetErrorCode(NetLog::TYPE_SOCKET_POOL, rv);
   }
 
   return rv;
 }
 
 void WebSocketTransportClientSocketPool::RequestSockets(
     const std::string& group_name,
     const void* params,
     int num_sockets,
     const BoundNetLog& net_log) {
   NOTIMPLEMENTED();
 }
 
 void WebSocketTransportClientSocketPool::CancelRequest(
     const std::string& group_name,
     ClientSocketHandle* handle) {
   DCHECK(!handle->is_initialized());
   if (DeleteStalledRequest(handle))
     return;
   scoped_ptr<StreamSocket> socket = handle->PassSocket();
   if (socket)
-    ReleaseSocket(handle->group_name(), socket.Pass(), handle->id());
+    ReleaseSocket(handle->group_name(), std::move(socket), handle->id());
   if (!DeleteJob(handle))
     pending_callbacks_.erase(handle);
   if (!ReachedMaxSocketsLimit() && !stalled_request_queue_.empty())
     ActivateStalledRequest();
 }
 
 void WebSocketTransportClientSocketPool::ReleaseSocket(
     const std::string& group_name,
     scoped_ptr<StreamSocket> socket,
     int id) {
@@ skipping 60 matching lines @@
         bool include_nested_pools) const {
   scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
   dict->SetString("name", name);
   dict->SetString("type", type);
   dict->SetInteger("handed_out_socket_count", handed_out_socket_count_);
   dict->SetInteger("connecting_socket_count", pending_connects_.size());
   dict->SetInteger("idle_socket_count", 0);
   dict->SetInteger("max_socket_count", max_sockets_);
   dict->SetInteger("max_sockets_per_group", max_sockets_);
   dict->SetInteger("pool_generation_number", 0);
-  return dict.Pass();
+  return dict;
 }
 
 TimeDelta WebSocketTransportClientSocketPool::ConnectionTimeout() const {
   return TimeDelta::FromSeconds(kTransportConnectJobTimeoutInSeconds);
 }
 
 bool WebSocketTransportClientSocketPool::IsStalled() const {
   return !stalled_request_queue_.empty();
 }
 
@@ skipping 13 matching lines @@
   BoundNetLog request_net_log = job->request_net_log();
   CompletionCallback callback = job->callback();
   LoadTimingInfo::ConnectTiming connect_timing = job->connect_timing();
 
   ClientSocketHandle* const handle = job->handle();
   bool handed_out_socket = false;
 
   if (result == OK) {
     DCHECK(socket.get());
     handed_out_socket = true;
-    HandOutSocket(socket.Pass(), connect_timing, handle, request_net_log);
+    HandOutSocket(std::move(socket), connect_timing, handle, request_net_log);
     request_net_log.EndEvent(NetLog::TYPE_SOCKET_POOL);
   } else {
     // If we got a socket, it must contain error information so pass that
     // up so that the caller can retrieve it.
     job->GetAdditionalErrorState(handle);
     if (socket.get()) {
       handed_out_socket = true;
-      HandOutSocket(socket.Pass(), connect_timing, handle, request_net_log);
+      HandOutSocket(std::move(socket), connect_timing, handle, request_net_log);
     }
     request_net_log.EndEventWithNetErrorCode(NetLog::TYPE_SOCKET_POOL, result);
   }
   bool delete_succeeded = DeleteJob(handle);
   DCHECK(delete_succeeded);
   if (!handed_out_socket && !stalled_request_queue_.empty() &&
       !ReachedMaxSocketsLimit())
     ActivateStalledRequest();
   InvokeUserCallbackLater(handle, callback, result);
 }
@@ skipping 23 matching lines @@
          base::checked_cast<int>(pending_connects_.size()) >=
              max_sockets_ - handed_out_socket_count_;
 }
 
 void WebSocketTransportClientSocketPool::HandOutSocket(
     scoped_ptr<StreamSocket> socket,
     const LoadTimingInfo::ConnectTiming& connect_timing,
     ClientSocketHandle* handle,
     const BoundNetLog& net_log) {
   DCHECK(socket);
-  handle->SetSocket(socket.Pass());
+  handle->SetSocket(std::move(socket));
   DCHECK_EQ(ClientSocketHandle::UNUSED, handle->reuse_type());
   DCHECK_EQ(0, handle->idle_time().InMicroseconds());
   handle->set_pool_id(0);
   handle->set_connect_timing(connect_timing);
 
   net_log.AddEvent(
       NetLog::TYPE_SOCKET_POOL_BOUND_TO_SOCKET,
       handle->socket()->NetLog().source().ToEventParametersCallback());
 
   ++handed_out_socket_count_;
@@ skipping 86 matching lines @@
     const BoundNetLog& net_log)
     : params(params),
       priority(priority),
       handle(handle),
       callback(callback),
       net_log(net_log) {}
 
 WebSocketTransportClientSocketPool::StalledRequest::~StalledRequest() {}
 
 }  // namespace net