Add getUserSelectedDevices to the USB extensions API.

extensions/browser/api/usb/usb_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/usb/usb_api.h"
 
 #include <string>
 #include <vector>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "device/core/device_client.h"
 #include "device/usb/usb_device_handle.h"
 #include "device/usb/usb_service.h"
+#include "extensions/browser/api/device_permissions_manager.h"
+#include "extensions/browser/api/device_permissions_prompt.h"
+#include "extensions/browser/api/extensions_api_client.h"
 #include "extensions/browser/api/usb/usb_device_resource.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/common/api/usb.h"
 #include "extensions/common/permissions/permissions_data.h"
 #include "extensions/common/permissions/usb_device_permission.h"
 
 namespace usb = extensions::core_api::usb;
 namespace BulkTransfer = usb::BulkTransfer;
 namespace ClaimInterface = usb::ClaimInterface;
 namespace CloseDevice = usb::CloseDevice;
 namespace ControlTransfer = usb::ControlTransfer;
 namespace FindDevices = usb::FindDevices;
 namespace GetDevices = usb::GetDevices;
+namespace GetUserSelectedDevices = usb::GetUserSelectedDevices;
 namespace InterruptTransfer = usb::InterruptTransfer;
 namespace IsochronousTransfer = usb::IsochronousTransfer;
 namespace GetConfiguration = usb::GetConfiguration;
 namespace ListInterfaces = usb::ListInterfaces;
 namespace OpenDevice = usb::OpenDevice;
 namespace ReleaseInterface = usb::ReleaseInterface;
 namespace RequestAccess = usb::RequestAccess;
 namespace ResetDevice = usb::ResetDevice;
 namespace SetInterfaceAlternateSetting = usb::SetInterfaceAlternateSetting;
 
 using content::BrowserThread;
+using device::UsbConfigDescriptor;
+using device::UsbDevice;
+using device::UsbDeviceFilter;
+using device::UsbDeviceHandle;
+using device::UsbEndpointDescriptor;
+using device::UsbEndpointDirection;
+using device::UsbInterfaceDescriptor;
+using device::UsbService;
+using device::UsbSynchronizationType;
+using device::UsbTransferStatus;
+using device::UsbTransferType;
+using device::UsbUsageType;
+using std::string;
+using std::vector;
 using usb::ConfigDescriptor;
 using usb::ControlTransferInfo;
 using usb::ConnectionHandle;
 using usb::Device;
 using usb::Direction;
 using usb::EndpointDescriptor;
 using usb::GenericTransferInfo;
 using usb::InterfaceDescriptor;
 using usb::IsochronousTransferInfo;
 using usb::Recipient;
 using usb::RequestType;
 using usb::SynchronizationType;
 using usb::TransferType;
 using usb::UsageType;
