Add chrome.hid.getUserSelectedDevices API.

extensions/browser/api/hid/hid_device_manager.cc

Index: extensions/browser/api/hid/hid_device_manager.cc
diff --git a/extensions/browser/api/hid/hid_device_manager.cc b/extensions/browser/api/hid/hid_device_manager.cc
index 5a6403c87c95b01bc5fb318e76adb27b5c647ee1..e1bbc0cdc064b1cf0df2a62d9b4a75f0952bbd73 100644
--- a/extensions/browser/api/hid/hid_device_manager.cc
+++ b/extensions/browser/api/hid/hid_device_manager.cc
@@ -11,6 +11,7 @@
 #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"
 
@@ -57,12 +58,13 @@ void PopulateHidDeviceInfo(hid::HidDeviceInfo* output,
   }
 }
 
-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;
 }
@@ -83,10 +85,8 @@ struct HidDeviceManager::GetApiDevicesParams {
 };
 
 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_) {
@@ -125,6 +125,22 @@ void HidDeviceManager::GetApiDevices(
   }
 }
 
+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());

[Devlin, 2015/05/05 22:19:50]

a const& to an iterator is kind of weird...

[Reilly Grant (use Gerrit), 2015/05/06 00:52:53]

Fixed.

+    DCHECK(device_entry != resource_ids_.end());

[Devlin, 2015/05/05 22:19:50]

DCHECK_NE

[Reilly Grant (use Gerrit), 2015/05/06 00:52:53]

DCHECK_EQ and DCHECK_NE don't work for iterators because they don't implement
operator<<.

+
+    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();
@@ -139,9 +155,26 @@ scoped_refptr<HidDeviceInfo> HidDeviceManager::GetDeviceInfo(int resource_id) {
   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_);
+  if (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;

[Devlin, 2015/05/05 22:19:50]

When is |updatre_last_used| true?  (Maybe I just missed it somewhere, but I
didn't see it in this CL).  Also, this looks kind of weird - it looks like this
method does something totally different when |update_last_used| is true than
when it's not.  Does this really all belong in one method?  If so, why?  (It
totally could - I'm not super familiar with this code yet.)

[Reilly Grant (use Gerrit), 2015/05/06 00:52:53]

All it does when update_last_used is set update the timestamp on the permission
entry. It's set to true by the hid.connect API and false by hid.getDevices and
other places where we're only enumerating devices the app has permission to
access.

+    }
+  }
+
   UsbDevicePermission::CheckParam usbParam(
       device_info->vendor_id(), device_info->product_id(),
       UsbDevicePermissionData::UNSPECIFIED_INTERFACE);
@@ -250,7 +283,7 @@ scoped_ptr<base::ListValue> HidDeviceManager::CreateApiDeviceList(
       continue;
     }
 
-    if (!HasPermission(extension, device_info)) {
+    if (!HasPermission(extension, device_info, false)) {
       continue;
     }
 
@@ -288,8 +321,8 @@ 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());
 }