Revert of Convert device::UsbConfigDescriptor and friends to structs.

chrome/browser/devtools/device/usb/android_usb_device.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 "chrome/browser/devtools/device/usb/android_usb_device.h"
 
 #include <set>
 
 #include "base/barrier_closure.h"
 #include "base/base64.h"
 #include "base/lazy_instance.h"
 #include "base/message_loop/message_loop.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/devtools/device/usb/android_rsa.h"
 #include "chrome/browser/devtools/device/usb/android_usb_socket.h"
 #include "content/public/browser/browser_thread.h"
 #include "crypto/rsa_private_key.h"
 #include "device/core/device_client.h"
-#include "device/usb/usb_descriptors.h"
 #include "device/usb/usb_device.h"
+#include "device/usb/usb_interface.h"
 #include "device/usb/usb_service.h"
 #include "net/base/ip_endpoint.h"
 #include "net/base/net_errors.h"
 #include "net/socket/stream_socket.h"
 
 using device::UsbConfigDescriptor;
 using device::UsbDevice;
 using device::UsbDeviceHandle;
+using device::UsbInterfaceAltSettingDescriptor;
 using device::UsbInterfaceDescriptor;
 using device::UsbEndpointDescriptor;
 using device::UsbService;
 using device::UsbTransferStatus;
 
 namespace {
 
 const size_t kHeaderSize = 24;
 
 const int kAdbClass = 0xff;
 const int kAdbSubclass = 0x42;
 const int kAdbProtocol = 0x1;
 
 const int kUsbTimeout = 0;
 
 const uint32 kMaxPayload = 4096;
 const uint32 kVersion = 0x01000000;
 
 static const char kHostConnectMessage[] = "host::";
 
 using content::BrowserThread;
 
 typedef std::vector<scoped_refptr<UsbDevice> > UsbDevices;
 typedef std::set<scoped_refptr<UsbDevice> > UsbDeviceSet;
 
 // Stores android wrappers around claimed usb devices on caller thread.
 base::LazyInstance<std::vector<AndroidUsbDevice*> >::Leaky g_devices =
     LAZY_INSTANCE_INITIALIZER;
 
-bool IsAndroidInterface(const UsbInterfaceDescriptor& interface) {
-  if (interface.alternate_setting != 0 ||
-      interface.interface_class != kAdbClass ||
-      interface.interface_subclass != kAdbSubclass ||
-      interface.interface_protocol != kAdbProtocol ||
-      interface.endpoints.size() != 2) {
+bool IsAndroidInterface(scoped_refptr<const UsbInterfaceDescriptor> interface) {
+  if (interface->GetNumAltSettings() == 0)
+    return false;
+
+  scoped_refptr<const UsbInterfaceAltSettingDescriptor> idesc =
+      interface->GetAltSetting(0);
+
+  if (idesc->GetInterfaceClass() != kAdbClass ||
+      idesc->GetInterfaceSubclass() != kAdbSubclass ||
+      idesc->GetInterfaceProtocol() != kAdbProtocol ||
+      idesc->GetNumEndpoints() != 2) {
     return false;
   }
   return true;
 }
 
 scoped_refptr<AndroidUsbDevice> ClaimInterface(
     crypto::RSAPrivateKey* rsa_key,
     scoped_refptr<UsbDeviceHandle> usb_handle,
-    const UsbInterfaceDescriptor& interface) {
+    scoped_refptr<const UsbInterfaceDescriptor> interface,
+    int interface_id) {
+  scoped_refptr<const UsbInterfaceAltSettingDescriptor> idesc =
+      interface->GetAltSetting(0);
+
   int inbound_address = 0;
   int outbound_address = 0;
   int zero_mask = 0;
 
-  for (UsbEndpointDescriptor::Iterator endpointIt = interface.endpoints.begin();
-       endpointIt != interface.endpoints.end();
-       ++endpointIt) {
-    if (endpointIt->transfer_type != device::USB_TRANSFER_BULK)
+  for (size_t i = 0; i < idesc->GetNumEndpoints(); ++i) {
+    scoped_refptr<const UsbEndpointDescriptor> edesc =
+        idesc->GetEndpoint(i);
+    if (edesc->GetTransferType() != device::USB_TRANSFER_BULK)
       continue;
-    if (endpointIt->direction == device::USB_DIRECTION_INBOUND)
-      inbound_address = endpointIt->address;
+    if (edesc->GetDirection() == device::USB_DIRECTION_INBOUND)
+      inbound_address = edesc->GetAddress();
     else
-      outbound_address = endpointIt->address;
-    zero_mask = endpointIt->maximum_packet_size - 1;
+      outbound_address = edesc->GetAddress();
+    zero_mask = edesc->GetMaximumPacketSize() - 1;
   }
 
   if (inbound_address == 0 || outbound_address == 0)
     return NULL;
 
-  if (!usb_handle->ClaimInterface(interface.interface_number))
+  if (!usb_handle->ClaimInterface(interface_id))
     return NULL;
 
   base::string16 serial;
   if (!usb_handle->GetSerial(&serial) || serial.empty())
     return NULL;
 
-  return new AndroidUsbDevice(rsa_key,
-                              usb_handle,
-                              base::UTF16ToASCII(serial),
-                              inbound_address,
-                              outbound_address,
-                              zero_mask,
-                              interface.interface_number);
+  return new AndroidUsbDevice(rsa_key, usb_handle, base::UTF16ToASCII(serial),
+                              inbound_address, outbound_address, zero_mask,
+                              interface_id);
 }
 
 uint32 Checksum(const std::string& data) {
   unsigned char* x = (unsigned char*)data.data();
   int count = data.length();
   uint32 sum = 0;
   while (count-- > 0)
     sum += *x++;
   return sum;
 }
@@ skipping 75 matching lines @@
 
 static void OpenAndroidDeviceOnFileThread(
     AndroidUsbDevices* devices,
     crypto::RSAPrivateKey* rsa_key,
     const base::Closure& barrier,
     scoped_refptr<UsbDevice> device,
     int interface_id,
     bool success) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   if (success) {
-    const UsbConfigDescriptor& config = device->GetConfiguration();
+    scoped_refptr<UsbConfigDescriptor> config = device->ListInterfaces();
     scoped_refptr<UsbDeviceHandle> usb_handle = device->Open();
     if (usb_handle.get()) {
       scoped_refptr<AndroidUsbDevice> android_device =
-          ClaimInterface(rsa_key, usb_handle, config.interfaces[interface_id]);
+        ClaimInterface(rsa_key, usb_handle, config->GetInterface(interface_id),
+                       interface_id);
       if (android_device.get())
         devices->push_back(android_device.get());
       else
         usb_handle->Close();
     }
   }
   barrier.Run();
 }
 
 static int CountOnFileThread() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   UsbService* service = device::DeviceClient::Get()->GetUsbService();
   UsbDevices usb_devices;
   if (service != NULL)
     service->GetDevices(&usb_devices);
   int device_count = 0;
-  for (UsbDevices::iterator deviceIt = usb_devices.begin();
-       deviceIt != usb_devices.end();
-       ++deviceIt) {
-    const UsbConfigDescriptor& config = (*deviceIt)->GetConfiguration();
+  for (UsbDevices::iterator it = usb_devices.begin(); it != usb_devices.end();
+       ++it) {
+    scoped_refptr<UsbConfigDescriptor> config = (*it)->ListInterfaces();
+    if (!config.get())
+      continue;
 
-    for (UsbInterfaceDescriptor::Iterator ifaceIt = config.interfaces.begin();
-         ifaceIt != config.interfaces.end();
-         ++ifaceIt) {
-      if (IsAndroidInterface(*ifaceIt)) {
+    for (size_t j = 0; j < config->GetNumInterfaces(); ++j) {
+      if (IsAndroidInterface(config->GetInterface(j)))
         ++device_count;
-      }
     }
   }
   return device_count;
 }
 
 static void EnumerateOnFileThread(
     crypto::RSAPrivateKey* rsa_key,
     const AndroidUsbDevicesCallback& callback,
     scoped_refptr<base::MessageLoopProxy> caller_message_loop_proxy) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
   UsbService* service = device::DeviceClient::Get()->GetUsbService();
   UsbDevices usb_devices;
   if (service != NULL)
     service->GetDevices(&usb_devices);
 
   // Add new devices.
   AndroidUsbDevices* devices = new AndroidUsbDevices();
   base::Closure barrier = base::BarrierClosure(
       usb_devices.size(), base::Bind(&RespondOnFileThread,
                                      callback,
                                      devices,
                                      caller_message_loop_proxy));
 
   for (UsbDevices::iterator it = usb_devices.begin(); it != usb_devices.end();
        ++it) {
-    const UsbConfigDescriptor& config = (*it)->GetConfiguration();
+    scoped_refptr<UsbConfigDescriptor> config = (*it)->ListInterfaces();
+    if (!config.get()) {
+      barrier.Run();
+      continue;
+    }
 
     bool has_android_interface = false;
-    for (size_t j = 0; j < config.interfaces.size(); ++j) {
-      if (!IsAndroidInterface(config.interfaces[j])) {
+    for (size_t j = 0; j < config->GetNumInterfaces(); ++j) {
+      if (!IsAndroidInterface(config->GetInterface(j)))
         continue;
-      }
 
       // Request permission on Chrome OS.
 #if defined(OS_CHROMEOS)
       (*it)->RequestUsbAccess(j, base::Bind(&OpenAndroidDeviceOnFileThread,
                                             devices, rsa_key, barrier, *it, j));
 #else
       OpenAndroidDeviceOnFileThread(devices, rsa_key, barrier, *it, j, true);
 #endif  // defined(OS_CHROMEOS)
 
       has_android_interface = true;
@@ skipping 367 matching lines @@
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
       base::Bind(&ReleaseInterface, usb_handle, interface_id_));
 }
 
 void AndroidUsbDevice::SocketDeleted(uint32 socket_id) {
   DCHECK(message_loop_ == base::MessageLoop::current());
 
   sockets_.erase(socket_id);
 }