unique_ptr_migration: clean up references to scoped_ptr as of r389721

device/usb/usb_device_handle_usbfs.cc

 // Copyright 2016 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_usbfs.h"
 
 #if defined(OS_ANDROID) && __ANDROID_API__ < 21
 #include <linux/usb_ch9.h>
 #else
 #include <linux/usb/ch9.h>
@@ skipping 125 matching lines @@
 
 class UsbDeviceHandleUsbfs::FileThreadHelper
     : public base::MessagePumpLibevent::Watcher,
       public base::MessageLoop::DestructionObserver {
  public:
   FileThreadHelper(int fd,
                    scoped_refptr<UsbDeviceHandleUsbfs> device_handle,
                    scoped_refptr<base::SequencedTaskRunner> task_runner);
   ~FileThreadHelper() override;
 
-  static void Start(scoped_ptr<FileThreadHelper> self);
+  static void Start(std::unique_ptr<FileThreadHelper> self);
 
   // base::MessagePumpLibevent::Watcher overrides.
   void OnFileCanReadWithoutBlocking(int fd) override;
   void OnFileCanWriteWithoutBlocking(int fd) override;
 
   // base::MessageLoop::DestructionObserver overrides.
   void WillDestroyCurrentMessageLoop() override;
 
  private:
   int fd_;
@@ skipping 11 matching lines @@
     scoped_refptr<base::SequencedTaskRunner> task_runner)
     : fd_(fd), device_handle_(device_handle), task_runner_(task_runner) {}
 
 UsbDeviceHandleUsbfs::FileThreadHelper::~FileThreadHelper() {
   DCHECK(thread_checker_.CalledOnValidThread());
   base::MessageLoop::current()->RemoveDestructionObserver(this);
 }
 
 // static
 void UsbDeviceHandleUsbfs::FileThreadHelper::Start(
-    scoped_ptr<FileThreadHelper> self) {
+    std::unique_ptr<FileThreadHelper> self) {
   base::ThreadRestrictions::AssertIOAllowed();
   self->thread_checker_.DetachFromThread();
 
   // Linux indicates that URBs are available to reap by marking the file
   // descriptor writable.
   if (!base::MessageLoopForIO::current()->WatchFileDescriptor(
           self->fd_, true, base::MessageLoopForIO::WATCH_WRITE,
           &self->file_watcher_, self.get())) {
     USB_LOG(ERROR) << "Failed to start watching device file descriptor.";
   }
@@ skipping 99 matching lines @@
     scoped_refptr<base::SequencedTaskRunner> blocking_task_runner)
     : device_(device),
       fd_(std::move(fd)),
       blocking_task_runner_(blocking_task_runner) {
   DCHECK(device_);
   DCHECK(fd_.is_valid());
   DCHECK(blocking_task_runner_);
 
   task_runner_ = base::ThreadTaskRunnerHandle::Get();
 
-  scoped_ptr<FileThreadHelper> helper(
+  std::unique_ptr<FileThreadHelper> helper(
       new FileThreadHelper(fd_.get(), this, task_runner_));
   helper_ = helper.get();
   blocking_task_runner_->PostTask(
       FROM_HERE, base::Bind(&FileThreadHelper::Start, base::Passed(&helper)));
 }
 
 scoped_refptr<UsbDevice> UsbDeviceHandleUsbfs::GetDevice() const {
   return device_;
 }
 
@@ skipping 99 matching lines @@
                                            scoped_refptr<net::IOBuffer> buffer,
                                            size_t length,
                                            unsigned int timeout,
                                            const TransferCallback& callback) {
   if (!device_) {
     task_runner_->PostTask(
         FROM_HERE, base::Bind(callback, USB_TRANSFER_DISCONNECT, nullptr, 0));
     return;
   }
 
-  scoped_ptr<Transfer> transfer(new (0) Transfer(buffer, callback));
+  std::unique_ptr<Transfer> transfer(new (0) Transfer(buffer, callback));
   transfer->control_transfer_buffer =
       BuildControlTransferBuffer(direction, request_type, recipient, request,
                                  value, index, buffer, length);
   transfer->urb.type = USBDEVFS_URB_TYPE_CONTROL;
   transfer->urb.endpoint = 0;
   transfer->urb.buffer = transfer->control_transfer_buffer->data();
   transfer->urb.buffer_length = 8 + length;
 
   // USBDEVFS_SUBMITURB appears to be non-blocking as completion is reported
   // by USBDEVFS_REAPURBNDELAY.
@@ skipping 50 matching lines @@
       ConvertEndpointDirection(direction) | endpoint_number;
   auto it = endpoints_.find(endpoint_address);
   if (it == endpoints_.end()) {
     USB_LOG(USER) << "Endpoint address " << static_cast<int>(endpoint_address)
                   << " is not part of a claimed interface.";
     task_runner_->PostTask(
         FROM_HERE, base::Bind(callback, USB_TRANSFER_ERROR, nullptr, 0));
     return;
   }
 
-  scoped_ptr<Transfer> transfer(new (0) Transfer(buffer, callback));
+  std::unique_ptr<Transfer> transfer(new (0) Transfer(buffer, callback));
   transfer->urb.endpoint = endpoint_address;
   transfer->urb.buffer_length = length;
   transfer->urb.type = ConvertTransferType(it->second.type);
 
   // USBDEVFS_SUBMITURB appears to be non-blocking as completion is reported
   // by USBDEVFS_REAPURBNDELAY. This code assumes a recent kernel that can
   // accept arbitrarily large transfer requests, hopefully also using a scatter-
   // gather list.
   int rc = HANDLE_EINTR(ioctl(fd_.get(), USBDEVFS_SUBMITURB, &transfer->urb));
   if (rc) {
@@ skipping 151 matching lines @@
   }
 
   auto it = endpoints_.find(endpoint_address);
   if (it == endpoints_.end()) {
     USB_LOG(USER) << "Endpoint address " << static_cast<int>(endpoint_address)
                   << " is not part of a claimed interface.";
     ReportIsochronousError(packet_lengths, callback, USB_TRANSFER_ERROR);
     return;
   }
 
-  scoped_ptr<Transfer> transfer(new (packet_lengths.size())
-                                    Transfer(buffer, callback));
+  std::unique_ptr<Transfer> transfer(new (packet_lengths.size())
+                                         Transfer(buffer, callback));
   transfer->urb.type = USBDEVFS_URB_TYPE_ISO;
   transfer->urb.endpoint = endpoint_address;
   transfer->urb.buffer_length = total_length;
 
   for (size_t i = 0; i < packet_lengths.size(); ++i)
     transfer->urb.iso_frame_desc[i].length = packet_lengths[i];
 
   // USBDEVFS_SUBMITURB appears to be non-blocking as completion is reported
   // by USBDEVFS_REAPURBNDELAY. This code assumes a recent kernel that can
   // accept arbitrarily large transfer requests, hopefully also using a scatter-
   // gather list.
   int rc = HANDLE_EINTR(ioctl(fd_.get(), USBDEVFS_SUBMITURB, &transfer->urb));
   if (rc) {
     rc = logging::GetLastSystemErrorCode();
     USB_PLOG(DEBUG) << "Failed to submit transfer";
     ReportIsochronousError(packet_lengths, callback, ConvertTransferResult(rc));
   } else {
     SetUpTimeoutCallback(transfer.get(), timeout);
     transfers_.push_back(std::move(transfer));
   }
 }
 
 void UsbDeviceHandleUsbfs::ReapedUrbs(const std::vector<usbdevfs_urb*>& urbs) {
   for (const auto& urb : urbs) {
     Transfer* this_transfer = static_cast<Transfer*>(urb->usercontext);
     DCHECK_EQ(urb, &this_transfer->urb);
     auto it = std::find_if(
         transfers_.begin(), transfers_.end(),
-        [this_transfer](const scoped_ptr<Transfer>& transfer) -> bool {
+        [this_transfer](const std::unique_ptr<Transfer>& transfer) -> bool {
           return transfer.get() == this_transfer;
         });
     DCHECK(it != transfers_.end());
-    scoped_ptr<Transfer> transfer = std::move(*it);
+    std::unique_ptr<Transfer> transfer = std::move(*it);
     transfers_.erase(it);
     TransferComplete(std::move(transfer));
   }
 }
 
-void UsbDeviceHandleUsbfs::TransferComplete(scoped_ptr<Transfer> transfer) {
+void UsbDeviceHandleUsbfs::TransferComplete(
+    std::unique_ptr<Transfer> transfer) {
   if (transfer->cancelled)
     return;
 
   // The transfer will soon be freed. Cancel the timeout callback so that the
   // raw pointer it holds to |transfer| is not used.
   transfer->timeout_closure.Cancel();
 
   if (transfer->urb.type == USBDEVFS_URB_TYPE_ISO) {
     std::vector<IsochronousPacket> packets(transfer->urb.number_of_packets);
     for (size_t i = 0; i < packets.size(); ++i) {
@@ skipping 85 matching lines @@
       packets[i].transferred_length = 0;
       packets[i].status = status;
     }
     transfer->isoc_callback.Run(transfer->buffer, packets);
   } else {
     transfer->callback.Run(status, transfer->buffer, 0);
   }
 }
 
 }  // namespace device