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

extensions/browser/api/hid/hid_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/hid/hid_api.h"
 
 #include <string>
 #include <vector>
 
 #include "device/hid/hid_connection.h"
+#include "device/hid/hid_device_filter.h"
 #include "device/hid/hid_device_info.h"
 #include "device/hid/hid_service.h"
 #include "extensions/browser/api/api_resource_manager.h"
 #include "extensions/browser/api/extensions_api_client.h"
 #include "extensions/common/api/hid.h"
-#include "extensions/common/permissions/permissions_data.h"
-#include "extensions/common/permissions/usb_device_permission.h"
 #include "net/base/io_buffer.h"
 
 namespace hid = extensions::core_api::hid;
 
 using device::HidConnection;
+using device::HidDeviceFilter;
 using device::HidDeviceInfo;
 using device::HidService;
 
 namespace {
 
 const char kErrorPermissionDenied[] = "Permission to access device was denied.";
 const char kErrorInvalidDeviceId[] = "Invalid HID device ID.";
 const char kErrorFailedToOpenDevice[] = "Failed to open HID device.";
 const char kErrorConnectionNotFound[] = "Connection not established.";
 const char kErrorTransfer[] = "Transfer failed.";
 
 base::Value* PopulateHidConnection(int connection_id,
                                    scoped_refptr<HidConnection> connection) {
   hid::HidConnectInfo connection_value;
   connection_value.connection_id = connection_id;
   return connection_value.ToValue().release();
 }
 
+void ConvertHidDeviceFilter(linked_ptr<hid::DeviceFilter> input,
+                            HidDeviceFilter* output) {
+  if (input->vendor_id) {
+    output->SetVendorId(*input->vendor_id);
+  }
+  if (input->product_id) {
+    output->SetProductId(*input->product_id);
+  }
+  if (input->usage_page) {
+    output->SetUsagePage(*input->usage_page);
+  }
+  if (input->usage) {
+    output->SetUsage(*input->usage);
+  }
+}
+
 }  // namespace
 
 namespace extensions {
 
 HidAsyncApiFunction::HidAsyncApiFunction()
     : device_manager_(NULL), connection_manager_(NULL) {}
 
 HidAsyncApiFunction::~HidAsyncApiFunction() {}
 
 bool HidAsyncApiFunction::PrePrepare() {
@@ skipping 26 matching lines @@
 
 HidGetDevicesFunction::~HidGetDevicesFunction() {}
 
 bool HidGetDevicesFunction::Prepare() {
   parameters_ = hid::GetDevices::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(parameters_.get());
   return true;
 }
 
 void HidGetDevicesFunction::AsyncWorkStart() {
-  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<HidDeviceFilter> filters;
+  if (parameters_->options.filters) {
+    filters.resize(parameters_->options.filters->size());
+    for (size_t i = 0; i < parameters_->options.filters->size(); ++i) {
+      ConvertHidDeviceFilter(parameters_->options.filters->at(i), &filters[i]);
+    }
+  }
+  if (parameters_->options.vendor_id) {
+    HidDeviceFilter legacy_filter;
+    legacy_filter.SetVendorId(*parameters_->options.vendor_id);
+    if (parameters_->options.product_id) {
+      legacy_filter.SetProductId(*parameters_->options.product_id);
+    }
+    filters.push_back(legacy_filter);
   }
 
-  SetResult(device_manager_->GetApiDevices(vendor_id, product_id).release());
+  SetResult(device_manager_->GetApiDevices(extension(), filters).release());
   AsyncWorkCompleted();
 }
 
 HidConnectFunction::HidConnectFunction() {}
 
 HidConnectFunction::~HidConnectFunction() {}
 
 bool HidConnectFunction::Prepare() {
   parameters_ = hid::Connect::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(parameters_.get());
   return true;
 }
 
 void HidConnectFunction::AsyncWorkStart() {
   device::HidDeviceInfo device_info;
   if (!device_manager_->GetDeviceInfo(parameters_->device_id, &device_info)) {
     CompleteWithError(kErrorInvalidDeviceId);
     return;
   }
 
-  UsbDevicePermission::CheckParam param(
-      device_info.vendor_id,
-      device_info.product_id,
-      UsbDevicePermissionData::UNSPECIFIED_INTERFACE);
-  if (!extension()->permissions_data()->CheckAPIPermissionWithParam(
-          APIPermission::kUsbDevice, &param)) {
+  if (!device_manager_->HasPermission(extension(), device_info)) {
     LOG(WARNING) << "Insufficient permissions to access device.";
     CompleteWithError(kErrorPermissionDenied);
     return;
   }
 
   HidService* hid_service = ExtensionsAPIClient::Get()->GetHidService();
   DCHECK(hid_service);
   scoped_refptr<HidConnection> connection =
       hid_service->Connect(device_info.device_id);
   if (!connection.get()) {
@@ skipping 176 matching lines @@
 
 void HidSendFeatureReportFunction::OnFinished(bool success) {
   if (!success) {
     CompleteWithError(kErrorTransfer);
     return;
   }
   AsyncWorkCompleted();
 }
 
 }  // namespace extensions