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/api/async_api_function.h"
  18 #include "extensions/browser/api/device_permissions_prompt.h"
  19 #include "extensions/common/api/usb.h"
  20 #include "net/base/io_buffer.h"
  21
  22 namespace extensions {
  23
  24 class DevicePermissionEntry;
  25 class DevicePermissions;
  26 class DevicePermissionsManager;
  27 class UsbDeviceResource;
  28
  29 class UsbAsyncApiFunction : public AsyncApiFunction {
  30  public:
  31   UsbAsyncApiFunction();
  32
  33  protected:
  34   ~UsbAsyncApiFunction() override;
  35
  36   // AsyncApiFunction:
  37   bool PrePrepare() override;
  38   bool Respond() override;
  39
  40   bool HasDevicePermission(scoped_refptr<device::UsbDevice> device);
  41   scoped_refptr<device::UsbDeviceHandle> GetDeviceHandleOrCompleteWithError(
  42       const extensions::core_api::usb::ConnectionHandle& input_device_handle);
  43   void RemoveUsbDeviceResource(int api_resource_id);
  44   void CompleteWithError(const std::string& error);
  45
  46   ApiResourceManager<UsbDeviceResource>* manager_;
  47   scoped_ptr<DevicePermissions> device_permissions_;
  48   scoped_refptr<DevicePermissionEntry> permission_entry_;
  49 };
  50
  51 class UsbAsyncApiTransferFunction : public UsbAsyncApiFunction {
  52  protected:
  53   UsbAsyncApiTransferFunction();
  54   ~UsbAsyncApiTransferFunction() override;
  55
  56   bool ConvertDirectionSafely(const extensions::core_api::usb::Direction& input,
  57                               device::UsbEndpointDirection* output);
  58   bool ConvertRequestTypeSafely(
  59       const extensions::core_api::usb::RequestType& input,
  60       device::UsbDeviceHandle::TransferRequestType* output);
  61   bool ConvertRecipientSafely(
  62       const extensions::core_api::usb::Recipient& input,
  63       device::UsbDeviceHandle::TransferRecipient* output);
  64
  65   void OnCompleted(device::UsbTransferStatus status,
  66                    scoped_refptr<net::IOBuffer> data,
  67                    size_t length);
  68 };
  69
  70 class UsbFindDevicesFunction : public UsbAsyncApiFunction {
  71  public:
  72   DECLARE_EXTENSION_FUNCTION("usb.findDevices", USB_FINDDEVICES)
  73
  74   UsbFindDevicesFunction();
  75
  76  protected:
  77   ~UsbFindDevicesFunction() override;
  78
  79   // AsyncApiFunction:
  80   bool Prepare() override;
  81   void AsyncWorkStart() override;
  82
  83  private:
  84   void OpenDevices(
  85       scoped_ptr<std::vector<scoped_refptr<device::UsbDevice> > > devices);
  86
  87   std::vector<scoped_refptr<device::UsbDeviceHandle> > device_handles_;
  88   scoped_ptr<extensions::core_api::usb::FindDevices::Params> parameters_;
  89 };
  90
  91 class UsbGetDevicesFunction : public UsbAsyncApiFunction {
  92  public:
  93   DECLARE_EXTENSION_FUNCTION("usb.getDevices", USB_GETDEVICES)
  94
  95   UsbGetDevicesFunction();
  96
  97   // AsyncApiFunction:
  98   bool Prepare() override;
  99   void AsyncWorkStart() override;
 100
 101  protected:
 102   ~UsbGetDevicesFunction() override;
 103
 104  private:
 105   scoped_ptr<extensions::core_api::usb::GetDevices::Params> parameters_;
 106 };
 107
 108 class UsbGetUserSelectedDevicesFunction
 109     : public UIThreadExtensionFunction,
 110       public DevicePermissionsPrompt::Delegate {
 111  public:
 112   DECLARE_EXTENSION_FUNCTION("usb.getUserSelectedDevices",
 113                              USB_GETUSERSELECTEDDEVICES)
 114
 115   UsbGetUserSelectedDevicesFunction();
 116
 117  protected:
 118   ~UsbGetUserSelectedDevicesFunction() override;
 119
 120   // ExtensionFunction:
 121   ResponseAction Run() override;
 122
 123  private:
 124   void OnUsbDevicesChosen(
 125       const std::vector<scoped_refptr<device::UsbDevice>>& devices) override;
 126
 127   scoped_ptr<DevicePermissionsPrompt> prompt_;
 128   std::vector<uint32> device_ids_;
 129   std::vector<scoped_refptr<device::UsbDevice>> devices_;
 130   std::vector<base::string16> serial_numbers_;
 131 };
 132
 133 class UsbRequestAccessFunction : public UsbAsyncApiFunction {
 134  public:
 135   DECLARE_EXTENSION_FUNCTION("usb.requestAccess", USB_REQUESTACCESS)
 136
 137   UsbRequestAccessFunction();
 138
 139   // AsyncApiFunction:
 140   bool Prepare() override;
 141   void AsyncWorkStart() override;
 142
 143  protected:
 144   ~UsbRequestAccessFunction() override;
 145
 146  private:
 147   scoped_ptr<extensions::core_api::usb::RequestAccess::Params> parameters_;
 148 };
 149
 150 class UsbOpenDeviceFunction : public UsbAsyncApiFunction {
 151  public:
 152   DECLARE_EXTENSION_FUNCTION("usb.openDevice", USB_OPENDEVICE)
 153
 154   UsbOpenDeviceFunction();
 155
 156   // AsyncApiFunction:
 157   bool Prepare() override;
 158   void AsyncWorkStart() override;
 159   bool Respond() override;
 160
 161  protected:
 162   ~UsbOpenDeviceFunction() override;
 163
 164  private:
 165   void OnRequestAccessComplete(bool success);
 166
 167   DevicePermissionsManager* device_permissions_manager_;
 168   scoped_refptr<device::UsbDevice> device_;
 169   scoped_ptr<extensions::core_api::usb::OpenDevice::Params> parameters_;
 170 };
 171
 172 class UsbSetConfigurationFunction : public UsbAsyncApiFunction {
 173  public:
 174   DECLARE_EXTENSION_FUNCTION("usb.setConfiguration", USB_SETCONFIGURATION)
 175
 176   UsbSetConfigurationFunction();
 177
 178  protected:
 179   ~UsbSetConfigurationFunction() override;
 180
 181   // AsyncApiFunction:
 182   bool Prepare() override;
 183   void AsyncWorkStart() override;
 184
 185  private:
 186   scoped_ptr<extensions::core_api::usb::SetConfiguration::Params> parameters_;
 187 };
 188
 189 class UsbGetConfigurationFunction : public UsbAsyncApiFunction {
 190  public:
 191   DECLARE_EXTENSION_FUNCTION("usb.getConfiguration", USB_GETCONFIGURATION)
 192
 193   UsbGetConfigurationFunction();
 194
 195  protected:
 196   ~UsbGetConfigurationFunction() override;
 197
 198   // AsyncApiFunction:
 199   bool Prepare() override;
 200   void AsyncWorkStart() override;
 201
 202  private:
 203   scoped_ptr<extensions::core_api::usb::GetConfiguration::Params> parameters_;
 204 };
 205
 206 class UsbListInterfacesFunction : public UsbAsyncApiFunction {
 207  public:
 208   DECLARE_EXTENSION_FUNCTION("usb.listInterfaces", USB_LISTINTERFACES)
 209
 210   UsbListInterfacesFunction();
 211
 212  protected:
 213   ~UsbListInterfacesFunction() override;
 214
 215   // AsyncApiFunction:
 216   bool Prepare() override;
 217   void AsyncWorkStart() override;
 218
 219  private:
 220   scoped_ptr<extensions::core_api::usb::ListInterfaces::Params> parameters_;
 221 };
 222
 223 class UsbCloseDeviceFunction : public UsbAsyncApiFunction {
 224  public:
 225   DECLARE_EXTENSION_FUNCTION("usb.closeDevice", USB_CLOSEDEVICE)
 226
 227   UsbCloseDeviceFunction();
 228
 229  protected:
 230   ~UsbCloseDeviceFunction() override;
 231
 232   // AsyncApiFunction:
 233   bool Prepare() override;
 234   void AsyncWorkStart() override;
 235
 236  private:
 237   scoped_ptr<extensions::core_api::usb::CloseDevice::Params> parameters_;
 238 };
 239
 240 class UsbClaimInterfaceFunction : public UsbAsyncApiFunction {
 241  public:
 242   DECLARE_EXTENSION_FUNCTION("usb.claimInterface", USB_CLAIMINTERFACE)
 243
 244   UsbClaimInterfaceFunction();
 245
 246  protected:
 247   ~UsbClaimInterfaceFunction() override;
 248
 249   // AsyncApiFunction:
 250   bool Prepare() override;
 251   void AsyncWorkStart() override;
 252
 253  private:
 254   scoped_ptr<extensions::core_api::usb::ClaimInterface::Params> parameters_;
 255 };
 256
 257 class UsbReleaseInterfaceFunction : public UsbAsyncApiFunction {
 258  public:
 259   DECLARE_EXTENSION_FUNCTION("usb.releaseInterface", USB_RELEASEINTERFACE)
 260
 261   UsbReleaseInterfaceFunction();
 262
 263  protected:
 264   ~UsbReleaseInterfaceFunction() override;
 265
 266   // AsyncApiFunction:
 267   bool Prepare() override;
 268   void AsyncWorkStart() override;
 269
 270  private:
 271   scoped_ptr<extensions::core_api::usb::ReleaseInterface::Params> parameters_;
 272 };
 273
 274 class UsbSetInterfaceAlternateSettingFunction : public UsbAsyncApiFunction {
 275  public:
 276   DECLARE_EXTENSION_FUNCTION("usb.setInterfaceAlternateSetting",
 277                              USB_SETINTERFACEALTERNATESETTING)
 278
 279   UsbSetInterfaceAlternateSettingFunction();
 280
 281  private:
 282   ~UsbSetInterfaceAlternateSettingFunction() override;
 283
 284   // AsyncApiFunction:
 285   bool Prepare() override;
 286   void AsyncWorkStart() override;
 287
 288   scoped_ptr<extensions::core_api::usb::SetInterfaceAlternateSetting::Params>
 289       parameters_;
 290 };
 291
 292 class UsbControlTransferFunction : public UsbAsyncApiTransferFunction {
 293  public:
 294   DECLARE_EXTENSION_FUNCTION("usb.controlTransfer", USB_CONTROLTRANSFER)
 295
 296   UsbControlTransferFunction();
 297
 298  protected:
 299   ~UsbControlTransferFunction() override;
 300
 301   // AsyncApiFunction:
 302   bool Prepare() override;
 303   void AsyncWorkStart() override;
 304
 305  private:
 306   scoped_ptr<extensions::core_api::usb::ControlTransfer::Params> parameters_;
 307 };
 308
 309 class UsbBulkTransferFunction : public UsbAsyncApiTransferFunction {
 310  public:
 311   DECLARE_EXTENSION_FUNCTION("usb.bulkTransfer", USB_BULKTRANSFER)
 312
 313   UsbBulkTransferFunction();
 314
 315  protected:
 316   ~UsbBulkTransferFunction() override;
 317
 318   // AsyncApiFunction:
 319   bool Prepare() override;
 320   void AsyncWorkStart() override;
 321
 322  private:
 323   scoped_ptr<extensions::core_api::usb::BulkTransfer::Params> parameters_;
 324 };
 325
 326 class UsbInterruptTransferFunction : public UsbAsyncApiTransferFunction {
 327  public:
 328   DECLARE_EXTENSION_FUNCTION("usb.interruptTransfer", USB_INTERRUPTTRANSFER)
 329
 330   UsbInterruptTransferFunction();
 331
 332  protected:
 333   ~UsbInterruptTransferFunction() override;
 334
 335   // AsyncApiFunction:
 336   bool Prepare() override;
 337   void AsyncWorkStart() override;
 338
 339  private:
 340   scoped_ptr<extensions::core_api::usb::InterruptTransfer::Params> parameters_;
 341 };
 342
 343 class UsbIsochronousTransferFunction : public UsbAsyncApiTransferFunction {
 344  public:
 345   DECLARE_EXTENSION_FUNCTION("usb.isochronousTransfer", USB_ISOCHRONOUSTRANSFER)
 346
 347   UsbIsochronousTransferFunction();
 348
 349  protected:
 350   ~UsbIsochronousTransferFunction() override;
 351
 352   // AsyncApiFunction:
 353   bool Prepare() override;
 354   void AsyncWorkStart() override;
 355
 356  private:
 357   scoped_ptr<extensions::core_api::usb::IsochronousTransfer::Params>
 358       parameters_;
 359 };
 360
 361 class UsbResetDeviceFunction : public UsbAsyncApiFunction {
 362  public:
 363   DECLARE_EXTENSION_FUNCTION("usb.resetDevice", USB_RESETDEVICE)
 364
 365   UsbResetDeviceFunction();
 366
 367  protected:
 368   ~UsbResetDeviceFunction() override;
 369
 370   // AsyncApiFunction:
 371   bool Prepare() override;
 372   void AsyncWorkStart() override;
 373
 374  private:
 375   scoped_ptr<extensions::core_api::usb::ResetDevice::Params> parameters_;
 376 };
 377 }  // namespace extensions
 378
 379 #endif  // EXTENSIONS_BROWSER_API_USB_USB_API_H_