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

net/dns/dns_session.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/dns/dns_session.h"
 
 #include <stdint.h>
-
 #include <limits>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/lazy_instance.h"
 #include "base/macros.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/metrics/sample_vector.h"
 #include "base/rand_util.h"
 #include "base/stl_util.h"
 #include "base/time/time.h"
 #include "net/base/ip_endpoint.h"
@@ skipping 51 matching lines @@
 base::LazyInstance<DnsSession::RttBuckets>::Leaky DnsSession::rtt_buckets_ =
     LAZY_INSTANCE_INITIALIZER;
 
 DnsSession::RttBuckets::RttBuckets() : base::BucketRanges(kRTTBucketCount + 1) {
   base::Histogram::InitializeBucketRanges(1, 5000, this);
 }
 
 DnsSession::SocketLease::SocketLease(scoped_refptr<DnsSession> session,
                                      unsigned server_index,
                                      scoped_ptr<DatagramClientSocket> socket)
-    : session_(session), server_index_(server_index), socket_(socket.Pass()) {}
+    : session_(session),
+      server_index_(server_index),
+      socket_(std::move(socket)) {}
 
 DnsSession::SocketLease::~SocketLease() {
-  session_->FreeSocket(server_index_, socket_.Pass());
+  session_->FreeSocket(server_index_, std::move(socket_));
 }
 
 DnsSession::DnsSession(const DnsConfig& config,
                        scoped_ptr<DnsSocketPool> socket_pool,
                        const RandIntCallback& rand_int_callback,
                        NetLog* net_log)
     : config_(config),
-      socket_pool_(socket_pool.Pass()),
+      socket_pool_(std::move(socket_pool)),
       rand_callback_(base::Bind(rand_int_callback,
                                 0,
                                 std::numeric_limits<uint16_t>::max())),
       net_log_(net_log),
       server_index_(0) {
   socket_pool_->Initialize(&config_.nameservers, net_log);
   UMA_HISTOGRAM_CUSTOM_COUNTS(
       "AsyncDNS.ServerCount", config_.nameservers.size(), 0, 10, 11);
   for (size_t i = 0; i < config_.nameservers.size(); ++i) {
     server_stats_.push_back(make_scoped_ptr(
@@ skipping 129 matching lines @@
     unsigned server_index, const NetLog::Source& source) {
   scoped_ptr<DatagramClientSocket> socket;
 
   socket = socket_pool_->AllocateSocket(server_index);
   if (!socket.get())
     return scoped_ptr<SocketLease>();
 
   socket->NetLog().BeginEvent(NetLog::TYPE_SOCKET_IN_USE,
                               source.ToEventParametersCallback());
 
-  SocketLease* lease = new SocketLease(this, server_index, socket.Pass());
+  SocketLease* lease = new SocketLease(this, server_index, std::move(socket));
   return scoped_ptr<SocketLease>(lease);
 }
 
 scoped_ptr<StreamSocket> DnsSession::CreateTCPSocket(
     unsigned server_index, const NetLog::Source& source) {
   return socket_pool_->CreateTCPSocket(server_index, source);
 }
 
 // Release a socket.
 void DnsSession::FreeSocket(unsigned server_index,
                             scoped_ptr<DatagramClientSocket> socket) {
   DCHECK(socket.get());
 
   socket->NetLog().EndEvent(NetLog::TYPE_SOCKET_IN_USE);
 
-  socket_pool_->FreeSocket(server_index, socket.Pass());
+  socket_pool_->FreeSocket(server_index, std::move(socket));
 }
 
 base::TimeDelta DnsSession::NextTimeoutFromJacobson(unsigned server_index,
                                                     int attempt) {
   DCHECK_LT(server_index, server_stats_.size());
 
   base::TimeDelta timeout = server_stats_[server_index]->rtt_estimate +
                             4 * server_stats_[server_index]->rtt_deviation;
 
   timeout = std::max(timeout, base::TimeDelta::FromMilliseconds(kMinTimeoutMs));
@@ skipping 30 matching lines @@
   timeout = std::max(timeout, base::TimeDelta::FromMilliseconds(kMinTimeoutMs));
 
   // The timeout still doubles every full round.
   unsigned num_backoffs = attempt / config_.nameservers.size();
 
   return std::min(timeout * (1 << num_backoffs),
                   base::TimeDelta::FromMilliseconds(kMaxTimeoutMs));
 }
 
 }  // namespace net