Convert device to std::unique_ptr

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 <memory>
 #include <numeric>
 #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"
@@ skipping 175 matching lines @@
   if (!release_callback_.is_null()) {
     task_runner_->PostTask(FROM_HERE,
                            base::Bind(release_callback_, rc == LIBUSB_SUCCESS));
   }
 }
 
 // This inner class owns the underlying libusb_transfer and may outlast
 // the UsbDeviceHandle that created it.
 class UsbDeviceHandleImpl::Transfer {
  public:
-  static scoped_ptr<Transfer> CreateControlTransfer(
+  static std::unique_ptr<Transfer> CreateControlTransfer(
       scoped_refptr<UsbDeviceHandleImpl> device_handle,
       uint8_t type,
       uint8_t request,
       uint16_t value,
       uint16_t index,
       uint16_t length,
       scoped_refptr<net::IOBuffer> buffer,
       unsigned int timeout,
       scoped_refptr<base::TaskRunner> callback_task_runner,
       const TransferCallback& callback);
-  static scoped_ptr<Transfer> CreateBulkTransfer(
+  static std::unique_ptr<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);
-  static scoped_ptr<Transfer> CreateInterruptTransfer(
+  static std::unique_ptr<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);
-  static scoped_ptr<Transfer> CreateIsochronousTransfer(
+  static std::unique_ptr<Transfer> CreateIsochronousTransfer(
       scoped_refptr<UsbDeviceHandleImpl> device_handle,
       uint8_t endpoint,
       scoped_refptr<net::IOBuffer> buffer,
       size_t length,
       const std::vector<uint32_t>& packet_lengths,
       unsigned int timeout,
       scoped_refptr<base::TaskRunner> callback_task_runner,
       const IsochronousTransferCallback& callback);
 
   ~Transfer();
@@ skipping 36 matching lines @@
   scoped_refptr<UsbDeviceHandleImpl::InterfaceClaimer> claimed_interface_;
   size_t length_;
   bool cancelled_ = false;
   scoped_refptr<base::SequencedTaskRunner> task_runner_;
   scoped_refptr<base::TaskRunner> callback_task_runner_;
   TransferCallback callback_;
   IsochronousTransferCallback iso_callback_;
 };
 
 // static
-scoped_ptr<UsbDeviceHandleImpl::Transfer>
+std::unique_ptr<UsbDeviceHandleImpl::Transfer>
 UsbDeviceHandleImpl::Transfer::CreateControlTransfer(
     scoped_refptr<UsbDeviceHandleImpl> device_handle,
     uint8_t type,
     uint8_t request,
     uint16_t value,
     uint16_t index,
     uint16_t length,
     scoped_refptr<net::IOBuffer> buffer,
     unsigned int timeout,
     scoped_refptr<base::TaskRunner> callback_task_runner,
     const TransferCallback& callback) {
-  scoped_ptr<Transfer> transfer(new Transfer(
+  std::unique_ptr<Transfer> transfer(new Transfer(
       device_handle, nullptr, USB_TRANSFER_CONTROL, buffer,
       length + LIBUSB_CONTROL_SETUP_SIZE, callback_task_runner, callback));
 
   transfer->platform_transfer_ = libusb_alloc_transfer(0);
   if (!transfer->platform_transfer_) {
     USB_LOG(ERROR) << "Failed to allocate control transfer.";
     return nullptr;
   }
 
   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;
 }
 
 // static
-scoped_ptr<UsbDeviceHandleImpl::Transfer>
+std::unique_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(
+  std::unique_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()), length,
                             &UsbDeviceHandleImpl::Transfer::PlatformCallback,
                             transfer.get(), timeout);
 
   return transfer;
 }
 
 // static
-scoped_ptr<UsbDeviceHandleImpl::Transfer>
+std::unique_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(
+  std::unique_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()), length,
       &UsbDeviceHandleImpl::Transfer::PlatformCallback, transfer.get(),
       timeout);
 
   return transfer;
 }
 
 // static
