Add chrome.usb.listInterfaces API

chrome/browser/usb/usb_device.cc

 // Copyright (c) 2012 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 "chrome/browser/usb/usb_device.h"
 
+#include <vector>
+
 #include "base/stl_util.h"
 #include "base/synchronization/lock.h"
+#include "chrome/browser/usb/usb_interface.h"
 #include "chrome/browser/usb/usb_service.h"
 #include "third_party/libusb/src/libusb/libusb.h"
 
 namespace {
 
 static uint8 ConvertTransferDirection(
-    const UsbDevice::TransferDirection direction) {
+    const UsbEndpointDirection direction) {
   switch (direction) {
-    case UsbDevice::INBOUND:
+    case USB_DIRECTION_INBOUND:
       return LIBUSB_ENDPOINT_IN;
-    case UsbDevice::OUTBOUND:
+    case USB_DIRECTION_OUTBOUND:
       return LIBUSB_ENDPOINT_OUT;
+    default:
+      NOTREACHED();
+      return LIBUSB_ENDPOINT_IN;
   }
-  NOTREACHED();
-  return LIBUSB_ENDPOINT_OUT;
 }
 
-static uint8 CreateRequestType(const UsbDevice::TransferDirection direction,
+static uint8 CreateRequestType(const UsbEndpointDirection direction,
     const UsbDevice::TransferRequestType request_type,
     const UsbDevice::TransferRecipient recipient) {
   uint8 result = ConvertTransferDirection(direction);
 
   switch (request_type) {
     case UsbDevice::STANDARD:
       result |= LIBUSB_REQUEST_TYPE_STANDARD;
       break;
     case UsbDevice::CLASS:
       result |= LIBUSB_REQUEST_TYPE_CLASS;
@@ skipping 34 matching lines @@
     case LIBUSB_TRANSFER_TIMED_OUT:
       return USB_TRANSFER_TIMEOUT;
     case LIBUSB_TRANSFER_STALL:
       return USB_TRANSFER_STALLED;
     case LIBUSB_TRANSFER_NO_DEVICE:
       return USB_TRANSFER_DISCONNECT;
     case LIBUSB_TRANSFER_OVERFLOW:
       return USB_TRANSFER_OVERFLOW;
     case LIBUSB_TRANSFER_CANCELLED:
       return USB_TRANSFER_CANCELLED;
+    default:
+      NOTREACHED();
+      return USB_TRANSFER_ERROR;
   }
-  NOTREACHED();
-  return USB_TRANSFER_ERROR;
 }
 
 static void LIBUSB_CALL HandleTransferCompletion(
     struct libusb_transfer* transfer) {
   UsbDevice* const device = reinterpret_cast<UsbDevice*>(transfer->user_data);
   device->TransferComplete(transfer);
 }
 
 }  // namespace
 
@@ skipping 90 matching lines @@
       NOTREACHED() << "Invalid usb transfer type";
   }
 
   transfer->callback.Run(ConvertTransferStatus(handle->status), buffer,
                          actual_length);
 
   transfers_.erase(handle);
   libusb_free_transfer(handle);
 }
 
+void UsbDevice::ListInterfaces(UsbConfigDescriptor* config,
+                               const UsbInterfaceCallback& callback) {
+  CheckDevice();
+
+  PlatformUsbDevice device = libusb_get_device(handle_);
+
+  PlatformUsbConfigDescriptor platform_config;
+  const int list_result = libusb_get_active_config_descriptor(device,
+      &platform_config);
+  if (list_result == 0) {
+    config->Reset(platform_config);
+  }
+  callback.Run(list_result == 0);
+}
+
 void UsbDevice::ClaimInterface(const int interface_number,
                                const UsbInterfaceCallback& callback) {
   CheckDevice();
 
   const int claim_result = libusb_claim_interface(handle_, interface_number);
   callback.Run(claim_result == 0);
 }
 
 void UsbDevice::ReleaseInterface(const int interface_number,
                                  const UsbInterfaceCallback& callback) {
   CheckDevice();
 
   const int release_result = libusb_release_interface(handle_,
                                                       interface_number);
   callback.Run(release_result == 0);
 }
 
 void UsbDevice::SetInterfaceAlternateSetting(
     const int interface_number,
     const int alternate_setting,
     const UsbInterfaceCallback& callback) {
   CheckDevice();
 
   const int setting_result = libusb_set_interface_alt_setting(handle_,
       interface_number, alternate_setting);
 
   callback.Run(setting_result == 0);
 }
 
