Convert //extensions/browser/api from scoped_ptr to std::unique_ptr

extensions/browser/api/usb/usb_api.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 "extensions/browser/api/usb/usb_api.h"
 
 #include <algorithm>
+#include <memory>
 #include <numeric>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/barrier_closure.h"
-#include "base/memory/scoped_ptr.h"
 #include "device/core/device_client.h"
 #include "device/usb/usb_descriptors.h"
 #include "device/usb/usb_device_handle.h"
 #include "device/usb/usb_service.h"
 #include "extensions/browser/api/device_permissions_manager.h"
 #include "extensions/browser/api/device_permissions_prompt.h"
 #include "extensions/browser/api/extensions_api_client.h"
 #include "extensions/browser/api/usb/usb_device_resource.h"
 #include "extensions/browser/api/usb/usb_guid_map.h"
 #include "extensions/browser/extension_system.h"
@@ skipping 427 matching lines @@
 
 UsbTransferFunction::UsbTransferFunction() {
 }
 
 UsbTransferFunction::~UsbTransferFunction() {
 }
 
 void UsbTransferFunction::OnCompleted(UsbTransferStatus status,
                                       scoped_refptr<net::IOBuffer> data,
                                       size_t length) {
-  scoped_ptr<base::DictionaryValue> transfer_info(new base::DictionaryValue());
+  std::unique_ptr<base::DictionaryValue> transfer_info(
+      new base::DictionaryValue());
   transfer_info->SetInteger(kResultCodeKey, status);
   transfer_info->Set(kDataKey, base::BinaryValue::CreateWithCopiedBuffer(
                                    data->data(), length));
 
   if (status == device::USB_TRANSFER_COMPLETED) {
     Respond(OneArgument(std::move(transfer_info)));
   } else {
-    scoped_ptr<base::ListValue> error_args(new base::ListValue());
+    std::unique_ptr<base::ListValue> error_args(new base::ListValue());
     error_args->Append(std::move(transfer_info));
     // Using ErrorWithArguments is discouraged but required to provide the
     // detailed transfer info as the transfer may have partially succeeded.
     Respond(ErrorWithArguments(std::move(error_args),
                                ConvertTransferStatusToApi(status)));
   }
 }
 
 UsbFindDevicesFunction::UsbFindDevicesFunction() {
 }
 
 UsbFindDevicesFunction::~UsbFindDevicesFunction() {
 }
 
 ExtensionFunction::ResponseAction UsbFindDevicesFunction::Run() {
-  scoped_ptr<extensions::api::usb::FindDevices::Params> parameters =
+  std::unique_ptr<extensions::api::usb::FindDevices::Params> parameters =
       FindDevices::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(parameters.get());
 
   vendor_id_ = parameters->options.vendor_id;
   product_id_ = parameters->options.product_id;
   int interface_id = parameters->options.interface_id.get()
                          ? *parameters->options.interface_id.get()
                          : UsbDevicePermissionData::ANY_INTERFACE;
   UsbDevicePermission::CheckParam param(vendor_id_, product_id_, interface_id);
   if (!extension()->permissions_data()->CheckAPIPermissionWithParam(
@@ skipping 45 matching lines @@
   Respond(OneArgument(std::move(result_)));
 }
 
 UsbGetDevicesFunction::UsbGetDevicesFunction() {
 }
 
 UsbGetDevicesFunction::~UsbGetDevicesFunction() {
 }
 
 ExtensionFunction::ResponseAction UsbGetDevicesFunction::Run() {
-  scoped_ptr<extensions::api::usb::GetDevices::Params> parameters =
+  std::unique_ptr<extensions::api::usb::GetDevices::Params> parameters =
       GetDevices::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(parameters.get());
 
   if (parameters->options.filters) {
     filters_.resize(parameters->options.filters->size());
     for (size_t i = 0; i < parameters->options.filters->size(); ++i) {
       ConvertDeviceFilter(parameters->options.filters->at(i), &filters_[i]);
     }
   }
   if (parameters->options.vendor_id) {
     filters_.resize(filters_.size() + 1);
     filters_.back().SetVendorId(*parameters->options.vendor_id);
     if (parameters->options.product_id) {
       filters_.back().SetProductId(*parameters->options.product_id);
     }
   }
 
   UsbService* service = device::DeviceClient::Get()->GetUsbService();
   if (!service) {
     return RespondNow(Error(kErrorInitService));
   }
 
   service->GetDevices(
       base::Bind(&UsbGetDevicesFunction::OnGetDevicesComplete, this));
   return RespondLater();
 }
 
 void UsbGetDevicesFunction::OnGetDevicesComplete(
     const std::vector<scoped_refptr<UsbDevice>>& devices) {
-  scoped_ptr<base::ListValue> result(new base::ListValue());
+  std::unique_ptr<base::ListValue> result(new base::ListValue());
   UsbGuidMap* guid_map = UsbGuidMap::Get(browser_context());
   for (const scoped_refptr<UsbDevice>& device : devices) {
     if ((filters_.empty() || UsbDeviceFilter::MatchesAny(device, filters_)) &&
         HasDevicePermission(device)) {
       Device api_device;
       guid_map->GetApiDevice(device, &api_device);
       result->Append(api_device.ToValue());
     }
   }
 
   Respond(OneArgument(std::move(result)));
 }
 
 UsbGetUserSelectedDevicesFunction::UsbGetUserSelectedDevicesFunction() {
 }
 
 UsbGetUserSelectedDevicesFunction::~UsbGetUserSelectedDevicesFunction() {
 }
 
 ExtensionFunction::ResponseAction UsbGetUserSelectedDevicesFunction::Run() {
-  scoped_ptr<extensions::api::usb::GetUserSelectedDevices::Params> parameters =
-      GetUserSelectedDevices::Params::Create(*args_);
+  std::unique_ptr<extensions::api::usb::GetUserSelectedDevices::Params>
+      parameters = GetUserSelectedDevices::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(parameters.get());
 
   if (!user_gesture()) {
     return RespondNow(OneArgument(new base::ListValue()));
   }
 
   bool multiple = false;
   if (parameters->options.multiple) {
     multiple = *parameters->options.multiple;
   }
@@ skipping 13 matching lines @@
   }
 
   prompt_->AskForUsbDevices(
       extension(), browser_context(), multiple, filters,
       base::Bind(&UsbGetUserSelectedDevicesFunction::OnDevicesChosen, this));
   return RespondLater();
 }
 
 void UsbGetUserSelectedDevicesFunction::OnDevicesChosen(
     const std::vector<scoped_refptr<UsbDevice>>& devices) {
-  scoped_ptr<base::ListValue> result(new base::ListValue());
+  std::unique_ptr<base::ListValue> result(new base::ListValue());
   UsbGuidMap* guid_map = UsbGuidMap::Get(browser_context());
   for (const auto& device : devices) {
     Device api_device;
     guid_map->GetApiDevice(device, &api_device);
     result->Append(api_device.ToValue());
   }
 
   Respond(OneArgument(std::move(result)));
 }
 
 UsbGetConfigurationsFunction::UsbGetConfigurationsFunction() {}
 
 UsbGetConfigurationsFunction::~UsbGetConfigurationsFunction() {}
 
 ExtensionFunction::ResponseAction UsbGetConfigurationsFunction::Run() {
-  scoped_ptr<extensions::api::usb::GetConfigurations::Params> parameters =
+  std::unique_ptr<extensions::api::usb::GetConfigurations::Params> parameters =
       GetConfigurations::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(parameters.get());
 
   UsbService* service = device::DeviceClient::Get()->GetUsbService();
   if (!service) {
     return RespondNow(Error(kErrorInitService));
   }
 
   std::string guid;
   if (!UsbGuidMap::Get(browser_context())
            ->GetGuidFromId(parameters->device.device, &guid)) {
     return RespondNow(Error(kErrorNoDevice));
   }
 
   scoped_refptr<UsbDevice> device = service->GetDevice(guid);
   if (!device.get()) {
     return RespondNow(Error(kErrorNoDevice));
   }
 
   if (!HasDevicePermission(device)) {
     // This function must act as if there is no such device. Otherwise it can be
     // used to fingerprint unauthorized devices.
     return RespondNow(Error(kErrorNoDevice));
   }
 
-  scoped_ptr<base::ListValue> configs(new base::ListValue());
+  std::unique_ptr<base::ListValue> configs(new base::ListValue());
   const UsbConfigDescriptor* active_config = device->GetActiveConfiguration();
   for (const UsbConfigDescriptor& config : device->configurations()) {
     ConfigDescriptor api_config = ConvertConfigDescriptor(config);
     if (active_config &&
         config.configuration_value == active_config->configuration_value) {
       api_config.active = true;
     }
     configs->Append(api_config.ToValue());
   }
   return RespondNow(OneArgument(std::move(configs)));
 }
 
 UsbRequestAccessFunction::UsbRequestAccessFunction() {
 }
 
 UsbRequestAccessFunction::~UsbRequestAccessFunction() {
 }
 
 ExtensionFunction::ResponseAction UsbRequestAccessFunction::Run() {
-  scoped_ptr<extensions::api::usb::RequestAccess::Params> parameters =
+  std::unique_ptr<extensions::api::usb::RequestAccess::Params> parameters =
       RequestAccess::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(parameters.get());
   return RespondNow(OneArgument(new base::FundamentalValue(true)));
 }
 
 UsbOpenDeviceFunction::UsbOpenDeviceFunction() {
 }
 
 UsbOpenDeviceFunction::~UsbOpenDeviceFunction() {
 }
 
 ExtensionFunction::ResponseAction UsbOpenDeviceFunction::Run() {
-  scoped_ptr<extensions::api::usb::OpenDevice::Params> parameters =
+  std::unique_ptr<extensions::api::usb::OpenDevice::Params> parameters =
       OpenDevice::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(parameters.get());
 
   UsbService* service = device::DeviceClient::Get()->GetUsbService();
   if (!service) {
     return RespondNow(Error(kErrorInitService));
   }
 
   std::string guid;
   if (!UsbGuidMap::Get(browser_context())
@@ skipping 33 matching lines @@
       device->vendor_id(), device->product_id())));
 }
 
 UsbSetConfigurationFunction::UsbSetConfigurationFunction() {
 }
 
 UsbSetConfigurationFunction::~UsbSetConfigurationFunction() {
 }
 
 ExtensionFunction::ResponseAction UsbSetConfigurationFunction::Run() {
-  scoped_ptr<extensions::api::usb::SetConfiguration::Params> parameters =
+  std::unique_ptr<extensions::api::usb::SetConfiguration::Params> parameters =
       SetConfiguration::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(parameters.get());
 
   scoped_refptr<UsbDeviceHandle> device_handle =
       GetDeviceHandle(parameters->handle);
   if (!device_handle.get()) {
     return RespondNow(Error(kErrorNoConnection));
   }
 
   device_handle->SetConfiguration(
@@ skipping 10 matching lines @@
   }
 }
 
 UsbGetConfigurationFunction::UsbGetConfigurationFunction() {
 }
 
 UsbGetConfigurationFunction::~UsbGetConfigurationFunction() {
 }
 
 ExtensionFunction::ResponseAction UsbGetConfigurationFunction::Run() {
-  scoped_ptr<extensions::api::usb::GetConfiguration::Params> parameters =
+  std::unique_ptr<extensions::api::usb::GetConfiguration::Params> parameters =
       GetConfiguration::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(parameters.get());
 
   scoped_refptr<UsbDeviceHandle> device_handle =
       GetDeviceHandle(parameters->handle);
   if (!device_handle.get()) {
     return RespondNow(Error(kErrorNoConnection));
   }
 
   const UsbConfigDescriptor* config_descriptor =
       device_handle->GetDevice()->GetActiveConfiguration();
   if (config_descriptor) {
     ConfigDescriptor config = ConvertConfigDescriptor(*config_descriptor);
     config.active = true;
     return RespondNow(OneArgument(config.ToValue()));
   } else {
     return RespondNow(Error(kErrorNotConfigured));
   }
 }
 
 UsbListInterfacesFunction::UsbListInterfacesFunction() {
 }
 
 UsbListInterfacesFunction::~UsbListInterfacesFunction() {
 }
 
 ExtensionFunction::ResponseAction UsbListInterfacesFunction::Run() {
-  scoped_ptr<extensions::api::usb::ListInterfaces::Params> parameters =
+  std::unique_ptr<extensions::api::usb::ListInterfaces::Params> parameters =
       ListInterfaces::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(parameters.get());
 
   scoped_refptr<UsbDeviceHandle> device_handle =
       GetDeviceHandle(parameters->handle);
   if (!device_handle.get()) {
     return RespondNow(Error(kErrorNoConnection));
   }
 
   const UsbConfigDescriptor* config_descriptor =
       device_handle->GetDevice()->GetActiveConfiguration();
   if (config_descriptor) {
     ConfigDescriptor config = ConvertConfigDescriptor(*config_descriptor);
 
-    scoped_ptr<base::ListValue> result(new base::ListValue);
+    std::unique_ptr<base::ListValue> result(new base::ListValue);
     for (size_t i = 0; i < config.interfaces.size(); ++i) {
       result->Append(config.interfaces[i].ToValue());
     }
 
     return RespondNow(OneArgument(std::move(result)));
   } else {
     return RespondNow(Error(kErrorNotConfigured));
   }
 }
 
 UsbCloseDeviceFunction::UsbCloseDeviceFunction() {
 }
 
 UsbCloseDeviceFunction::~UsbCloseDeviceFunction() {
 }
 
 ExtensionFunction::ResponseAction UsbCloseDeviceFunction::Run() {
-  scoped_ptr<extensions::api::usb::CloseDevice::Params> parameters =
+  std::unique_ptr<extensions::api::usb::CloseDevice::Params> parameters =
       CloseDevice::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(parameters.get());
 
   scoped_refptr<UsbDeviceHandle> device_handle =
       GetDeviceHandle(parameters->handle);
   if (!device_handle.get()) {
     return RespondNow(Error(kErrorNoConnection));
   }
 
   // The device handle is closed when the resource is destroyed.
   ReleaseDeviceHandle(parameters->handle);
   return RespondNow(NoArguments());
 }
 
 UsbClaimInterfaceFunction::UsbClaimInterfaceFunction() {
 }
 
 UsbClaimInterfaceFunction::~UsbClaimInterfaceFunction() {
 }
 
 ExtensionFunction::ResponseAction UsbClaimInterfaceFunction::Run() {
-  scoped_ptr<extensions::api::usb::ClaimInterface::Params> parameters =
+  std::unique_ptr<extensions::api::usb::ClaimInterface::Params> parameters =
       ClaimInterface::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(parameters.get());
 
   scoped_refptr<UsbDeviceHandle> device_handle =
       GetDeviceHandle(parameters->handle);
   if (!device_handle.get()) {
     return RespondNow(Error(kErrorNoConnection));
   }
 
   device_handle->ClaimInterface(
@@ skipping 10 matching lines @@
   }
 }
 
 UsbReleaseInterfaceFunction::UsbReleaseInterfaceFunction() {
 }
 
 UsbReleaseInterfaceFunction::~UsbReleaseInterfaceFunction() {
 }
 
 ExtensionFunction::ResponseAction UsbReleaseInterfaceFunction::Run() {
-  scoped_ptr<extensions::api::usb::ReleaseInterface::Params> parameters =
+  std::unique_ptr<extensions::api::usb::ReleaseInterface::Params> parameters =
       ReleaseInterface::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(parameters.get());
 
   scoped_refptr<UsbDeviceHandle> device_handle =
       GetDeviceHandle(parameters->handle);
   if (!device_handle.get()) {
     return RespondNow(Error(kErrorNoConnection));
   }
 
   device_handle->ReleaseInterface(
@@ skipping 12 matching lines @@
 UsbSetInterfaceAlternateSettingFunction::
     UsbSetInterfaceAlternateSettingFunction() {
 }
 
 UsbSetInterfaceAlternateSettingFunction::
     ~UsbSetInterfaceAlternateSettingFunction() {
 }
 
 ExtensionFunction::ResponseAction
 UsbSetInterfaceAlternateSettingFunction::Run() {
-  scoped_ptr<extensions::api::usb::SetInterfaceAlternateSetting::Params>
+  std::unique_ptr<extensions::api::usb::SetInterfaceAlternateSetting::Params>
       parameters = SetInterfaceAlternateSetting::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(parameters.get());
 
   scoped_refptr<UsbDeviceHandle> device_handle =
       GetDeviceHandle(parameters->handle);
   if (!device_handle.get()) {
     return RespondNow(Error(kErrorNoConnection));
   }
 
   device_handle->SetInterfaceAlternateSetting(
@@ skipping 10 matching lines @@
   }
 }
 
 UsbControlTransferFunction::UsbControlTransferFunction() {
 }
 
 UsbControlTransferFunction::~UsbControlTransferFunction() {
 }
 
 ExtensionFunction::ResponseAction UsbControlTransferFunction::Run() {
-  scoped_ptr<extensions::api::usb::ControlTransfer::Params> parameters =
+  std::unique_ptr<extensions::api::usb::ControlTransfer::Params> parameters =
       ControlTransfer::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(parameters.get());
 
   scoped_refptr<UsbDeviceHandle> device_handle =
       GetDeviceHandle(parameters->handle);
   if (!device_handle.get()) {
     return RespondNow(Error(kErrorNoConnection));
   }
 
   const ControlTransferInfo& transfer = parameters->transfer_info;
@@ skipping 36 matching lines @@
   return RespondLater();
 }
 
 UsbBulkTransferFunction::UsbBulkTransferFunction() {
 }
 
 UsbBulkTransferFunction::~UsbBulkTransferFunction() {
 }
 
 ExtensionFunction::ResponseAction UsbBulkTransferFunction::Run() {
-  scoped_ptr<extensions::api::usb::BulkTransfer::Params> parameters =
+  std::unique_ptr<extensions::api::usb::BulkTransfer::Params> parameters =
       BulkTransfer::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(parameters.get());
 
   scoped_refptr<UsbDeviceHandle> device_handle =
       GetDeviceHandle(parameters->handle);
   if (!device_handle.get()) {
     return RespondNow(Error(kErrorNoConnection));
   }
 
   const GenericTransferInfo& transfer = parameters->transfer_info;
@@ skipping 25 matching lines @@
   return RespondLater();
 }
 
 UsbInterruptTransferFunction::UsbInterruptTransferFunction() {
 }
 
 UsbInterruptTransferFunction::~UsbInterruptTransferFunction() {
 }
 
 ExtensionFunction::ResponseAction UsbInterruptTransferFunction::Run() {
-  scoped_ptr<extensions::api::usb::InterruptTransfer::Params> parameters =
+  std::unique_ptr<extensions::api::usb::InterruptTransfer::Params> parameters =
       InterruptTransfer::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(parameters.get());
 
   scoped_refptr<UsbDeviceHandle> device_handle =
       GetDeviceHandle(parameters->handle);
   if (!device_handle.get()) {
     return RespondNow(Error(kErrorNoConnection));
   }
 
   const GenericTransferInfo& transfer = parameters->transfer_info;
@@ skipping 25 matching lines @@
   return RespondLater();
 }
 
 UsbIsochronousTransferFunction::UsbIsochronousTransferFunction() {
 }
 
 UsbIsochronousTransferFunction::~UsbIsochronousTransferFunction() {
 }
 
 ExtensionFunction::ResponseAction UsbIsochronousTransferFunction::Run() {
-  scoped_ptr<extensions::api::usb::IsochronousTransfer::Params> parameters =
-      IsochronousTransfer::Params::Create(*args_);
+  std::unique_ptr<extensions::api::usb::IsochronousTransfer::Params>
+      parameters = IsochronousTransfer::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(parameters.get());
 
   scoped_refptr<UsbDeviceHandle> device_handle =
       GetDeviceHandle(parameters->handle);
   if (!device_handle.get()) {
     return RespondNow(Error(kErrorNoConnection));
   }
 
   const IsochronousTransferInfo& transfer = parameters->transfer_info;
   const GenericTransferInfo& generic_transfer = transfer.transfer_info;
@@ skipping 42 matching lines @@
 }
 
 void UsbIsochronousTransferFunction::OnCompleted(
     scoped_refptr<net::IOBuffer> data,
     const std::vector<UsbDeviceHandle::IsochronousPacket>& packets) {
   size_t length = std::accumulate(
       packets.begin(), packets.end(), 0,
       [](const size_t& a, const UsbDeviceHandle::IsochronousPacket& packet) {
         return a + packet.transferred_length;
       });
-  scoped_ptr<char[]> buffer(new char[length]);
+  std::unique_ptr<char[]> buffer(new char[length]);
 
   UsbTransferStatus status = device::USB_TRANSFER_COMPLETED;
   size_t buffer_offset = 0;
   size_t data_offset = 0;
   for (const auto& packet : packets) {
     // Capture the error status of the first unsuccessful packet.
     if (status == device::USB_TRANSFER_COMPLETED &&
         packet.status != device::USB_TRANSFER_COMPLETED) {
       status = packet.status;
     }
 
     memcpy(&buffer[buffer_offset], data->data() + data_offset,
            packet.transferred_length);
     buffer_offset += packet.transferred_length;
     data_offset += packet.length;
   }
 
-  scoped_ptr<base::DictionaryValue> transfer_info(new base::DictionaryValue());
+  std::unique_ptr<base::DictionaryValue> transfer_info(
+      new base::DictionaryValue());
   transfer_info->SetInteger(kResultCodeKey, status);
   transfer_info->Set(kDataKey,
                      new base::BinaryValue(std::move(buffer), length));
   if (status == device::USB_TRANSFER_COMPLETED) {
     Respond(OneArgument(std::move(transfer_info)));
   } else {
-    scoped_ptr<base::ListValue> error_args(new base::ListValue());
+    std::unique_ptr<base::ListValue> error_args(new base::ListValue());
     error_args->Append(std::move(transfer_info));
     // Using ErrorWithArguments is discouraged but required to provide the
     // detailed transfer info as the transfer may have partially succeeded.
     Respond(ErrorWithArguments(std::move(error_args),
                                ConvertTransferStatusToApi(status)));
   }
 }
 
 UsbResetDeviceFunction::UsbResetDeviceFunction() {
 }
@@ skipping 20 matching lines @@
   if (success) {
     Respond(OneArgument(new base::FundamentalValue(true)));
   } else {
     scoped_refptr<UsbDeviceHandle> device_handle =
         GetDeviceHandle(parameters_->handle);
     if (device_handle.get()) {
       device_handle->Close();
     }
     ReleaseDeviceHandle(parameters_->handle);
 
-    scoped_ptr<base::ListValue> error_args(new base::ListValue());
+    std::unique_ptr<base::ListValue> error_args(new base::ListValue());
     error_args->AppendBoolean(false);
     // Using ErrorWithArguments is discouraged but required to maintain
     // compatibility with existing applications.
     Respond(ErrorWithArguments(std::move(error_args), kErrorResetDevice));
   }
 }
 
 }  // namespace extensions