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

device/devices_app/usb/device_impl.cc

 // Copyright 2015 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 "device/devices_app/usb/device_impl.h"
 
 #include <stddef.h>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/stl_util.h"
 #include "device/devices_app/usb/type_converters.h"
 #include "device/usb/usb_descriptors.h"
 #include "device/usb/usb_device.h"
 #include "net/base/io_buffer.h"
 
 namespace device {
@@ skipping 49 matching lines @@
                   size_t buffer_size) {
   mojo::Array<uint8_t> data;
   if (buffer) {
     // TODO(rockot/reillyg): We should change UsbDeviceHandle to use a
     // std::vector<uint8_t> instead of net::IOBuffer. Then we could move
     // instead of copy.
     std::vector<uint8_t> bytes(buffer_size);
     std::copy(buffer->data(), buffer->data() + buffer_size, bytes.begin());
     data.Swap(&bytes);
   }
-  callback->Run(mojo::ConvertTo<TransferStatus>(status), data.Pass());
+  callback->Run(mojo::ConvertTo<TransferStatus>(status), std::move(data));
 }
 
 void OnControlTransferInPermissionCheckComplete(
     scoped_refptr<UsbDeviceHandle> device_handle,
     ControlTransferParamsPtr params,
     int length,
     int timeout,
     scoped_ptr<Device::ControlTransferInCallback> callback,
     bool allowed) {
   if (allowed) {
     scoped_refptr<net::IOBuffer> buffer = CreateTransferBuffer(length);
     device_handle->ControlTransfer(
         USB_DIRECTION_INBOUND,
         mojo::ConvertTo<UsbDeviceHandle::TransferRequestType>(params->type),
         mojo::ConvertTo<UsbDeviceHandle::TransferRecipient>(params->recipient),
         params->request, params->value, params->index, buffer, length, timeout,
         base::Bind(&OnTransferIn, base::Passed(&callback)));
   } else {
     mojo::Array<uint8_t> data;
-    callback->Run(TRANSFER_STATUS_PERMISSION_DENIED, data.Pass());
+    callback->Run(TRANSFER_STATUS_PERMISSION_DENIED, std::move(data));
   }
 }
 
 void OnTransferOut(scoped_ptr<MojoTransferOutCallback> callback,
                    UsbTransferStatus status,
                    scoped_refptr<net::IOBuffer> buffer,
                    size_t buffer_size) {
   callback->Run(mojo::ConvertTo<TransferStatus>(status));
 }
 
@@ skipping 29 matching lines @@
   mojo::Array<mojo::Array<uint8_t>> packets(num_packets);
   if (buffer) {
     for (size_t i = 0; i < num_packets; ++i) {
       size_t packet_index = i * packet_size;
       std::vector<uint8_t> bytes(packet_size);
       std::copy(buffer->data() + packet_index,
                 buffer->data() + packet_index + packet_size, bytes.begin());
       packets[i].Swap(&bytes);
     }
   }
-  callback->Run(mojo::ConvertTo<TransferStatus>(status), packets.Pass());
+  callback->Run(mojo::ConvertTo<TransferStatus>(status), std::move(packets));
 }
 
 void OnIsochronousTransferOut(
     scoped_ptr<Device::IsochronousTransferOutCallback> callback,
     UsbTransferStatus status,
     scoped_refptr<net::IOBuffer> buffer,
     size_t buffer_size) {
   callback->Run(mojo::ConvertTo<TransferStatus>(status));
 }
 
 }  // namespace
 
 DeviceImpl::DeviceImpl(scoped_refptr<UsbDevice> device,
                        PermissionProviderPtr permission_provider,
                        mojo::InterfaceRequest<Device> request)
-    : binding_(this, request.Pass()),
+    : binding_(this, std::move(request)),
       device_(device),
-      permission_provider_(permission_provider.Pass()),
+      permission_provider_(std::move(permission_provider)),
       weak_factory_(this) {
   // This object owns itself and will be destroyed if either the message pipe
   // it is bound to is closed or the PermissionProvider it depends on is
   // unavailable.
   binding_.set_connection_error_handler([this]() { delete this; });
   permission_provider_.set_connection_error_handler([this]() { delete this; });
 }
 
 DeviceImpl::~DeviceImpl() {
   CloseHandle();
@@ skipping 270 matching lines @@
     memcpy(packet, packets[i].storage().data(), packets[i].size());
   }
   device_handle_->IsochronousTransfer(
       USB_DIRECTION_OUTBOUND, endpoint_address, buffer, transfer_size,
       static_cast<uint32_t>(packets.size()), packet_size, timeout,
       base::Bind(&OnIsochronousTransferOut, base::Passed(&callback_ptr)));
 }
 
 }  // namespace usb
 }  // namespace device