Get all the UsbConfigDescriptor for the device configuration

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 <algorithm>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/sequenced_task_runner.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/thread_task_runner_handle.h"
 #include "components/device_event_log/device_event_log.h"
 #include "device/usb/usb_context.h"
-#include "device/usb/usb_descriptors.h"
 #include "device/usb/usb_device_handle_impl.h"
 #include "device/usb/usb_error.h"
 #include "third_party/libusb/src/libusb/libusb.h"
 
 #if defined(OS_CHROMEOS)
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/permission_broker_client.h"
 #include "dbus/file_descriptor.h"
 #endif  // defined(OS_CHROMEOS)
 
@@ skipping 54 matching lines @@
     case LIBUSB_ISO_USAGE_TYPE_FEEDBACK:
       return USB_USAGE_FEEDBACK;
     case LIBUSB_ISO_USAGE_TYPE_IMPLICIT:
       return USB_USAGE_EXPLICIT_FEEDBACK;
     default:
       NOTREACHED();
       return USB_USAGE_DATA;
   }
 }
 
+void SetConfigDescriptor(const libusb_config_descriptor* platform_config,

[Reilly Grant (use Gerrit), 2015/08/03 18:04:04]

I suggest renaming this to "ConvertConfigDescriptor()".

[juncai, 2015/08/03 21:56:25]

Done.

+                         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;
+
+      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>(
+            platform_endpoint->extra,
+            platform_endpoint->extra + platform_endpoint->extra_length);
+
+        interface.endpoints.push_back(endpoint);
+      }
+
+      interface.extra_data = std::vector<uint8_t>(
+          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>(
+      platform_config->extra,
+      platform_config->extra + platform_config->extra_length);
+}
+
 }  // namespace
 
 UsbDeviceImpl::UsbDeviceImpl(
     scoped_refptr<UsbContext> context,
     PlatformUsbDevice platform_device,
     uint16 vendor_id,
     uint16 product_id,
     scoped_refptr<base::SequencedTaskRunner> blocking_task_runner)
     : UsbDevice(vendor_id,
                 product_id,
                 base::string16(),
                 base::string16(),
                 base::string16()),
       platform_device_(platform_device),
       context_(context),
       task_runner_(base::ThreadTaskRunnerHandle::Get()),
       blocking_task_runner_(blocking_task_runner) {
   CHECK(platform_device) << "platform_device cannot be NULL";
   libusb_ref_device(platform_device);
+  set_configurations();

[Reilly Grant (use Gerrit), 2015/08/03 18:04:04]

This function is non-trivial and so cannot use this style of function name. I
suggest "ReadAllConfigurations()".

[juncai, 2015/08/03 21:56:25]

Done.

   RefreshConfiguration();

[Reilly Grant (use Gerrit), 2015/08/03 18:04:04]

I suggest renaming this to "RefreshActiveConfiguration()".

[juncai, 2015/08/03 21:56:25]

Done.

 }
 
 UsbDeviceImpl::~UsbDeviceImpl() {
   // The destructor must be safe to call from any thread.
   libusb_unref_device(platform_device_);
 }
 
 #if defined(OS_CHROMEOS)
 
 void UsbDeviceImpl::CheckUsbAccess(const ResultCallback& callback) {
@@ skipping 30 matching lines @@
        ++it) {
     if (it->get() == handle.get()) {
       (*it)->InternalClose();
       handles_.erase(it);
       return true;
     }
   }
   return false;
 }
 
-const UsbConfigDescriptor* UsbDeviceImpl::GetConfiguration() {
+const UsbConfigDescriptor* UsbDeviceImpl::GetActiveConfiguration() {
   DCHECK(thread_checker_.CalledOnValidThread());
-  return configuration_.get();
+  return configuration_;
 }
 
 void UsbDeviceImpl::OnDisconnect() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // Swap the list of handles into a local variable because closing all open
   // handles may release the last reference to this object.
   HandlesVector handles;
   swap(handles, handles_);
 
   for (const scoped_refptr<UsbDeviceHandleImpl>& handle : handles_) {
     handle->InternalClose();
   }
 }
 
+void UsbDeviceImpl::set_configurations() {
+  libusb_device_descriptor device_descriptor;
+  int rv = libusb_get_device_descriptor(platform_device_, &device_descriptor);
+  if (rv == LIBUSB_SUCCESS) {
+    uint8_t num_configurations = device_descriptor.bNumConfigurations;
+    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;
+      SetConfigDescriptor(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);
+  }
+}
+
 void UsbDeviceImpl::RefreshConfiguration() {
   libusb_config_descriptor* platform_config;
   int rv =
       libusb_get_active_config_descriptor(platform_device_, &platform_config);
   if (rv != LIBUSB_SUCCESS) {
     USB_LOG(EVENT) << "Failed to get config descriptor: "
                    << ConvertPlatformUsbErrorToString(rv);
     return;
   }
 
-  configuration_.reset(new UsbConfigDescriptor());
-  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;
-
-      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>(
-            platform_endpoint->extra,
-            platform_endpoint->extra + platform_endpoint->extra_length);
-
-        interface.endpoints.push_back(endpoint);
-      }
-
-      interface.extra_data = std::vector<uint8_t>(
-          platform_alt_setting->extra,
-          platform_alt_setting->extra + platform_alt_setting->extra_length);
-
-      configuration_->interfaces.push_back(interface);
+  configuration_ = nullptr;
+  size_t num_configurations = configurations_.size();
+  for (size_t i = 0; i < num_configurations; ++i) {
+    if (configurations_[i].configuration_value ==
+        platform_config->bConfigurationValue) {
+      configuration_ = &configurations_[i];
+      break;
     }
   }
 
-  configuration_->extra_data = std::vector<uint8_t>(
-      platform_config->extra,
-      platform_config->extra + platform_config->extra_length);
-
   libusb_free_config_descriptor(platform_config);
 }
 
 #if defined(OS_CHROMEOS)
 
 void UsbDeviceImpl::OnOpenRequestComplete(const OpenCallback& callback,
                                           dbus::FileDescriptor fd) {
   blocking_task_runner_->PostTask(
       FROM_HERE, base::Bind(&UsbDeviceImpl::OpenOnBlockingThreadWithFd, this,
                             base::Passed(&fd), callback));
@@ skipping 38 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