Convert device::UsbConfigDescriptor and friends to structs.

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"
 #include "base/location.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/string16.h"
 #include "base/synchronization/lock.h"
 #include "base/thread_task_runner_handle.h"
 #include "device/usb/usb_context.h"
+#include "device/usb/usb_descriptors.h"
 #include "device/usb/usb_device_impl.h"
 #include "device/usb/usb_error.h"
-#include "device/usb/usb_interface.h"
 #include "device/usb/usb_service.h"
 #include "third_party/libusb/src/libusb/libusb.h"
 
 namespace device {
 
 typedef libusb_device* PlatformUsbDevice;
 
 void HandleTransferCompletion(PlatformUsbTransferHandle transfer);
 
 namespace {
@@ skipping 144 matching lines @@
 void UsbDeviceHandleImpl::Transfer::Complete(UsbTransferStatus status,
                                              size_t bytes_transferred) {
   if (task_runner->RunsTasksOnCurrentThread()) {
     callback.Run(status, buffer, bytes_transferred);
   } else {
     task_runner->PostTask(
         FROM_HERE, base::Bind(callback, status, buffer, bytes_transferred));
   }
 }
 
-UsbDeviceHandleImpl::UsbDeviceHandleImpl(
-    scoped_refptr<UsbContext> context,
-    UsbDeviceImpl* device,
-    PlatformUsbDeviceHandle handle,
-    scoped_refptr<UsbConfigDescriptor> interfaces)
+UsbDeviceHandleImpl::UsbDeviceHandleImpl(scoped_refptr<UsbContext> context,
+                                         UsbDeviceImpl* device,
+                                         PlatformUsbDeviceHandle handle,
+                                         const UsbConfigDescriptor& config)
     : device_(device),
       handle_(handle),
-      interfaces_(interfaces),
+      config_(config),
       context_(context),
       task_runner_(base::ThreadTaskRunnerHandle::Get()) {
   DCHECK(handle) << "Cannot create device with NULL handle.";
-  DCHECK(interfaces_.get()) << "Unable to list interfaces";
 }
 
 UsbDeviceHandleImpl::~UsbDeviceHandleImpl() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   libusb_close(handle_);
   handle_ = NULL;
 }
 
 scoped_refptr<UsbDevice> UsbDeviceHandleImpl::GetDevice() const {
@@ skipping 447 matching lines @@
                            timeout);
   libusb_set_iso_packet_lengths(transfer, packet_length);
 
   PostOrSubmitTransfer(
       transfer, USB_TRANSFER_ISOCHRONOUS, buffer, length, callback);
 }
 
 void UsbDeviceHandleImpl::RefreshEndpointMap() {
   DCHECK(thread_checker_.CalledOnValidThread());
   endpoint_map_.clear();
-  for (ClaimedInterfaceMap::iterator it = claimed_interfaces_.begin();
-       it != claimed_interfaces_.end();
-       ++it) {
-    scoped_refptr<const UsbInterfaceAltSettingDescriptor> interface_desc =
-        interfaces_->GetInterface(it->first)
-            ->GetAltSetting(it->second->alternate_setting());
-    for (size_t i = 0; i < interface_desc->GetNumEndpoints(); i++) {
-      scoped_refptr<const UsbEndpointDescriptor> endpoint =
-          interface_desc->GetEndpoint(i);
-      endpoint_map_[endpoint->GetAddress()] = it->first;
+  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;
+        }
+        break;
+      }
     }
   }
 }
 
 scoped_refptr<UsbDeviceHandleImpl::InterfaceClaimer>
 UsbDeviceHandleImpl::GetClaimedInterfaceForEndpoint(unsigned char endpoint) {
   unsigned char address = endpoint & LIBUSB_ENDPOINT_ADDRESS_MASK;
   if (ContainsKey(endpoint_map_, address))
     return claimed_interfaces_[endpoint_map_[address]];
   return NULL;
@@ skipping 75 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