[Extensions] Convert APIs to use movable types [14]

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 <numeric>
 #include <string>
 #include <utility>
@@ skipping 299 matching lines @@
     case device::USB_USAGE_FEEDBACK:
       return usb::USAGE_TYPE_FEEDBACK;
     case device::USB_USAGE_EXPLICIT_FEEDBACK:
       return usb::USAGE_TYPE_EXPLICITFEEDBACK;
     default:
       NOTREACHED();
       return usb::USAGE_TYPE_NONE;
   }
 }
 
-void ConvertEndpointDescriptor(const UsbEndpointDescriptor& input,
-                               EndpointDescriptor* output) {
-  output->address = input.address;
-  output->type = ConvertTransferTypeToApi(input.transfer_type);
-  output->direction = ConvertDirectionToApi(input.direction);
-  output->maximum_packet_size = input.maximum_packet_size;
-  output->synchronization =
+EndpointDescriptor ConvertEndpointDescriptor(
+    const UsbEndpointDescriptor& input) {
+  EndpointDescriptor output;
+  output.address = input.address;
+  output.type = ConvertTransferTypeToApi(input.transfer_type);
+  output.direction = ConvertDirectionToApi(input.direction);
+  output.maximum_packet_size = input.maximum_packet_size;
+  output.synchronization =
       ConvertSynchronizationTypeToApi(input.synchronization_type);
-  output->usage = ConvertUsageTypeToApi(input.usage_type);
-  output->polling_interval.reset(new int(input.polling_interval));
-  output->extra_data.assign(input.extra_data.begin(), input.extra_data.end());
+  output.usage = ConvertUsageTypeToApi(input.usage_type);
+  output.polling_interval.reset(new int(input.polling_interval));
+  output.extra_data.assign(input.extra_data.begin(), input.extra_data.end());
+  return output;
 }
 
-void ConvertInterfaceDescriptor(const UsbInterfaceDescriptor& input,
-                                InterfaceDescriptor* output) {
-  output->interface_number = input.interface_number;
-  output->alternate_setting = input.alternate_setting;
-  output->interface_class = input.interface_class;
-  output->interface_subclass = input.interface_subclass;
-  output->interface_protocol = input.interface_protocol;
-  for (const UsbEndpointDescriptor& input_endpoint : input.endpoints) {
-    linked_ptr<EndpointDescriptor> endpoint(new EndpointDescriptor);
-    ConvertEndpointDescriptor(input_endpoint, endpoint.get());
-    output->endpoints.push_back(endpoint);
-  }
-  output->extra_data.assign(input.extra_data.begin(), input.extra_data.end());
+InterfaceDescriptor ConvertInterfaceDescriptor(
+    const UsbInterfaceDescriptor& input) {
+  InterfaceDescriptor output;
+  output.interface_number = input.interface_number;
+  output.alternate_setting = input.alternate_setting;
+  output.interface_class = input.interface_class;
+  output.interface_subclass = input.interface_subclass;
+  output.interface_protocol = input.interface_protocol;
+  for (const UsbEndpointDescriptor& input_endpoint : input.endpoints)
+    output.endpoints.push_back(ConvertEndpointDescriptor(input_endpoint));
+  output.extra_data.assign(input.extra_data.begin(), input.extra_data.end());
+  return output;
 }
 
-void ConvertConfigDescriptor(const UsbConfigDescriptor& input,
-                             ConfigDescriptor* output) {
-  output->configuration_value = input.configuration_value;
-  output->self_powered = input.self_powered;
-  output->remote_wakeup = input.remote_wakeup;
-  output->max_power = input.maximum_power;
-  for (const UsbInterfaceDescriptor& input_interface : input.interfaces) {
-    linked_ptr<InterfaceDescriptor> interface(new InterfaceDescriptor);
-    ConvertInterfaceDescriptor(input_interface, interface.get());
-    output->interfaces.push_back(interface);
-  }
-  output->extra_data.assign(input.extra_data.begin(), input.extra_data.end());
+ConfigDescriptor ConvertConfigDescriptor(const UsbConfigDescriptor& input) {
+  ConfigDescriptor output;
+  output.configuration_value = input.configuration_value;
+  output.self_powered = input.self_powered;
+  output.remote_wakeup = input.remote_wakeup;
+  output.max_power = input.maximum_power;
+  for (const UsbInterfaceDescriptor& input_interface : input.interfaces)
+    output.interfaces.push_back(ConvertInterfaceDescriptor(input_interface));
+  output.extra_data.assign(input.extra_data.begin(), input.extra_data.end());
+  return output;
 }
 
 void ConvertDeviceFilter(const usb::DeviceFilter& input,
                          UsbDeviceFilter* output) {
   if (input.vendor_id) {
     output->SetVendorId(*input.vendor_id);
   }
   if (input.product_id) {
     output->SetProductId(*input.product_id);
   }
@@ skipping 180 matching lines @@
 }
 
 ExtensionFunction::ResponseAction UsbGetDevicesFunction::Run() {
   scoped_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).get(),
-                          &filters_[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);
     }
   }
 
@@ skipping 40 matching lines @@
 
   bool multiple = false;
   if (parameters->options.multiple) {
     multiple = *parameters->options.multiple;
   }
 
   std::vector<UsbDeviceFilter> filters;
   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).get(),
-                          &filters[i]);
+      ConvertDeviceFilter(parameters->options.filters->at(i), &filters[i]);
     }
   }
 
   prompt_ = ExtensionsAPIClient::Get()->CreateDevicePermissionsPrompt(
       GetAssociatedWebContents());
   if (!prompt_) {
     return RespondNow(Error(kErrorNotSupported));
   }
 
   prompt_->AskForUsbDevices(
@@ skipping 42 matching lines @@
 
   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());
   const UsbConfigDescriptor* active_config = device->GetActiveConfiguration();
   for (const UsbConfigDescriptor& config : device->configurations()) {
-    ConfigDescriptor api_config;
-    ConvertConfigDescriptor(config, &api_config);
+    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() {
@@ skipping 107 matching lines @@
 
   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);
+    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 =
       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, &config);
+    ConfigDescriptor config = ConvertConfigDescriptor(*config_descriptor);
 
     scoped_ptr<base::ListValue> result(new base::ListValue);
     for (size_t i = 0; i < config.interfaces.size(); ++i) {
-      result->Append(config.interfaces[i]->ToValue());
+      result->Append(config.interfaces[i].ToValue());
     }
 
     return RespondNow(OneArgument(std::move(result)));
   } else {
     return RespondNow(Error(kErrorNotConfigured));
   }
 }
 
 UsbCloseDeviceFunction::UsbCloseDeviceFunction() {
 }
@@ skipping 400 matching lines @@
 
     scoped_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