Add more generic filters to the chrome.usb.getDevices API.

extensions/browser/api/usb/usb_api.cc

 // Copyright 2014 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 "extensions/browser/api/usb/usb_api.h"
 
 #include <string>
 #include <vector>
 
 #include "base/memory/scoped_ptr.h"
@@ skipping 33 matching lines @@
 using usb::GenericTransferInfo;
 using usb::InterfaceDescriptor;
 using usb::IsochronousTransferInfo;
 using usb::Recipient;
 using usb::RequestType;
 using usb::SynchronizationType;
 using usb::TransferType;
 using usb::UsageType;
 using usb_service::UsbConfigDescriptor;
 using usb_service::UsbDevice;
+using usb_service::UsbDeviceFilter;
 using usb_service::UsbDeviceHandle;
 using usb_service::UsbEndpointDescriptor;
 using usb_service::UsbEndpointDirection;
 using usb_service::UsbInterfaceAltSettingDescriptor;
 using usb_service::UsbInterfaceDescriptor;
 using usb_service::UsbService;
 using usb_service::UsbSynchronizationType;
 using usb_service::UsbTransferStatus;
 using usb_service::UsbTransferType;
 using usb_service::UsbUsageType;
@@ skipping 345 matching lines @@
 bool UsbAsyncApiFunction::PrePrepare() {
   manager_ = ApiResourceManager<UsbDeviceResource>::Get(browser_context());
   set_work_thread_id(BrowserThread::FILE);
   return manager_ != NULL;
 }
 
 bool UsbAsyncApiFunction::Respond() {
   return error_.empty();
 }
 
