Introducing chrome.usb.getDevices/openDevice API

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

 // 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.
 
 #include "chrome/browser/extensions/api/usb/usb_api.h"
 
 #include <string>
 #include <vector>
 
 #include "base/memory/scoped_ptr.h"
+#include "base/message_loop/message_loop_proxy.h"
 #include "chrome/browser/extensions/api/usb/usb_device_resource.h"
 #include "chrome/browser/extensions/extension_system.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/usb/usb_device_handle.h"
 #include "chrome/browser/usb/usb_service.h"
 #include "chrome/common/extensions/api/usb.h"
 #include "chrome/common/extensions/permissions/permissions_data.h"
 #include "chrome/common/extensions/permissions/usb_device_permission.h"
 
-namespace BulkTransfer = extensions::api::usb::BulkTransfer;
-namespace ClaimInterface = extensions::api::usb::ClaimInterface;
-namespace ListInterfaces = extensions::api::usb::ListInterfaces;
-namespace CloseDevice = extensions::api::usb::CloseDevice;
-namespace ControlTransfer = extensions::api::usb::ControlTransfer;
-namespace FindDevices = extensions::api::usb::FindDevices;
-namespace InterruptTransfer = extensions::api::usb::InterruptTransfer;
-namespace IsochronousTransfer = extensions::api::usb::IsochronousTransfer;
-namespace ReleaseInterface = extensions::api::usb::ReleaseInterface;
-namespace ResetDevice = extensions::api::usb::ResetDevice;
-namespace SetInterfaceAlternateSetting =
-    extensions::api::usb::SetInterfaceAlternateSetting;
 namespace usb = extensions::api::usb;
+namespace BulkTransfer = usb::BulkTransfer;
+namespace ClaimInterface = usb::ClaimInterface;
+namespace ListInterfaces = usb::ListInterfaces;
+namespace CloseDevice = usb::CloseDevice;
+namespace ControlTransfer = usb::ControlTransfer;
+namespace FindDevices = usb::FindDevices;
+namespace InterruptTransfer = usb::InterruptTransfer;
+namespace IsochronousTransfer = usb::IsochronousTransfer;
+namespace ReleaseInterface = usb::ReleaseInterface;
+namespace ResetDevice = usb::ResetDevice;
+namespace SetInterfaceAlternateSetting = usb::SetInterfaceAlternateSetting;
+namespace GetDevices = usb::GetDevices;
+namespace OpenDevice = usb::OpenDevice;

[asargent_no_longer_on_chrome, 2013/08/22 21:06:13]

nit: can you sort these alphabetically? It would make them easier to read

[Bei Zhang, 2013/08/23 22:52:00]

Done.

 
 using content::BrowserThread;
 using std::string;
 using std::vector;
 using usb::ControlTransferInfo;
 using usb::Device;
+using usb::DeviceHandle;
 using usb::Direction;
 using usb::EndpointDescriptor;
 using usb::GenericTransferInfo;
 using usb::InterfaceDescriptor;
 using usb::IsochronousTransferInfo;
 using usb::Recipient;
 using usb::RequestType;
 using usb::SynchronizationType;
 using usb::TransferType;
 using usb::UsageType;
 
