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());

[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();
   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_);
+  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);
   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