Add support for sending a USB SET_CONFIGURATION request.

device/usb/usb_device_handle_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_handle_impl.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 359 matching lines @@
   } else {
     VLOG(1) << "Failed to submit transfer: "
             << ConvertPlatformUsbErrorToString(rv);
     Complete(USB_TRANSFER_ERROR, 0);
     return false;
   }
 }
 
 void UsbDeviceHandleImpl::Transfer::Cancel() {
   libusb_cancel_transfer(platform_transfer_);
+  claimed_interface_ = nullptr;
 }
 
 void UsbDeviceHandleImpl::Transfer::ProcessCompletion() {
   DCHECK_GE(platform_transfer_->actual_length, 0)
       << "Negative actual length received";
   size_t actual_length =
       static_cast<size_t>(std::max(platform_transfer_->actual_length, 0));
 
   DCHECK(length_ >= actual_length)
       << "data too big for our buffer (libusb failure?)";
@@ skipping 80 matching lines @@
   // will be discarded if the handle has been freed.
   Transfer* tmp_transfer = transfer.get();  // base::Passed invalidates transfer
   tmp_transfer->task_runner_->PostTask(
       FROM_HERE, base::Bind(&UsbDeviceHandleImpl::CompleteTransfer,
                             tmp_transfer->device_handle_,
                             base::Passed(&transfer)));
 }
 
 UsbDeviceHandleImpl::UsbDeviceHandleImpl(scoped_refptr<UsbContext> context,
                                          UsbDeviceImpl* device,
-                                         PlatformUsbDeviceHandle handle,
-                                         const UsbConfigDescriptor& config)
+                                         PlatformUsbDeviceHandle handle)
     : device_(device),
       handle_(handle),
-      config_(config),
       context_(context),
       task_runner_(base::ThreadTaskRunnerHandle::Get()),
       weak_factory_(this) {
   DCHECK(handle) << "Cannot create device with NULL handle.";
 }
 
 UsbDeviceHandleImpl::~UsbDeviceHandleImpl() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   libusb_close(handle_);
   handle_ = NULL;
 }
 
 scoped_refptr<UsbDevice> UsbDeviceHandleImpl::GetDevice() const {
   return static_cast<UsbDevice*>(device_);
 }
 
 void UsbDeviceHandleImpl::Close() {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (device_)
     device_->Close(this);
 }
 
+bool UsbDeviceHandleImpl::SetConfiguration(int configuration_value) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  if (!device_) {
+    return false;
+  }
+
+  for (Transfer* transfer : transfers_) {
+    transfer->Cancel();
+  }
+  claimed_interfaces_.clear();
+
+  int rv = libusb_set_configuration(handle_, configuration_value);
+  if (rv == LIBUSB_SUCCESS) {
+    device_->RefreshConfiguration();
+    RefreshEndpointMap();
+  } else {
+    VLOG(1) << "Failed to set configuration " << configuration_value << ": "
+            << ConvertPlatformUsbErrorToString(rv);
+  }
+  return rv == LIBUSB_SUCCESS;
+}
+
 bool UsbDeviceHandleImpl::ClaimInterface(const int interface_number) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (!device_)
     return false;
   if (ContainsKey(claimed_interfaces_, interface_number))
     return true;
 
   scoped_refptr<InterfaceClaimer> claimer =
       new InterfaceClaimer(this, interface_number);
 
@@ skipping 205 matching lines @@
   scoped_ptr<Transfer> transfer = Transfer::CreateIsochronousTransfer(
       ConvertTransferDirection(direction) | endpoint, buffer,
       static_cast<int>(length), packets, packet_length, timeout, callback);
 
   PostOrSubmitTransfer(transfer.Pass());
 }
 
 void UsbDeviceHandleImpl::RefreshEndpointMap() {
   DCHECK(thread_checker_.CalledOnValidThread());
   endpoint_map_.clear();
-  for (ClaimedInterfaceMap::iterator claimedIt = claimed_interfaces_.begin();
-       claimedIt != claimed_interfaces_.end();
-       ++claimedIt) {
-    for (UsbInterfaceDescriptor::Iterator ifaceIt = config_.interfaces.begin();
-         ifaceIt != config_.interfaces.end();
-         ++ifaceIt) {
-      if (ifaceIt->interface_number == claimedIt->first &&
-          ifaceIt->alternate_setting ==
-              claimedIt->second->alternate_setting()) {
-        for (UsbEndpointDescriptor::Iterator endpointIt =
-                 ifaceIt->endpoints.begin();
-             endpointIt != ifaceIt->endpoints.end();
-             ++endpointIt) {
-          endpoint_map_[endpointIt->address] = claimedIt->first;
+  const UsbConfigDescriptor* config = device_->GetConfiguration();
+  if (config) {
+    for (const auto& map_entry : claimed_interfaces_) {
+      int interface_number = map_entry.first;
+      const scoped_refptr<InterfaceClaimer>& claimed_iface = map_entry.second;
+
+      for (const UsbInterfaceDescriptor& iface : config->interfaces) {
+        if (iface.interface_number == interface_number &&
+            iface.alternate_setting == claimed_iface->alternate_setting()) {
+          for (const UsbEndpointDescriptor& endpoint : iface.endpoints) {
+            endpoint_map_[endpoint.address] = interface_number;
+          }
+          break;
         }
-        break;
       }
     }
   }
 }
 
 scoped_refptr<UsbDeviceHandleImpl::InterfaceClaimer>
 UsbDeviceHandleImpl::GetClaimedInterfaceForEndpoint(unsigned char endpoint) {
   if (ContainsKey(endpoint_map_, endpoint))
     return claimed_interfaces_[endpoint_map_[endpoint]];
   return NULL;
@@ skipping 78 matching lines @@
   // Attempt-release all the interfaces.
   // It will be retained until the transfer cancellation is finished.
   claimed_interfaces_.clear();
 
   // Cannot close device handle here. Need to wait for libusb_cancel_transfer to
   // finish.
   device_ = NULL;
 }
 
 }  // namespace device