+typedef scoped_ptr<std::vector<scoped_refptr<UsbDevice> > > ScopedDeviceVector;
+
 namespace {
 
 static const char kDataKey[] = "data";
 static const char kResultCodeKey[] = "resultCode";
 
 static const char kErrorCancelled[] = "Transfer was cancelled.";
 static const char kErrorDisconnect[] = "Device disconnected.";
 static const char kErrorGeneric[] = "Transfer failed.";
 static const char kErrorOverflow[] = "Inbound transfer overflow.";
 static const char kErrorStalled[] = "Transfer stalled.";
@@ skipping 17 matching lines @@
 static const char kErrorPermissionDenied[] =
     "Permission to access device was denied";
 static const char kErrorInvalidTransferLength[] = "Transfer length must be a "
     "positive number less than 104,857,600.";
 static const char kErrorInvalidNumberOfPackets[] = "Number of packets must be "
     "a positive number less than 4,194,304.";
 static const char kErrorInvalidPacketLength[] = "Packet length must be a "
     "positive number less than 65,536.";
 static const char kErrorResetDevice[] =
     "Error resetting the device. The device has been closed.";
+static const char kErrorOpen[] = "Failed to open device.";
 
 static const size_t kMaxTransferLength = 100 * 1024 * 1024;
 static const int kMaxPackets = 4 * 1024 * 1024;
 static const int kMaxPacketLength = 64 * 1024;
 
 static UsbDevice* device_for_test_ = NULL;
 
 static bool ConvertDirectionToApi(const UsbEndpointDirection& input,
                                   Direction* output) {
   switch (input) {
@@ skipping 200 matching lines @@
     UsbTransferStatus status,
     scoped_refptr<net::IOBuffer> data,
     size_t length) {
   base::DictionaryValue* result = new base::DictionaryValue();
   result->SetInteger(kResultCodeKey, status);
   result->Set(kDataKey, base::BinaryValue::CreateWithCopiedBuffer(data->data(),
                                                                   length));
   return result;
 }
 
-static base::Value* PopulateDevice(int handle, int vendor_id, int product_id) {
-  Device device;
-  device.handle = handle;
-  device.vendor_id = vendor_id;
-  device.product_id = product_id;
-  return device.ToValue().release();
+base::Value* PopulateDeviceHandle(int resource_id,
+                                  int vendor_id,
+                                  int product_id) {
+  DeviceHandle result;
+  result.handle = resource_id;
+  result.vendor_id.reset(new int(vendor_id));
+  result.product_id.reset(new int(product_id));
+  return result.ToValue().release();
 }
 
-static base::Value* PopulateInterfaceDescriptor(int interface_number,
-        int alternate_setting, int interface_class, int interface_subclass,
-        int interface_protocol,
-        std::vector<linked_ptr<EndpointDescriptor> >* endpoints) {
+base::Value* PopulateDevice(UsbDevice* device) {
+  Device result;
+  result.device = device->unique_id();
+  result.vendor_id.reset(new int(device->vendor_id()));
+  result.product_id.reset(new int(device->product_id()));
+  return result.ToValue().release();
+}
+
+base::Value* PopulateInterfaceDescriptor(
+    int interface_number,
+    int alternate_setting,
+    int interface_class,
+    int interface_subclass,
+    int interface_protocol,
+    std::vector<linked_ptr<EndpointDescriptor> >* endpoints) {

[asargent_no_longer_on_chrome, 2013/08/22 21:06:13]

nit: It looks like you removed the "static" linkage declaration from these
functions, which is fine since they're all in an anonymous namespace anyway. But
there are still several functions above marked as static. I think it would best
if either:

-All the functions in this part of the file are *outside* of an anonymous
namespace and marked static.

or

-All of them are *inside* an anonymous namespace and none of them are marked as
static. 

I don't care which way we do it, we should just be consistent in the file.

[Bei Zhang, 2013/08/23 22:52:00]

Done.

   InterfaceDescriptor descriptor;
   descriptor.interface_number = interface_number;
   descriptor.alternate_setting = alternate_setting;
   descriptor.interface_class = interface_class;
   descriptor.interface_subclass = interface_subclass;
   descriptor.interface_protocol = interface_protocol;
   descriptor.endpoints = *endpoints;
   return descriptor.ToValue().release();
 }
 
@@ skipping 66 matching lines @@
   const bool converted = ConvertRecipient(input, output);
   if (!converted)
     SetError(kErrorConvertRecipient);
   return converted;
 }
 
 UsbFindDevicesFunction::UsbFindDevicesFunction() {}
 
 UsbFindDevicesFunction::~UsbFindDevicesFunction() {}
 
-void UsbFindDevicesFunction::SetDeviceForTest(UsbDevice* device) {
-  device_for_test_ = device;
-}
-
 bool UsbFindDevicesFunction::Prepare() {
   parameters_ = FindDevices::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(parameters_.get());
   if (!device_for_test_)
     set_work_thread_id(BrowserThread::FILE);
   return true;
 }
 
 void UsbFindDevicesFunction::AsyncWorkStart() {
   result_.reset(new base::ListValue());
 
   if (device_for_test_) {
     UsbDeviceResource* const resource = new UsbDeviceResource(
         extension_->id(),
         device_for_test_->Open());
 
     Device device;
-    result_->Append(PopulateDevice(manager_->Add(resource), 0, 0));
+    result_->Append(PopulateDeviceHandle(manager_->Add(resource), 0, 0));
     SetResult(result_.release());
     AsyncWorkCompleted();
     return;
   }
 
   const uint16_t vendor_id = parameters_->options.vendor_id;
   const uint16_t product_id = parameters_->options.product_id;
   int interface_id = parameters_->options.interface_id.get() ?
       *parameters_->options.interface_id.get() :
       UsbDevicePermissionData::ANY_INTERFACE;
@@ skipping 26 matching lines @@
       FROM_HERE,
       base::Bind(&UsbFindDevicesFunction::OnCompleted, this));
 }
 
 void UsbFindDevicesFunction::OnCompleted() {
   for (size_t i = 0; i < device_handles_.size(); ++i) {
     UsbDeviceHandle* const device_handle = device_handles_[i].get();
     UsbDeviceResource* const resource =
         new UsbDeviceResource(extension_->id(), device_handle);
 
-    result_->Append(PopulateDevice(manager_->Add(resource),
+    result_->Append(PopulateDeviceHandle(manager_->Add(resource),
                                    parameters_->options.vendor_id,
                                    parameters_->options.product_id));
   }
 
   SetResult(result_.release());
   AsyncWorkCompleted();
 }
 
+UsbGetDevicesFunction::UsbGetDevicesFunction() {
+}
+
+UsbGetDevicesFunction::~UsbGetDevicesFunction() {
+}
+
+void UsbGetDevicesFunction::SetDeviceForTest(UsbDevice* device) {
+  device_for_test_ = device;
+}
+
+bool UsbGetDevicesFunction::Prepare() {
+  parameters_ = GetDevices::Params::Create(*args_);
+  EXTENSION_FUNCTION_VALIDATE(parameters_.get());
+  if (!device_for_test_)
+    set_work_thread_id(BrowserThread::FILE);
+  return true;
+}
+
+void UsbGetDevicesFunction::AsyncWorkStart() {
+  result_.reset(new base::ListValue());
+
+  if (device_for_test_) {
+    result_->Append(PopulateDevice(device_for_test_));
+    SetResult(result_.release());
+    AsyncWorkCompleted();
+    return;
+  }
+
+  const uint16_t vendor_id = parameters_->options.vendor_id;
+  const uint16_t product_id = parameters_->options.product_id;
+  int interface_id = parameters_->options.interface_id.get() ?
+      *parameters_->options.interface_id.get() :
+      UsbDevicePermissionData::ANY_INTERFACE;
+  UsbDevicePermission::CheckParam param(vendor_id, product_id, interface_id);
+  if (!PermissionsData::CheckAPIPermissionWithParam(
+          GetExtension(), APIPermission::kUsbDevice, &param)) {
+    LOG(WARNING) << "Insufficient permissions to access device.";
+    CompleteWithError(kErrorPermissionDenied);
+    return;
+  }
+
+  UsbService* service = UsbService::GetInstance();
+  service->FindDevices(
+      vendor_id,
+      product_id,
+      interface_id,
+      base::Bind(&UsbGetDevicesFunction::EnumerationCompletedFileThread, this));
+}
+
+void UsbGetDevicesFunction::EnumerationCompletedFileThread(
+    scoped_ptr<std::vector<scoped_refptr<UsbDevice> > > devices) {
+  for (size_t i = 0; i < devices->size(); ++i) {
+    result_->Append(PopulateDevice(devices->at(i).get()));
+  }
+
+  SetResult(result_.release());
+  AsyncWorkCompleted();
+}
+
+UsbOpenDeviceFunction::UsbOpenDeviceFunction() {}
+
+UsbOpenDeviceFunction::~UsbOpenDeviceFunction() {}
+
+bool UsbOpenDeviceFunction::Prepare() {
+  parameters_ = OpenDevice::Params::Create(*args_);
+  EXTENSION_FUNCTION_VALIDATE(parameters_.get());
+  return true;
+}
+
+void UsbOpenDeviceFunction::AsyncWorkStart() {
+  BrowserThread::PostTask(BrowserThread::FILE,
+                          FROM_HERE,
+                          base::Bind(&UsbOpenDeviceFunction::OpenDeviceOnFile,
+                                     this));
+}
+
+void UsbOpenDeviceFunction::OpenDeviceOnFile() {
+  UsbService* service = UsbService::GetInstance();
+  scoped_refptr<UsbDevice> device;
+  if (device_for_test_)
+    device = device_for_test_;
+  else
+    device = service->GetDeviceById(parameters_->device.device);
+
+  if (!device) {
+    SetError(kErrorNoDevice);
+    AsyncWorkCompleted();
+    return;
+  }
+
+  if (!parameters_->device.vendor_id ||
+      *parameters_->device.vendor_id.get() != device->vendor_id()) {
+    SetError(kErrorOpen);
+    AsyncWorkCompleted();
+    return;
+  }
+
+  if (!parameters_->device.product_id ||
+      *parameters_->device.product_id.get() != device->product_id()) {
+    SetError(kErrorOpen);
+    AsyncWorkCompleted();
+    return;
+  }
+
+  handle_ = device->Open();
+  BrowserThread::PostTask(BrowserThread::IO,
+                          FROM_HERE,
+                          base::Bind(&UsbOpenDeviceFunction::OnCompleted,
+                                     this));
+}
+
+void UsbOpenDeviceFunction::OnCompleted() {
+  if (!handle_) {
+    SetError(kErrorOpen);
+    AsyncWorkCompleted();
+    return;
+  }
+
+  SetResult(PopulateDeviceHandle(

[asargent_no_longer_on_chrome, 2013/08/22 21:06:13]

If the device handle could live on the FILE thread, could you cut the thread
hops from UI->IO->FILE->IO->UI to just UI->FILE->UI ?

[Bei Zhang, 2013/08/23 22:52:00]

This is addressed by another CL.

On 2013/08/22 21:06:13, Antony Sargent wrote:

+      manager_->Add(new UsbDeviceResource(extension_->id(), handle_)),
+      handle_->device()->vendor_id(),
+      handle_->device()->product_id()));
+  AsyncWorkCompleted();
+}
+
 UsbListInterfacesFunction::UsbListInterfacesFunction() {}
 
 UsbListInterfacesFunction::~UsbListInterfacesFunction() {}
 
 bool UsbListInterfacesFunction::Prepare() {
   parameters_ = ListInterfaces::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(parameters_.get());
   return true;
 }
 
@@ skipping 531 matching lines @@
 }
 
 void UsbResetDeviceFunction::OnError() {
   RemoveUsbDeviceResource(parameters_->device.handle);
   SetError(kErrorResetDevice);
   SetResult(new base::FundamentalValue(false));
   AsyncWorkCompleted();
 }
 
 }  // namespace extensions