Construct USB descriptors over explicit values.

Instead of specifying a bunch of arbitrary defaults and then updating
them in the code building the structure. This makes them friendly to use
with C++11's emplace_back() method.

BUG=None

Review URL: https://codereview.chromium.org/1468423003

Cr-Commit-Position: refs/heads/master@{#375081}

9 files changed, 111 insertions, 118 deletions

diff --git a/device/usb/mojo/device_impl_unittest.cc b/device/usb/mojo/device_impl_unittest.cc
index c6c2e49..df23b01 100644
--- a/device/usb/mojo/device_impl_unittest.cc
+++ b/device/usb/mojo/device_impl_unittest.cc
@@ -37,20 +37,15 @@ namespace {
 
 class ConfigBuilder {
  public:
-  explicit ConfigBuilder(uint8_t value) { config_.configuration_value = value; }
+  explicit ConfigBuilder(uint8_t value) : config_(value, false, false, 0) {}
 
   ConfigBuilder& AddInterface(uint8_t interface_number,
                               uint8_t alternate_setting,
                               uint8_t class_code,
                               uint8_t subclass_code,
                               uint8_t protocol_code) {
-    UsbInterfaceDescriptor interface;
-    interface.interface_number = interface_number;
-    interface.alternate_setting = alternate_setting;
-    interface.interface_class = class_code;
-    interface.interface_subclass = subclass_code;
-    interface.interface_protocol = protocol_code;
-    config_.interfaces.push_back(interface);
+    config_.interfaces.emplace_back(interface_number, alternate_setting,
+                                    class_code, subclass_code, protocol_code);
     return *this;
   }
 
@@ -219,7 +214,7 @@ class USBDeviceImplTest : public testing::Test {
   void AddMockConfig(const ConfigBuilder& builder) {
     const UsbConfigDescriptor& config = builder.config();
     DCHECK(!ContainsKey(mock_configs_, config.configuration_value));
-    mock_configs_[config.configuration_value] = config;
+    mock_configs_.insert(std::make_pair(config.configuration_value, config));
   }
 
   void AddMockInboundData(const std::vector<uint8_t>& data) {
diff --git a/device/usb/usb_configuration_android.cc b/device/usb/usb_configuration_android.cc
index 4a9c712..d7c1401 100644
--- a/device/usb/usb_configuration_android.cc
+++ b/device/usb/usb_configuration_android.cc
@@ -23,15 +23,11 @@ UsbConfigDescriptor UsbConfigurationAndroid::Convert(
   ScopedJavaLocalRef<jobject> wrapper =
       Java_ChromeUsbConfiguration_create(env, usb_configuration.obj());
 
-  UsbConfigDescriptor config;
-  config.configuration_value =
-      Java_ChromeUsbConfiguration_getConfigurationValue(env, wrapper.obj());
-  config.self_powered =
-      Java_ChromeUsbConfiguration_isSelfPowered(env, wrapper.obj());
-  config.remote_wakeup =
-      Java_ChromeUsbConfiguration_isRemoteWakeup(env, wrapper.obj());
-  config.maximum_power =
-      Java_ChromeUsbConfiguration_getMaxPower(env, wrapper.obj());
+  UsbConfigDescriptor config(
+      Java_ChromeUsbConfiguration_getConfigurationValue(env, wrapper.obj()),
+      Java_ChromeUsbConfiguration_isSelfPowered(env, wrapper.obj()),
+      Java_ChromeUsbConfiguration_isRemoteWakeup(env, wrapper.obj()),
+      Java_ChromeUsbConfiguration_getMaxPower(env, wrapper.obj()));
 
   ScopedJavaLocalRef<jobjectArray> interfaces =
       Java_ChromeUsbConfiguration_getInterfaces(env, wrapper.obj());
diff --git a/device/usb/usb_descriptors.cc b/device/usb/usb_descriptors.cc
index 840eb5d..6defda8 100644
--- a/device/usb/usb_descriptors.cc
+++ b/device/usb/usb_descriptors.cc
@@ -86,39 +86,47 @@ void OnReadLanguageIds(scoped_refptr<UsbDeviceHandle> device_handle,
 
 }  // namespace
 
-UsbEndpointDescriptor::UsbEndpointDescriptor()
-    : address(0),
-      direction(USB_DIRECTION_INBOUND),
-      maximum_packet_size(0),
-      synchronization_type(USB_SYNCHRONIZATION_NONE),
-      transfer_type(USB_TRANSFER_CONTROL),
-      usage_type(USB_USAGE_DATA),
-      polling_interval(0) {
-}
-
-UsbEndpointDescriptor::~UsbEndpointDescriptor() {
-}
-
-UsbInterfaceDescriptor::UsbInterfaceDescriptor()
-    : interface_number(0),
-      alternate_setting(0),
-      interface_class(0),
-      interface_subclass(0),
-      interface_protocol(0) {
-}
-
-UsbInterfaceDescriptor::~UsbInterfaceDescriptor() {
-}
-
-UsbConfigDescriptor::UsbConfigDescriptor()
-    : configuration_value(0),
-      self_powered(false),
-      remote_wakeup(false),
-      maximum_power(0) {
-}
-
-UsbConfigDescriptor::~UsbConfigDescriptor() {
-}
+UsbEndpointDescriptor::UsbEndpointDescriptor(
+    uint8_t address,
+    UsbEndpointDirection direction,
+    uint16_t maximum_packet_size,
+    UsbSynchronizationType synchronization_type,
+    UsbTransferType transfer_type,
+    UsbUsageType usage_type,
+    uint16_t polling_interval)
+    : address(address),
+      direction(direction),
+      maximum_packet_size(maximum_packet_size),
+      synchronization_type(synchronization_type),
+      transfer_type(transfer_type),
+      usage_type(usage_type),
+      polling_interval(polling_interval) {}
+
+UsbEndpointDescriptor::~UsbEndpointDescriptor() = default;
+
+UsbInterfaceDescriptor::UsbInterfaceDescriptor(uint8_t interface_number,
+                                               uint8_t alternate_setting,
+                                               uint8_t interface_class,
+                                               uint8_t interface_subclass,
+                                               uint8_t interface_protocol)
+    : interface_number(interface_number),
+      alternate_setting(alternate_setting),
+      interface_class(interface_class),
+      interface_subclass(interface_subclass),
+      interface_protocol(interface_protocol) {}
+
+UsbInterfaceDescriptor::~UsbInterfaceDescriptor() = default;
+
+UsbConfigDescriptor::UsbConfigDescriptor(uint8_t configuration_value,
+                                         bool self_powered,
+                                         bool remote_wakeup,
+                                         uint16_t maximum_power)
+    : configuration_value(configuration_value),
+      self_powered(self_powered),
+      remote_wakeup(remote_wakeup),
+      maximum_power(maximum_power) {}
+
+UsbConfigDescriptor::~UsbConfigDescriptor() = default;
 
 bool ParseUsbStringDescriptor(const std::vector<uint8_t>& descriptor,
                               base::string16* output) {
diff --git a/device/usb/usb_descriptors.h b/device/usb/usb_descriptors.h
index cd8490a..c99a6de 100644
--- a/device/usb/usb_descriptors.h
+++ b/device/usb/usb_descriptors.h
@@ -49,7 +49,14 @@ enum UsbUsageType {
 };
 
 struct UsbEndpointDescriptor {
-  UsbEndpointDescriptor();
+  UsbEndpointDescriptor(uint8_t address,
+                        UsbEndpointDirection direction,
+                        uint16_t maximum_packet_size,
+                        UsbSynchronizationType synchronization_type,
+                        UsbTransferType transfer_type,
+                        UsbUsageType usage_type,
+                        uint16_t polling_interval);
+  UsbEndpointDescriptor() = delete;
   ~UsbEndpointDescriptor();
 
   uint8_t address;
@@ -63,7 +70,12 @@ struct UsbEndpointDescriptor {
 };
 
 struct UsbInterfaceDescriptor {
-  UsbInterfaceDescriptor();
+  UsbInterfaceDescriptor(uint8_t interface_number,
+                         uint8_t alternate_setting,
+                         uint8_t interface_class,
+                         uint8_t interface_subclass,
+                         uint8_t interface_protocol);
+  UsbInterfaceDescriptor() = delete;
   ~UsbInterfaceDescriptor();
 
   uint8_t interface_number;
@@ -76,7 +88,11 @@ struct UsbInterfaceDescriptor {
 };
 
 struct UsbConfigDescriptor {
-  UsbConfigDescriptor();
+  UsbConfigDescriptor(uint8_t configuration_value,
+                      bool self_powered,
+                      bool remote_wakeup,
+                      uint16_t maximum_power);
+  UsbConfigDescriptor() = delete;
   ~UsbConfigDescriptor();
 
   uint8_t configuration_value;
diff --git a/device/usb/usb_device_android.cc b/device/usb/usb_device_android.cc
index ee9e93b..6d246ba 100644
--- a/device/usb/usb_device_android.cc
+++ b/device/usb/usb_device_android.cc
@@ -83,11 +83,10 @@ UsbDeviceAndroid::UsbDeviceAndroid(JNIEnv* env,
   } else {
     // Pre-lollipop only the first configuration was supported. Build a basic
     // configuration out of the available interfaces.
-    UsbConfigDescriptor config;
-    config.configuration_value = 1;  // Reasonable guess.
-    config.self_powered = false;     // Arbitrary default.
-    config.remote_wakeup = false;    // Arbitrary default.
-    config.maximum_power = 0;        // Arbitrary default.
+    UsbConfigDescriptor config(1,      // Configuration value, reasonable guess.
+                               false,  // Self powered, arbitrary default.
+                               false,  // Remote wakeup, rbitrary default.
+                               0);     // Maximum power, aitrary default.
 
     ScopedJavaLocalRef<jobjectArray> interfaces =
         Java_ChromeUsbDevice_getInterfaces(env, wrapper.obj());
diff --git a/device/usb/usb_device_filter_unittest.cc b/device/usb/usb_device_filter_unittest.cc
index 303ffa7..df1a223 100644
--- a/device/usb/usb_device_filter_unittest.cc
+++ b/device/usb/usb_device_filter_unittest.cc
@@ -20,15 +20,8 @@ using testing::Return;
 class UsbFilterTest : public testing::Test {
  public:
   void SetUp() override {
-    UsbInterfaceDescriptor interface;
-    interface.interface_number = 1;
-    interface.alternate_setting = 0;
-    interface.interface_class = 0xFF;
-    interface.interface_subclass = 0x42;
-    interface.interface_protocol = 0x01;
-
-    UsbConfigDescriptor config;
-    config.interfaces.push_back(interface);
+    UsbConfigDescriptor config(1, false, false, 0);
+    config.interfaces.emplace_back(1, 0, 0xff, 0x42, 0x01);
 
     android_phone_ = new MockUsbDevice(0x18d1, 0x4ee2, config);
   }
diff --git a/device/usb/usb_device_impl.cc b/device/usb/usb_device_impl.cc
index 5280699..1a8bedf 100644
--- a/device/usb/usb_device_impl.cc
+++ b/device/usb/usb_device_impl.cc
@@ -94,47 +94,37 @@ UsbUsageType GetUsageType(const libusb_endpoint_descriptor* descriptor) {
 
 void ConvertConfigDescriptor(const libusb_config_descriptor* platform_config,
                              UsbConfigDescriptor* configuration) {
-  configuration->configuration_value = platform_config->bConfigurationValue;
-  configuration->self_powered = (platform_config->bmAttributes & 0x40) != 0;
-  configuration->remote_wakeup = (platform_config->bmAttributes & 0x20) != 0;
-  configuration->maximum_power = platform_config->MaxPower * 2;
-
   for (size_t i = 0; i < platform_config->bNumInterfaces; ++i) {
     const struct libusb_interface* platform_interface =
         &platform_config->interface[i];
     for (int j = 0; j < platform_interface->num_altsetting; ++j) {
       const struct libusb_interface_descriptor* platform_alt_setting =
           &platform_interface->altsetting[j];
-      UsbInterfaceDescriptor interface;
-
-      interface.interface_number = platform_alt_setting->bInterfaceNumber;
-      interface.alternate_setting = platform_alt_setting->bAlternateSetting;
-      interface.interface_class = platform_alt_setting->bInterfaceClass;
-      interface.interface_subclass = platform_alt_setting->bInterfaceSubClass;
-      interface.interface_protocol = platform_alt_setting->bInterfaceProtocol;
+      UsbInterfaceDescriptor interface(
+          platform_alt_setting->bInterfaceNumber,
+          platform_alt_setting->bAlternateSetting,
+          platform_alt_setting->bInterfaceClass,
+          platform_alt_setting->bInterfaceSubClass,
+          platform_alt_setting->bInterfaceProtocol);
 
       interface.endpoints.reserve(platform_alt_setting->bNumEndpoints);
       for (size_t k = 0; k < platform_alt_setting->bNumEndpoints; ++k) {
         const struct libusb_endpoint_descriptor* platform_endpoint =
             &platform_alt_setting->endpoint[k];
-        UsbEndpointDescriptor endpoint;
-
-        endpoint.address = platform_endpoint->bEndpointAddress;
-        endpoint.direction = GetDirection(platform_endpoint);
-        endpoint.maximum_packet_size = platform_endpoint->wMaxPacketSize;
-        endpoint.synchronization_type =
-            GetSynchronizationType(platform_endpoint);
-        endpoint.transfer_type = GetTransferType(platform_endpoint);
-        endpoint.usage_type = GetUsageType(platform_endpoint);
-        endpoint.polling_interval = platform_endpoint->bInterval;
-        endpoint.extra_data = std::vector<uint8_t>(
+        UsbEndpointDescriptor endpoint(
+            platform_endpoint->bEndpointAddress,
+            GetDirection(platform_endpoint), platform_endpoint->wMaxPacketSize,
+            GetSynchronizationType(platform_endpoint),
+            GetTransferType(platform_endpoint), GetUsageType(platform_endpoint),
+            platform_endpoint->bInterval);
+        endpoint.extra_data.assign(
             platform_endpoint->extra,
             platform_endpoint->extra + platform_endpoint->extra_length);
 
         interface.endpoints.push_back(endpoint);
       }
 
-      interface.extra_data = std::vector<uint8_t>(
+      interface.extra_data.assign(
           platform_alt_setting->extra,
           platform_alt_setting->extra + platform_alt_setting->extra_length);
 
@@ -142,7 +132,7 @@ void ConvertConfigDescriptor(const libusb_config_descriptor* platform_config,
     }
   }
 
-  configuration->extra_data = std::vector<uint8_t>(
+  configuration->extra_data.assign(
       platform_config->extra,
       platform_config->extra + platform_config->extra_length);
 }
@@ -251,7 +241,11 @@ void UsbDeviceImpl::ReadAllConfigurations() {
         continue;
       }
 
-      UsbConfigDescriptor config_descriptor;
+      UsbConfigDescriptor config_descriptor(
+          platform_config->bConfigurationValue,
+          (platform_config->bmAttributes & 0x40) != 0,
+          (platform_config->bmAttributes & 0x20) != 0,
+          platform_config->MaxPower * 2);
       ConvertConfigDescriptor(platform_config, &config_descriptor);
       configurations_.push_back(config_descriptor);
       libusb_free_config_descriptor(platform_config);
diff --git a/device/usb/usb_endpoint_android.cc b/device/usb/usb_endpoint_android.cc
index 3280b04..d05d73b 100644
--- a/device/usb/usb_endpoint_android.cc
+++ b/device/usb/usb_endpoint_android.cc
@@ -20,20 +20,17 @@ UsbEndpointDescriptor UsbEndpointAndroid::Convert(
   base::android::ScopedJavaLocalRef<jobject> wrapper =
       Java_ChromeUsbEndpoint_create(env, usb_endpoint.obj());
 
-  UsbEndpointDescriptor endpoint;
-  endpoint.address = Java_ChromeUsbEndpoint_getAddress(env, wrapper.obj());
-  endpoint.direction = static_cast<UsbEndpointDirection>(
-      Java_ChromeUsbEndpoint_getDirection(env, wrapper.obj()));
-  endpoint.maximum_packet_size =
-      Java_ChromeUsbEndpoint_getMaxPacketSize(env, wrapper.obj());
   jint attributes = Java_ChromeUsbEndpoint_getAttributes(env, wrapper.obj());
-  endpoint.synchronization_type =
-      static_cast<UsbSynchronizationType>((attributes >> 2) & 3);
-  endpoint.usage_type = static_cast<UsbUsageType>((attributes >> 4) & 3);
-  endpoint.transfer_type = static_cast<UsbTransferType>(
-      Java_ChromeUsbEndpoint_getType(env, wrapper.obj()));
-  endpoint.polling_interval =
-      Java_ChromeUsbEndpoint_getInterval(env, wrapper.obj());
+  UsbEndpointDescriptor endpoint(
+      Java_ChromeUsbEndpoint_getAddress(env, wrapper.obj()),
+      static_cast<UsbEndpointDirection>(
+          Java_ChromeUsbEndpoint_getDirection(env, wrapper.obj())),
+      Java_ChromeUsbEndpoint_getMaxPacketSize(env, wrapper.obj()),
+      static_cast<UsbSynchronizationType>((attributes >> 2) & 3),
+      static_cast<UsbTransferType>(
+          Java_ChromeUsbEndpoint_getType(env, wrapper.obj())),
+      static_cast<UsbUsageType>((attributes >> 4) & 3),
+      Java_ChromeUsbEndpoint_getInterval(env, wrapper.obj()));
 
   return endpoint;
 }
diff --git a/device/usb/usb_interface_android.cc b/device/usb/usb_interface_android.cc
index 60403ae..fefe671 100644
--- a/device/usb/usb_interface_android.cc
+++ b/device/usb/usb_interface_android.cc
@@ -23,17 +23,12 @@ UsbInterfaceDescriptor UsbInterfaceAndroid::Convert(
   ScopedJavaLocalRef<jobject> wrapper =
       Java_ChromeUsbInterface_create(env, usb_interface.obj());
 
-  UsbInterfaceDescriptor interface;
-  interface.interface_number =
-      Java_ChromeUsbInterface_getInterfaceNumber(env, wrapper.obj());
-  interface.alternate_setting =
-      Java_ChromeUsbInterface_getAlternateSetting(env, wrapper.obj());
-  interface.interface_class =
-      Java_ChromeUsbInterface_getInterfaceClass(env, wrapper.obj());
-  interface.interface_subclass =
-      Java_ChromeUsbInterface_getInterfaceSubclass(env, wrapper.obj());
-  interface.interface_protocol =
-      Java_ChromeUsbInterface_getInterfaceProtocol(env, wrapper.obj());
+  UsbInterfaceDescriptor interface(
+      Java_ChromeUsbInterface_getInterfaceNumber(env, wrapper.obj()),
+      Java_ChromeUsbInterface_getAlternateSetting(env, wrapper.obj()),
+      Java_ChromeUsbInterface_getInterfaceClass(env, wrapper.obj()),
+      Java_ChromeUsbInterface_getInterfaceSubclass(env, wrapper.obj()),
+      Java_ChromeUsbInterface_getInterfaceProtocol(env, wrapper.obj()));
 
   ScopedJavaLocalRef<jobjectArray> endpoints =
       Java_ChromeUsbInterface_getEndpoints(env, wrapper.obj());