Convert //content/renderer from scoped_ptr to std::unique_ptr

content/renderer/usb/web_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 "content/renderer/usb/web_usb_device_impl.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 20 matching lines @@
 const char kReleaseInterfaceFailed[] = "Unable to release interface.";
 const char kSetConfigurationFailed[] = "Unable to set device configuration.";
 const char kSetInterfaceFailed[] = "Unable to set device interface.";
 const char kTransferFailed[] = "Transfer failed.";
 
 // Generic default rejection handler for any WebUSB callbacks type. Assumes
 // |CallbacksType| is a blink::WebCallbacks<T, const blink::WebUSBError&>
 // for any type |T|.
 template <typename CallbacksType>
 void RejectWithError(const blink::WebUSBError& error,
-                     scoped_ptr<CallbacksType> callbacks) {
+                     std::unique_ptr<CallbacksType> callbacks) {
   callbacks->onError(error);
 }
 
 template <typename CallbacksType>
-void RejectWithTransferError(scoped_ptr<CallbacksType> callbacks) {
+void RejectWithTransferError(std::unique_ptr<CallbacksType> callbacks) {
   RejectWithError(blink::WebUSBError(blink::WebUSBError::Error::Network,
                                      base::ASCIIToUTF16(kTransferFailed)),
                   std::move(callbacks));
 }
 
 // Create a new ScopedWebCallbacks for WebUSB device callbacks, defaulting to
 // a "device unavailable" rejection.
 template <typename CallbacksType>
 ScopedWebCallbacks<CallbacksType> MakeScopedUSBCallbacks(
     CallbacksType* callbacks) {
@@ skipping 60 matching lines @@
     case device::usb::TransferStatus::STALLED:
       web_status = blink::WebUSBTransferInfo::Status::Stall;
       break;
     case device::usb::TransferStatus::BABBLE:
       web_status = blink::WebUSBTransferInfo::Status::Babble;
       break;
     default:
       RejectWithTransferError(std::move(scoped_callbacks));
       return;
   }
-  scoped_ptr<blink::WebUSBTransferInfo> info(new blink::WebUSBTransferInfo());
+  std::unique_ptr<blink::WebUSBTransferInfo> info(
+      new blink::WebUSBTransferInfo());
   info->status.assign(
       std::vector<blink::WebUSBTransferInfo::Status>(1, web_status));
   info->data.assign(data);
   scoped_callbacks->onSuccess(std::move(info));
 }
 
 void OnTransferOut(
     ScopedWebCallbacks<blink::WebUSBDeviceTransferCallbacks> callbacks,
     size_t bytes_written,
     device::usb::TransferStatus status) {
   auto scoped_callbacks = callbacks.PassCallbacks();
   blink::WebUSBTransferInfo::Status web_status;
   switch (status) {
     case device::usb::TransferStatus::COMPLETED:
       web_status = blink::WebUSBTransferInfo::Status::Ok;
       break;
     case device::usb::TransferStatus::STALLED:
       web_status = blink::WebUSBTransferInfo::Status::Stall;
       break;
     default:
       RejectWithTransferError(std::move(scoped_callbacks));
       return;
   }
   // TODO(rockot): Device::ControlTransferOut should expose the number of bytes
   // actually transferred so we can send it from here.
-  scoped_ptr<blink::WebUSBTransferInfo> info(new blink::WebUSBTransferInfo());
+  std::unique_ptr<blink::WebUSBTransferInfo> info(
+      new blink::WebUSBTransferInfo());
   info->status.assign(
       std::vector<blink::WebUSBTransferInfo::Status>(1, web_status));
   info->bytesTransferred.assign(std::vector<uint32_t>(1, bytes_written));
   scoped_callbacks->onSuccess(std::move(info));
 }
 
 void OnIsochronousTransferIn(
     ScopedWebCallbacks<blink::WebUSBDeviceTransferCallbacks> callbacks,
     mojo::Array<uint8_t> data,
     mojo::Array<device::usb::IsochronousPacketPtr> packets) {
   auto scoped_callbacks = callbacks.PassCallbacks();
-  scoped_ptr<blink::WebUSBTransferInfo> info(new blink::WebUSBTransferInfo());
+  std::unique_ptr<blink::WebUSBTransferInfo> info(
+      new blink::WebUSBTransferInfo());
   info->data.assign(data);
   info->status =
       blink::WebVector<blink::WebUSBTransferInfo::Status>(packets.size());
   info->packetLength = blink::WebVector<uint32_t>(packets.size());
   info->bytesTransferred = blink::WebVector<uint32_t>(packets.size());
   for (size_t i = 0; i < packets.size(); ++i) {
     switch (packets[i]->status) {
       case device::usb::TransferStatus::COMPLETED:
         info->status[i] = blink::WebUSBTransferInfo::Status::Ok;
         break;
@@ skipping 10 matching lines @@
     info->packetLength[i] = packets[i]->length;
     info->bytesTransferred[i] = packets[i]->transferred_length;
   }
   scoped_callbacks->onSuccess(std::move(info));
 }
 
 void OnIsochronousTransferOut(
     ScopedWebCallbacks<blink::WebUSBDeviceTransferCallbacks> callbacks,
     mojo::Array<device::usb::IsochronousPacketPtr> packets) {
   auto scoped_callbacks = callbacks.PassCallbacks();
-  scoped_ptr<blink::WebUSBTransferInfo> info(new blink::WebUSBTransferInfo());
+  std::unique_ptr<blink::WebUSBTransferInfo> info(
+      new blink::WebUSBTransferInfo());
   info->status =
       blink::WebVector<blink::WebUSBTransferInfo::Status>(packets.size());
   info->bytesTransferred = blink::WebVector<uint32_t>(packets.size());
   for (size_t i = 0; i < packets.size(); ++i) {
     switch (packets[i]->status) {
       case device::usb::TransferStatus::COMPLETED:
         info->status[i] = blink::WebUSBTransferInfo::Status::Ok;
         break;
       case device::usb::TransferStatus::STALLED:
         info->status[i] = blink::WebUSBTransferInfo::Status::Stall;
@@ skipping 201 matching lines @@
 
 void WebUSBDeviceImpl::reset(blink::WebUSBDeviceResetCallbacks* callbacks) {
   auto scoped_callbacks = MakeScopedUSBCallbacks(callbacks);
   if (device_)
     device_->Reset(base::Bind(&HandlePassFailDeviceOperation,
                               base::Passed(&scoped_callbacks),
                               kDeviceResetFailed));
 }
 
 }  // namespace content