Add chrome.usb.getConfiguration and expose extra descriptors.

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/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 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 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;
@@ skipping 27 matching lines @@
 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 kErrorCannotListInterfaces[] = "Error listing interfaces.";
 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.";
 const char kErrorConvertRequestType[] = "Invalid request type.";
-const char kErrorConvertSynchronizationType[] = "Invalid synchronization type";
-const char kErrorConvertTransferType[] = "Invalid endpoint type.";
-const char kErrorConvertUsageType[] = "Invalid usage type.";
 const char kErrorMalformedParameters[] = "Error parsing parameters.";
 const char kErrorNoDevice[] = "No such device.";
 const char kErrorPermissionDenied[] = "Permission to access device was denied";
 const char kErrorInvalidTransferLength[] =
     "Transfer length must be a positive number less than 104,857,600.";
 const char kErrorInvalidNumberOfPackets[] =
     "Number of packets must be a positive number less than 4,194,304.";
 const char kErrorInvalidPacketLength[] =
     "Packet length must be a positive number less than 65,536.";
 const char kErrorResetDevice[] =
     "Error resetting the device. The device has been closed.";
 
 const size_t kMaxTransferLength = 100 * 1024 * 1024;
 const int kMaxPackets = 4 * 1024 * 1024;
 const int kMaxPacketLength = 64 * 1024;
 
