Add chrome.hid.getUserSelectedDevices API.

extensions/browser/api/hid/hid_device_manager.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_device_manager.h"
 
 #include <limits>
 #include <vector>
 
 #include "base/lazy_instance.h"
 #include "device/core/device_client.h"
 #include "device/hid/hid_device_filter.h"
 #include "device/hid/hid_service.h"
+#include "extensions/browser/api/device_permissions_manager.h"
 #include "extensions/common/permissions/permissions_data.h"
 #include "extensions/common/permissions/usb_device_permission.h"
 
 namespace hid = extensions::core_api::hid;
 
 using device::HidDeviceFilter;
 using device::HidDeviceId;
 using device::HidDeviceInfo;
 using device::HidService;
 
@@ skipping 26 matching lines @@
     output->collections.push_back(make_linked_ptr(api_collection));
   }
 
   const std::vector<uint8>& report_descriptor = input->report_descriptor();
   if (report_descriptor.size() > 0) {
     output->report_descriptor.assign(report_descriptor.begin(),
                                      report_descriptor.end());
   }
 }
 
-bool WillDispatchDeviceEvent(scoped_refptr<HidDeviceInfo> device_info,
+bool WillDispatchDeviceEvent(base::WeakPtr<HidDeviceManager> device_manager,
+                             scoped_refptr<device::HidDeviceInfo> device_info,
                              content::BrowserContext* context,
                              const Extension* extension,
                              base::ListValue* event_args) {
-  if (extension) {
-    return HidDeviceManager::HasPermission(extension, device_info);
+  if (device_manager && extension) {
+    return device_manager->HasPermission(extension, device_info, false);
   }
   return false;
 }
 
 }  // namespace
 
 struct HidDeviceManager::GetApiDevicesParams {
  public:
   GetApiDevicesParams(const Extension* extension,
                       const std::vector<HidDeviceFilter>& filters,
                       const GetApiDevicesCallback& callback)
       : extension(extension), filters(filters), callback(callback) {}
   ~GetApiDevicesParams() {}
 
   const Extension* extension;
   std::vector<HidDeviceFilter> filters;
   GetApiDevicesCallback callback;
 };
 
 HidDeviceManager::HidDeviceManager(content::BrowserContext* context)
-    : initialized_(false),
+    : browser_context_(context),
       hid_service_observer_(this),
-      enumeration_ready_(false),
-      next_resource_id_(0),
       weak_factory_(this) {
   event_router_ = EventRouter::Get(context);
   if (event_router_) {
     event_router_->RegisterObserver(this, hid::OnDeviceAdded::kEventName);
     event_router_->RegisterObserver(this, hid::OnDeviceRemoved::kEventName);
   }
 }
 
 HidDeviceManager::~HidDeviceManager() {
   DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 18 matching lines @@
     scoped_ptr<base::ListValue> devices =
         CreateApiDeviceList(extension, filters);
     base::MessageLoop::current()->PostTask(
         FROM_HERE, base::Bind(callback, base::Passed(&devices)));
   } else {
     pending_enumerations_.push_back(
         new GetApiDevicesParams(extension, filters, callback));
   }
 }
 
+scoped_ptr<base::ListValue> HidDeviceManager::GetApiDevicesFromList(
+    const std::vector<scoped_refptr<HidDeviceInfo>>& devices) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  scoped_ptr<base::ListValue> device_list(new base::ListValue());
+  for (const auto& device : devices) {
+    const auto device_entry = resource_ids_.find(device->device_id());
+    DCHECK(device_entry != resource_ids_.end());
+
+    hid::HidDeviceInfo device_info;
+    device_info.device_id = device_entry->second;
+    PopulateHidDeviceInfo(&device_info, device);
+    device_list->Append(device_info.ToValue().release());
+  }
+  return device_list.Pass();
+}
+
 scoped_refptr<HidDeviceInfo> HidDeviceManager::GetDeviceInfo(int resource_id) {
   DCHECK(thread_checker_.CalledOnValidThread());
   HidService* hid_service = device::DeviceClient::Get()->GetHidService();
   DCHECK(hid_service);
 
   ResourceIdToDeviceIdMap::const_iterator device_iter =
       device_ids_.find(resource_id);
   if (device_iter == device_ids_.end()) {
     return nullptr;
   }
 
   return hid_service->GetDeviceInfo(device_iter->second);
 }
 
-// static
 bool HidDeviceManager::HasPermission(const Extension* extension,
-                                     scoped_refptr<HidDeviceInfo> device_info) {
+                                     scoped_refptr<HidDeviceInfo> device_info,
+                                     bool update_last_used) {
+  DevicePermissionsManager* permissions_manager =
+      DevicePermissionsManager::Get(browser_context_);
+  CHECK(permissions_manager);
+  DevicePermissions* device_permissions =
+      permissions_manager->GetForExtension(extension->id());
+  DCHECK(device_permissions);
+  scoped_refptr<DevicePermissionEntry> permission_entry =
+      device_permissions->FindHidDeviceEntry(device_info);
+  if (permission_entry) {
+    if (update_last_used) {
+      permissions_manager->UpdateLastUsed(extension->id(), permission_entry);
+    }
+    return true;
+  }
+
   UsbDevicePermission::CheckParam usbParam(
       device_info->vendor_id(), device_info->product_id(),
       UsbDevicePermissionData::UNSPECIFIED_INTERFACE);
   if (extension->permissions_data()->CheckAPIPermissionWithParam(
           APIPermission::kUsbDevice, &usbParam)) {
     return true;
   }
 
   if (extension->permissions_data()->HasAPIPermission(
           APIPermission::kU2fDevices)) {
@@ skipping 88 matching lines @@
         hid_service->GetDeviceInfo(device_id);
     if (!device_info) {
       continue;
     }
 
     if (!filters.empty() &&
         !HidDeviceFilter::MatchesAny(device_info, filters)) {
       continue;
     }
 
-    if (!HasPermission(extension, device_info)) {
+    if (!HasPermission(extension, device_info, false)) {
       continue;
     }
 
     hid::HidDeviceInfo api_device_info;
     api_device_info.device_id = resource_id;
     PopulateHidDeviceInfo(&api_device_info, device_info);
 
     // Expose devices with which user can communicate.
     if (api_device_info.collections.size() > 0) {
       api_devices->Append(api_device_info.ToValue().release());
@@ skipping 17 matching lines @@
         CreateApiDeviceList(params->extension, params->filters);
     params->callback.Run(devices.Pass());
   }
   pending_enumerations_.clear();
 }
 
 void HidDeviceManager::DispatchEvent(const std::string& event_name,
                                      scoped_ptr<base::ListValue> event_args,
                                      scoped_refptr<HidDeviceInfo> device_info) {
   scoped_ptr<Event> event(new Event(event_name, event_args.Pass()));
-  event->will_dispatch_callback =
-      base::Bind(&WillDispatchDeviceEvent, device_info);
+  event->will_dispatch_callback = base::Bind(
+      &WillDispatchDeviceEvent, weak_factory_.GetWeakPtr(), device_info);
   event_router_->BroadcastEvent(event.Pass());
 }
 
 }  // namespace extensions