Add chrome.hid.getUserSelectedDevices 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 "base/stl_util.h"
 #include "device/core/device_client.h"
 #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/device_permissions_prompt.h"
+#include "extensions/browser/api/extensions_api_client.h"
 #include "extensions/common/api/hid.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;
 
@@ skipping 67 matching lines @@
       extension(), filters,
       base::Bind(&HidGetDevicesFunction::OnEnumerationComplete, this));
   return RespondLater();
 }
 
 void HidGetDevicesFunction::OnEnumerationComplete(
     scoped_ptr<base::ListValue> devices) {
   Respond(OneArgument(devices.release()));
 }
 
+HidGetUserSelectedDevicesFunction::HidGetUserSelectedDevicesFunction() {
+}
+
+HidGetUserSelectedDevicesFunction::~HidGetUserSelectedDevicesFunction() {
+}
+
+ExtensionFunction::ResponseAction HidGetUserSelectedDevicesFunction::Run() {

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

I thought I saw something in the IDL about this needing user gesture, but I
don't see that implemented anywhere?

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

Good catch.

+  scoped_ptr<core_api::hid::GetUserSelectedDevices::Params> parameters =
+      hid::GetUserSelectedDevices::Params::Create(*args_);
+  EXTENSION_FUNCTION_VALIDATE(parameters.get());

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

nit: scoped_ptrs are Testable, so you don't need the .get().  I don't really
care between using it and not, but you should probably be consistent :)  (It
looks like you don't use it on, e.g., line 123)

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

Fixed.

+
+  bool multiple = false;
+  if (parameters->options.multiple) {

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

inline all this?
bool multiple = parameters->options.multiple && *parameters->options.multiple;

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

Done.

+    multiple = *parameters->options.multiple;
+  }
+
+  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]);
+    }
+  }
+
+  prompt_ = ExtensionsAPIClient::Get()->CreateDevicePermissionsPrompt(
+      GetAssociatedWebContents());

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

Prefer GetSenderWebContents() in most cases.

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

Done.

+  if (!prompt_) {
+    return RespondNow(Error(kErrorServiceUnavailable));
+  }
+
+  prompt_->AskForHidDevices(
+      extension(), browser_context(), multiple, filters,
+      base::Bind(&HidGetUserSelectedDevicesFunction::OnDevicesChosen, this));
+  return RespondLater();
+}
+
+void HidGetUserSelectedDevicesFunction::OnDevicesChosen(
+    const std::vector<scoped_refptr<HidDeviceInfo>>& devices) {
+  HidDeviceManager* device_manager = HidDeviceManager::Get(browser_context());
+  if (!device_manager) {

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

I'm seeing a lot of these null checks in this patch.  Under what circumstances
can device_manager be unavailable?  Should we gate the availability on the API
on the availability of the manager?  Should we at least make this check before
we try and show a picker to the user?

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

I've moved the check into Run. HidDeviceManager should always be available but
I've been bitten by incognito bugs where something goes wrong and it isn't and
I'd rather a clean failure than a crash.

[Devlin, 2015/05/06 23:04:28]

I can sympathize, but if something should always be available, we should treat
it as though it is (feel free to put in a DCHECK/CHECK so we can get really nice
traces), for the same reasons that we discourage behavior like
DCHECK(!bad)
if (bad)
  return;

So if the manager is meant to be null, e.g., in incognito, then the check should
be
if (!manager)
  return Error()  // Manager can be null while incognito

But otherwise, we should assume it exists, so we can flush out any times it
doesn't erroneously.

[Reilly Grant (use Gerrit), 2015/05/06 23:48:52]

I've removed the kErrorServiceUnavailable message and turned all instances into
CHECKs.

+    Respond(Error(kErrorServiceUnavailable));
+    return;
+  }
+
+  Respond(
+      OneArgument(device_manager->GetApiDevicesFromList(devices).release()));

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

There's a OneArgument variation that takes a scoped_ptr - use that instead of
release()ing here.

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

Done.

+}
+
 HidConnectFunction::HidConnectFunction() : connection_manager_(nullptr) {
 }
 
 HidConnectFunction::~HidConnectFunction() {}
 
 ExtensionFunction::ResponseAction HidConnectFunction::Run() {
   scoped_ptr<core_api::hid::Connect::Params> parameters =
       hid::Connect::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(parameters.get());
 
   HidDeviceManager* device_manager = HidDeviceManager::Get(browser_context());
   if (!device_manager) {
     return RespondNow(Error(kErrorServiceUnavailable));
   }
 
   connection_manager_ =
       ApiResourceManager<HidConnectionResource>::Get(browser_context());
   if (!connection_manager_) {
     return RespondNow(Error(kErrorServiceUnavailable));
   }
 
   scoped_refptr<HidDeviceInfo> device_info =
       device_manager->GetDeviceInfo(parameters->device_id);
   if (!device_info) {
     return RespondNow(Error(kErrorInvalidDeviceId));
   }
 
-  if (!HidDeviceManager::HasPermission(extension(), device_info)) {
+  if (!device_manager->HasPermission(extension(), device_info, true)) {
     return RespondNow(Error(kErrorPermissionDenied));
   }
 
   HidService* hid_service = device::DeviceClient::Get()->GetHidService();
   if (!hid_service) {
     return RespondNow(Error(kErrorServiceUnavailable));
   }
 
   hid_service->Connect(
       device_info->device_id(),
@@ skipping 179 matching lines @@
 
 void HidSendFeatureReportFunction::OnFinished(bool success) {
   if (success) {
     Respond(NoArguments());
   } else {
     Respond(Error(kErrorTransfer));
   }
 }
 
 }  // namespace extensions