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

device/usb/usb_device_handle_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 "device/usb/usb_device_handle_impl.h"
 
 #include <algorithm>
+#include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/string16.h"
 #include "base/synchronization/lock.h"
 #include "base/thread_task_runner_handle.h"
@@ skipping 239 matching lines @@
   }
 
   libusb_fill_control_setup(reinterpret_cast<uint8_t*>(buffer->data()), type,
                             request, value, index, length);
   libusb_fill_control_transfer(transfer->platform_transfer_,
                                device_handle->handle_,
                                reinterpret_cast<uint8_t*>(buffer->data()),
                                &UsbDeviceHandleImpl::Transfer::PlatformCallback,
                                transfer.get(), timeout);
 
-  return transfer.Pass();
+  return transfer;
 }
 
 // static
 scoped_ptr<UsbDeviceHandleImpl::Transfer>
 UsbDeviceHandleImpl::Transfer::CreateBulkTransfer(
     scoped_refptr<UsbDeviceHandleImpl> device_handle,
     uint8_t endpoint,
     scoped_refptr<net::IOBuffer> buffer,
     int length,
     unsigned int timeout,
     scoped_refptr<base::TaskRunner> callback_task_runner,
     const TransferCallback& callback) {
   scoped_ptr<Transfer> transfer(new Transfer(
       device_handle, device_handle->GetClaimedInterfaceForEndpoint(endpoint),
       USB_TRANSFER_BULK, buffer, length, callback_task_runner, callback));
 
   transfer->platform_transfer_ = libusb_alloc_transfer(0);
   if (!transfer->platform_transfer_) {
     USB_LOG(ERROR) << "Failed to allocate bulk transfer.";
     return nullptr;
   }
 
   libusb_fill_bulk_transfer(
       transfer->platform_transfer_, device_handle->handle_, endpoint,
       reinterpret_cast<uint8_t*>(buffer->data()), static_cast<int>(length),
       &UsbDeviceHandleImpl::Transfer::PlatformCallback, transfer.get(),
       timeout);
 
-  return transfer.Pass();
+  return transfer;
 }
 
 // static
 scoped_ptr<UsbDeviceHandleImpl::Transfer>
 UsbDeviceHandleImpl::Transfer::CreateInterruptTransfer(
     scoped_refptr<UsbDeviceHandleImpl> device_handle,
     uint8_t endpoint,
     scoped_refptr<net::IOBuffer> buffer,
     int length,
     unsigned int timeout,
     scoped_refptr<base::TaskRunner> callback_task_runner,
     const TransferCallback& callback) {
   scoped_ptr<Transfer> transfer(new Transfer(
       device_handle, device_handle->GetClaimedInterfaceForEndpoint(endpoint),
       USB_TRANSFER_INTERRUPT, buffer, length, callback_task_runner, callback));
 
   transfer->platform_transfer_ = libusb_alloc_transfer(0);
   if (!transfer->platform_transfer_) {
     USB_LOG(ERROR) << "Failed to allocate interrupt transfer.";
     return nullptr;
   }
 
   libusb_fill_interrupt_transfer(
       transfer->platform_transfer_, device_handle->handle_, endpoint,
       reinterpret_cast<uint8_t*>(buffer->data()), static_cast<int>(length),
       &UsbDeviceHandleImpl::Transfer::PlatformCallback, transfer.get(),
       timeout);
 
-  return transfer.Pass();
+  return transfer;
 }
 
 // static
 scoped_ptr<UsbDeviceHandleImpl::Transfer>
 UsbDeviceHandleImpl::Transfer::CreateIsochronousTransfer(
     scoped_refptr<UsbDeviceHandleImpl> device_handle,
     uint8_t endpoint,
     scoped_refptr<net::IOBuffer> buffer,
     size_t length,
     unsigned int packets,
@@ skipping 14 matching lines @@
     USB_LOG(ERROR) << "Failed to allocate isochronous transfer.";
     return nullptr;
   }
 
   libusb_fill_iso_transfer(
       transfer->platform_transfer_, device_handle->handle_, endpoint,
       reinterpret_cast<uint8_t*>(buffer->data()), static_cast<int>(length),
       packets, &Transfer::PlatformCallback, transfer.get(), timeout);
   libusb_set_iso_packet_lengths(transfer->platform_transfer_, packet_length);
 
