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

device/usb/mojo/type_converters.h

 // 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.
 
 #ifndef DEVICE_USB_MOJO_TYPE_CONVERTERS_H_
 #define DEVICE_USB_MOJO_TYPE_CONVERTERS_H_
 
 #include <vector>
 
 #include "device/usb/public/interfaces/device.mojom.h"
 #include "device/usb/public/interfaces/device_manager.mojom.h"
 #include "device/usb/usb_descriptors.h"
 #include "device/usb/usb_device_filter.h"
 #include "device/usb/usb_device_handle.h"
-#include "mojo/public/cpp/bindings/array.h"
 #include "mojo/public/cpp/bindings/type_converter.h"
 
 // Type converters to translate between internal device/usb data types and
 // public Mojo interface data types. This must be included by any source file
 // that uses these conversions explicitly or implicitly.
 
 namespace device {
 class UsbDevice;
 }
 
@@ skipping 49 matching lines @@
                      device::UsbInterfaceDescriptor> {
   static device::usb::AlternateInterfaceInfoPtr Convert(
       const device::UsbInterfaceDescriptor& iface);
 };
 
 // Note that this is an explicit vector-to-array conversion, as
 // UsbInterfaceDescriptor collections are flattened to contain all alternate
 // settings, whereas InterfaceInfos contain their own sets of alternates with
 // a different structure type.
 template <>
-struct TypeConverter<mojo::Array<device::usb::InterfaceInfoPtr>,
+struct TypeConverter<std::vector<device::usb::InterfaceInfoPtr>,
                      std::vector<device::UsbInterfaceDescriptor>> {
-  static mojo::Array<device::usb::InterfaceInfoPtr> Convert(
+  static std::vector<device::usb::InterfaceInfoPtr> Convert(
       const std::vector<device::UsbInterfaceDescriptor>& interfaces);
 };
 
 template <>
 struct TypeConverter<device::usb::ConfigurationInfoPtr,
                      device::UsbConfigDescriptor> {
   static device::usb::ConfigurationInfoPtr Convert(
       const device::UsbConfigDescriptor& config);
 };
 
 template <>
 struct TypeConverter<device::usb::DeviceInfoPtr, device::UsbDevice> {
   static device::usb::DeviceInfoPtr Convert(const device::UsbDevice& device);
 };
 
 template <>
 struct TypeConverter<device::usb::IsochronousPacketPtr,
                      device::UsbDeviceHandle::IsochronousPacket> {
   static device::usb::IsochronousPacketPtr Convert(
       const device::UsbDeviceHandle::IsochronousPacket& packet);
 };
 
+template <typename A, typename B>

[dcheng, 2016/08/15 21:41:28]

The main thing I'm worried about is this leading to ODR violations. I guess
we'll just have to hope...

+struct TypeConverter<std::vector<A>, std::vector<B>> {
+  static std::vector<A> Convert(const std::vector<B>& input) {
+    std::vector<A> result;
+    result.reserve(input.size());
+    for (const B& item : input)
+      result.push_back(mojo::ConvertTo<A>(item));
+    return result;
+  };
+};
+
 }  // namespace mojo
 
 #endif  // DEVICE_DEVICES_APP_USB_TYPE_CONVERTERS_H_