Construct USB descriptors over explicit values.

device/usb/usb_descriptors.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_descriptors.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 
@@ skipping 68 matching lines @@
                            base::Bind(callback, base::Passed(&index_map)));
   for (const auto& map_entry : iterator_map) {
     ReadStringDescriptor(
         device_handle, map_entry.first, language_id,
         base::Bind(&StoreStringDescriptor, map_entry.second, barrier));
   }
 }
 
 }  // 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(
+    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() {
-}
+UsbEndpointDescriptor::~UsbEndpointDescriptor() = default;
 
-UsbInterfaceDescriptor::UsbInterfaceDescriptor()
-    : interface_number(0),
-      alternate_setting(0),
-      interface_class(0),
-      interface_subclass(0),
-      interface_protocol(0) {
-}
+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() {
-}
+UsbInterfaceDescriptor::~UsbInterfaceDescriptor() = default;
 
-UsbConfigDescriptor::UsbConfigDescriptor()
-    : configuration_value(0),
-      self_powered(false),
-      remote_wakeup(false),
-      maximum_power(0) {
-}
+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() {
-}
+UsbConfigDescriptor::~UsbConfigDescriptor() = default;
 
 bool ParseUsbStringDescriptor(const std::vector<uint8_t>& descriptor,
                               base::string16* output) {
   if (descriptor.size() < 2 || descriptor[1] != kStringDescriptorType)
     return false;
 
   // Let the device return a buffer larger than the actual string but prefer the
   // length reported inside the descriptor.
   size_t length = descriptor[0];
   length = std::min(length, descriptor.size());
@@ skipping 17 matching lines @@
     callback.Run(std::move(index_map));
     return;
   }
 
   ReadStringDescriptor(device_handle, 0, 0,
                        base::Bind(&OnReadLanguageIds, device_handle,
                                   base::Passed(&index_map), callback));
 }
 
 }  // namespace device