extensions/browser/api/usb/usb_api.h

   1 // Copyright 2014 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 EXTENSIONS_BROWSER_API_USB_USB_API_H_
   6 #define EXTENSIONS_BROWSER_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 "device/usb/usb_device.h"
  14 #include "device/usb/usb_device_filter.h"
  15 #include "device/usb/usb_device_handle.h"
  16 #include "extensions/browser/api/api_resource_manager.h"
  17 #include "extensions/browser/extension_function.h"
  18 #include "extensions/common/api/usb.h"
  19 #include "net/base/io_buffer.h"
  20
  21 namespace extensions {
  22
  23 class DevicePermissionEntry;
  24 class DevicePermissions;
  25 class DevicePermissionsPrompt;
  26 class DevicePermissionsManager;
  27 class UsbDeviceResource;
  28
  29 class UsbPermissionCheckingFunction : public UIThreadExtensionFunction {
  30  protected:
  31   UsbPermissionCheckingFunction();
  32   ~UsbPermissionCheckingFunction() override;
  33
  34   bool HasDevicePermission(scoped_refptr<device::UsbDevice> device);
  35   void RecordDeviceLastUsed();
  36
  37  private:
  38   DevicePermissionsManager* device_permissions_manager_;
  39   scoped_refptr<DevicePermissionEntry> permission_entry_;
  40 };
  41
  42 class UsbConnectionFunction : public UIThreadExtensionFunction {
  43  protected:
  44   UsbConnectionFunction();
  45   ~UsbConnectionFunction() override;
  46
  47   scoped_refptr<device::UsbDeviceHandle> GetDeviceHandle(
  48       const extensions::core_api::usb::ConnectionHandle& handle);
  49   void ReleaseDeviceHandle(
  50       const extensions::core_api::usb::ConnectionHandle& handle);
  51 };
  52
  53 class UsbTransferFunction : public UsbConnectionFunction {
  54  protected:
  55   UsbTransferFunction();
  56   ~UsbTransferFunction() override;
  57
  58   void OnCompleted(device::UsbTransferStatus status,
  59                    scoped_refptr<net::IOBuffer> data,
  60                    size_t length);
  61 };
  62
  63 class UsbFindDevicesFunction : public UIThreadExtensionFunction {
  64  public:
  65   DECLARE_EXTENSION_FUNCTION("usb.findDevices", USB_FINDDEVICES)
  66
  67   UsbFindDevicesFunction();
  68
  69  private:
  70   ~UsbFindDevicesFunction() override;
  71
  72   // ExtensionFunction:
  73   ResponseAction Run() override;
  74
  75   void OnGetDevicesComplete(
  76       const std::vector<scoped_refptr<device::UsbDevice>>& devices);
  77   void OnDeviceOpened(scoped_refptr<device::UsbDeviceHandle> device_handle);
  78   void OpenComplete();
  79
  80   uint16_t vendor_id_;
  81   uint16_t product_id_;
  82   scoped_ptr<base::ListValue> result_;
  83   base::Closure barrier_;
  84
  85   DISALLOW_COPY_AND_ASSIGN(UsbFindDevicesFunction);
  86 };
  87
  88 class UsbGetDevicesFunction : public UsbPermissionCheckingFunction {
  89  public:
  90   DECLARE_EXTENSION_FUNCTION("usb.getDevices", USB_GETDEVICES)
  91
  92   UsbGetDevicesFunction();
  93
  94  private:
  95   ~UsbGetDevicesFunction() override;
  96
  97   // ExtensionFunction:
  98   ResponseAction Run() override;
  99
 100   void OnGetDevicesComplete(
 101       const std::vector<scoped_refptr<device::UsbDevice>>& devices);
 102
 103   std::vector<device::UsbDeviceFilter> filters_;
 104
 105   DISALLOW_COPY_AND_ASSIGN(UsbGetDevicesFunction);
 106 };
 107
 108 class UsbGetUserSelectedDevicesFunction : public UIThreadExtensionFunction {
 109  public:
 110   DECLARE_EXTENSION_FUNCTION("usb.getUserSelectedDevices",
 111                              USB_GETUSERSELECTEDDEVICES)
 112
 113   UsbGetUserSelectedDevicesFunction();
 114
 115  private:
 116   ~UsbGetUserSelectedDevicesFunction() override;
 117
 118   // ExtensionFunction:
 119   ResponseAction Run() override;
 120
 121   void OnDevicesChosen(
 122       const std::vector<scoped_refptr<device::UsbDevice>>& devices);
 123
 124   scoped_ptr<DevicePermissionsPrompt> prompt_;
 125
 126   DISALLOW_COPY_AND_ASSIGN(UsbGetUserSelectedDevicesFunction);
 127 };
 128
 129 class UsbRequestAccessFunction : public UIThreadExtensionFunction {
 130  public:
 131   DECLARE_EXTENSION_FUNCTION("usb.requestAccess", USB_REQUESTACCESS)
 132
 133   UsbRequestAccessFunction();
 134
 135  private:
 136   ~UsbRequestAccessFunction() override;
 137
 138   // ExtensionFunction:
 139   ResponseAction Run() override;
 140
 141   DISALLOW_COPY_AND_ASSIGN(UsbRequestAccessFunction);
 142 };
 143
 144 class UsbOpenDeviceFunction : public UsbPermissionCheckingFunction {
 145  public:
 146   DECLARE_EXTENSION_FUNCTION("usb.openDevice", USB_OPENDEVICE)
 147
 148   UsbOpenDeviceFunction();
 149
 150  private:
 151   ~UsbOpenDeviceFunction() override;
 152
 153   // ExtensionFunction:
 154   ResponseAction Run() override;
 155
 156   void OnDeviceOpened(scoped_refptr<device::UsbDeviceHandle> device_handle);
 157
 158   DISALLOW_COPY_AND_ASSIGN(UsbOpenDeviceFunction);
 159 };
 160
 161 class UsbSetConfigurationFunction : public UsbConnectionFunction {
 162  public:
 163   DECLARE_EXTENSION_FUNCTION("usb.setConfiguration", USB_SETCONFIGURATION)
 164
 165   UsbSetConfigurationFunction();
 166
 167  private:
 168   ~UsbSetConfigurationFunction() override;
 169
 170   // ExtensionFunction:
 171   ResponseAction Run() override;
 172
 173   void OnComplete(bool success);
 174
 175   DISALLOW_COPY_AND_ASSIGN(UsbSetConfigurationFunction);
 176 };
 177
 178 class UsbGetConfigurationFunction : public UsbConnectionFunction {
 179  public:
 180   DECLARE_EXTENSION_FUNCTION("usb.getConfiguration", USB_GETCONFIGURATION)
 181
 182   UsbGetConfigurationFunction();
 183
 184  private:
 185   ~UsbGetConfigurationFunction() override;
 186
 187   // ExtensionFunction:
 188   ResponseAction Run() override;
 189
 190   DISALLOW_COPY_AND_ASSIGN(UsbGetConfigurationFunction);
 191 };
 192
 193 class UsbListInterfacesFunction : public UsbConnectionFunction {
 194  public:
 195   DECLARE_EXTENSION_FUNCTION("usb.listInterfaces", USB_LISTINTERFACES)
 196
 197   UsbListInterfacesFunction();
 198
 199  private:
 200   ~UsbListInterfacesFunction() override;
 201
 202   // ExtensionFunction:
 203   ResponseAction Run() override;
 204
 205   DISALLOW_COPY_AND_ASSIGN(UsbListInterfacesFunction);
 206 };
 207
 208 class UsbCloseDeviceFunction : public UsbConnectionFunction {
 209  public:
 210   DECLARE_EXTENSION_FUNCTION("usb.closeDevice", USB_CLOSEDEVICE)
 211
 212   UsbCloseDeviceFunction();
 213
 214  private:
 215   ~UsbCloseDeviceFunction() override;
 216
 217   // ExtensionFunction:
 218   ResponseAction Run() override;
 219
 220   DISALLOW_COPY_AND_ASSIGN(UsbCloseDeviceFunction);
 221 };
 222
 223 class UsbClaimInterfaceFunction : public UsbConnectionFunction {
 224  public:
 225   DECLARE_EXTENSION_FUNCTION("usb.claimInterface", USB_CLAIMINTERFACE)
 226
 227   UsbClaimInterfaceFunction();
 228
 229  protected:
 230   ~UsbClaimInterfaceFunction() override;
 231
 232   // ExtensionFunction:
 233   ResponseAction Run() override;
 234
 235   void OnComplete(bool success);
 236
 237   DISALLOW_COPY_AND_ASSIGN(UsbClaimInterfaceFunction);
 238 };
 239
 240 class UsbReleaseInterfaceFunction : public UsbConnectionFunction {
 241  public:
 242   DECLARE_EXTENSION_FUNCTION("usb.releaseInterface", USB_RELEASEINTERFACE)
 243
 244   UsbReleaseInterfaceFunction();
 245
 246  private:
 247   ~UsbReleaseInterfaceFunction() override;
 248
 249   // ExtensionFunction:
 250   ResponseAction Run() override;
 251
 252   DISALLOW_COPY_AND_ASSIGN(UsbReleaseInterfaceFunction);
 253 };
 254
 255 class UsbSetInterfaceAlternateSettingFunction : public UsbConnectionFunction {
 256  public:
 257   DECLARE_EXTENSION_FUNCTION("usb.setInterfaceAlternateSetting",
 258                              USB_SETINTERFACEALTERNATESETTING)
 259
 260   UsbSetInterfaceAlternateSettingFunction();
 261
 262  private:
 263   ~UsbSetInterfaceAlternateSettingFunction() override;
 264
 265   // ExtensionFunction:
 266   ResponseAction Run() override;
 267
 268   void OnComplete(bool success);
 269
 270   DISALLOW_COPY_AND_ASSIGN(UsbSetInterfaceAlternateSettingFunction);
 271 };
 272
 273 class UsbControlTransferFunction : public UsbTransferFunction {
 274  public:
 275   DECLARE_EXTENSION_FUNCTION("usb.controlTransfer", USB_CONTROLTRANSFER)
 276
 277   UsbControlTransferFunction();
 278
 279  private:
 280   ~UsbControlTransferFunction() override;
 281
 282   // ExtensionFunction:
 283   ResponseAction Run() override;
 284
 285   DISALLOW_COPY_AND_ASSIGN(UsbControlTransferFunction);
 286 };
 287
 288 class UsbBulkTransferFunction : public UsbTransferFunction {
 289  public:
 290   DECLARE_EXTENSION_FUNCTION("usb.bulkTransfer", USB_BULKTRANSFER)
 291
 292   UsbBulkTransferFunction();
 293
 294  private:
 295   ~UsbBulkTransferFunction() override;
 296
 297   // ExtensionFunction:
 298   ResponseAction Run() override;
 299
 300   DISALLOW_COPY_AND_ASSIGN(UsbBulkTransferFunction);
 301 };
 302
 303 class UsbInterruptTransferFunction : public UsbTransferFunction {
 304  public:
 305   DECLARE_EXTENSION_FUNCTION("usb.interruptTransfer", USB_INTERRUPTTRANSFER)
 306
 307   UsbInterruptTransferFunction();
 308
 309  private:
 310   ~UsbInterruptTransferFunction() override;
 311
 312   // ExtensionFunction:
 313   ResponseAction Run() override;
 314
 315   DISALLOW_COPY_AND_ASSIGN(UsbInterruptTransferFunction);
 316 };
 317
 318 class UsbIsochronousTransferFunction : public UsbTransferFunction {
 319  public:
 320   DECLARE_EXTENSION_FUNCTION("usb.isochronousTransfer", USB_ISOCHRONOUSTRANSFER)
 321
 322   UsbIsochronousTransferFunction();
 323
 324  private:
 325   ~UsbIsochronousTransferFunction() override;
 326
 327   // ExtensionFunction:
 328   ResponseAction Run() override;
 329
 330   DISALLOW_COPY_AND_ASSIGN(UsbIsochronousTransferFunction);
 331 };
 332
 333 class UsbResetDeviceFunction : public UsbConnectionFunction {
 334  public:
 335   DECLARE_EXTENSION_FUNCTION("usb.resetDevice", USB_RESETDEVICE)
 336
 337   UsbResetDeviceFunction();
 338
 339  private:
 340   ~UsbResetDeviceFunction() override;
 341
 342   // ExtensionFunction:
 343   ResponseAction Run() override;
 344
 345   void OnComplete(bool success);
 346
 347   scoped_ptr<extensions::core_api::usb::ResetDevice::Params> parameters_;
 348
 349   DISALLOW_COPY_AND_ASSIGN(UsbResetDeviceFunction);
 350 };
 351 }  // namespace extensions
 352
 353 #endif  // EXTENSIONS_BROWSER_API_USB_USB_API_H_