Add support for reading USB descriptors to the new Windows backend.

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>
 #include <memory>
@@ skipping 64 matching lines @@
     }
     std::advance(it, length);
   }
 }
 
 void OnDoneReadingConfigDescriptors(
     scoped_refptr<UsbDeviceHandle> device_handle,
     std::unique_ptr<UsbDeviceDescriptor> desc,
     const base::Callback<void(std::unique_ptr<UsbDeviceDescriptor>)>&
         callback) {
-  if (desc->num_configurations == desc->configurations.size())
+  if (desc->num_configurations == desc->configurations.size()) {
     callback.Run(std::move(desc));
-  else
+  } else {
+    LOG(ERROR) << "Failed to read all configuration descriptors. Expected "
+               << static_cast<int>(desc->num_configurations) << ", got "
+               << desc->configurations.size() << ".";
     callback.Run(nullptr);
+  }
 }
 
 void OnReadConfigDescriptor(UsbDeviceDescriptor* desc,
                             const base::Closure& closure,
                             UsbTransferStatus status,
                             scoped_refptr<IOBuffer> buffer,
                             size_t length) {
-  if (status == USB_TRANSFER_COMPLETED)
-    desc->Parse(std::vector<uint8_t>(buffer->data(), buffer->data() + length));
+  if (status == USB_TRANSFER_COMPLETED) {
+    if (!desc->Parse(
+            std::vector<uint8_t>(buffer->data(), buffer->data() + length))) {
+      LOG(ERROR) << "Failed to parse configuration descriptor.";
+    }
+  } else {
+    LOG(ERROR) << "Failed to read configuration descriptor.";
+  }
   closure.Run();
 }
 
 void OnReadConfigDescriptorHeader(scoped_refptr<UsbDeviceHandle> device_handle,
                                   UsbDeviceDescriptor* desc,
                                   uint8_t index,
                                   const base::Closure& closure,
                                   UsbTransferStatus status,
                                   scoped_refptr<IOBuffer> header,
                                   size_t length) {
   if (status == USB_TRANSFER_COMPLETED && length == 4) {
     const uint8_t* data = reinterpret_cast<const uint8_t*>(header->data());
     uint16_t total_length = data[2] | data[3] << 8;
     scoped_refptr<IOBuffer> buffer = new IOBuffer(total_length);
     device_handle->ControlTransfer(
         USB_DIRECTION_INBOUND, UsbDeviceHandle::STANDARD,
         UsbDeviceHandle::DEVICE, kGetDescriptorRequest,
         kConfigurationDescriptorType << 8 | index, 0, buffer, total_length,
         kControlTransferTimeout,
         base::Bind(&OnReadConfigDescriptor, desc, closure));
   } else {
+    LOG(ERROR) << "Failed to read length for configuration "
+               << static_cast<int>(index) << ".";
     closure.Run();
   }
 }
 
 void OnReadDeviceDescriptor(
     scoped_refptr<UsbDeviceHandle> device_handle,
     const base::Callback<void(std::unique_ptr<UsbDeviceDescriptor>)>& callback,
     UsbTransferStatus status,
     scoped_refptr<IOBuffer> buffer,
     size_t length) {
   if (status != USB_TRANSFER_COMPLETED) {
+    LOG(ERROR) << "Failed to read device descriptor.";
     callback.Run(nullptr);
     return;
   }
 
   std::unique_ptr<UsbDeviceDescriptor> desc(new UsbDeviceDescriptor());
   if (!desc->Parse(
           std::vector<uint8_t>(buffer->data(), buffer->data() + length))) {
+    LOG(ERROR) << "Device descriptor parsing error.";
     callback.Run(nullptr);
     return;
   }
 
   if (desc->num_configurations == 0) {
     callback.Run(std::move(desc));
     return;
   }
 
   uint8_t num_configurations = desc->num_configurations;
@@ skipping 276 matching lines @@
       case kDeviceDescriptorType:
         if (configurations.size() > 0 || length < kDeviceDescriptorLength)
           return false;
         usb_version = data[2] | data[3] << 8;
         device_class = data[4];
         device_subclass = data[5];
         device_protocol = data[6];
         vendor_id = data[8] | data[9] << 8;
         product_id = data[10] | data[11] << 8;
         device_version = data[12] | data[13] << 8;
+        i_manufacturer = data[14];
+        i_product = data[15];
+        i_serial_number = data[16];
         num_configurations = data[17];
         break;
       case kConfigurationDescriptorType:
         if (length < kConfigurationDescriptorLength)
           return false;
         if (last_config)
           last_config->AssignFirstInterfaceNumbers();
         configurations.emplace_back(data);
         last_config = &configurations.back();
         last_interface = nullptr;
@@ skipping 75 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