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;
 
 namespace {
 
-const char kErrorServiceUnavailable[] = "HID services are unavailable.";
 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;
@@ skipping 20 matching lines @@
 
 namespace extensions {
 
 HidGetDevicesFunction::HidGetDevicesFunction() {}
 
 HidGetDevicesFunction::~HidGetDevicesFunction() {}
 
 ExtensionFunction::ResponseAction HidGetDevicesFunction::Run() {
   scoped_ptr<core_api::hid::GetDevices::Params> parameters =
       hid::GetDevices::Params::Create(*args_);
-  EXTENSION_FUNCTION_VALIDATE(parameters.get());
+  EXTENSION_FUNCTION_VALIDATE(parameters);
 
   HidDeviceManager* device_manager = HidDeviceManager::Get(browser_context());
-  if (!device_manager) {
-    return RespondNow(Error(kErrorServiceUnavailable));
-  }
+  CHECK(device_manager);
 
   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);
   }
 
   device_manager->GetApiDevices(
       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() {
+  scoped_ptr<core_api::hid::GetUserSelectedDevices::Params> parameters =
+      hid::GetUserSelectedDevices::Params::Create(*args_);
+  EXTENSION_FUNCTION_VALIDATE(parameters);
+
+  content::WebContents* web_contents = GetSenderWebContents();
+  if (!web_contents || !user_gesture()) {
+    return RespondNow(OneArgument(new base::ListValue()));
+  }
+
+  bool multiple = false;
+  std::vector<HidDeviceFilter> filters;
+  if (parameters->options) {
+    multiple = parameters->options->multiple && *parameters->options->multiple;
+    if (parameters->options->filters) {
+      const auto& api_filters = *parameters->options->filters;
+      filters.resize(api_filters.size());
+      for (size_t i = 0; i < api_filters.size(); ++i) {
+        ConvertHidDeviceFilter(api_filters[i], &filters[i]);
+      }
+    }
+  }
+
+  prompt_ =
+      ExtensionsAPIClient::Get()->CreateDevicePermissionsPrompt(web_contents);
+  CHECK(prompt_);
+  prompt_->AskForHidDevices(

[Devlin, 2015/05/14 17:38:11]

This is problematic with your handling of having no PopupManager.
- This calls into AskForHidDevices()
- AskForHidDevices() calls into ShowDialog()
- ShowDialog() calls Prompt::Dismissed()
- Dimissed() calls OnDevicesChosen()
- OnDevicesChosen() calls Respond()
(All of the above happens synchronously...)
- The call to AskForHidDevices() finishes, and we call RespondLater() (after
already calling Respond()). -> Error.

[Reilly Grant (use Gerrit), 2015/05/14 18:04:28]

You're right that the documentation for RespondLater says that Respond should be
called afterwards, but actually RespondLater is a no-op. This should be
documented because requiring RespondLater to be returned first leads to
unnecessary complexity.

The browser tests for this API exercise the synchronous path to make sure it is
safe.

[Devlin, 2015/05/14 18:32:02]

But there's a larger problem, which is that the API is very clear and well
documented, and it should be used in a certain way.  It's not just for safety;
it's also for readability and reasoning.  Calling things re-entrantly is
generally dangerous, especially when it's undocumented and unpredictable. 
Couple that with the fact that this makes the RespondLater() below a lie, and
this code becomes very hard to understand.  I'd rather have
slightly-more-complex, deterministic code than simple code with an execution
trail that we won't be able to grok in three months. :)

My advice for this would probably be to have PostTask() for the prompt
dismissal, so that any future calls of the prompt also avoid re-entrant calling.
 It's about two more lines of code, and waives my concerns.

+      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());
+  CHECK(device_manager);
+  Respond(OneArgument(device_manager->GetApiDevicesFromList(devices).Pass()));
+}
+
 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());
+  EXTENSION_FUNCTION_VALIDATE(parameters);
 
   HidDeviceManager* device_manager = HidDeviceManager::Get(browser_context());
-  if (!device_manager) {
-    return RespondNow(Error(kErrorServiceUnavailable));
-  }
+  CHECK(device_manager);
 
   connection_manager_ =
       ApiResourceManager<HidConnectionResource>::Get(browser_context());
-  if (!connection_manager_) {
-    return RespondNow(Error(kErrorServiceUnavailable));
-  }
+  CHECK(connection_manager_);
 
   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));