-using device::UsbConfigDescriptor;
-using device::UsbDevice;
-using device::UsbDeviceFilter;
-using device::UsbDeviceHandle;
-using device::UsbEndpointDescriptor;
-using device::UsbEndpointDirection;
-using device::UsbInterfaceDescriptor;
-using device::UsbService;
-using device::UsbSynchronizationType;
-using device::UsbTransferStatus;
-using device::UsbTransferType;
-using device::UsbUsageType;
 
 typedef std::vector<scoped_refptr<UsbDevice> > DeviceVector;
 typedef scoped_ptr<DeviceVector> ScopedDeviceVector;
 
 namespace {
 
 const char kDataKey[] = "data";
 const char kResultCodeKey[] = "resultCode";
 
 const char kErrorInitService[] = "Failed to initialize USB service.";
 
 const char kErrorOpen[] = "Failed to open device.";
 const char kErrorCancelled[] = "Transfer was cancelled.";
 const char kErrorDisconnect[] = "Device disconnected.";
 const char kErrorGeneric[] = "Transfer failed.";
-#if !defined(OS_CHROMEOS)
 const char kErrorNotSupported[] = "Not supported on this platform.";
-#endif
 const char kErrorOverflow[] = "Inbound transfer overflow.";
 const char kErrorStalled[] = "Transfer stalled.";
 const char kErrorTimeout[] = "Transfer timed out.";
 const char kErrorTransferLength[] = "Transfer length is insufficient.";
 const char kErrorCannotClaimInterface[] = "Error claiming interface.";
 const char kErrorCannotReleaseInterface[] = "Error releasing interface.";
 const char kErrorCannotSetInterfaceAlternateSetting[] =
     "Error setting alternate interface setting.";
 const char kErrorConvertDirection[] = "Invalid transfer direction.";
 const char kErrorConvertRecipient[] = "Invalid transfer recipient.";
@@ skipping 194 matching lines @@
 base::Value* PopulateConnectionHandle(int handle,
                                       int vendor_id,
                                       int product_id) {
   ConnectionHandle result;
   result.handle = handle;
   result.vendor_id = vendor_id;
   result.product_id = product_id;
   return result.ToValue().release();
 }
 
-base::Value* PopulateDevice(UsbDevice* device) {
+base::Value* PopulateDevice(const UsbDevice* device) {
   Device result;
   result.device = device->unique_id();
   result.vendor_id = device->vendor_id();
   result.product_id = device->product_id();
   return result.ToValue().release();
 }
 
 TransferType ConvertTransferTypeToApi(const UsbTransferType& input) {
   switch (input) {
     case device::USB_TRANSFER_CONTROL:
@@ skipping 104 matching lines @@
     ConvertInterfaceDescriptor(*interfaceIt, interface.get());
     output->interfaces.push_back(interface);
   }
   if (input.extra_data.size() > 0) {
     output->extra_data =
         std::string(reinterpret_cast<const char*>(&input.extra_data[0]),
                     input.extra_data.size());
   }
 }
 
+void ConvertDeviceFilter(const usb::DeviceFilter& input,
+                         UsbDeviceFilter* output) {
+  if (input.vendor_id) {
+    output->SetVendorId(*input.vendor_id);
+  }
+  if (input.product_id) {
+    output->SetProductId(*input.product_id);
+  }
+  if (input.interface_class) {
+    output->SetInterfaceClass(*input.interface_class);
+  }
+  if (input.interface_subclass) {
+    output->SetInterfaceSubclass(*input.interface_subclass);
+  }
+  if (input.interface_protocol) {
+    output->SetInterfaceProtocol(*input.interface_protocol);
+  }
+}
+
 }  // namespace
 
 namespace extensions {
 
 UsbAsyncApiFunction::UsbAsyncApiFunction() : manager_(NULL) {
 }
 
 UsbAsyncApiFunction::~UsbAsyncApiFunction() {
 }
 
 bool UsbAsyncApiFunction::PrePrepare() {
   manager_ = ApiResourceManager<UsbDeviceResource>::Get(browser_context());
   set_work_thread_id(BrowserThread::FILE);
   return manager_ != NULL;
 }
 
 bool UsbAsyncApiFunction::Respond() {
   return error_.empty();
 }
 
-// static
-void UsbAsyncApiFunction::CreateDeviceFilter(const usb::DeviceFilter& input,
-                                             UsbDeviceFilter* output) {
-  if (input.vendor_id) {
-    output->SetVendorId(*input.vendor_id);
-  }
-  if (input.product_id) {
-    output->SetProductId(*input.product_id);
-  }
-  if (input.interface_class) {
-    output->SetInterfaceClass(*input.interface_class);
-  }
-  if (input.interface_subclass) {
-    output->SetInterfaceSubclass(*input.interface_subclass);
-  }
-  if (input.interface_protocol) {
-    output->SetInterfaceProtocol(*input.interface_protocol);
-  }
-}
-
 bool UsbAsyncApiFunction::HasDevicePermission(scoped_refptr<UsbDevice> device) {
   UsbDevicePermission::CheckParam param(
       device->vendor_id(),
       device->product_id(),
       UsbDevicePermissionData::UNSPECIFIED_INTERFACE);
-  return extension()->permissions_data()->CheckAPIPermissionWithParam(
-      APIPermission::kUsbDevice, &param);
+  if (extension()->permissions_data()->CheckAPIPermissionWithParam(
+          APIPermission::kUsbDevice, &param)) {
+    return true;
+  }
+
+  if (device_permissions_.get()) {
+    return device_permissions_->CheckUsbDevice(device);
+  }
+
+  return false;
 }
 
 scoped_refptr<UsbDevice> UsbAsyncApiFunction::GetDeviceOrCompleteWithError(
     const Device& input_device) {
   UsbService* service = device::DeviceClient::Get()->GetUsbService();
   if (!service) {
     CompleteWithError(kErrorInitService);
     return NULL;
   }
 
@@ skipping 171 matching lines @@
 
 UsbGetDevicesFunction::UsbGetDevicesFunction() {
 }
 
 UsbGetDevicesFunction::~UsbGetDevicesFunction() {
 }
 
 bool UsbGetDevicesFunction::Prepare() {
   parameters_ = GetDevices::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(parameters_.get());
+  device_permissions_ = DevicePermissionsManager::Get(browser_context())
+                            ->GetForExtension(extension()->id());
   return true;
 }
 
 void UsbGetDevicesFunction::AsyncWorkStart() {
   std::vector<UsbDeviceFilter> filters;
   if (parameters_->options.filters) {
     filters.resize(parameters_->options.filters->size());
     for (size_t i = 0; i < parameters_->options.filters->size(); ++i) {
-      CreateDeviceFilter(*parameters_->options.filters->at(i).get(),
-                         &filters[i]);
+      ConvertDeviceFilter(*parameters_->options.filters->at(i).get(),
+                          &filters[i]);
     }
   }
   if (parameters_->options.vendor_id) {
     filters.resize(filters.size() + 1);
     filters.back().SetVendorId(*parameters_->options.vendor_id);
     if (parameters_->options.product_id) {
       filters.back().SetProductId(*parameters_->options.product_id);
     }
   }
 
@@ skipping 12 matching lines @@
     if ((filters.empty() || UsbDeviceFilter::MatchesAny(device, filters)) &&
         HasDevicePermission(device)) {
       result->Append(PopulateDevice(it->get()));
     }
   }
 
   SetResult(result.release());
   AsyncWorkCompleted();
 }
 
+UsbGetUserSelectedDevicesFunction::UsbGetUserSelectedDevicesFunction() {
+}
+
+UsbGetUserSelectedDevicesFunction::~UsbGetUserSelectedDevicesFunction() {
+}
+
+AsyncApiFunction::ResponseAction UsbGetUserSelectedDevicesFunction::Run() {
+  scoped_ptr<extensions::core_api::usb::GetUserSelectedDevices::Params>
+      parameters = GetUserSelectedDevices::Params::Create(*args_);
+  EXTENSION_FUNCTION_VALIDATE(parameters.get());
+
+  if (!user_gesture()) {
+    return RespondNow(OneArgument(new base::ListValue()));
+  }
+
+  bool multiple = false;
+  if (parameters->options.multiple) {
+    multiple = *parameters->options.multiple;
+  }
+
+  std::vector<UsbDeviceFilter> filters;
+  if (parameters->options.filters) {
+    filters.resize(parameters->options.filters->size());
+    for (size_t i = 0; i < parameters->options.filters->size(); ++i) {
+      ConvertDeviceFilter(*parameters->options.filters->at(i).get(),
+                          &filters[i]);
+    }
+  }
+
+  prompt_ = ExtensionsAPIClient::Get()->CreateDevicePermissionsPrompt(
+      GetAssociatedWebContents());
+  if (!prompt_) {
+    return RespondNow(Error(kErrorNotSupported));
+  }
+
+  AddRef();
+  prompt_->AskForUsbDevices(
+      this, extension(), browser_context(), multiple, filters);
+  return RespondLater();
+}
+
+void UsbGetUserSelectedDevicesFunction::OnUsbDevicesChosen(
+    const std::vector<scoped_refptr<UsbDevice>>& devices) {
+  scoped_ptr<base::ListValue> result(new base::ListValue());
+  for (const auto& device : devices) {
+    result->Append(PopulateDevice(device.get()));
+  }
+
+  SetResult(result.release());
+  SendResponse(true);
+  Release();
+}
+
 UsbRequestAccessFunction::UsbRequestAccessFunction() {
 }
 
 UsbRequestAccessFunction::~UsbRequestAccessFunction() {
 }
 
 bool UsbRequestAccessFunction::Prepare() {
   parameters_ = RequestAccess::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(parameters_.get());
+  device_permissions_ = DevicePermissionsManager::Get(browser_context())
+                            ->GetForExtension(extension()->id());
   return true;
 }
 
 void UsbRequestAccessFunction::AsyncWorkStart() {
 #if defined(OS_CHROMEOS)
   scoped_refptr<UsbDevice> device =
       GetDeviceOrCompleteWithError(parameters_->device);
   if (!device.get())
     return;
 
@@ skipping 13 matching lines @@
 
 UsbOpenDeviceFunction::UsbOpenDeviceFunction() {
 }
 
 UsbOpenDeviceFunction::~UsbOpenDeviceFunction() {
 }
 
 bool UsbOpenDeviceFunction::Prepare() {
   parameters_ = OpenDevice::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(parameters_.get());
+  device_permissions_ = DevicePermissionsManager::Get(browser_context())
+                            ->GetForExtension(extension()->id());
   return true;
 }
 
 void UsbOpenDeviceFunction::AsyncWorkStart() {
   scoped_refptr<UsbDevice> device =
       GetDeviceOrCompleteWithError(parameters_->device);
   if (!device.get())
     return;
 
   handle_ = device->Open();
@@ skipping 416 matching lines @@
     SetResult(new base::FundamentalValue(false));
     CompleteWithError(kErrorResetDevice);
     return;
   }
 
   SetResult(new base::FundamentalValue(true));
   AsyncWorkCompleted();
 }
 
 }  // namespace extensions