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

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef CHROME_BROWSER_EXTENSIONS_API_USB_USB_API_H_
   6 #define CHROME_BROWSER_EXTENSIONS_API_USB_USB_API_H_
   7
   8 #include <string>
   9 #include <vector>
  10
  11 #include "base/memory/ref_counted.h"
  12 #include "base/memory/scoped_ptr.h"
  13 #include "chrome/browser/usb/usb_device.h"
  14 #include "chrome/browser/usb/usb_device_handle.h"
  15 #include "chrome/common/extensions/api/usb.h"
  16 #include "extensions/browser/api/api_resource_manager.h"
  17 #include "extensions/browser/api/async_api_function.h"
  18 #include "net/base/io_buffer.h"
  19
  20 class UsbDevice;
  21 class UsbDeviceHandle;
  22 class UsbService;
  23
  24 namespace extensions {
  25
  26 class UsbDeviceResource;
  27
  28 class UsbAsyncApiFunction : public AsyncApiFunction {
  29  public:
  30   UsbAsyncApiFunction();
  31
  32  protected:
  33   virtual ~UsbAsyncApiFunction();
  34
  35   virtual bool PrePrepare() OVERRIDE;
  36   virtual bool Respond() OVERRIDE;
  37
  38   scoped_refptr<UsbDevice> GetDeviceOrOrCompleteWithError(
  39       const extensions::api::usb::Device& input_device);
  40
  41   scoped_refptr<UsbDeviceHandle> GetDeviceHandleOrCompleteWithError(
  42       const extensions::api::usb::ConnectionHandle& input_device_handle);
  43
  44   void RemoveUsbDeviceResource(int api_resource_id);
  45
  46   void CompleteWithError(const std::string& error);
  47
  48   ApiResourceManager<UsbDeviceResource>* manager_;
  49 };
  50
  51 class UsbAsyncApiTransferFunction : public UsbAsyncApiFunction {
  52  protected:
  53   UsbAsyncApiTransferFunction();
  54   virtual ~UsbAsyncApiTransferFunction();
  55
  56   bool ConvertDirectionSafely(const extensions::api::usb::Direction& input,
  57                               UsbEndpointDirection* output);
  58   bool ConvertRequestTypeSafely(const extensions::api::usb::RequestType& input,
  59                                 UsbDeviceHandle::TransferRequestType* output);
  60   bool ConvertRecipientSafely(const extensions::api::usb::Recipient& input,
  61                               UsbDeviceHandle::TransferRecipient* output);
  62
  63   void OnCompleted(UsbTransferStatus status,
  64                    scoped_refptr<net::IOBuffer> data,
  65                    size_t length);
  66 };
  67
  68 class UsbFindDevicesFunction : public UsbAsyncApiFunction {
  69  public:
  70   DECLARE_EXTENSION_FUNCTION("usb.findDevices", USB_FINDDEVICES)
  71
  72   UsbFindDevicesFunction();
  73
  74  protected:
  75   virtual ~UsbFindDevicesFunction();
  76
  77   virtual bool Prepare() OVERRIDE;
  78   virtual void AsyncWorkStart() OVERRIDE;
  79
  80  private:
  81   void OpenDevices(scoped_ptr<std::vector<scoped_refptr<UsbDevice> > > devices);
  82
  83   std::vector<scoped_refptr<UsbDeviceHandle> > device_handles_;
  84   scoped_ptr<extensions::api::usb::FindDevices::Params> parameters_;
  85 };
  86
  87 class UsbGetDevicesFunction : public UsbAsyncApiFunction {
  88  public:
  89   DECLARE_EXTENSION_FUNCTION("usb.getDevices", USB_GETDEVICES)
  90
  91   UsbGetDevicesFunction();
  92
  93   static void SetDeviceForTest(UsbDevice* device);
  94
  95   virtual bool Prepare() OVERRIDE;
  96   virtual void AsyncWorkStart() OVERRIDE;
  97
  98  protected:
  99   virtual ~UsbGetDevicesFunction();
 100
 101  private:
 102   void EnumerationCompletedFileThread(
 103       scoped_ptr<std::vector<scoped_refptr<UsbDevice> > > devices);
 104
 105   scoped_ptr<extensions::api::usb::GetDevices::Params> parameters_;
 106 };
 107
 108 class UsbRequestAccessFunction : public UsbAsyncApiFunction {
 109  public:
 110   DECLARE_EXTENSION_FUNCTION("usb.requestAccess", USB_REQUESTACCESS)
 111
 112   UsbRequestAccessFunction();
 113
 114   virtual bool Prepare() OVERRIDE;
 115   virtual void AsyncWorkStart() OVERRIDE;
 116
 117  protected:
 118   virtual ~UsbRequestAccessFunction();
 119
 120   void OnCompleted(bool success);
 121
 122  private:
 123   scoped_ptr<extensions::api::usb::RequestAccess::Params> parameters_;
 124 };
 125
 126 class UsbOpenDeviceFunction : public UsbAsyncApiFunction {
 127  public:
 128   DECLARE_EXTENSION_FUNCTION("usb.openDevice", USB_OPENDEVICE)
 129
 130   UsbOpenDeviceFunction();
 131
 132   virtual bool Prepare() OVERRIDE;
 133   virtual void AsyncWorkStart() OVERRIDE;
 134
 135  protected:
 136   virtual ~UsbOpenDeviceFunction();
 137
 138  private:
 139   scoped_refptr<UsbDeviceHandle> handle_;
 140   scoped_ptr<extensions::api::usb::OpenDevice::Params> parameters_;
 141 };
 142
 143 class UsbListInterfacesFunction : public UsbAsyncApiFunction {
 144  public:
 145   DECLARE_EXTENSION_FUNCTION("usb.listInterfaces", USB_LISTINTERFACES)
 146
 147   UsbListInterfacesFunction();
 148
 149  protected:
 150   virtual ~UsbListInterfacesFunction();
 151
 152   virtual bool Prepare() OVERRIDE;
 153   virtual void AsyncWorkStart() OVERRIDE;
 154
 155  private:
 156   bool ConvertDirectionSafely(const UsbEndpointDirection& input,
 157                               extensions::api::usb::Direction* output);
 158   bool ConvertSynchronizationTypeSafely(
 159       const UsbSynchronizationType& input,
 160       extensions::api::usb::SynchronizationType* output);
 161   bool ConvertTransferTypeSafely(const UsbTransferType& input,
 162                                  extensions::api::usb::TransferType* output);
 163   bool ConvertUsageTypeSafely(const UsbUsageType& input,
 164                               extensions::api::usb::UsageType* output);
 165
 166   scoped_ptr<base::ListValue> result_;
 167   scoped_ptr<extensions::api::usb::ListInterfaces::Params> parameters_;
 168 };
 169
 170 class UsbCloseDeviceFunction : public UsbAsyncApiFunction {
 171  public:
 172   DECLARE_EXTENSION_FUNCTION("usb.closeDevice", USB_CLOSEDEVICE)
 173
 174   UsbCloseDeviceFunction();
 175
 176  protected:
 177   virtual ~UsbCloseDeviceFunction();
 178
 179   virtual bool Prepare() OVERRIDE;
 180   virtual void AsyncWorkStart() OVERRIDE;
 181
 182  private:
 183   scoped_ptr<extensions::api::usb::CloseDevice::Params> parameters_;
 184 };
 185
 186 class UsbClaimInterfaceFunction : public UsbAsyncApiFunction {
 187  public:
 188   DECLARE_EXTENSION_FUNCTION("usb.claimInterface", USB_CLAIMINTERFACE)
 189
 190   UsbClaimInterfaceFunction();
 191
 192  protected:
 193   virtual ~UsbClaimInterfaceFunction();
 194
 195   virtual bool Prepare() OVERRIDE;
 196   virtual void AsyncWorkStart() OVERRIDE;
 197
 198  private:
 199   scoped_ptr<extensions::api::usb::ClaimInterface::Params> parameters_;
 200 };
 201
 202 class UsbReleaseInterfaceFunction : public UsbAsyncApiFunction {
 203  public:
 204   DECLARE_EXTENSION_FUNCTION("usb.releaseInterface", USB_RELEASEINTERFACE)
 205
 206   UsbReleaseInterfaceFunction();
 207
 208  protected:
 209   virtual ~UsbReleaseInterfaceFunction();
 210
 211   virtual bool Prepare() OVERRIDE;
 212   virtual void AsyncWorkStart() OVERRIDE;
 213
 214  private:
 215   scoped_ptr<extensions::api::usb::ReleaseInterface::Params> parameters_;
 216 };
 217
 218 class UsbSetInterfaceAlternateSettingFunction : public UsbAsyncApiFunction {
 219  public:
 220   DECLARE_EXTENSION_FUNCTION("usb.setInterfaceAlternateSetting",
 221                              USB_SETINTERFACEALTERNATESETTING)
 222
 223   UsbSetInterfaceAlternateSettingFunction();
 224
 225  private:
 226   virtual ~UsbSetInterfaceAlternateSettingFunction();
 227
 228   virtual bool Prepare() OVERRIDE;
 229   virtual void AsyncWorkStart() OVERRIDE;
 230
 231   scoped_ptr<extensions::api::usb::SetInterfaceAlternateSetting::Params>
 232       parameters_;
 233 };
 234
 235 class UsbControlTransferFunction : public UsbAsyncApiTransferFunction {
 236  public:
 237   DECLARE_EXTENSION_FUNCTION("usb.controlTransfer", USB_CONTROLTRANSFER)
 238
 239   UsbControlTransferFunction();
 240
 241  protected:
 242   virtual ~UsbControlTransferFunction();
 243
 244   virtual bool Prepare() OVERRIDE;
 245   virtual void AsyncWorkStart() OVERRIDE;
 246
 247  private:
 248   scoped_ptr<extensions::api::usb::ControlTransfer::Params> parameters_;
 249 };
 250
 251 class UsbBulkTransferFunction : public UsbAsyncApiTransferFunction {
 252  public:
 253   DECLARE_EXTENSION_FUNCTION("usb.bulkTransfer", USB_BULKTRANSFER)
 254
 255   UsbBulkTransferFunction();
 256
 257  protected:
 258   virtual ~UsbBulkTransferFunction();
 259
 260   virtual bool Prepare() OVERRIDE;
 261   virtual void AsyncWorkStart() OVERRIDE;
 262
 263  private:
 264   scoped_ptr<extensions::api::usb::BulkTransfer::Params> parameters_;
 265 };
 266
 267 class UsbInterruptTransferFunction : public UsbAsyncApiTransferFunction {
 268  public:
 269   DECLARE_EXTENSION_FUNCTION("usb.interruptTransfer", USB_INTERRUPTTRANSFER)
 270
 271   UsbInterruptTransferFunction();
 272
 273  protected:
 274   virtual ~UsbInterruptTransferFunction();
 275
 276   virtual bool Prepare() OVERRIDE;
 277   virtual void AsyncWorkStart() OVERRIDE;
 278
 279  private:
 280   scoped_ptr<extensions::api::usb::InterruptTransfer::Params> parameters_;
 281 };
 282
 283 class UsbIsochronousTransferFunction : public UsbAsyncApiTransferFunction {
 284  public:
 285   DECLARE_EXTENSION_FUNCTION("usb.isochronousTransfer", USB_ISOCHRONOUSTRANSFER)
 286
 287   UsbIsochronousTransferFunction();
 288
 289  protected:
 290   virtual ~UsbIsochronousTransferFunction();
 291
 292   virtual bool Prepare() OVERRIDE;
 293   virtual void AsyncWorkStart() OVERRIDE;
 294
 295  private:
 296   scoped_ptr<extensions::api::usb::IsochronousTransfer::Params> parameters_;
 297 };
 298
 299 class UsbResetDeviceFunction : public UsbAsyncApiFunction {
 300  public:
 301   DECLARE_EXTENSION_FUNCTION("usb.resetDevice", USB_RESETDEVICE)
 302
 303   UsbResetDeviceFunction();
 304
 305  protected:
 306   virtual ~UsbResetDeviceFunction();
 307
 308   virtual bool Prepare() OVERRIDE;
 309   virtual void AsyncWorkStart() OVERRIDE;
 310
 311  private:
 312   scoped_ptr<extensions::api::usb::ResetDevice::Params> parameters_;
 313 };
 314 }  // namespace extensions
 315
 316 #endif  // CHROME_BROWSER_EXTENSIONS_API_USB_USB_API_H_