-scoped_refptr<UsbDevice> UsbAsyncApiFunction::GetDeviceOrOrCompleteWithError(
+// static
+void UsbAsyncApiFunction::CreateDeviceFilter(const usb::DeviceFilter& input,
+                                             UsbDeviceFilter* output) {
+  if (input.vendor_id) {
+    output->SetVendorId(*input.vendor_id);
+  }
+  if (input.product_id) {
+    output->SetProductId(*input.product_id);
+  }
+  if (input.interface_class) {
+    output->SetInterfaceClass(*input.interface_class);
+  }
+  if (input.interface_subclass) {
+    output->SetInterfaceSubclass(*input.interface_subclass);
+  }
+  if (input.interface_protocol) {
+    output->SetInterfaceProtocol(*input.interface_protocol);
+  }
+}
+
+bool UsbAsyncApiFunction::HasDevicePermission(
+    scoped_refptr<usb_service::UsbDevice> device) {
+  UsbDevicePermission::CheckParam param(
+      device->vendor_id(),
+      device->product_id(),
+      UsbDevicePermissionData::UNSPECIFIED_INTERFACE);
+  return extension()->permissions_data()->CheckAPIPermissionWithParam(
+      APIPermission::kUsbDevice, &param);
+}
+
+scoped_refptr<UsbDevice> UsbAsyncApiFunction::GetDeviceOrCompleteWithError(
     const Device& input_device) {
-  const uint16_t vendor_id = input_device.vendor_id;
-  const uint16_t product_id = input_device.product_id;
-  UsbDevicePermission::CheckParam param(
-      vendor_id, product_id, UsbDevicePermissionData::UNSPECIFIED_INTERFACE);
-  if (!extension()->permissions_data()->CheckAPIPermissionWithParam(
-          APIPermission::kUsbDevice, &param)) {
-    LOG(WARNING) << "Insufficient permissions to access device.";
-    CompleteWithError(kErrorPermissionDenied);
-    return NULL;
-  }
-
   UsbService* service = UsbService::GetInstance();
   if (!service) {
     CompleteWithError(kErrorInitService);
     return NULL;
   }
-  scoped_refptr<UsbDevice> device;
 
-  device = service->GetDeviceById(input_device.device);
-
+  scoped_refptr<UsbDevice> device = service->GetDeviceById(input_device.device);
   if (!device.get()) {
     CompleteWithError(kErrorNoDevice);
     return NULL;
   }
 
-  if (device->vendor_id() != input_device.vendor_id ||
-      device->product_id() != input_device.product_id) {
+  if (!HasDevicePermission(device)) {
     // Must act as if there is no such a device.
     // Otherwise can be used to finger print unauthorized devices.
     CompleteWithError(kErrorNoDevice);
     return NULL;
   }
 
   return device;
 }
 
 scoped_refptr<UsbDeviceHandle>
@@ skipping 158 matching lines @@
 UsbGetDevicesFunction::~UsbGetDevicesFunction() {
 }
 
 bool UsbGetDevicesFunction::Prepare() {
   parameters_ = GetDevices::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(parameters_.get());
   return true;
 }
 
 void UsbGetDevicesFunction::AsyncWorkStart() {
-  scoped_ptr<base::ListValue> result(new base::ListValue());
-
-  const uint16_t vendor_id = parameters_->options.vendor_id;
-  const uint16_t product_id = parameters_->options.product_id;
-  UsbDevicePermission::CheckParam param(
-      vendor_id, product_id, UsbDevicePermissionData::UNSPECIFIED_INTERFACE);
-  if (!extension()->permissions_data()->CheckAPIPermissionWithParam(
-          APIPermission::kUsbDevice, &param)) {
-    LOG(WARNING) << "Insufficient permissions to access device.";
-    CompleteWithError(kErrorPermissionDenied);
-    return;
+  std::vector<UsbDeviceFilter> filters;
+  if (parameters_->options.filters) {
+    filters.resize(parameters_->options.filters->size());
+    for (size_t i = 0; i < parameters_->options.filters->size(); ++i) {
+      CreateDeviceFilter(*parameters_->options.filters->at(i).get(),
+                         &filters[i]);
+    }
+  }
+  if (parameters_->options.vendor_id) {
+    filters.resize(filters.size() + 1);
+    filters.back().SetVendorId(*parameters_->options.vendor_id);
+    if (parameters_->options.product_id) {
+      filters.back().SetProductId(*parameters_->options.product_id);
+    }
   }
 
   UsbService* service = UsbService::GetInstance();
   if (!service) {
     CompleteWithError(kErrorInitService);
     return;
   }
 
   DeviceVector devices;
   service->GetDevices(&devices);
 
-  for (DeviceVector::iterator it = devices.begin(); it != devices.end();) {
-    if ((*it)->vendor_id() != vendor_id || (*it)->product_id() != product_id) {
-      it = devices.erase(it);
-    } else {
-      ++it;
+  scoped_ptr<base::ListValue> result(new base::ListValue());
+  for (DeviceVector::iterator it = devices.begin(); it != devices.end(); ++it) {
+    scoped_refptr<UsbDevice> device = *it;
+    if ((filters.empty() || UsbDeviceFilter::MatchesAny(device, filters)) &&
+        HasDevicePermission(device)) {
+      result->Append(PopulateDevice(it->get()));
     }
   }
 
-  for (size_t i = 0; i < devices.size(); ++i) {
-    result->Append(PopulateDevice(devices[i].get()));
-  }
-
   SetResult(result.release());
   AsyncWorkCompleted();
 }
 
 UsbRequestAccessFunction::UsbRequestAccessFunction() {
 }
 
 UsbRequestAccessFunction::~UsbRequestAccessFunction() {
 }
 
 bool UsbRequestAccessFunction::Prepare() {
   parameters_ = RequestAccess::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(parameters_.get());
   return true;
 }
 
 void UsbRequestAccessFunction::AsyncWorkStart() {
 #if defined(OS_CHROMEOS)
   scoped_refptr<UsbDevice> device =
-      GetDeviceOrOrCompleteWithError(parameters_->device);
+      GetDeviceOrCompleteWithError(parameters_->device);
   if (!device)
     return;
 
   device->RequestUsbAccess(
       parameters_->interface_id,
       base::Bind(&UsbRequestAccessFunction::OnCompleted, this));
 #else
   SetResult(new base::FundamentalValue(false));
   CompleteWithError(kErrorNotSupported);
 #endif  // OS_CHROMEOS
@@ skipping 11 matching lines @@
 }
 
 bool UsbOpenDeviceFunction::Prepare() {
   parameters_ = OpenDevice::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(parameters_.get());
   return true;
 }
 
 void UsbOpenDeviceFunction::AsyncWorkStart() {
   scoped_refptr<UsbDevice> device =
-      GetDeviceOrOrCompleteWithError(parameters_->device);
+      GetDeviceOrCompleteWithError(parameters_->device);
   if (!device.get())
     return;
 
   handle_ = device->Open();
   if (!handle_.get()) {
     SetError(kErrorOpen);
     AsyncWorkCompleted();
     return;
   }
 
@@ skipping 477 matching lines @@
     SetResult(new base::FundamentalValue(false));
     CompleteWithError(kErrorResetDevice);
     return;
   }
 
   SetResult(new base::FundamentalValue(true));
   AsyncWorkCompleted();
 }
 
 }  // namespace extensions