Add support for sending a USB SET_CONFIGURATION request.

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"
@@ skipping 13 matching lines @@
 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 SetConfiguration = usb::SetConfiguration;
 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;
@@ skipping 33 matching lines @@
 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.";
 const char kErrorNotSupported[] = "Not supported on this platform.";
+const char kErrorNotConfigured[] = "The device is not in a configured state.";
 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 kErrorCannotSetConfiguration[] =
+    "Error setting device configuration.";
 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 kErrorMalformedParameters[] = "Error parsing parameters.";
 const char kErrorNoDevice[] = "No such device.";
 const char kErrorPermissionDenied[] = "Permission to access device was denied";
@@ skipping 281 matching lines @@
   }
 }
 
 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) {
+  for (const UsbEndpointDescriptor& input_endpoint : input.endpoints) {
     linked_ptr<EndpointDescriptor> endpoint(new EndpointDescriptor);
-    ConvertEndpointDescriptor(*endpointIt, endpoint.get());
+    ConvertEndpointDescriptor(input_endpoint, 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) {
+  for (const UsbInterfaceDescriptor& input_interface : input.interfaces) {
     linked_ptr<InterfaceDescriptor> interface(new InterfaceDescriptor);
-    ConvertInterfaceDescriptor(*interfaceIt, interface.get());
+    ConvertInterfaceDescriptor(input_interface, 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,
@@ skipping 402 matching lines @@
 }
 
 bool UsbOpenDeviceFunction::Respond() {
   if (permission_entry_.get()) {
     device_permissions_manager_->UpdateLastUsed(extension_->id(),
                                                 permission_entry_);
   }
   return UsbAsyncApiFunction::Respond();
 }
 
+UsbSetConfigurationFunction::UsbSetConfigurationFunction() {
+}
+
+UsbSetConfigurationFunction::~UsbSetConfigurationFunction() {
+}
+
+bool UsbSetConfigurationFunction::Prepare() {
+  parameters_ = SetConfiguration::Params::Create(*args_);
+  EXTENSION_FUNCTION_VALIDATE(parameters_.get());
+  return true;
+}
+
+void UsbSetConfigurationFunction::AsyncWorkStart() {
+  scoped_refptr<UsbDeviceHandle> device_handle =
+      GetDeviceHandleOrCompleteWithError(parameters_->handle);
+  if (!device_handle.get()) {
+    return;
+  }
+
+  if (device_handle->SetConfiguration(parameters_->configuration_value)) {
+    SetResult(new base::FundamentalValue(true));
+  } else {
+    SetError(kErrorCannotSetConfiguration);
+  }
+  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);
+  const UsbConfigDescriptor* config_descriptor =
+      device_handle->GetDevice()->GetConfiguration();
+  if (config_descriptor) {
+    ConfigDescriptor config;
+    ConvertConfigDescriptor(*config_descriptor, &config);
+    SetResult(config.ToValue().release());
+  } else {
+    SetError(kErrorNotConfigured);
+  }
 
-  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()) {
     return;
   }
 
-  ConfigDescriptor config;
-  ConvertConfigDescriptor(device_handle->GetDevice()->GetConfiguration(),
-                          &config);
+  const UsbConfigDescriptor* config_descriptor =
+      device_handle->GetDevice()->GetConfiguration();
+  if (config_descriptor) {
+    ConfigDescriptor config;
+    ConvertConfigDescriptor(*config_descriptor, &config);
 
-  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());
+    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());
+  } else {
+    SetError(kErrorNotConfigured);
   }
 
-  SetResult(result.release());
   AsyncWorkCompleted();
 }
 
 UsbCloseDeviceFunction::UsbCloseDeviceFunction() {
 }
 
 UsbCloseDeviceFunction::~UsbCloseDeviceFunction() {
 }
 
 bool UsbCloseDeviceFunction::Prepare() {
@@ skipping 337 matching lines @@
     SetResult(new base::FundamentalValue(false));
     CompleteWithError(kErrorResetDevice);
     return;
   }
 
   SetResult(new base::FundamentalValue(true));
   AsyncWorkCompleted();
 }
 
 }  // namespace extensions