Mojo C++ binding: make device/usb mojom targets use STD string/vector types

device/usb/mojo/type_converters.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 "device/usb/mojo/type_converters.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <map>
 #include <utility>
 
 #include "base/logging.h"
 #include "base/strings/utf_string_conversions.h"
 #include "device/usb/usb_device.h"
+#include "mojo/common/common_type_converters.h"
 #include "mojo/public/cpp/bindings/array.h"
 
 namespace mojo {
 
 // static
 device::UsbDeviceFilter
 TypeConverter<device::UsbDeviceFilter, device::usb::DeviceFilterPtr>::Convert(
     const device::usb::DeviceFilterPtr& mojo_filter) {
   device::UsbDeviceFilter filter;
   if (mojo_filter->has_vendor_id)
@@ skipping 125 matching lines @@
               device::UsbInterfaceDescriptor>::
     Convert(const device::UsbInterfaceDescriptor& interface) {
   device::usb::AlternateInterfaceInfoPtr info =
       device::usb::AlternateInterfaceInfo::New();
   info->alternate_setting = interface.alternate_setting;
   info->class_code = interface.interface_class;
   info->subclass_code = interface.interface_subclass;
   info->protocol_code = interface.interface_protocol;
 
   // Filter out control endpoints for the public interface.
-  info->endpoints = mojo::Array<device::usb::EndpointInfoPtr>::New(0);
+  info->endpoints.reserve(interface.endpoints.size());
   for (const auto& endpoint : interface.endpoints) {
     if (endpoint.transfer_type != device::USB_TRANSFER_CONTROL)
       info->endpoints.push_back(device::usb::EndpointInfo::From(endpoint));
   }
 
   return info;
 }
 
 // static
-mojo::Array<device::usb::InterfaceInfoPtr>
-TypeConverter<mojo::Array<device::usb::InterfaceInfoPtr>,
+std::vector<device::usb::InterfaceInfoPtr>
+TypeConverter<std::vector<device::usb::InterfaceInfoPtr>,
               std::vector<device::UsbInterfaceDescriptor>>::
     Convert(const std::vector<device::UsbInterfaceDescriptor>& interfaces) {
-  auto infos = mojo::Array<device::usb::InterfaceInfoPtr>::New(0);
+  std::vector<device::usb::InterfaceInfoPtr> infos;
 
   // Aggregate each alternate setting into an InterfaceInfo corresponding to its
   // interface number.
   std::map<uint8_t, device::usb::InterfaceInfo*> interface_map;
   for (size_t i = 0; i < interfaces.size(); ++i) {
     auto alternate = device::usb::AlternateInterfaceInfo::From(interfaces[i]);
     auto iter = interface_map.find(interfaces[i].interface_number);
     if (iter == interface_map.end()) {
       // This is the first time we're seeing an alternate with this interface
       // number, so add a new InterfaceInfo to the array and map the number.
@@ skipping 12 matching lines @@
 }
 
 // static
 device::usb::ConfigurationInfoPtr
 TypeConverter<device::usb::ConfigurationInfoPtr, device::UsbConfigDescriptor>::
     Convert(const device::UsbConfigDescriptor& config) {
   device::usb::ConfigurationInfoPtr info =
       device::usb::ConfigurationInfo::New();
   info->configuration_value = config.configuration_value;
   info->interfaces =
-      mojo::Array<device::usb::InterfaceInfoPtr>::From(config.interfaces);
+      mojo::ConvertTo<std::vector<device::usb::InterfaceInfoPtr>>(
+          config.interfaces);
   return info;
 }
 
 // static
 device::usb::DeviceInfoPtr
 TypeConverter<device::usb::DeviceInfoPtr, device::UsbDevice>::Convert(
     const device::UsbDevice& device) {
   device::usb::DeviceInfoPtr info = device::usb::DeviceInfo::New();
   info->guid = device.guid();
   info->usb_version_major = device.usb_version() >> 8;
   info->usb_version_minor = device.usb_version() >> 4 & 0xf;
   info->usb_version_subminor = device.usb_version() & 0xf;
   info->class_code = device.device_class();
   info->subclass_code = device.device_subclass();
   info->protocol_code = device.device_protocol();
   info->vendor_id = device.vendor_id();
   info->product_id = device.product_id();
   info->device_version_major = device.device_version() >> 8;
   info->device_version_minor = device.device_version() >> 4 & 0xf;
   info->device_version_subminor = device.device_version() & 0xf;
   info->manufacturer_name = base::UTF16ToUTF8(device.manufacturer_string());
   info->product_name = base::UTF16ToUTF8(device.product_string());
   info->serial_number = base::UTF16ToUTF8(device.serial_number());
   const device::UsbConfigDescriptor* config = device.active_configuration();
   info->active_configuration = config ? config->configuration_value : 0;
-  info->configurations = mojo::Array<device::usb::ConfigurationInfoPtr>::From(
-      device.configurations());
+  info->configurations =
+      mojo::ConvertTo<std::vector<device::usb::ConfigurationInfoPtr>>(
+          device.configurations());
   return info;
 }
 
 // static
 device::usb::IsochronousPacketPtr
 TypeConverter<device::usb::IsochronousPacketPtr,
               device::UsbDeviceHandle::IsochronousPacket>::
     Convert(const device::UsbDeviceHandle::IsochronousPacket& packet) {
   device::usb::IsochronousPacketPtr info =
       device::usb::IsochronousPacket::New();
   info->length = packet.length;
   info->transferred_length = packet.transferred_length;
   info->status = mojo::ConvertTo<device::usb::TransferStatus>(packet.status);
   return info;
 }
 
 }  // namespace mojo