-void UsbDevice::ControlTransfer(const TransferDirection direction,
+void UsbDevice::ControlTransfer(const UsbEndpointDirection direction,
     const TransferRequestType request_type, const TransferRecipient recipient,
     const uint8 request, const uint16 value, const uint16 index,
     net::IOBuffer* buffer, const size_t length, const unsigned int timeout,
     const UsbTransferCallback& callback) {
   CheckDevice();
 
   const size_t resized_length = LIBUSB_CONTROL_SETUP_SIZE + length;
   scoped_refptr<net::IOBuffer> resized_buffer(new net::IOBufferWithSize(
       resized_length));
   memcpy(resized_buffer->data() + LIBUSB_CONTROL_SETUP_SIZE, buffer->data(),
          length);
 
   struct libusb_transfer* const transfer = libusb_alloc_transfer(0);
   const uint8 converted_type = CreateRequestType(direction, request_type,
                                                  recipient);
   libusb_fill_control_setup(reinterpret_cast<uint8*>(resized_buffer->data()),
                             converted_type, request, value, index, length);
   libusb_fill_control_transfer(transfer, handle_, reinterpret_cast<uint8*>(
       resized_buffer->data()), HandleTransferCompletion, this, timeout);
   SubmitTransfer(transfer, USB_TRANSFER_CONTROL, resized_buffer, resized_length,
                  callback);
 }
 
-void UsbDevice::BulkTransfer(const TransferDirection direction,
+void UsbDevice::BulkTransfer(const UsbEndpointDirection direction,
     const uint8 endpoint, net::IOBuffer* buffer, const size_t length,
     const unsigned int timeout, const UsbTransferCallback& callback) {
   CheckDevice();
 
   struct libusb_transfer* const transfer = libusb_alloc_transfer(0);
   const uint8 new_endpoint = ConvertTransferDirection(direction) | endpoint;
   libusb_fill_bulk_transfer(transfer, handle_, new_endpoint,
       reinterpret_cast<uint8*>(buffer->data()), length,
       HandleTransferCompletion, this, timeout);
   SubmitTransfer(transfer, USB_TRANSFER_BULK, buffer, length, callback);
 }
 
-void UsbDevice::InterruptTransfer(const TransferDirection direction,
+void UsbDevice::InterruptTransfer(const UsbEndpointDirection direction,
     const uint8 endpoint, net::IOBuffer* buffer, const size_t length,
     const unsigned int timeout, const UsbTransferCallback& callback) {
   CheckDevice();
 
   struct libusb_transfer* const transfer = libusb_alloc_transfer(0);
   const uint8 new_endpoint = ConvertTransferDirection(direction) | endpoint;
   libusb_fill_interrupt_transfer(transfer, handle_, new_endpoint,
       reinterpret_cast<uint8*>(buffer->data()), length,
       HandleTransferCompletion, this, timeout);
   SubmitTransfer(transfer, USB_TRANSFER_INTERRUPT, buffer, length, callback);
 }
 
-void UsbDevice::IsochronousTransfer(const TransferDirection direction,
+void UsbDevice::IsochronousTransfer(const UsbEndpointDirection direction,
     const uint8 endpoint, net::IOBuffer* buffer, const size_t length,
     const unsigned int packets, const unsigned int packet_length,
     const unsigned int timeout, const UsbTransferCallback& callback) {
   CheckDevice();
 
   const uint64 total_length = packets * packet_length;
   CHECK(packets <= length && total_length <= length) <<
       "transfer length is too small";
 
   struct libusb_transfer* const transfer = libusb_alloc_transfer(packets);
@@ skipping 25 matching lines @@
   transfer.buffer = buffer;
   transfer.length = length;
   transfer.callback = callback;
 
   {
     base::AutoLock lock(lock_);
     transfers_[handle] = transfer;
     libusb_submit_transfer(handle);
   }
 }