-  return transfer.Pass();
+  return transfer;
 }
 
 UsbDeviceHandleImpl::Transfer::Transfer(
     scoped_refptr<UsbDeviceHandleImpl> device_handle,
     scoped_refptr<InterfaceClaimer> claimed_interface,
     UsbTransferType transfer_type,
     scoped_refptr<net::IOBuffer> buffer,
     size_t length,
     scoped_refptr<base::TaskRunner> callback_task_runner,
     const TransferCallback& callback)
@@ skipping 503 matching lines @@
   scoped_ptr<Transfer> transfer = Transfer::CreateControlTransfer(
       this, CreateRequestType(direction, request_type, recipient), request,
       value, index, static_cast<uint16_t>(length), resized_buffer, timeout,
       callback_task_runner, callback);
   if (!transfer) {
     RunTransferCallback(callback_task_runner, callback, USB_TRANSFER_ERROR,
                         buffer, 0);
     return;
   }
 
-  SubmitTransfer(transfer.Pass());
+  SubmitTransfer(std::move(transfer));
 }
 
 void UsbDeviceHandleImpl::IsochronousTransferInternal(
     uint8_t endpoint_address,
     scoped_refptr<net::IOBuffer> buffer,
     size_t length,
     unsigned int packets,
     unsigned int packet_length,
     unsigned int timeout,
     scoped_refptr<base::TaskRunner> callback_task_runner,
@@ skipping 10 matching lines @@
     USB_LOG(USER) << "Transfer too long.";
     RunTransferCallback(callback_task_runner, callback, USB_TRANSFER_ERROR,
                         buffer, 0);
     return;
   }
 
   scoped_ptr<Transfer> transfer = Transfer::CreateIsochronousTransfer(
       this, endpoint_address, buffer, static_cast<int>(length), packets,
       packet_length, timeout, callback_task_runner, callback);
 
-  SubmitTransfer(transfer.Pass());
+  SubmitTransfer(std::move(transfer));
 }
 
 void UsbDeviceHandleImpl::GenericTransferInternal(
     uint8_t endpoint_address,
     scoped_refptr<net::IOBuffer> buffer,
     size_t length,
     unsigned int timeout,
     scoped_refptr<base::TaskRunner> callback_task_runner,
     const TransferCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 32 matching lines @@
         this, endpoint_address, buffer, static_cast<int>(length), timeout,
         callback_task_runner, callback);
   } else {
     USB_LOG(DEBUG) << "Endpoint " << static_cast<int>(endpoint_address)
                    << " is not a bulk or interrupt endpoint.";
     RunTransferCallback(callback_task_runner, callback, USB_TRANSFER_ERROR,
                         buffer, 0);
     return;
   }
 
-  SubmitTransfer(transfer.Pass());
+  SubmitTransfer(std::move(transfer));
 }
 
 void UsbDeviceHandleImpl::SubmitTransfer(scoped_ptr<Transfer> transfer) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // Transfer is owned by libusb until its completion callback is run. This
   // object holds a weak reference.
   transfers_.insert(transfer.get());
   blocking_task_runner_->PostTask(
       FROM_HERE,
@@ skipping 31 matching lines @@
   // Attempt-release all the interfaces.
   // It will be retained until the transfer cancellation is finished.
   claimed_interfaces_.clear();
 
   // Cannot close device handle here. Need to wait for libusb_cancel_transfer to
   // finish.
   device_ = NULL;
 }
 
 }  // namespace device