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 33 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));
   }
 
   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) {
@@ skipping 13 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() {
+  scoped_ptr<core_api::hid::GetUserSelectedDevices::Params> parameters =
+      hid::GetUserSelectedDevices::Params::Create(*args_);
+  EXTENSION_FUNCTION_VALIDATE(parameters);
+
+  device_manager_ = HidDeviceManager::Get(browser_context());
+  if (!device_manager_) {
+    return RespondNow(Error(kErrorServiceUnavailable));
+  }
+
+  if (!user_gesture()) {
+    return RespondNow(OneArgument(new base::ListValue()));

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

This looks like it should be an error, not an empty result.

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

The documented behavior is that this returns an empty result when there is not a
user gesture.

[Devlin, 2015/05/07 20:43:55]

Oh, odd.  In other places (e.g., the management api), we return an extension
error so that the developer knows what happened - which I think makes more
sense.  But, that's just me.  I'll leave it to the API owners.

+  }
+
+  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(
+      GetSenderWebContents());
+  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) {
+  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));
   }
 
   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(),
       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));
   }
 
   int connection_id = parameters->connection_id;
   HidConnectionResource* resource =
       connection_manager->Get(extension_id(), connection_id);
@@ skipping 31 matching lines @@
   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