Add chrome.usb.listInterfaces API

chrome/browser/extensions/api/usb/usb_api.h

 // 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.
 
 #ifndef CHROME_BROWSER_EXTENSIONS_API_USB_USB_API_H_
 #define CHROME_BROWSER_EXTENSIONS_API_USB_USB_API_H_
 
 #include <string>
 
 #include "base/memory/ref_counted.h"
@@ skipping 26 matching lines @@
 
   ApiResourceManager<UsbDeviceResource>* manager_;
 };
 
 class UsbAsyncApiTransferFunction : public UsbAsyncApiFunction {
  protected:
   UsbAsyncApiTransferFunction();
   virtual ~UsbAsyncApiTransferFunction();
 
   bool ConvertDirectionSafely(const extensions::api::usb::Direction& input,
-                              UsbDevice::TransferDirection* output);
+                              UsbInterfaceDirection* output);

[Bei Zhang, 2013/04/26 22:38:01]

I think direction is not a property of USB interface. This should be called
either UsbTransferDirection or UsbEndpointDirection.

[Kenny Root (Google), 2013/05/08 01:15:08]

Done.

   bool ConvertRequestTypeSafely(const extensions::api::usb::RequestType& input,
                                 UsbDevice::TransferRequestType* output);
   bool ConvertRecipientSafely(const extensions::api::usb::Recipient& input,
                               UsbDevice::TransferRecipient* output);
 
   void OnCompleted(UsbTransferStatus status,
                    scoped_refptr<net::IOBuffer> data,
                    size_t length);
 };
 
@@ skipping 12 matching lines @@
   virtual void AsyncWorkStart() OVERRIDE;
 
  private:
   void OnCompleted();
 
   scoped_ptr<base::ListValue> result_;
   std::vector<scoped_refptr<UsbDevice> > devices_;
   scoped_ptr<extensions::api::usb::FindDevices::Params> parameters_;
 };
 
+class UsbListInterfacesFunction : public UsbAsyncApiFunction {
+ public:
+  DECLARE_EXTENSION_FUNCTION("usb.listInterfaces", USB_LISTINTERFACES)
+
+  UsbListInterfacesFunction();
+
+  static void SetDeviceForTest(UsbDevice* device);
+
+ protected:
+  virtual ~UsbListInterfacesFunction();
+
+  virtual bool Prepare() OVERRIDE;
+  virtual void AsyncWorkStart() OVERRIDE;
+
+ private:
+  void OnCompleted(bool success);
+
+  bool ConvertDirectionSafely(const UsbInterfaceDirection& input,
+                              extensions::api::usb::Direction* output);
+  bool ConvertEndpointTypeSafely(const UsbEndpointType& input,
+                                 extensions::api::usb::EndpointType* output);
+  bool ConvertSynchronizationTypeSafely(
+      const UsbSynchronizationType& input,
+      extensions::api::usb::SynchronizationType* output);
+  bool ConvertUsageTypeSafely(const UsbUsageType& input,
+                              extensions::api::usb::UsageType* output);
+
+  scoped_ptr<base::ListValue> result_;
+  scoped_refptr<UsbConfigDescriptor> config_;
+  scoped_ptr<extensions::api::usb::ListInterfaces::Params> parameters_;
+};
+
 class UsbCloseDeviceFunction : public UsbAsyncApiFunction {
  public:
   DECLARE_EXTENSION_FUNCTION("usb.closeDevice", USB_CLOSEDEVICE)
 
   UsbCloseDeviceFunction();
 
  protected:
   virtual ~UsbCloseDeviceFunction();
 
   virtual bool Prepare() OVERRIDE;
@@ skipping 121 matching lines @@
   virtual bool Prepare() OVERRIDE;
   virtual void AsyncWorkStart() OVERRIDE;
 
  private:
   scoped_ptr<extensions::api::usb::IsochronousTransfer::Params> parameters_;
 };
 
 }  // namespace extensions
 
 #endif  // CHROME_BROWSER_EXTENSIONS_API_USB_USB_API_H_