Add chrome.usb.listInterfaces API

chrome/common/extensions/api/usb.idl

 // 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.
 
 namespace usb {
 
-  // Direction, Recipient and RequestType all map to their namesakes within the
-  // USB specification.
+  // Direction, Recipient, RequestType, and TransferType all map to their
+  // namesakes within the USB specification.
   enum Direction {in, out};
   enum Recipient {device, _interface, endpoint, other};
   enum RequestType {standard, class, vendor, reserved};
+  enum TransferType {control, interrupt, isochronous, bulk};
+
+  // For isochronous mode, SynchronizationType and UsageType map to their
+  // namesakes within the USB specification.
+  enum SynchronizationType {asynchronous, adaptive, synchronous};
+  enum UsageType {data, feedback, explicitFeedback};
 
   // A Device encapsulates everything that is needed to communicate with a USB
   // device. They are returned by findDevice calls and have all of their
   // fields populated before being returned.
   dictionary Device {
     long handle;
     long vendorId;
     long productId;
   };
 
+  dictionary EndpointDescriptor {
+    long address;
+    TransferType type;
+    Direction direction;
+    long maximumPacketSize;
+
+    // Used for isochronous mode.
+    SynchronizationType? synchronization;
+    UsageType? usage;
+
+    // If this is an interrupt endpoint, this will be 1-255
+    long? pollingInterval;
+  };
+
+  dictionary InterfaceDescriptor {
+    long interfaceNumber;
+    long alternateSetting;
+    long interfaceClass;
+    long interfaceSubclass;
+    long interfaceProtocol;
+    DOMString? description;
+    EndpointDescriptor[] endpoints;
+  };
+
   // ControlTransferInfo represents that parameters to a single USB control
   // transfer.
   dictionary ControlTransferInfo {
     // The direction of this transfer.
     Direction direction;
 
     // The intended recipient for this transfer.
     Recipient recipient;
 
     // The type of this request.
@@ skipping 58 matching lines @@
 
   // FindDevicesOptions describes the properties of devices which are found and
   // opened via findDevices.
   dictionary FindDevicesOptions {
     long vendorId;
     long productId;
   };
 
   callback VoidCallback = void ();
   callback FindDevicesCallback = void (Device[] device);
+  callback ListInterfacesCallback = void (InterfaceDescriptor[] descriptors);
   callback CloseDeviceCallback = void ();
   callback TransferCallback = void (TransferResultInfo info);
   callback ResetDeviceCallback = void(boolean result);
 
   interface Functions {
     // Finds the first instance of the USB device specified by the vendorId/
     // productId pair and, if permissions allow, opens it for use.
     // Upon successfully opening a device the callback is invoked with a
     // populated Device object. On failure, the callback is invoked with null.
     // |options|: The properties to search for on target devices.
     // |callback|: Invoked with the opened Device on success.
     static void findDevices(FindDevicesOptions options,
         FindDevicesCallback callback);
 
     // Closes an open device instance. Invoking operations on a device after it
     // has been closed is a safe operation, but causes no action to be taken.
     // |device|: The device to close.
     // |callback|: The callback to invoke once the device is closed.
     static void closeDevice(Device device,
         optional CloseDeviceCallback callback);
 
+    // Lists all the interfaces on the USB device.
+    // |device|: The device from which the interfaces should be listed.
+    // |callback|: The callback to invoke when the interfaces are enumerated.
+    static void listInterfaces(Device device,
+        ListInterfacesCallback callback);
+
     // Claims an interface on the specified USB device.
     // |device|: The device on which the interface is to be claimed.
     // |interface|: The interface number to be claimed.
     // |callback|: The callback to invoke once the interface is claimed.
     static void claimInterface(Device device, long interfaceNumber,
         VoidCallback callback);
 
     // Releases a claim to an interface on the provided device.
     // |device|: The device on which the interface is to be released.
     // |interface|: The interface number to be released.
@@ skipping 48 matching lines @@
     // will appear to be disconected and reconnected.
     // You must call <code>findDevice</code> again to acquire the device.
     //
     // |device|: An opened device to reset.
     // |callback|: Invoked once the device is reset with a boolean indicating
     // whether the reset is completed successfully.
     static void resetDevice(Device device,
         ResetDeviceCallback callback);
   };
 };