-scoped_ptr<UsbDeviceHandleImpl::Transfer>
+std::unique_ptr<UsbDeviceHandleImpl::Transfer>
 UsbDeviceHandleImpl::Transfer::CreateIsochronousTransfer(
     scoped_refptr<UsbDeviceHandleImpl> device_handle,
     uint8_t endpoint,
     scoped_refptr<net::IOBuffer> buffer,
     size_t length,
     const std::vector<uint32_t>& packet_lengths,
     unsigned int timeout,
     scoped_refptr<base::TaskRunner> callback_task_runner,
     const IsochronousTransferCallback& callback) {
-  scoped_ptr<Transfer> transfer(new Transfer(
+  std::unique_ptr<Transfer> transfer(new Transfer(
       device_handle, device_handle->GetClaimedInterfaceForEndpoint(endpoint),
       buffer, callback_task_runner, callback));
 
   int num_packets = static_cast<int>(packet_lengths.size());
   transfer->platform_transfer_ = libusb_alloc_transfer(num_packets);
   if (!transfer->platform_transfer_) {
     USB_LOG(ERROR) << "Failed to allocate isochronous transfer.";
     return nullptr;
   }
 
@@ skipping 577 matching lines @@
   scoped_refptr<net::IOBuffer> resized_buffer =
       new net::IOBufferWithSize(resized_length);
   if (!resized_buffer.get()) {
     RunTransferCallback(callback_task_runner, callback, USB_TRANSFER_ERROR,
                         buffer, 0);
     return;
   }
   memcpy(resized_buffer->data() + LIBUSB_CONTROL_SETUP_SIZE, buffer->data(),
          length);
 
-  scoped_ptr<Transfer> transfer = Transfer::CreateControlTransfer(
+  std::unique_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(std::move(transfer));
 }
 
 void UsbDeviceHandleImpl::IsochronousTransferInInternal(
     uint8_t endpoint_address,
     const std::vector<uint32_t>& packet_lengths,
     unsigned int timeout,
     scoped_refptr<base::TaskRunner> callback_task_runner,
     const IsochronousTransferCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (!device_) {
     ReportIsochronousTransferError(callback_task_runner, callback,
                                    packet_lengths, USB_TRANSFER_DISCONNECT);
     return;
   }
 
   size_t length =
       std::accumulate(packet_lengths.begin(), packet_lengths.end(), 0u);
   scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(length));
-  scoped_ptr<Transfer> transfer = Transfer::CreateIsochronousTransfer(
+  std::unique_ptr<Transfer> transfer = Transfer::CreateIsochronousTransfer(
       this, endpoint_address, buffer, length, packet_lengths, timeout,
       callback_task_runner, callback);
 
   SubmitTransfer(std::move(transfer));
 }
 
 void UsbDeviceHandleImpl::IsochronousTransferOutInternal(
     uint8_t endpoint_address,
     scoped_refptr<net::IOBuffer> buffer,
     const std::vector<uint32_t>& packet_lengths,
     unsigned int timeout,
     scoped_refptr<base::TaskRunner> callback_task_runner,
     const IsochronousTransferCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (!device_) {
     ReportIsochronousTransferError(callback_task_runner, callback,
                                    packet_lengths, USB_TRANSFER_DISCONNECT);
     return;
   }
 
   size_t length =
       std::accumulate(packet_lengths.begin(), packet_lengths.end(), 0u);
-  scoped_ptr<Transfer> transfer = Transfer::CreateIsochronousTransfer(
+  std::unique_ptr<Transfer> transfer = Transfer::CreateIsochronousTransfer(
       this, endpoint_address, buffer, length, packet_lengths, timeout,
       callback_task_runner, callback);
 
   SubmitTransfer(std::move(transfer));
 }
 
 void UsbDeviceHandleImpl::GenericTransferInternal(
     uint8_t endpoint_address,
     scoped_refptr<net::IOBuffer> buffer,
     size_t length,
@@ skipping 18 matching lines @@
     return;
   }
 
   if (!base::IsValueInRangeForNumericType<int>(length)) {
     USB_LOG(DEBUG) << "Transfer too long.";
     RunTransferCallback(callback_task_runner, callback, USB_TRANSFER_ERROR,
                         buffer, 0);
     return;
   }
 
-  scoped_ptr<Transfer> transfer;
+  std::unique_ptr<Transfer> transfer;
   UsbTransferType transfer_type = endpoint_it->second.endpoint->transfer_type;
   if (transfer_type == USB_TRANSFER_BULK) {
     transfer = Transfer::CreateBulkTransfer(this, endpoint_address, buffer,
                                             static_cast<int>(length), timeout,
                                             callback_task_runner, callback);
   } else if (transfer_type == USB_TRANSFER_INTERRUPT) {
     transfer = Transfer::CreateInterruptTransfer(
         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(std::move(transfer));
 }
 
-void UsbDeviceHandleImpl::SubmitTransfer(scoped_ptr<Transfer> transfer) {
+void UsbDeviceHandleImpl::SubmitTransfer(std::unique_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,
       base::Bind(&Transfer::Submit, base::Unretained(transfer.release())));
 }
 
 void UsbDeviceHandleImpl::TransferComplete(Transfer* transfer,
                                            const base::Closure& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(ContainsKey(transfers_, transfer)) << "Missing transfer completed";
   transfers_.erase(transfer);
 
   if (transfer->callback_task_runner()->RunsTasksOnCurrentThread()) {
     callback.Run();
   } else {
     transfer->callback_task_runner()->PostTask(FROM_HERE, callback);
   }
 
   // libusb_free_transfer races with libusb_submit_transfer and only work-
   // around is to make sure to call them on the same thread.
   blocking_task_runner_->DeleteSoon(FROM_HERE, transfer);
 }
 
 }  // namespace device