-  }
+  CHECK(hid_service);
 
   hid_service->Connect(
       device_info->device_id(),
       base::Bind(&HidConnectFunction::OnConnectComplete, this));
   return RespondLater();
 }
 
 void HidConnectFunction::OnConnectComplete(
     scoped_refptr<HidConnection> connection) {
-  if (!connection.get()) {
+  if (!connection) {
     Respond(Error(kErrorFailedToOpenDevice));
     return;
   }
 
   DCHECK(connection_manager_);
   int connection_id = connection_manager_->Add(
       new HidConnectionResource(extension_id(), connection));
   Respond(OneArgument(PopulateHidConnection(connection_id, connection)));
 }
 
 HidDisconnectFunction::HidDisconnectFunction() {}
 
 HidDisconnectFunction::~HidDisconnectFunction() {}
 
 ExtensionFunction::ResponseAction HidDisconnectFunction::Run() {
   scoped_ptr<core_api::hid::Disconnect::Params> parameters =
       hid::Disconnect::Params::Create(*args_);
-  EXTENSION_FUNCTION_VALIDATE(parameters.get());
+  EXTENSION_FUNCTION_VALIDATE(parameters);
 
   ApiResourceManager<HidConnectionResource>* connection_manager =
       ApiResourceManager<HidConnectionResource>::Get(browser_context());
-  if (!connection_manager) {
-    return RespondNow(Error(kErrorServiceUnavailable));
-  }
+  CHECK(connection_manager);
 
   int connection_id = parameters->connection_id;
   HidConnectionResource* resource =
       connection_manager->Get(extension_id(), connection_id);
   if (!resource) {
     return RespondNow(Error(kErrorConnectionNotFound));
   }
 
   connection_manager->Remove(extension_id(), connection_id);
   return RespondNow(NoArguments());
 }
 
 HidConnectionIoFunction::HidConnectionIoFunction() {
 }
 
 HidConnectionIoFunction::~HidConnectionIoFunction() {
 }
 
 ExtensionFunction::ResponseAction HidConnectionIoFunction::Run() {
   if (!ValidateParameters()) {
     return RespondNow(Error(error_));
   }
 
   ApiResourceManager<HidConnectionResource>* connection_manager =
       ApiResourceManager<HidConnectionResource>::Get(browser_context());
-  if (!connection_manager) {
-    return RespondNow(Error(kErrorServiceUnavailable));
-  }
+  CHECK(connection_manager);
 
   HidConnectionResource* resource =
       connection_manager->Get(extension_id(), connection_id_);
   if (!resource) {
     return RespondNow(Error(kErrorConnectionNotFound));
   }
 
   StartWork(resource->connection().get());
   return RespondLater();
 }
 
 HidReceiveFunction::HidReceiveFunction() {}
 
 HidReceiveFunction::~HidReceiveFunction() {}
 
 bool HidReceiveFunction::ValidateParameters() {
   parameters_ = hid::Receive::Params::Create(*args_);
-  EXTENSION_FUNCTION_VALIDATE(parameters_.get());
+  EXTENSION_FUNCTION_VALIDATE(parameters_);
   set_connection_id(parameters_->connection_id);
   return true;
 }
 
 void HidReceiveFunction::StartWork(HidConnection* connection) {
   connection->Read(base::Bind(&HidReceiveFunction::OnFinished, this));
 }
 
 void HidReceiveFunction::OnFinished(bool success,
                                     scoped_refptr<net::IOBuffer> buffer,
                                     size_t size) {
   if (success) {
     DCHECK_GE(size, 1u);
     int report_id = reinterpret_cast<uint8_t*>(buffer->data())[0];
 
     Respond(TwoArguments(new base::FundamentalValue(report_id),
                          base::BinaryValue::CreateWithCopiedBuffer(
                              buffer->data() + 1, size - 1)));
   } else {
     Respond(Error(kErrorTransfer));
   }
 }
 
 HidSendFunction::HidSendFunction() {}
 
 HidSendFunction::~HidSendFunction() {}
 
 bool HidSendFunction::ValidateParameters() {
   parameters_ = hid::Send::Params::Create(*args_);
-  EXTENSION_FUNCTION_VALIDATE(parameters_.get());
+  EXTENSION_FUNCTION_VALIDATE(parameters_);
   set_connection_id(parameters_->connection_id);
   return true;
 }
 
 void HidSendFunction::StartWork(HidConnection* connection) {
   scoped_refptr<net::IOBufferWithSize> buffer(
       new net::IOBufferWithSize(parameters_->data.size() + 1));
   buffer->data()[0] = static_cast<uint8_t>(parameters_->report_id);
   memcpy(buffer->data() + 1, parameters_->data.data(),
          parameters_->data.size());
   connection->Write(buffer, buffer->size(),
                     base::Bind(&HidSendFunction::OnFinished, this));
 }
 
 void HidSendFunction::OnFinished(bool success) {
   if (success) {
     Respond(NoArguments());
   } else {
     Respond(Error(kErrorTransfer));
   }
 }
 
 HidReceiveFeatureReportFunction::HidReceiveFeatureReportFunction() {}
 
 HidReceiveFeatureReportFunction::~HidReceiveFeatureReportFunction() {}
 
 bool HidReceiveFeatureReportFunction::ValidateParameters() {
   parameters_ = hid::ReceiveFeatureReport::Params::Create(*args_);
-  EXTENSION_FUNCTION_VALIDATE(parameters_.get());
+  EXTENSION_FUNCTION_VALIDATE(parameters_);
   set_connection_id(parameters_->connection_id);
   return true;
 }
 
 void HidReceiveFeatureReportFunction::StartWork(HidConnection* connection) {
   connection->GetFeatureReport(
       static_cast<uint8_t>(parameters_->report_id),
       base::Bind(&HidReceiveFeatureReportFunction::OnFinished, this));
 }
 
 void HidReceiveFeatureReportFunction::OnFinished(
     bool success,
     scoped_refptr<net::IOBuffer> buffer,
     size_t size) {
   if (success) {
     Respond(OneArgument(
         base::BinaryValue::CreateWithCopiedBuffer(buffer->data(), size)));
   } else {
     Respond(Error(kErrorTransfer));
   }
 }
 
 HidSendFeatureReportFunction::HidSendFeatureReportFunction() {}
 
 HidSendFeatureReportFunction::~HidSendFeatureReportFunction() {}
 
 bool HidSendFeatureReportFunction::ValidateParameters() {
   parameters_ = hid::SendFeatureReport::Params::Create(*args_);
-  EXTENSION_FUNCTION_VALIDATE(parameters_.get());
+  EXTENSION_FUNCTION_VALIDATE(parameters_);
   set_connection_id(parameters_->connection_id);
   return true;
 }
 
 void HidSendFeatureReportFunction::StartWork(HidConnection* connection) {
   scoped_refptr<net::IOBufferWithSize> buffer(
       new net::IOBufferWithSize(parameters_->data.size() + 1));
   buffer->data()[0] = static_cast<uint8_t>(parameters_->report_id);
   memcpy(buffer->data() + 1, vector_as_array(&parameters_->data),
          parameters_->data.size());
   connection->SendFeatureReport(
       buffer, buffer->size(),
       base::Bind(&HidSendFeatureReportFunction::OnFinished, this));
 }
 
 void HidSendFeatureReportFunction::OnFinished(bool success) {
   if (success) {
     Respond(NoArguments());
   } else {
     Respond(Error(kErrorTransfer));
   }
 }
 
 }  // namespace extensions