Construct USB descriptors over explicit values.

device/usb/usb_device_impl.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 "device/usb/usb_device_impl.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 
@@ skipping 76 matching lines @@
     case LIBUSB_ISO_USAGE_TYPE_IMPLICIT:
       return USB_USAGE_EXPLICIT_FEEDBACK;
     default:
       NOTREACHED();
       return USB_USAGE_DATA;
   }
 }
 
 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);
 
       configuration->interfaces.push_back(interface);
     }
   }
 
-  configuration->extra_data = std::vector<uint8_t>(
+  configuration->extra_data.assign(
       platform_config->extra,
       platform_config->extra + platform_config->extra_length);
 }
 
 }  // namespace
 
 UsbDeviceImpl::UsbDeviceImpl(
     scoped_refptr<UsbContext> context,
     PlatformUsbDevice platform_device,
     uint16_t vendor_id,
@@ skipping 88 matching lines @@
     configurations_.reserve(num_configurations);
     for (uint8_t i = 0; i < num_configurations; ++i) {
       libusb_config_descriptor* platform_config;
       rv = libusb_get_config_descriptor(platform_device_, i, &platform_config);
       if (rv != LIBUSB_SUCCESS) {
         USB_LOG(EVENT) << "Failed to get config descriptor: "
                        << ConvertPlatformUsbErrorToString(rv);
         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);
     }
   } else {
     USB_LOG(EVENT) << "Failed to get device descriptor: "
                    << ConvertPlatformUsbErrorToString(rv);
   }
 }
 
@@ skipping 70 matching lines @@
 void UsbDeviceImpl::Opened(PlatformUsbDeviceHandle platform_handle,
                            const OpenCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   scoped_refptr<UsbDeviceHandleImpl> device_handle = new UsbDeviceHandleImpl(
       context_, this, platform_handle, blocking_task_runner_);
   handles_.push_back(device_handle);
   callback.Run(device_handle);
 }
 
 }  // namespace device