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

   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 #include "chrome/browser/extensions/api/usb/usb_api.h"
   6
   7 #include <string>
   8 #include <vector>
   9
  10 #include "base/memory/scoped_ptr.h"
  11 #include "base/message_loop/message_loop_proxy.h"
  12 #include "chrome/browser/extensions/api/usb/usb_device_resource.h"
  13 #include "chrome/browser/extensions/extension_system.h"
  14 #include "chrome/browser/profiles/profile.h"
  15 #include "chrome/browser/usb/usb_device_handle.h"
  16 #include "chrome/browser/usb/usb_service.h"
  17 #include "chrome/common/extensions/api/usb.h"
  18 #include "chrome/common/extensions/permissions/permissions_data.h"
  19 #include "chrome/common/extensions/permissions/usb_device_permission.h"
  20
  21 namespace usb = extensions::api::usb;
  22 namespace BulkTransfer = usb::BulkTransfer;
  23 namespace ClaimInterface = usb::ClaimInterface;
  24 namespace CloseDevice = usb::CloseDevice;
  25 namespace ControlTransfer = usb::ControlTransfer;
  26 namespace FindDevices = usb::FindDevices;
  27 namespace GetDevices = usb::GetDevices;
  28 namespace InterruptTransfer = usb::InterruptTransfer;
  29 namespace IsochronousTransfer = usb::IsochronousTransfer;
  30 namespace ListInterfaces = usb::ListInterfaces;
  31 namespace OpenDevice = usb::OpenDevice;
  32 namespace ReleaseInterface = usb::ReleaseInterface;
  33 namespace RequestAccess = usb::RequestAccess;
  34 namespace ResetDevice = usb::ResetDevice;
  35 namespace SetInterfaceAlternateSetting = usb::SetInterfaceAlternateSetting;
  36
  37 using content::BrowserThread;
  38 using std::string;
  39 using std::vector;
  40 using usb::ControlTransferInfo;
  41 using usb::ConnectionHandle;
  42 using usb::Device;
  43 using usb::Direction;
  44 using usb::EndpointDescriptor;
  45 using usb::GenericTransferInfo;
  46 using usb::InterfaceDescriptor;
  47 using usb::IsochronousTransferInfo;
  48 using usb::Recipient;
  49 using usb::RequestType;
  50 using usb::SynchronizationType;
  51 using usb::TransferType;
  52 using usb::UsageType;
  53
  54 typedef std::vector<scoped_refptr<UsbDevice> > DeviceVector;
  55 typedef scoped_ptr<DeviceVector> ScopedDeviceVector;
  56
  57 namespace {
  58
  59 const char kDataKey[] = "data";
  60 const char kResultCodeKey[] = "resultCode";
  61
  62 const char kErrorInitService[] = "Failed to initialize USB service.";
  63
  64 const char kErrorOpen[] = "Failed to open device.";
  65 const char kErrorCancelled[] = "Transfer was cancelled.";
  66 const char kErrorDisconnect[] = "Device disconnected.";
  67 const char kErrorGeneric[] = "Transfer failed.";
  68 #if !defined(OS_CHROMEOS)
  69 const char kErrorNotSupported[] = "Not supported on this platform.";
  70 #endif
  71 const char kErrorOverflow[] = "Inbound transfer overflow.";
  72 const char kErrorStalled[] = "Transfer stalled.";
  73 const char kErrorTimeout[] = "Transfer timed out.";
  74 const char kErrorTransferLength[] = "Transfer length is insufficient.";
  75
  76 const char kErrorCannotListInterfaces[] = "Error listing interfaces.";
  77 const char kErrorCannotClaimInterface[] = "Error claiming interface.";
  78 const char kErrorCannotReleaseInterface[] = "Error releasing interface.";
  79 const char kErrorCannotSetInterfaceAlternateSetting[] =
  80     "Error setting alternate interface setting.";
  81 const char kErrorConvertDirection[] = "Invalid transfer direction.";
  82 const char kErrorConvertRecipient[] = "Invalid transfer recipient.";
  83 const char kErrorConvertRequestType[] = "Invalid request type.";
  84 const char kErrorConvertSynchronizationType[] = "Invalid synchronization type";
  85 const char kErrorConvertTransferType[] = "Invalid endpoint type.";
  86 const char kErrorConvertUsageType[] = "Invalid usage type.";
  87 const char kErrorMalformedParameters[] = "Error parsing parameters.";
  88 const char kErrorNoDevice[] = "No such device.";
  89 const char kErrorPermissionDenied[] =
  90     "Permission to access device was denied";
  91 const char kErrorInvalidTransferLength[] =
  92     "Transfer length must be a positive number less than 104,857,600.";
  93 const char kErrorInvalidNumberOfPackets[] =
  94     "Number of packets must be a positive number less than 4,194,304.";
  95 const char kErrorInvalidPacketLength[] = "Packet length must be a "
  96     "positive number less than 65,536.";
  97 const char kErrorResetDevice[] =
  98     "Error resetting the device. The device has been closed.";
  99
 100 const size_t kMaxTransferLength = 100 * 1024 * 1024;
 101 const int kMaxPackets = 4 * 1024 * 1024;
 102 const int kMaxPacketLength = 64 * 1024;
 103
 104 UsbDevice* g_device_for_test = NULL;
 105
 106 bool ConvertDirectionToApi(const UsbEndpointDirection& input,
 107                            Direction* output) {
 108   switch (input) {
 109     case USB_DIRECTION_INBOUND:
 110       *output = usb::DIRECTION_IN;
 111       return true;
 112     case USB_DIRECTION_OUTBOUND:
 113       *output = usb::DIRECTION_OUT;
 114       return true;
 115     default:
 116       NOTREACHED();
 117       return false;
 118   }
 119 }
 120
 121 bool ConvertSynchronizationTypeToApi(const UsbSynchronizationType& input,
 122                                      usb::SynchronizationType* output) {
 123   switch (input) {
 124     case USB_SYNCHRONIZATION_NONE:
 125       *output = usb::SYNCHRONIZATION_TYPE_NONE;
 126       return true;
 127     case USB_SYNCHRONIZATION_ASYNCHRONOUS:
 128       *output = usb::SYNCHRONIZATION_TYPE_ASYNCHRONOUS;
 129       return true;
 130     case USB_SYNCHRONIZATION_ADAPTIVE:
 131       *output = usb::SYNCHRONIZATION_TYPE_ADAPTIVE;
 132       return true;
 133     case USB_SYNCHRONIZATION_SYNCHRONOUS:
 134       *output = usb::SYNCHRONIZATION_TYPE_SYNCHRONOUS;
 135       return true;
 136     default:
 137       NOTREACHED();
 138       return false;
 139   }
 140 }
 141
 142 bool ConvertTransferTypeToApi(
 143     const UsbTransferType& input,
 144     usb::TransferType* output) {
 145   switch (input) {
 146     case USB_TRANSFER_CONTROL:
 147       *output = usb::TRANSFER_TYPE_CONTROL;
 148       return true;
 149     case USB_TRANSFER_INTERRUPT:
 150       *output = usb::TRANSFER_TYPE_INTERRUPT;
 151       return true;
 152     case USB_TRANSFER_ISOCHRONOUS:
 153       *output = usb::TRANSFER_TYPE_ISOCHRONOUS;
 154       return true;
 155     case USB_TRANSFER_BULK:
 156       *output = usb::TRANSFER_TYPE_BULK;
 157       return true;
 158     default:
 159       NOTREACHED();
 160       return false;
 161   }
 162 }
 163
 164 bool ConvertUsageTypeToApi(const UsbUsageType& input, usb::UsageType* output) {
 165   switch (input) {
 166     case USB_USAGE_DATA:
 167       *output = usb::USAGE_TYPE_DATA;
 168       return true;
 169     case USB_USAGE_FEEDBACK:
 170       *output = usb::USAGE_TYPE_FEEDBACK;
 171       return true;
 172     case USB_USAGE_EXPLICIT_FEEDBACK:
 173       *output = usb::USAGE_TYPE_EXPLICITFEEDBACK;
 174       return true;
 175     default:
 176       NOTREACHED();
 177       return false;
 178   }
 179 }
 180
 181 bool ConvertDirection(const Direction& input,
 182                       UsbEndpointDirection* output) {
 183   switch (input) {
 184     case usb::DIRECTION_IN:
 185       *output = USB_DIRECTION_INBOUND;
 186       return true;
 187     case usb::DIRECTION_OUT:
 188       *output = USB_DIRECTION_OUTBOUND;
 189       return true;
 190     default:
 191       NOTREACHED();
 192       return false;
 193   }
 194 }
 195
 196 bool ConvertRequestType(const RequestType& input,
 197                         UsbDeviceHandle::TransferRequestType* output) {
 198   switch (input) {
 199     case usb::REQUEST_TYPE_STANDARD:
 200       *output = UsbDeviceHandle::STANDARD;
 201       return true;
 202     case usb::REQUEST_TYPE_CLASS:
 203       *output = UsbDeviceHandle::CLASS;
 204       return true;
 205     case usb::REQUEST_TYPE_VENDOR:
 206       *output = UsbDeviceHandle::VENDOR;
 207       return true;
 208     case usb::REQUEST_TYPE_RESERVED:
 209       *output = UsbDeviceHandle::RESERVED;
 210       return true;
 211     default:
 212       NOTREACHED();
 213       return false;
 214   }
 215 }
 216
 217 bool ConvertRecipient(const Recipient& input,
 218                       UsbDeviceHandle::TransferRecipient* output) {
 219   switch (input) {
 220     case usb::RECIPIENT_DEVICE:
 221       *output = UsbDeviceHandle::DEVICE;
 222       return true;
 223     case usb::RECIPIENT_INTERFACE:
 224       *output = UsbDeviceHandle::INTERFACE;
 225       return true;
 226     case usb::RECIPIENT_ENDPOINT:
 227       *output = UsbDeviceHandle::ENDPOINT;
 228       return true;
 229     case usb::RECIPIENT_OTHER:
 230       *output = UsbDeviceHandle::OTHER;
 231       return true;
 232     default:
 233       NOTREACHED();
 234       return false;
 235   }
 236 }
 237
 238 template<class T>
 239 bool GetTransferSize(const T& input, size_t* output) {
 240   if (input.direction == usb::DIRECTION_IN) {
 241     const int* length = input.length.get();
 242     if (length && *length >= 0 &&
 243         static_cast<size_t>(*length) < kMaxTransferLength) {
 244       *output = *length;
 245       return true;
 246     }
 247   } else if (input.direction == usb::DIRECTION_OUT) {
 248     if (input.data.get()) {
 249       *output = input.data->size();
 250       return true;
 251     }
 252   }
 253   return false;
 254 }
 255
 256 template<class T>
 257 scoped_refptr<net::IOBuffer> CreateBufferForTransfer(
 258     const T& input, UsbEndpointDirection direction, size_t size) {
 259
 260   if (size >= kMaxTransferLength)
 261     return NULL;
 262
 263   // Allocate a |size|-bytes buffer, or a one-byte buffer if |size| is 0. This
 264   // is due to an impedance mismatch between IOBuffer and URBs. An IOBuffer
 265   // cannot represent a zero-length buffer, while an URB can.
 266   scoped_refptr<net::IOBuffer> buffer = new net::IOBuffer(std::max(
 267       static_cast<size_t>(1), size));
 268
 269   if (direction == USB_DIRECTION_INBOUND) {
 270     return buffer;
 271   } else if (direction == USB_DIRECTION_OUTBOUND) {
 272     if (input.data.get() && size <= input.data->size()) {
 273       memcpy(buffer->data(), input.data->data(), size);
 274       return buffer;
 275     }
 276   }
 277   NOTREACHED();
 278   return NULL;
 279 }
 280
 281 const char* ConvertTransferStatusToErrorString(const UsbTransferStatus status) {
 282   switch (status) {
 283     case USB_TRANSFER_COMPLETED:
 284       return "";
 285     case USB_TRANSFER_ERROR:
 286       return kErrorGeneric;
 287     case USB_TRANSFER_TIMEOUT:
 288       return kErrorTimeout;
 289     case USB_TRANSFER_CANCELLED:
 290       return kErrorCancelled;
 291     case USB_TRANSFER_STALLED:
 292       return kErrorStalled;
 293     case USB_TRANSFER_DISCONNECT:
 294       return kErrorDisconnect;
 295     case USB_TRANSFER_OVERFLOW:
 296       return kErrorOverflow;
 297     case USB_TRANSFER_LENGTH_SHORT:
 298       return kErrorTransferLength;
 299     default:
 300       NOTREACHED();
 301       return "";
 302   }
 303 }
 304
 305 #if defined(OS_CHROMEOS)
 306 void RequestUsbDevicesAccessHelper(
 307     ScopedDeviceVector devices,
 308     std::vector<scoped_refptr<UsbDevice> >::iterator i,
 309     int interface_id,
 310     const base::Callback<void(ScopedDeviceVector result)>& callback,
 311     bool success) {
 312   if (success) {
 313     ++i;
 314   } else {
 315     i = devices->erase(i);
 316   }
 317   if (i == devices->end()) {
 318     callback.Run(devices.Pass());
 319     return;
 320   }
 321   (*i)->RequestUsbAcess(interface_id, base::Bind(RequestUsbDevicesAccessHelper,
 322                                                  base::Passed(devices.Pass()),
 323                                                  i, interface_id, callback));
 324 }
 325
 326 void RequestUsbDevicesAccess(
 327     ScopedDeviceVector devices,
 328     int interface_id,
 329     const base::Callback<void(ScopedDeviceVector result)>& callback) {
 330   if (devices->empty()) {
 331     callback.Run(devices.Pass());
 332     return;
 333   }
 334   std::vector<scoped_refptr<UsbDevice> >::iterator i = devices->begin();
 335   (*i)->RequestUsbAcess(
 336       interface_id,
 337       base::Bind(RequestUsbDevicesAccessHelper, base::Passed(devices.Pass()),
 338                  i, interface_id, callback));
 339 }
 340 #endif  // OS_CHROMEOS
 341
 342 base::DictionaryValue* CreateTransferInfo(
 343     UsbTransferStatus status,
 344     scoped_refptr<net::IOBuffer> data,
 345     size_t length) {
 346   base::DictionaryValue* result = new base::DictionaryValue();
 347   result->SetInteger(kResultCodeKey, status);
 348   result->Set(kDataKey, base::BinaryValue::CreateWithCopiedBuffer(data->data(),
 349                                                                   length));
 350   return result;
 351 }
 352
 353 base::Value* PopulateConnectionHandle(int handle, int vendor_id,
 354                                       int product_id) {
 355   ConnectionHandle result;
 356   result.handle = handle;
 357   result.vendor_id = vendor_id;
 358   result.product_id = product_id;
 359   return result.ToValue().release();
 360 }
 361
 362 base::Value* PopulateDevice(UsbDevice* device) {
 363   Device result;
 364   result.device = device->unique_id();
 365   result.vendor_id = device->vendor_id();
 366   result.product_id = device->product_id();
 367   return result.ToValue().release();
 368 }
 369
 370 base::Value* PopulateInterfaceDescriptor(
 371     int interface_number,
 372     int alternate_setting,
 373     int interface_class,
 374     int interface_subclass,
 375     int interface_protocol,
 376     std::vector<linked_ptr<EndpointDescriptor> >* endpoints) {
 377   InterfaceDescriptor descriptor;
 378   descriptor.interface_number = interface_number;
 379   descriptor.alternate_setting = alternate_setting;
 380   descriptor.interface_class = interface_class;
 381   descriptor.interface_subclass = interface_subclass;
 382   descriptor.interface_protocol = interface_protocol;
 383   descriptor.endpoints = *endpoints;
 384   return descriptor.ToValue().release();
 385 }
 386
 387 }  // namespace
 388
 389 namespace extensions {
 390
 391 UsbAsyncApiFunction::UsbAsyncApiFunction()
 392     : manager_(NULL) {
 393 }
 394
 395 UsbAsyncApiFunction::~UsbAsyncApiFunction() {
 396 }
 397
 398 bool UsbAsyncApiFunction::PrePrepare() {
 399   manager_ = ApiResourceManager<UsbDeviceResource>::Get(GetProfile());
 400   set_work_thread_id(BrowserThread::FILE);
 401   return manager_ != NULL;
 402 }
 403
 404 bool UsbAsyncApiFunction::Respond() {
 405   return error_.empty();
 406 }
 407
 408 scoped_refptr<UsbDevice>
 409 UsbAsyncApiFunction::GetDeviceOrOrCompleteWithError(
 410     const Device& input_device) {
 411   if (g_device_for_test)
 412     return g_device_for_test;
 413
 414   const uint16_t vendor_id = input_device.vendor_id;
 415   const uint16_t product_id = input_device.product_id;
 416   UsbDevicePermission::CheckParam param(
 417       vendor_id, product_id, UsbDevicePermissionData::UNSPECIFIED_INTERFACE);
 418   if (!PermissionsData::CheckAPIPermissionWithParam(
 419           GetExtension(), APIPermission::kUsbDevice, &param)) {
 420     LOG(WARNING) << "Insufficient permissions to access device.";
 421     CompleteWithError(kErrorPermissionDenied);
 422     return NULL;
 423   }
 424
 425   UsbService* service = UsbService::GetInstance();
 426   if (!service) {
 427     CompleteWithError(kErrorInitService);
 428     return NULL;
 429   }
 430   scoped_refptr<UsbDevice> device;
 431
 432   device = service->GetDeviceById(input_device.device);
 433
 434   if (!device) {
 435     CompleteWithError(kErrorNoDevice);
 436     return NULL;
 437   }
 438
 439   if (device->vendor_id() != input_device.vendor_id ||
 440       device->product_id() != input_device.product_id) {
 441     // Must act as if there is no such a device.
 442     // Otherwise can be used to finger print unauthorized devices.
 443     CompleteWithError(kErrorNoDevice);
 444     return NULL;
 445   }
 446
 447   return device;
 448 }
 449
 450 scoped_refptr<UsbDeviceHandle>
 451 UsbAsyncApiFunction::GetDeviceHandleOrCompleteWithError(
 452     const ConnectionHandle& input_device_handle) {
 453   UsbDeviceResource* resource =
 454       manager_->Get(extension_->id(), input_device_handle.handle);
 455   if (!resource) {
 456     CompleteWithError(kErrorNoDevice);
 457     return NULL;
 458   }
 459
 460   if (!resource->device() || !resource->device()->device()) {
 461     CompleteWithError(kErrorDisconnect);
 462     manager_->Remove(extension_->id(), input_device_handle.handle);
 463     return NULL;
 464   }
 465
 466   if (resource->device()->device()->vendor_id() !=
 467           input_device_handle.vendor_id ||
 468       resource->device()->device()->product_id() !=
 469           input_device_handle.product_id) {
 470     CompleteWithError(kErrorNoDevice);
 471     return NULL;
 472   }
 473
 474   return resource->device();
 475 }
 476
 477 void UsbAsyncApiFunction::RemoveUsbDeviceResource(int api_resource_id) {
 478   manager_->Remove(extension_->id(), api_resource_id);
 479 }
 480
 481 void UsbAsyncApiFunction::CompleteWithError(const std::string& error) {
 482   SetError(error);
 483   AsyncWorkCompleted();
 484 }
 485
 486 UsbAsyncApiTransferFunction::UsbAsyncApiTransferFunction() {}
 487
 488 UsbAsyncApiTransferFunction::~UsbAsyncApiTransferFunction() {}
 489
 490 void UsbAsyncApiTransferFunction::OnCompleted(UsbTransferStatus status,
 491                                               scoped_refptr<net::IOBuffer> data,
 492                                               size_t length) {
 493   if (status != USB_TRANSFER_COMPLETED)
 494     SetError(ConvertTransferStatusToErrorString(status));
 495
 496   SetResult(CreateTransferInfo(status, data, length));
 497   AsyncWorkCompleted();
 498 }
 499
 500 bool UsbAsyncApiTransferFunction::ConvertDirectionSafely(
 501     const Direction& input, UsbEndpointDirection* output) {
 502   const bool converted = ConvertDirection(input, output);
 503   if (!converted)
 504     SetError(kErrorConvertDirection);
 505   return converted;
 506 }
 507
 508 bool UsbAsyncApiTransferFunction::ConvertRequestTypeSafely(
 509     const RequestType& input, UsbDeviceHandle::TransferRequestType* output) {
 510   const bool converted = ConvertRequestType(input, output);
 511   if (!converted)
 512     SetError(kErrorConvertRequestType);
 513   return converted;
 514 }
 515
 516 bool UsbAsyncApiTransferFunction::ConvertRecipientSafely(
 517     const Recipient& input, UsbDeviceHandle::TransferRecipient* output) {
 518   const bool converted = ConvertRecipient(input, output);
 519   if (!converted)
 520     SetError(kErrorConvertRecipient);
 521   return converted;
 522 }
 523
 524 UsbFindDevicesFunction::UsbFindDevicesFunction() {}
 525
 526 UsbFindDevicesFunction::~UsbFindDevicesFunction() {}
 527
 528 bool UsbFindDevicesFunction::Prepare() {
 529   parameters_ = FindDevices::Params::Create(*args_);
 530   EXTENSION_FUNCTION_VALIDATE(parameters_.get());
 531   return true;
 532 }
 533
 534 void UsbFindDevicesFunction::AsyncWorkStart() {
 535   scoped_ptr<base::ListValue> result(new base::ListValue());
 536
 537   if (g_device_for_test) {
 538     UsbDeviceResource* const resource = new UsbDeviceResource(
 539         extension_->id(),
 540         g_device_for_test->Open());
 541
 542     result->Append(PopulateConnectionHandle(manager_->Add(resource), 0, 0));
 543     SetResult(result.release());
 544     AsyncWorkCompleted();
 545     return;
 546   }
 547
 548   const uint16_t vendor_id = parameters_->options.vendor_id;
 549   const uint16_t product_id = parameters_->options.product_id;
 550   int interface_id = parameters_->options.interface_id.get() ?
 551       *parameters_->options.interface_id.get() :
 552       UsbDevicePermissionData::ANY_INTERFACE;
 553   UsbDevicePermission::CheckParam param(vendor_id, product_id, interface_id);
 554   if (!PermissionsData::CheckAPIPermissionWithParam(
 555           GetExtension(), APIPermission::kUsbDevice, &param)) {
 556     LOG(WARNING) << "Insufficient permissions to access device.";
 557     CompleteWithError(kErrorPermissionDenied);
 558     return;
 559   }
 560
 561   UsbService *service = UsbService::GetInstance();
 562   if (!service) {
 563     CompleteWithError(kErrorInitService);
 564     return;
 565   }
 566
 567   ScopedDeviceVector devices(new DeviceVector());
 568   service->GetDevices(devices.get());
 569
 570   for (DeviceVector::iterator it = devices->begin();
 571       it != devices->end();) {
 572     if ((*it)->vendor_id() != vendor_id || (*it)->product_id() != product_id) {
 573       it = devices->erase(it);
 574     } else {
 575       ++it;
 576     }
 577   }
 578
 579 #if defined(OS_CHROMEOS)
 580   RequestUsbDevicesAccess(
 581       devices.Pass(), interface_id,
 582       base::Bind(&UsbFindDevicesFunction::OpenDevices, this));
 583 #else
 584   OpenDevices(devices.Pass());
 585 #endif  // OS_CHROMEOS
 586 }
 587
 588 void UsbFindDevicesFunction::OpenDevices(ScopedDeviceVector devices) {
 589   base::ListValue* result = new base::ListValue();
 590
 591   for (size_t i = 0; i < devices->size(); ++i) {
 592     scoped_refptr<UsbDeviceHandle> device_handle =
 593       devices->at(i)->Open();
 594     if (device_handle)
 595       device_handles_.push_back(device_handle);
 596   }
 597
 598   for (size_t i = 0; i < device_handles_.size(); ++i) {
 599     UsbDeviceHandle* const device_handle = device_handles_[i].get();
 600     UsbDeviceResource* const resource =
 601         new UsbDeviceResource(extension_->id(), device_handle);
 602
 603     result->Append(PopulateConnectionHandle(manager_->Add(resource),
 604                                              parameters_->options.vendor_id,
 605                                              parameters_->options.product_id));
 606   }
 607
 608   SetResult(result);
 609   AsyncWorkCompleted();
 610 }
 611
 612 UsbGetDevicesFunction::UsbGetDevicesFunction() {
 613 }
 614
 615 UsbGetDevicesFunction::~UsbGetDevicesFunction() {
 616 }
 617
 618 void UsbGetDevicesFunction::SetDeviceForTest(UsbDevice* device) {
 619   g_device_for_test = device;
 620 }
 621
 622 bool UsbGetDevicesFunction::Prepare() {
 623   parameters_ = GetDevices::Params::Create(*args_);
 624   EXTENSION_FUNCTION_VALIDATE(parameters_.get());
 625   return true;
 626 }
 627
 628 void UsbGetDevicesFunction::AsyncWorkStart() {
 629   scoped_ptr<base::ListValue> result(new base::ListValue());
 630
 631   if (g_device_for_test) {
 632     result->Append(PopulateDevice(g_device_for_test));
 633     SetResult(result.release());
 634     AsyncWorkCompleted();
 635     return;
 636   }
 637
 638   const uint16_t vendor_id = parameters_->options.vendor_id;
 639   const uint16_t product_id = parameters_->options.product_id;
 640   UsbDevicePermission::CheckParam param(
 641       vendor_id, product_id, UsbDevicePermissionData::UNSPECIFIED_INTERFACE);
 642   if (!PermissionsData::CheckAPIPermissionWithParam(
 643           GetExtension(), APIPermission::kUsbDevice, &param)) {
 644     LOG(WARNING) << "Insufficient permissions to access device.";
 645     CompleteWithError(kErrorPermissionDenied);
 646     return;
 647   }
 648
 649   UsbService* service = UsbService::GetInstance();
 650   if (!service) {
 651     CompleteWithError(kErrorInitService);
 652     return;
 653   }
 654
 655   DeviceVector devices;
 656   service->GetDevices(&devices);
 657
 658   for (DeviceVector::iterator it = devices.begin(); it != devices.end();) {
 659     if ((*it)->vendor_id() != vendor_id || (*it)->product_id() != product_id) {
 660       it = devices.erase(it);
 661     } else {
 662       ++it;
 663     }
 664   }
 665
 666   for (size_t i = 0; i < devices.size(); ++i) {
 667     result->Append(PopulateDevice(devices[i].get()));
 668   }
 669
 670   SetResult(result.release());
 671   AsyncWorkCompleted();
 672 }
 673
 674 UsbRequestAccessFunction::UsbRequestAccessFunction() {}
 675
 676 UsbRequestAccessFunction::~UsbRequestAccessFunction() {}
 677
 678 bool UsbRequestAccessFunction::Prepare() {
 679   parameters_ = RequestAccess::Params::Create(*args_);
 680   EXTENSION_FUNCTION_VALIDATE(parameters_.get());
 681   return true;
 682 }
 683
 684 void UsbRequestAccessFunction::AsyncWorkStart() {
 685 #if defined(OS_CHROMEOS)
 686   scoped_refptr<UsbDevice> device =
 687       GetDeviceOrOrCompleteWithError(parameters_->device);
 688   if (!device) return;
 689
 690   device->RequestUsbAcess(parameters_->interface_id,
 691                           base::Bind(&UsbRequestAccessFunction::OnCompleted,
 692                                      this));
 693 #else
 694   SetResult(new base::FundamentalValue(false));
 695   CompleteWithError(kErrorNotSupported);
 696 #endif  // OS_CHROMEOS
 697 }
 698
 699 void UsbRequestAccessFunction::OnCompleted(bool success) {
 700   SetResult(new base::FundamentalValue(success));
 701   AsyncWorkCompleted();
 702 }
 703
 704 UsbOpenDeviceFunction::UsbOpenDeviceFunction() {}
 705
 706 UsbOpenDeviceFunction::~UsbOpenDeviceFunction() {}
 707
 708 bool UsbOpenDeviceFunction::Prepare() {
 709   parameters_ = OpenDevice::Params::Create(*args_);
 710   EXTENSION_FUNCTION_VALIDATE(parameters_.get());
 711   return true;
 712 }
 713
 714 void UsbOpenDeviceFunction::AsyncWorkStart() {
 715   scoped_refptr<UsbDevice> device =
 716       GetDeviceOrOrCompleteWithError(parameters_->device);
 717   if (!device) return;
 718
 719   handle_ = device->Open();
 720   if (!handle_) {
 721     SetError(kErrorOpen);
 722     AsyncWorkCompleted();
 723     return;
 724   }
 725
 726   SetResult(PopulateConnectionHandle(
 727       manager_->Add(new UsbDeviceResource(extension_->id(), handle_)),
 728       handle_->device()->vendor_id(),
 729       handle_->device()->product_id()));
 730   AsyncWorkCompleted();
 731 }
 732
 733 UsbListInterfacesFunction::UsbListInterfacesFunction() {}
 734
 735 UsbListInterfacesFunction::~UsbListInterfacesFunction() {}
 736
 737 bool UsbListInterfacesFunction::Prepare() {
 738   parameters_ = ListInterfaces::Params::Create(*args_);
 739   EXTENSION_FUNCTION_VALIDATE(parameters_.get());
 740   return true;
 741 }
 742
 743 void UsbListInterfacesFunction::AsyncWorkStart() {
 744   scoped_refptr<UsbDeviceHandle> device_handle =
 745       GetDeviceHandleOrCompleteWithError(parameters_->handle);
 746   if (!device_handle) return;
 747
 748   scoped_refptr<UsbConfigDescriptor> config =
 749       device_handle->device()->ListInterfaces();
 750
 751   if (!config) {
 752     SetError(kErrorCannotListInterfaces);
 753     AsyncWorkCompleted();
 754     return;
 755   }
 756
 757   result_.reset(new base::ListValue());
 758
 759   for (size_t i = 0, num_interfaces = config->GetNumInterfaces();
 760       i < num_interfaces; ++i) {
 761     scoped_refptr<const UsbInterfaceDescriptor>
 762         usb_interface(config->GetInterface(i));
 763     for (size_t j = 0, num_descriptors = usb_interface->GetNumAltSettings();
 764             j < num_descriptors; ++j) {
 765       scoped_refptr<const UsbInterfaceAltSettingDescriptor> descriptor
 766           = usb_interface->GetAltSetting(j);
 767       std::vector<linked_ptr<EndpointDescriptor> > endpoints;
 768       for (size_t k = 0, num_endpoints = descriptor->GetNumEndpoints();
 769           k < num_endpoints; k++) {
 770         scoped_refptr<const UsbEndpointDescriptor> endpoint
 771             = descriptor->GetEndpoint(k);
 772         linked_ptr<EndpointDescriptor> endpoint_desc(new EndpointDescriptor());
 773
 774         TransferType type;
 775         Direction direction;
 776         SynchronizationType synchronization;
 777         UsageType usage;
 778
 779         if (!ConvertTransferTypeSafely(endpoint->GetTransferType(), &type) ||
 780             !ConvertDirectionSafely(endpoint->GetDirection(), &direction) ||
 781             !ConvertSynchronizationTypeSafely(
 782                 endpoint->GetSynchronizationType(), &synchronization) ||
 783             !ConvertUsageTypeSafely(endpoint->GetUsageType(), &usage)) {
 784           SetError(kErrorCannotListInterfaces);
 785           AsyncWorkCompleted();
 786           return;
 787         }
 788
 789         endpoint_desc->address = endpoint->GetAddress();
 790         endpoint_desc->type = type;
 791         endpoint_desc->direction = direction;
 792         endpoint_desc->maximum_packet_size = endpoint->GetMaximumPacketSize();
 793         endpoint_desc->synchronization = synchronization;
 794         endpoint_desc->usage = usage;
 795
 796         int* polling_interval = new int;
 797         endpoint_desc->polling_interval.reset(polling_interval);
 798         *polling_interval = endpoint->GetPollingInterval();
 799
 800         endpoints.push_back(endpoint_desc);
 801       }
 802
 803       result_->Append(PopulateInterfaceDescriptor(
 804           descriptor->GetInterfaceNumber(),
 805           descriptor->GetAlternateSetting(),
 806           descriptor->GetInterfaceClass(),
 807           descriptor->GetInterfaceSubclass(),
 808           descriptor->GetInterfaceProtocol(),
 809           &endpoints));
 810     }
 811   }
 812
 813   SetResult(result_.release());
 814   AsyncWorkCompleted();
 815 }
 816
 817 bool UsbListInterfacesFunction::ConvertDirectionSafely(
 818     const UsbEndpointDirection& input,
 819     usb::Direction* output) {
 820   const bool converted = ConvertDirectionToApi(input, output);
 821   if (!converted)
 822     SetError(kErrorConvertDirection);
 823   return converted;
 824 }
 825
 826 bool UsbListInterfacesFunction::ConvertSynchronizationTypeSafely(
 827     const UsbSynchronizationType& input,
 828     usb::SynchronizationType* output) {
 829   const bool converted = ConvertSynchronizationTypeToApi(input, output);
 830   if (!converted)
 831     SetError(kErrorConvertSynchronizationType);
 832   return converted;
 833 }
 834
 835 bool UsbListInterfacesFunction::ConvertTransferTypeSafely(
 836     const UsbTransferType& input,
 837     usb::TransferType* output) {
 838   const bool converted = ConvertTransferTypeToApi(input, output);
 839   if (!converted)
 840     SetError(kErrorConvertTransferType);
 841   return converted;
 842 }
 843
 844 bool UsbListInterfacesFunction::ConvertUsageTypeSafely(
 845     const UsbUsageType& input,
 846     usb::UsageType* output) {
 847   const bool converted = ConvertUsageTypeToApi(input, output);
 848   if (!converted)
 849     SetError(kErrorConvertUsageType);
 850   return converted;
 851 }
 852
 853 UsbCloseDeviceFunction::UsbCloseDeviceFunction() {}
 854
 855 UsbCloseDeviceFunction::~UsbCloseDeviceFunction() {}
 856
 857 bool UsbCloseDeviceFunction::Prepare() {
 858   parameters_ = CloseDevice::Params::Create(*args_);
 859   EXTENSION_FUNCTION_VALIDATE(parameters_.get());
 860   return true;
 861 }
 862
 863 void UsbCloseDeviceFunction::AsyncWorkStart() {
 864   scoped_refptr<UsbDeviceHandle> device_handle =
 865       GetDeviceHandleOrCompleteWithError(parameters_->handle);
 866   if (!device_handle) return;
 867
 868   device_handle->Close();
 869   RemoveUsbDeviceResource(parameters_->handle.handle);
 870   AsyncWorkCompleted();
 871 }
 872
 873 UsbClaimInterfaceFunction::UsbClaimInterfaceFunction() {}
 874
 875 UsbClaimInterfaceFunction::~UsbClaimInterfaceFunction() {}
 876
 877 bool UsbClaimInterfaceFunction::Prepare() {
 878   parameters_ = ClaimInterface::Params::Create(*args_);
 879   EXTENSION_FUNCTION_VALIDATE(parameters_.get());
 880   return true;
 881 }
 882
 883 void UsbClaimInterfaceFunction::AsyncWorkStart() {
 884   scoped_refptr<UsbDeviceHandle> device_handle =
 885       GetDeviceHandleOrCompleteWithError(parameters_->handle);
 886   if (!device_handle) return;
 887
 888   bool success = device_handle->ClaimInterface(parameters_->interface_number);
 889
 890   if (!success)
 891     SetError(kErrorCannotClaimInterface);
 892   AsyncWorkCompleted();
 893 }
 894
 895 UsbReleaseInterfaceFunction::UsbReleaseInterfaceFunction() {}
 896
 897 UsbReleaseInterfaceFunction::~UsbReleaseInterfaceFunction() {}
 898
 899 bool UsbReleaseInterfaceFunction::Prepare() {
 900   parameters_ = ReleaseInterface::Params::Create(*args_);
 901   EXTENSION_FUNCTION_VALIDATE(parameters_.get());
 902   return true;
 903 }
 904
 905 void UsbReleaseInterfaceFunction::AsyncWorkStart() {
 906   scoped_refptr<UsbDeviceHandle> device_handle =
 907       GetDeviceHandleOrCompleteWithError(parameters_->handle);
 908   if (!device_handle) return;
 909
 910   bool success = device_handle->ReleaseInterface(parameters_->interface_number);
 911   if (!success)
 912     SetError(kErrorCannotReleaseInterface);
 913   AsyncWorkCompleted();
 914 }
 915
 916 UsbSetInterfaceAlternateSettingFunction::
 917     UsbSetInterfaceAlternateSettingFunction() {}
 918
 919 UsbSetInterfaceAlternateSettingFunction::
 920     ~UsbSetInterfaceAlternateSettingFunction() {}
 921
 922 bool UsbSetInterfaceAlternateSettingFunction::Prepare() {
 923   parameters_ = SetInterfaceAlternateSetting::Params::Create(*args_);
 924   EXTENSION_FUNCTION_VALIDATE(parameters_.get());
 925   return true;
 926 }
 927
 928 void UsbSetInterfaceAlternateSettingFunction::AsyncWorkStart() {
 929   scoped_refptr<UsbDeviceHandle> device_handle =
 930       GetDeviceHandleOrCompleteWithError(parameters_->handle);
 931   if (!device_handle) return;
 932
 933   bool success = device_handle->SetInterfaceAlternateSetting(
 934       parameters_->interface_number,
 935       parameters_->alternate_setting);
 936   if (!success)
 937     SetError(kErrorCannotSetInterfaceAlternateSetting);
 938
 939   AsyncWorkCompleted();
 940 }
 941
 942 UsbControlTransferFunction::UsbControlTransferFunction() {}
 943
 944 UsbControlTransferFunction::~UsbControlTransferFunction() {}
 945
 946 bool UsbControlTransferFunction::Prepare() {
 947   parameters_ = ControlTransfer::Params::Create(*args_);
 948   EXTENSION_FUNCTION_VALIDATE(parameters_.get());
 949   return true;
 950 }
 951
 952 void UsbControlTransferFunction::AsyncWorkStart() {
 953   scoped_refptr<UsbDeviceHandle> device_handle =
 954       GetDeviceHandleOrCompleteWithError(parameters_->handle);
 955   if (!device_handle) return;
 956
 957   const ControlTransferInfo& transfer = parameters_->transfer_info;
 958
 959   UsbEndpointDirection direction;
 960   UsbDeviceHandle::TransferRequestType request_type;
 961   UsbDeviceHandle::TransferRecipient recipient;
 962   size_t size = 0;
 963
 964   if (!ConvertDirectionSafely(transfer.direction, &direction) ||
 965       !ConvertRequestTypeSafely(transfer.request_type, &request_type) ||
 966       !ConvertRecipientSafely(transfer.recipient, &recipient)) {
 967     AsyncWorkCompleted();
 968     return;
 969   }
 970
 971   if (!GetTransferSize(transfer, &size)) {
 972     CompleteWithError(kErrorInvalidTransferLength);
 973     return;
 974   }
 975
 976   scoped_refptr<net::IOBuffer> buffer = CreateBufferForTransfer(
 977       transfer, direction, size);
 978   if (!buffer.get()) {
 979     CompleteWithError(kErrorMalformedParameters);
 980     return;
 981   }
 982
 983   device_handle->ControlTransfer(
 984       direction,
 985       request_type,
 986       recipient,
 987       transfer.request,
 988       transfer.value,
 989       transfer.index,
 990       buffer.get(),
 991       size,
 992       0,
 993       base::Bind(&UsbControlTransferFunction::OnCompleted, this));
 994 }
 995
 996 UsbBulkTransferFunction::UsbBulkTransferFunction() {}
 997
 998 UsbBulkTransferFunction::~UsbBulkTransferFunction() {}
 999
1000 bool UsbBulkTransferFunction::Prepare() {
1001   parameters_ = BulkTransfer::Params::Create(*args_);
1002   EXTENSION_FUNCTION_VALIDATE(parameters_.get());
1003   return true;
1004 }
1005
1006 void UsbBulkTransferFunction::AsyncWorkStart() {
1007   scoped_refptr<UsbDeviceHandle> device_handle =
1008       GetDeviceHandleOrCompleteWithError(parameters_->handle);
1009   if (!device_handle) return;
1010
1011   const GenericTransferInfo& transfer = parameters_->transfer_info;
1012
1013   UsbEndpointDirection direction;
1014   size_t size = 0;
1015
1016   if (!ConvertDirectionSafely(transfer.direction, &direction)) {
1017     AsyncWorkCompleted();
1018     return;
1019   }
1020
1021   if (!GetTransferSize(transfer, &size)) {
1022     CompleteWithError(kErrorInvalidTransferLength);
1023     return;
1024   }
1025
1026   scoped_refptr<net::IOBuffer> buffer = CreateBufferForTransfer(
1027       transfer, direction, size);
1028   if (!buffer.get()) {
1029     CompleteWithError(kErrorMalformedParameters);
1030     return;
1031   }
1032
1033   device_handle->BulkTransfer(
1034       direction,
1035       transfer.endpoint,
1036       buffer.get(),
1037       size,
1038       0,
1039       base::Bind(&UsbBulkTransferFunction::OnCompleted, this));
1040 }
1041
1042 UsbInterruptTransferFunction::UsbInterruptTransferFunction() {}
1043
1044 UsbInterruptTransferFunction::~UsbInterruptTransferFunction() {}
1045
1046 bool UsbInterruptTransferFunction::Prepare() {
1047   parameters_ = InterruptTransfer::Params::Create(*args_);
1048   EXTENSION_FUNCTION_VALIDATE(parameters_.get());
1049   return true;
1050 }
1051
1052 void UsbInterruptTransferFunction::AsyncWorkStart() {
1053   scoped_refptr<UsbDeviceHandle> device_handle =
1054       GetDeviceHandleOrCompleteWithError(parameters_->handle);
1055   if (!device_handle) return;
1056
1057   const GenericTransferInfo& transfer = parameters_->transfer_info;
1058
1059   UsbEndpointDirection direction;
1060   size_t size = 0;
1061
1062   if (!ConvertDirectionSafely(transfer.direction, &direction)) {
1063     AsyncWorkCompleted();
1064     return;
1065   }
1066
1067   if (!GetTransferSize(transfer, &size)) {
1068     CompleteWithError(kErrorInvalidTransferLength);
1069     return;
1070   }
1071
1072   scoped_refptr<net::IOBuffer> buffer = CreateBufferForTransfer(
1073       transfer, direction, size);
1074   if (!buffer.get()) {
1075     CompleteWithError(kErrorMalformedParameters);
1076     return;
1077   }
1078
1079   device_handle->InterruptTransfer(
1080       direction,
1081       transfer.endpoint,
1082       buffer.get(),
1083       size,
1084       0,
1085       base::Bind(&UsbInterruptTransferFunction::OnCompleted, this));
1086 }
1087
1088 UsbIsochronousTransferFunction::UsbIsochronousTransferFunction() {}
1089
1090 UsbIsochronousTransferFunction::~UsbIsochronousTransferFunction() {}
1091
1092 bool UsbIsochronousTransferFunction::Prepare() {
1093   parameters_ = IsochronousTransfer::Params::Create(*args_);
1094   EXTENSION_FUNCTION_VALIDATE(parameters_.get());
1095   return true;
1096 }
1097
1098 void UsbIsochronousTransferFunction::AsyncWorkStart() {
1099   scoped_refptr<UsbDeviceHandle> device_handle =
1100       GetDeviceHandleOrCompleteWithError(parameters_->handle);
1101   if (!device_handle) return;
1102
1103   const IsochronousTransferInfo& transfer = parameters_->transfer_info;
1104   const GenericTransferInfo& generic_transfer = transfer.transfer_info;
1105
1106   size_t size = 0;
1107   UsbEndpointDirection direction;
1108
1109   if (!ConvertDirectionSafely(generic_transfer.direction, &direction)) {
1110     AsyncWorkCompleted();
1111     return;
1112   }
1113   if (!GetTransferSize(generic_transfer, &size)) {
1114     CompleteWithError(kErrorInvalidTransferLength);
1115     return;
1116   }
1117   if (transfer.packets < 0 || transfer.packets >= kMaxPackets) {
1118     CompleteWithError(kErrorInvalidNumberOfPackets);
1119     return;
1120   }
1121   unsigned int packets = transfer.packets;
1122   if (transfer.packet_length < 0 ||
1123       transfer.packet_length >= kMaxPacketLength) {
1124     CompleteWithError(kErrorInvalidPacketLength);
1125     return;
1126   }
1127   unsigned int packet_length = transfer.packet_length;
1128   const uint64 total_length = packets * packet_length;
1129   if (packets > size || total_length > size) {
1130     CompleteWithError(kErrorTransferLength);
1131     return;
1132   }
1133
1134   scoped_refptr<net::IOBuffer> buffer = CreateBufferForTransfer(
1135       generic_transfer, direction, size);
1136   if (!buffer.get()) {
1137     CompleteWithError(kErrorMalformedParameters);
1138     return;
1139   }
1140
1141   device_handle->IsochronousTransfer(
1142       direction,
1143       generic_transfer.endpoint,
1144       buffer.get(),
1145       size,
1146       packets,
1147       packet_length,
1148       0,
1149       base::Bind(&UsbIsochronousTransferFunction::OnCompleted, this));
1150 }
1151
1152 UsbResetDeviceFunction::UsbResetDeviceFunction() {}
1153
1154 UsbResetDeviceFunction::~UsbResetDeviceFunction() {}
1155
1156 bool UsbResetDeviceFunction::Prepare() {
1157   parameters_ = ResetDevice::Params::Create(*args_);
1158   EXTENSION_FUNCTION_VALIDATE(parameters_.get());
1159   return true;
1160 }
1161
1162 void UsbResetDeviceFunction::AsyncWorkStart() {
1163   scoped_refptr<UsbDeviceHandle> device_handle =
1164       GetDeviceHandleOrCompleteWithError(parameters_->handle);
1165   if (!device_handle) return;
1166
1167   bool success = device_handle->ResetDevice();
1168   if (!success) {
1169     device_handle->Close();
1170     RemoveUsbDeviceResource(parameters_->handle.handle);
1171     SetResult(new base::FundamentalValue(false));
1172     CompleteWithError(kErrorResetDevice);
1173     return;
1174   }
1175
1176   SetResult(new base::FundamentalValue(true));
1177   AsyncWorkCompleted();
1178 }
1179
1180 }  // namespace extensions