Separate usb device handle from usb device. (deprecate)

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"
 #include "chrome/browser/extensions/api/api_function.h"
 #include "chrome/browser/extensions/api/api_resource_manager.h"
-#include "chrome/browser/usb/usb_device.h"
+#include "chrome/browser/usb/usb_device_handle.h"
 #include "chrome/common/extensions/api/usb.h"
 #include "net/base/io_buffer.h"
 
-class UsbDevice;
-
 namespace extensions {
 
 class UsbDeviceResource;
 
 class UsbAsyncApiFunction : public AsyncApiFunction {
  public:
   UsbAsyncApiFunction();
 
  protected:
   virtual ~UsbAsyncApiFunction();
@@ skipping 10 matching lines @@
 };
 
 class UsbAsyncApiTransferFunction : public UsbAsyncApiFunction {
  protected:
   UsbAsyncApiTransferFunction();
   virtual ~UsbAsyncApiTransferFunction();
 
   bool ConvertDirectionSafely(const extensions::api::usb::Direction& input,
                               UsbEndpointDirection* output);
   bool ConvertRequestTypeSafely(const extensions::api::usb::RequestType& input,
-                              UsbDevice::TransferRequestType* output);
+                                UsbDeviceHandle::TransferRequestType* output);
   bool ConvertRecipientSafely(const extensions::api::usb::Recipient& input,
-                              UsbDevice::TransferRecipient* output);
+                              UsbDeviceHandle::TransferRecipient* output);
 
-  void OnCompleted(UsbTransferStatus status,
-                   scoped_refptr<net::IOBuffer> data,
+  void OnCompleted(UsbTransferStatus status, scoped_refptr<net::IOBuffer> data,
                    size_t length);
 };
 
-class UsbFindDevicesFunction : public UsbAsyncApiFunction {
+class UsbGetDevicesFunction : public UsbAsyncApiFunction {
+ public:
+  DECLARE_EXTENSION_FUNCTION("usb.getDevices", USB_GETDEVICES)
+
+  UsbGetDevicesFunction();
+
+  static void SetDeviceForTest(UsbDeviceHandle* device);
+
+ protected:
+  virtual ~UsbGetDevicesFunction();
+
+  virtual bool PrePrepare() OVERRIDE;
+  virtual bool Prepare() OVERRIDE;
+  virtual void AsyncWorkStart() OVERRIDE;
+
+  // Called on FILE thread.
+  void OnDevicesFound();
+  virtual void OnCompleted();
+
+  scoped_ptr<base::ListValue> result_;
+  std::vector<int> devices_;
+  int vendor_id_;
+  int product_id_;
+  int interface_id_;
+  UsbService* service_;
+};
+
+class UsbFindDevicesFunction : public UsbGetDevicesFunction {
  public:
   DECLARE_EXTENSION_FUNCTION("usb.findDevices", USB_FINDDEVICES)
 
   UsbFindDevicesFunction();
 
-  static void SetDeviceForTest(UsbDevice* device);
-
  protected:
   virtual ~UsbFindDevicesFunction();
 
   virtual bool Prepare() OVERRIDE;
+
+  // Called on FILE thread.
+  virtual void OnCompleted() OVERRIDE;
+
+  // Called on IO thread.
+  void OpenDevices();
+
+  std::vector<scoped_refptr<UsbDeviceHandle> > handles_;
+};
+
+class UsbOpenDeviceFunction : public UsbAsyncApiFunction {
+ public:
+  DECLARE_EXTENSION_FUNCTION("usb.openDevice", USB_OPENDEVICE)
+
+  UsbOpenDeviceFunction();
+
+ protected:
+  virtual ~UsbOpenDeviceFunction();
+
+  virtual bool PrePrepare() OVERRIDE;
+  virtual bool Prepare() OVERRIDE;
   virtual void AsyncWorkStart() OVERRIDE;
 
  private:
-  void OnCompleted();
+  void OpenDevice();
+  void OnCompleted(scoped_refptr<UsbDeviceHandle> handle);
 
-  scoped_ptr<base::ListValue> result_;
-  std::vector<scoped_refptr<UsbDevice> > devices_;
-  scoped_ptr<extensions::api::usb::FindDevices::Params> parameters_;
+  scoped_ptr<extensions::api::usb::OpenDevice::Params> parameters_;
+  UsbService* service_;
 };
 
 class UsbListInterfacesFunction : public UsbAsyncApiFunction {
  public:
   DECLARE_EXTENSION_FUNCTION("usb.listInterfaces", USB_LISTINTERFACES)
 
   UsbListInterfacesFunction();
 
  protected:
   virtual ~UsbListInterfacesFunction();
 
   virtual bool Prepare() OVERRIDE;
   virtual void AsyncWorkStart() OVERRIDE;
 
  private:
   void OnCompleted(bool success);
 
   bool ConvertDirectionSafely(const UsbEndpointDirection& input,
                               extensions::api::usb::Direction* output);
   bool ConvertSynchronizationTypeSafely(
       const UsbSynchronizationType& input,
       extensions::api::usb::SynchronizationType* output);
   bool ConvertTransferTypeSafely(const UsbTransferType& input,
-                              extensions::api::usb::TransferType* output);
+                                 extensions::api::usb::TransferType* 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;
   virtual void AsyncWorkStart() OVERRIDE;
 
+ private:
   void OnCompleted();
 
- private:
   scoped_ptr<extensions::api::usb::CloseDevice::Params> parameters_;
 };
 
 class UsbClaimInterfaceFunction : public UsbAsyncApiFunction {
  public:
   DECLARE_EXTENSION_FUNCTION("usb.claimInterface", USB_CLAIMINTERFACE)
 
   UsbClaimInterfaceFunction();
 
  protected:
@@ skipping 67 matching lines @@
 
   UsbBulkTransferFunction();
 
  protected:
   virtual ~UsbBulkTransferFunction();
 
   virtual bool Prepare() OVERRIDE;
   virtual void AsyncWorkStart() OVERRIDE;
 
  private:
-  scoped_ptr<extensions::api::usb::BulkTransfer::Params>
-      parameters_;
+  scoped_ptr<extensions::api::usb::BulkTransfer::Params> parameters_;
 };
 
 class UsbInterruptTransferFunction : public UsbAsyncApiTransferFunction {
  public:
   DECLARE_EXTENSION_FUNCTION("usb.interruptTransfer", USB_INTERRUPTTRANSFER)
 
   UsbInterruptTransferFunction();
 
  protected:
   virtual ~UsbInterruptTransferFunction();
@@ skipping 40 matching lines @@
 
   // IO thread.
   void OnCompleted(bool success);
   void OnError();
 
   scoped_ptr<extensions::api::usb::ResetDevice::Params> parameters_;
 };
 }  // namespace extensions
 
 #endif  // CHROME_BROWSER_EXTENSIONS_API_USB_USB_API_H_