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);
+
+  if (!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(
+      GetSenderWebContents());
+  CHECK(prompt_);

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

This has me a little concerned.  If the extension calls this from a web contents
that doesn't support modal dialogs, then this will fail.  I'm not sure how often
that can happen when it's also in a user gesture, but I wouldn't be surprised if
there are cases.  I'd probably feel better if we checked that the web contents
supported modal dialogs before creating and using a prompt (that might be better
placed in the prompt itself?  Or in CreateDevicePermissionsPrompt?)

WDYT?

[Reilly Grant (use Gerrit), 2015/05/07 20:53:39]

There's no check in this path for whether the web contents supports modal
dialogs. (CreateDevicePermissionsPrompt in Chrome just calls "new" so it will
never fail.) The problem will likely occur later when we call ShowDialog and it
gets to, for example, ShowWebModalDialogViews and discovers the issue.

[Devlin, 2015/05/07 21:02:43]

Yeah, that's my point - I think we'll just crash.  But we should never crash
because an extension api was called from a weird place. :)  So, in other words,
I think we should *add* a check somewhere along this path (either here, or in
the CreateDevicePermissionsPrompt would be my recommendations).

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