-bool ConvertDirectionToApi(const UsbEndpointDirection& input,
-                           Direction* output) {
-  switch (input) {
-    case device::USB_DIRECTION_INBOUND:
-      *output = usb::DIRECTION_IN;
-      return true;
-    case device::USB_DIRECTION_OUTBOUND:
-      *output = usb::DIRECTION_OUT;
-      return true;
-    default:
-      NOTREACHED();
-      return false;
-  }
-}
-
-bool ConvertSynchronizationTypeToApi(const UsbSynchronizationType& input,
-                                     usb::SynchronizationType* output) {
-  switch (input) {
-    case device::USB_SYNCHRONIZATION_NONE:
-      *output = usb::SYNCHRONIZATION_TYPE_NONE;
-      return true;
-    case device::USB_SYNCHRONIZATION_ASYNCHRONOUS:
-      *output = usb::SYNCHRONIZATION_TYPE_ASYNCHRONOUS;
-      return true;
-    case device::USB_SYNCHRONIZATION_ADAPTIVE:
-      *output = usb::SYNCHRONIZATION_TYPE_ADAPTIVE;
-      return true;
-    case device::USB_SYNCHRONIZATION_SYNCHRONOUS:
-      *output = usb::SYNCHRONIZATION_TYPE_SYNCHRONOUS;
-      return true;
-    default:
-      NOTREACHED();
-      return false;
-  }
-}
-
-bool ConvertTransferTypeToApi(const UsbTransferType& input,
-                              usb::TransferType* output) {
-  switch (input) {
-    case device::USB_TRANSFER_CONTROL:
-      *output = usb::TRANSFER_TYPE_CONTROL;
-      return true;
-    case device::USB_TRANSFER_INTERRUPT:
-      *output = usb::TRANSFER_TYPE_INTERRUPT;
-      return true;
-    case device::USB_TRANSFER_ISOCHRONOUS:
-      *output = usb::TRANSFER_TYPE_ISOCHRONOUS;
-      return true;
-    case device::USB_TRANSFER_BULK:
-      *output = usb::TRANSFER_TYPE_BULK;
-      return true;
-    default:
-      NOTREACHED();
-      return false;
-  }
-}
-
-bool ConvertUsageTypeToApi(const UsbUsageType& input, usb::UsageType* output) {
-  switch (input) {
-    case device::USB_USAGE_DATA:
-      *output = usb::USAGE_TYPE_DATA;
-      return true;
-    case device::USB_USAGE_FEEDBACK:
-      *output = usb::USAGE_TYPE_FEEDBACK;
-      return true;
-    case device::USB_USAGE_EXPLICIT_FEEDBACK:
-      *output = usb::USAGE_TYPE_EXPLICITFEEDBACK;
-      return true;
-    default:
-      NOTREACHED();
-      return false;
-  }
-}
-
-bool ConvertDirection(const Direction& input, UsbEndpointDirection* output) {
+bool ConvertDirectionFromApi(const Direction& input,
+                             UsbEndpointDirection* output) {
   switch (input) {
     case usb::DIRECTION_IN:
       *output = device::USB_DIRECTION_INBOUND;
       return true;
     case usb::DIRECTION_OUT:
       *output = device::USB_DIRECTION_OUTBOUND;
       return true;
     default:
       NOTREACHED();
       return false;
   }
 }
 
-bool ConvertRequestType(const RequestType& input,
-                        UsbDeviceHandle::TransferRequestType* output) {
+bool ConvertRequestTypeFromApi(const RequestType& input,
+                               UsbDeviceHandle::TransferRequestType* output) {
   switch (input) {
     case usb::REQUEST_TYPE_STANDARD:
       *output = UsbDeviceHandle::STANDARD;
       return true;
     case usb::REQUEST_TYPE_CLASS:
       *output = UsbDeviceHandle::CLASS;
       return true;
     case usb::REQUEST_TYPE_VENDOR:
       *output = UsbDeviceHandle::VENDOR;
       return true;
     case usb::REQUEST_TYPE_RESERVED:
       *output = UsbDeviceHandle::RESERVED;
       return true;
     default:
       NOTREACHED();
       return false;
   }
 }
 
-bool ConvertRecipient(const Recipient& input,
-                      UsbDeviceHandle::TransferRecipient* output) {
+bool ConvertRecipientFromApi(const Recipient& input,
+                             UsbDeviceHandle::TransferRecipient* output) {
   switch (input) {
     case usb::RECIPIENT_DEVICE:
       *output = UsbDeviceHandle::DEVICE;
       return true;
     case usb::RECIPIENT_INTERFACE:
       *output = UsbDeviceHandle::INTERFACE;
       return true;
     case usb::RECIPIENT_ENDPOINT:
       *output = UsbDeviceHandle::ENDPOINT;
       return true;
@@ skipping 43 matching lines @@
   } else if (direction == device::USB_DIRECTION_OUTBOUND) {
     if (input.data.get() && size <= input.data->size()) {
       memcpy(buffer->data(), input.data->data(), size);
       return buffer;
     }
   }
   NOTREACHED();
   return NULL;
 }
 
-const char* ConvertTransferStatusToErrorString(const UsbTransferStatus status) {
+const char* ConvertTransferStatusToApi(const UsbTransferStatus status) {
   switch (status) {
     case device::USB_TRANSFER_COMPLETED:
       return "";
     case device::USB_TRANSFER_ERROR:
       return kErrorGeneric;
     case device::USB_TRANSFER_TIMEOUT:
       return kErrorTimeout;
     case device::USB_TRANSFER_CANCELLED:
       return kErrorCancelled;
     case device::USB_TRANSFER_STALLED:
@@ skipping 73 matching lines @@
 }
 
 base::Value* PopulateDevice(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();
 }
 
-base::Value* PopulateInterfaceDescriptor(
-    int interface_number,
-    int alternate_setting,
-    int interface_class,
-    int interface_subclass,
-    int interface_protocol,
-    std::vector<linked_ptr<EndpointDescriptor> >* endpoints) {
-  InterfaceDescriptor descriptor;
-  descriptor.interface_number = interface_number;
-  descriptor.alternate_setting = alternate_setting;
-  descriptor.interface_class = interface_class;
-  descriptor.interface_subclass = interface_subclass;
-  descriptor.interface_protocol = interface_protocol;
-  descriptor.endpoints = *endpoints;
-  return descriptor.ToValue().release();
+TransferType ConvertTransferTypeToApi(const UsbTransferType& input) {
+  switch (input) {
+    case device::USB_TRANSFER_CONTROL:
+      return usb::TRANSFER_TYPE_CONTROL;
+    case device::USB_TRANSFER_INTERRUPT:
+      return usb::TRANSFER_TYPE_INTERRUPT;
+    case device::USB_TRANSFER_ISOCHRONOUS:
+      return usb::TRANSFER_TYPE_ISOCHRONOUS;
+    case device::USB_TRANSFER_BULK:
+      return usb::TRANSFER_TYPE_BULK;
+    default:
+      NOTREACHED();
+      return usb::TRANSFER_TYPE_NONE;
+  }
+}
+
+Direction ConvertDirectionToApi(const UsbEndpointDirection& input) {
+  switch (input) {
+    case device::USB_DIRECTION_INBOUND:
+      return usb::DIRECTION_IN;
+    case device::USB_DIRECTION_OUTBOUND:
+      return usb::DIRECTION_OUT;
+    default:
+      NOTREACHED();
+      return usb::DIRECTION_NONE;
+  }
+}
+
+SynchronizationType ConvertSynchronizationTypeToApi(
+    const UsbSynchronizationType& input) {
+  switch (input) {
+    case device::USB_SYNCHRONIZATION_NONE:
+      return usb::SYNCHRONIZATION_TYPE_NONE;
+    case device::USB_SYNCHRONIZATION_ASYNCHRONOUS:
+      return usb::SYNCHRONIZATION_TYPE_ASYNCHRONOUS;
+    case device::USB_SYNCHRONIZATION_ADAPTIVE:
+      return usb::SYNCHRONIZATION_TYPE_ADAPTIVE;
+    case device::USB_SYNCHRONIZATION_SYNCHRONOUS:
+      return usb::SYNCHRONIZATION_TYPE_SYNCHRONOUS;
+    default:
+      NOTREACHED();
+      return usb::SYNCHRONIZATION_TYPE_NONE;
+  }
+}
+
+UsageType ConvertUsageTypeToApi(const UsbUsageType& input) {
+  switch (input) {
+    case device::USB_USAGE_DATA:
+      return usb::USAGE_TYPE_DATA;
+    case device::USB_USAGE_FEEDBACK:
+      return usb::USAGE_TYPE_FEEDBACK;
+    case device::USB_USAGE_EXPLICIT_FEEDBACK:
+      return usb::USAGE_TYPE_EXPLICITFEEDBACK;
+    default:
+      NOTREACHED();
+      return usb::USAGE_TYPE_NONE;
+  }
+}
+
+void ConvertEndpointDescriptor(const UsbEndpointDescriptor& input,
+                               EndpointDescriptor* output) {
+  output->address = input.address;
+  output->type = ConvertTransferTypeToApi(input.transfer_type);
+  output->direction = ConvertDirectionToApi(input.direction);
+  output->maximum_packet_size = input.maximum_packet_size;
+  output->synchronization =
+      ConvertSynchronizationTypeToApi(input.synchronization_type);
+  output->usage = ConvertUsageTypeToApi(input.usage_type);
+  output->polling_interval.reset(new int(input.polling_interval));
+  if (input.extra_data.size() > 0) {
+    output->extra_data =
+        std::string(reinterpret_cast<const char*>(&input.extra_data[0]),
+                    input.extra_data.size());
+  }
+}
+
+void ConvertInterfaceDescriptor(const UsbInterfaceDescriptor& input,
+                                InterfaceDescriptor* output) {
+  output->interface_number = input.interface_number;
+  output->alternate_setting = input.alternate_setting;
+  output->interface_class = input.interface_class;
+  output->interface_subclass = input.interface_subclass;
+  output->interface_protocol = input.interface_protocol;
+  for (UsbEndpointDescriptor::Iterator endpointIt = input.endpoints.begin();
+       endpointIt != input.endpoints.end();
+       ++endpointIt) {
+    linked_ptr<EndpointDescriptor> endpoint(new EndpointDescriptor);
+    ConvertEndpointDescriptor(*endpointIt, endpoint.get());
+    output->endpoints.push_back(endpoint);
+  }
+  if (input.extra_data.size() > 0) {
+    output->extra_data =
+        std::string(reinterpret_cast<const char*>(&input.extra_data[0]),
+                    input.extra_data.size());
+  }
+}
+
+void ConvertConfigDescriptor(const UsbConfigDescriptor& input,
+                             ConfigDescriptor* output) {
+  output->configuration_value = input.configuration_value;
+  output->self_powered = input.self_powered;
+  output->remote_wakeup = input.remote_wakeup;
+  output->max_power = input.maximum_power;
+  for (UsbInterfaceDescriptor::Iterator interfaceIt = input.interfaces.begin();
+       interfaceIt != input.interfaces.end();
+       ++interfaceIt) {
+    linked_ptr<InterfaceDescriptor> interface(new InterfaceDescriptor);
+    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());
+  }
 }
 
 }  // namespace
 
 namespace extensions {
 
 UsbAsyncApiFunction::UsbAsyncApiFunction() : manager_(NULL) {
 }
 
 UsbAsyncApiFunction::~UsbAsyncApiFunction() {
@@ skipping 101 matching lines @@
 UsbAsyncApiTransferFunction::UsbAsyncApiTransferFunction() {
 }
 
 UsbAsyncApiTransferFunction::~UsbAsyncApiTransferFunction() {
 }
 
 void UsbAsyncApiTransferFunction::OnCompleted(UsbTransferStatus status,
                                               scoped_refptr<net::IOBuffer> data,
                                               size_t length) {
   if (status != device::USB_TRANSFER_COMPLETED)
-    SetError(ConvertTransferStatusToErrorString(status));
+    SetError(ConvertTransferStatusToApi(status));
 
   SetResult(CreateTransferInfo(status, data, length));
   AsyncWorkCompleted();
 }
 
 bool UsbAsyncApiTransferFunction::ConvertDirectionSafely(
     const Direction& input,
     UsbEndpointDirection* output) {
-  const bool converted = ConvertDirection(input, output);
+  const bool converted = ConvertDirectionFromApi(input, output);
   if (!converted)
     SetError(kErrorConvertDirection);
   return converted;
 }
 
 bool UsbAsyncApiTransferFunction::ConvertRequestTypeSafely(
     const RequestType& input,
     UsbDeviceHandle::TransferRequestType* output) {
-  const bool converted = ConvertRequestType(input, output);
+  const bool converted = ConvertRequestTypeFromApi(input, output);
   if (!converted)
     SetError(kErrorConvertRequestType);
   return converted;
 }
 
 bool UsbAsyncApiTransferFunction::ConvertRecipientSafely(
     const Recipient& input,
     UsbDeviceHandle::TransferRecipient* output) {
-  const bool converted = ConvertRecipient(input, output);
+  const bool converted = ConvertRecipientFromApi(input, output);
   if (!converted)
     SetError(kErrorConvertRecipient);
   return converted;
 }
 
 UsbFindDevicesFunction::UsbFindDevicesFunction() {
 }
 
 UsbFindDevicesFunction::~UsbFindDevicesFunction() {
 }
@@ skipping 178 matching lines @@
     return;
   }
 
   SetResult(PopulateConnectionHandle(
       manager_->Add(new UsbDeviceResource(extension_->id(), handle_)),
       handle_->GetDevice()->vendor_id(),
       handle_->GetDevice()->product_id()));
   AsyncWorkCompleted();
 }
 
+UsbGetConfigurationFunction::UsbGetConfigurationFunction() {
+}
+
+UsbGetConfigurationFunction::~UsbGetConfigurationFunction() {
+}
+
+bool UsbGetConfigurationFunction::Prepare() {
+  parameters_ = GetConfiguration::Params::Create(*args_);
+  EXTENSION_FUNCTION_VALIDATE(parameters_.get());
+  return true;
+}
+
+void UsbGetConfigurationFunction::AsyncWorkStart() {
+  scoped_refptr<UsbDeviceHandle> device_handle =
+      GetDeviceHandleOrCompleteWithError(parameters_->handle);
+  if (!device_handle.get()) {
+    return;
+  }
+
+  ConfigDescriptor config;
+  ConvertConfigDescriptor(device_handle->GetDevice()->GetConfiguration(),
+                          &config);
+
+  SetResult(config.ToValue().release());
+  AsyncWorkCompleted();
+}
+
 UsbListInterfacesFunction::UsbListInterfacesFunction() {
 }
 
 UsbListInterfacesFunction::~UsbListInterfacesFunction() {
 }
 
 bool UsbListInterfacesFunction::Prepare() {
   parameters_ = ListInterfaces::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(parameters_.get());
   return true;
 }
 
 void UsbListInterfacesFunction::AsyncWorkStart() {
   scoped_refptr<UsbDeviceHandle> device_handle =
       GetDeviceHandleOrCompleteWithError(parameters_->handle);
-  if (!device_handle.get())
+  if (!device_handle.get()) {
     return;
+  }
 
-  const UsbConfigDescriptor& config =
-      device_handle->GetDevice()->GetConfiguration();
+  ConfigDescriptor config;
+  ConvertConfigDescriptor(device_handle->GetDevice()->GetConfiguration(),
+                          &config);
 
-  scoped_ptr<base::ListValue> result(new base::ListValue());
-
-  for (UsbInterfaceDescriptor::Iterator interfaceIt = config.interfaces.begin();
-       interfaceIt != config.interfaces.end();
-       ++interfaceIt) {
-    std::vector<linked_ptr<EndpointDescriptor> > endpoints;
-
-    for (UsbEndpointDescriptor::Iterator endpointIt =
-             interfaceIt->endpoints.begin();
-         endpointIt != interfaceIt->endpoints.end();
-         ++endpointIt) {
-      linked_ptr<EndpointDescriptor> endpoint_desc(new EndpointDescriptor());
-
-      TransferType type;
-      Direction direction;
-      SynchronizationType synchronization;
-      UsageType usage;
-
-      if (!ConvertTransferTypeSafely(endpointIt->transfer_type, &type) ||
-          !ConvertDirectionSafely(endpointIt->direction, &direction) ||
-          !ConvertSynchronizationTypeSafely(endpointIt->synchronization_type,
-                                            &synchronization) ||
-          !ConvertUsageTypeSafely(endpointIt->usage_type, &usage)) {
-        SetError(kErrorCannotListInterfaces);
-        AsyncWorkCompleted();
-        return;
-      }
-
-      endpoint_desc->address = endpointIt->address;
-      endpoint_desc->type = type;
-      endpoint_desc->direction = direction;
-      endpoint_desc->maximum_packet_size = endpointIt->maximum_packet_size;
-      endpoint_desc->synchronization = synchronization;
-      endpoint_desc->usage = usage;
-      endpoint_desc->polling_interval.reset(
-          new int(endpointIt->polling_interval));
-
-      endpoints.push_back(endpoint_desc);
-    }
-
-    result->Append(PopulateInterfaceDescriptor(interfaceIt->interface_number,
-                                               interfaceIt->alternate_setting,
-                                               interfaceIt->interface_class,
-                                               interfaceIt->interface_subclass,
-                                               interfaceIt->interface_protocol,
-                                               &endpoints));
+  scoped_ptr<base::ListValue> result(new base::ListValue);
+  for (size_t i = 0; i < config.interfaces.size(); ++i) {
+    result->Append(config.interfaces[i]->ToValue().release());
   }
 
   SetResult(result.release());
   AsyncWorkCompleted();
 }
 
-bool UsbListInterfacesFunction::ConvertDirectionSafely(
-    const UsbEndpointDirection& input,
-    usb::Direction* output) {
-  const bool converted = ConvertDirectionToApi(input, output);
-  if (!converted)
-    SetError(kErrorConvertDirection);
-  return converted;
-}
-
-bool UsbListInterfacesFunction::ConvertSynchronizationTypeSafely(
-    const UsbSynchronizationType& input,
-    usb::SynchronizationType* output) {
-  const bool converted = ConvertSynchronizationTypeToApi(input, output);
-  if (!converted)
-    SetError(kErrorConvertSynchronizationType);
-  return converted;
-}
-
-bool UsbListInterfacesFunction::ConvertTransferTypeSafely(
-    const UsbTransferType& input,
-    usb::TransferType* output) {
-  const bool converted = ConvertTransferTypeToApi(input, output);
-  if (!converted)
-    SetError(kErrorConvertTransferType);
-  return converted;
-}
-
-bool UsbListInterfacesFunction::ConvertUsageTypeSafely(
-    const UsbUsageType& input,
-    usb::UsageType* output) {
-  const bool converted = ConvertUsageTypeToApi(input, output);
-  if (!converted)
-    SetError(kErrorConvertUsageType);
-  return converted;
-}
-
 UsbCloseDeviceFunction::UsbCloseDeviceFunction() {
 }
 
 UsbCloseDeviceFunction::~UsbCloseDeviceFunction() {
 }
 
 bool UsbCloseDeviceFunction::Prepare() {
   parameters_ = CloseDevice::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(parameters_.get());
   return true;
@@ skipping 334 matching lines @@
     SetResult(new base::FundamentalValue(false));
     CompleteWithError(kErrorResetDevice);
     return;
   }
 
   SetResult(new base::FundamentalValue(true));
   AsyncWorkCompleted();
 }
 
 }  // namespace extensions