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

net/dns/dns_transaction.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_transaction.h"
 
 #include <deque>
 #include <string>
+#include <utility>
 #include <vector>
 
 #include "base/big_endian.h"
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/metrics/histogram.h"
@@ skipping 41 matching lines @@
   return ParseIPLiteralToNumber(hostname, &ip);
 }
 
 scoped_ptr<base::Value> NetLogStartCallback(
     const std::string* hostname,
     uint16_t qtype,
     NetLogCaptureMode /* capture_mode */) {
   scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
   dict->SetString("hostname", *hostname);
   dict->SetInteger("query_type", qtype);
-  return dict.Pass();
+  return std::move(dict);
 };
 
 // ----------------------------------------------------------------------------
 
 // A single asynchronous DNS exchange, which consists of sending out a
 // DNS query, waiting for a response, and returning the response that it
 // matches. Logging is done in the socket and in the outer DnsTransaction.
 class DnsAttempt {
  public:
   explicit DnsAttempt(unsigned server_index)
@@ skipping 21 matching lines @@
   // to the NetLog source source of the UDP socket used.  The request must have
   // completed before this is called.
   scoped_ptr<base::Value> NetLogResponseCallback(
       NetLogCaptureMode capture_mode) const {
     DCHECK(GetResponse()->IsValid());
 
     scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
     dict->SetInteger("rcode", GetResponse()->rcode());
     dict->SetInteger("answer_count", GetResponse()->answer_count());
     GetSocketNetLog().source().AddToEventParameters(dict.get());
-    return dict.Pass();
+    return std::move(dict);
   }
 
   void set_result(int result) {
     result_ = result;
   }
 
   // True if current attempt is pending (waiting for server response).
   bool is_pending() const {
     return result_ == ERR_IO_PENDING;
   }
@@ skipping 12 matching lines @@
 };
 
 class DnsUDPAttempt : public DnsAttempt {
  public:
   DnsUDPAttempt(unsigned server_index,
                 scoped_ptr<DnsSession::SocketLease> socket_lease,
                 scoped_ptr<DnsQuery> query)
       : DnsAttempt(server_index),
         next_state_(STATE_NONE),
         received_malformed_response_(false),
-        socket_lease_(socket_lease.Pass()),
-        query_(query.Pass()) {}
+        socket_lease_(std::move(socket_lease)),
+        query_(std::move(query)) {}
 
   // DnsAttempt:
   int Start(const CompletionCallback& callback) override {
     DCHECK_EQ(STATE_NONE, next_state_);
     callback_ = callback;
     start_time_ = base::TimeTicks::Now();
     next_state_ = STATE_SEND_QUERY;
     return DoLoop(OK);
   }
 
@@ skipping 139 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(DnsUDPAttempt);
 };
 
 class DnsTCPAttempt : public DnsAttempt {
  public:
   DnsTCPAttempt(unsigned server_index,
                 scoped_ptr<StreamSocket> socket,
                 scoped_ptr<DnsQuery> query)
       : DnsAttempt(server_index),
         next_state_(STATE_NONE),
-        socket_(socket.Pass()),
-        query_(query.Pass()),
+        socket_(std::move(socket)),
+        query_(std::move(query)),
         length_buffer_(new IOBufferWithSize(sizeof(uint16_t))),
         response_length_(0) {}
 
   // DnsAttempt:
   int Start(const CompletionCallback& callback) override {
     DCHECK_EQ(STATE_NONE, next_state_);
     callback_ = callback;
     start_time_ = base::TimeTicks::Now();
     next_state_ = STATE_CONNECT_COMPLETE;
     int rv = socket_->Connect(base::Bind(&DnsTCPAttempt::OnIOComplete,
@@ skipping 399 matching lines @@
         (first_server_index_ + attempt_number) % config.nameservers.size();
     // Skip over known failed servers.
     server_index = session_->NextGoodServerIndex(server_index);
 
     scoped_ptr<DnsSession::SocketLease> lease =
         session_->AllocateSocket(server_index, net_log_.source());
 
     bool got_socket = !!lease.get();
 
     DnsUDPAttempt* attempt =
-        new DnsUDPAttempt(server_index, lease.Pass(), query.Pass());
+        new DnsUDPAttempt(server_index, std::move(lease), std::move(query));
 
     attempts_.push_back(make_scoped_ptr(attempt));
     ++attempts_count_;
 
     if (!got_socket)
       return AttemptResult(ERR_CONNECTION_REFUSED, NULL);
 
     net_log_.AddEvent(
         NetLog::TYPE_DNS_TRANSACTION_ATTEMPT,
         attempt->GetSocketNetLog().source().ToEventParametersCallback());
@@ skipping 23 matching lines @@
     uint16_t id = session_->NextQueryId();
     scoped_ptr<DnsQuery> query =
         previous_attempt->GetQuery()->CloneWithNewId(id);
 
     RecordLostPacketsIfAny();
     // Cancel all other attempts, no point waiting on them.
     attempts_.clear();
 
     unsigned attempt_number = attempts_.size();
 
-    DnsTCPAttempt* attempt = new DnsTCPAttempt(server_index, socket.Pass(),
-                                               query.Pass());
+    DnsTCPAttempt* attempt =
+        new DnsTCPAttempt(server_index, std::move(socket), std::move(query));
 
     attempts_.push_back(make_scoped_ptr(attempt));
     ++attempts_count_;
     had_tcp_attempt_ = true;
 
     net_log_.AddEvent(
         NetLog::TYPE_DNS_TRANSACTION_TCP_ATTEMPT,
         attempt->GetSocketNetLog().source().ToEventParametersCallback());
 
     int rv = attempt->Start(base::Bind(&DnsTransactionImpl::OnAttemptComplete,
@@ skipping 209 matching lines @@
 }  // namespace
 
 // static
 scoped_ptr<DnsTransactionFactory> DnsTransactionFactory::CreateFactory(
     DnsSession* session) {
   return scoped_ptr<DnsTransactionFactory>(
       new DnsTransactionFactoryImpl(session));
 }
 
 }  // namespace net