Convert Pass()→std::move() in mojo/services/

mojo/services/network/udp_socket_impl.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 "mojo/services/network/udp_socket_impl.h"
 
 #include <string.h>
-
 #include <algorithm>
 #include <limits>
+#include <utility>
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/stl_util.h"
 #include "mojo/services/network/net_adapters.h"
 #include "mojo/services/network/net_address_type_converters.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/base/rand_callback.h"
 #include "net/udp/datagram_socket.h"
 
 namespace mojo {
 
 namespace {
 
 const int kMaxReadSize = 128 * 1024;
 const size_t kMaxWriteSize = 128 * 1024;
 const size_t kMaxPendingSendRequestsUpperbound = 128;
 const size_t kDefaultMaxPendingSendRequests = 32;
 
 }  // namespace
 
 UDPSocketImpl::PendingSendRequest::PendingSendRequest() {}
 
 UDPSocketImpl::PendingSendRequest::~PendingSendRequest() {}
 
 UDPSocketImpl::UDPSocketImpl(InterfaceRequest<UDPSocket> request,
                              scoped_ptr<mojo::AppRefCount> app_refcount)
-    : binding_(this, request.Pass()),
+    : binding_(this, std::move(request)),
       socket_(net::DatagramSocket::DEFAULT_BIND,
               net::RandIntCallback(),
               nullptr,
               net::NetLog::Source()),
       state_(NOT_BOUND_OR_CONNECTED),
       allow_address_reuse_(false),
       remaining_recv_slots_(0),
       max_pending_send_requests_(kDefaultMaxPendingSendRequests),
-      app_refcount_(app_refcount.Pass()) {
-}
+      app_refcount_(std::move(app_refcount)) {}
 
 UDPSocketImpl::~UDPSocketImpl() {
   STLDeleteElements(&pending_send_requests_);
 }
 
 void UDPSocketImpl::AllowAddressReuse(
     const Callback<void(NetworkErrorPtr)>& callback) {
   if (IsBoundOrConnected()) {
     callback.Run(MakeNetworkError(net::ERR_FAILED));
     return;
@@ skipping 194 matching lines @@
     return;
   }
 
   if (sendto_buffer_.get()) {
     if (pending_send_requests_.size() >= max_pending_send_requests_) {
       callback.Run(MakeNetworkError(net::ERR_INSUFFICIENT_RESOURCES));
       return;
     }
 
     PendingSendRequest* request = new PendingSendRequest;
-    request->addr = dest_addr.Pass();
-    request->data = data.Pass();
+    request->addr = std::move(dest_addr);
+    request->data = std::move(data);
     request->callback = callback;
     pending_send_requests_.push_back(request);
     return;
   }
 
   DCHECK_EQ(0u, pending_send_requests_.size());
 
-  DoSendTo(dest_addr.Pass(), data.Pass(), callback);
+  DoSendTo(std::move(dest_addr), std::move(data), callback);
 }
 
 void UDPSocketImpl::DoRecvFrom() {
   DCHECK(IsBoundOrConnected());
   DCHECK(receiver_);
   DCHECK(!recvfrom_buffer_.get());
   DCHECK_GT(remaining_recv_slots_, 0u);
 
   recvfrom_buffer_ = new net::IOBuffer(kMaxReadSize);
 
@@ skipping 58 matching lines @@
       net_address = NetAddress::From(recvfrom_address_);
 
     std::vector<uint8_t> data(net_result);
     if (net_result > 0)
       memcpy(&data[0], recvfrom_buffer_->data(), net_result);
 
     array.Swap(&data);
   }
   recvfrom_buffer_ = nullptr;
 
-  receiver_->OnReceived(MakeNetworkError(net_result), net_address.Pass(),
-                        array.Pass());
+  receiver_->OnReceived(MakeNetworkError(net_result), std::move(net_address),
+                        std::move(array));
   DCHECK_GT(remaining_recv_slots_, 0u);
   remaining_recv_slots_--;
   if (remaining_recv_slots_ > 0)
     DoRecvFrom();
 }
 
 void UDPSocketImpl::OnSendToCompleted(
     const Callback<void(NetworkErrorPtr)>& callback,
     int net_result) {
   DCHECK(sendto_buffer_.get());
 
   sendto_buffer_ = nullptr;
 
   callback.Run(MakeNetworkError(net_result));
 
   if (pending_send_requests_.empty())
     return;
 
   scoped_ptr<PendingSendRequest> request(pending_send_requests_.front());
   pending_send_requests_.pop_front();
 
-  DoSendTo(request->addr.Pass(), request->data.Pass(), request->callback);
+  DoSendTo(std::move(request->addr), std::move(request->data),
+           request->callback);
 }
 
 }  // namespace mojo