Convert device::UsbConfigDescriptor and friends to structs.

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 38 matching lines @@
 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::UsbInterfaceAltSettingDescriptor;
 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;
 
@@ skipping 684 matching lines @@
   EXTENSION_FUNCTION_VALIDATE(parameters_.get());
   return true;
 }
 
 void UsbListInterfacesFunction::AsyncWorkStart() {
   scoped_refptr<UsbDeviceHandle> device_handle =
       GetDeviceHandleOrCompleteWithError(parameters_->handle);
   if (!device_handle.get())
     return;
 
-  scoped_refptr<UsbConfigDescriptor> config =
-      device_handle->GetDevice()->ListInterfaces();
+  const UsbConfigDescriptor& config =
+      device_handle->GetDevice()->GetConfiguration();
 
-  if (!config.get()) {
-    SetError(kErrorCannotListInterfaces);
-    AsyncWorkCompleted();
-    return;
+  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));
   }
 
-  result_.reset(new base::ListValue());
-
-  for (size_t i = 0, num_interfaces = config->GetNumInterfaces();
-       i < num_interfaces;
-       ++i) {
-    scoped_refptr<const UsbInterfaceDescriptor> usb_interface(
-        config->GetInterface(i));
-    for (size_t j = 0, num_descriptors = usb_interface->GetNumAltSettings();
-         j < num_descriptors;
-         ++j) {
-      scoped_refptr<const UsbInterfaceAltSettingDescriptor> descriptor =
-          usb_interface->GetAltSetting(j);
-      std::vector<linked_ptr<EndpointDescriptor> > endpoints;
-      for (size_t k = 0, num_endpoints = descriptor->GetNumEndpoints();
-           k < num_endpoints;
-           k++) {
-        scoped_refptr<const UsbEndpointDescriptor> endpoint =
-            descriptor->GetEndpoint(k);
-        linked_ptr<EndpointDescriptor> endpoint_desc(new EndpointDescriptor());
-
-        TransferType type;
-        Direction direction;
-        SynchronizationType synchronization;
-        UsageType usage;
-
-        if (!ConvertTransferTypeSafely(endpoint->GetTransferType(), &type) ||
-            !ConvertDirectionSafely(endpoint->GetDirection(), &direction) ||
-            !ConvertSynchronizationTypeSafely(
-                endpoint->GetSynchronizationType(), &synchronization) ||
-            !ConvertUsageTypeSafely(endpoint->GetUsageType(), &usage)) {
-          SetError(kErrorCannotListInterfaces);
-          AsyncWorkCompleted();
-          return;
-        }
-
-        endpoint_desc->address = endpoint->GetAddress();
-        endpoint_desc->type = type;
-        endpoint_desc->direction = direction;
-        endpoint_desc->maximum_packet_size = endpoint->GetMaximumPacketSize();
-        endpoint_desc->synchronization = synchronization;
-        endpoint_desc->usage = usage;
-
-        int* polling_interval = new int;
-        endpoint_desc->polling_interval.reset(polling_interval);
-        *polling_interval = endpoint->GetPollingInterval();
-
-        endpoints.push_back(endpoint_desc);
-      }
-
-      result_->Append(
-          PopulateInterfaceDescriptor(descriptor->GetInterfaceNumber(),
-                                      descriptor->GetAlternateSetting(),
-                                      descriptor->GetInterfaceClass(),
-                                      descriptor->GetInterfaceSubclass(),
-                                      descriptor->GetInterfaceProtocol(),
-                                      &endpoints));
-    }
-  }
-
-  SetResult(result_.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;
@@ skipping 373 matching lines @@
     SetResult(new base::FundamentalValue(false));
     CompleteWithError(kErrorResetDevice);
     return;
   }
 
   SetResult(new base::FundamentalValue(true));
   AsyncWorkCompleted();
 }
 
 }  // namespace extensions