2 files changed, 70 insertions, 172 deletions

diff --git a/chrome/browser/devtools/device/usb/android_usb_browsertest.cc b/chrome/browser/devtools/device/usb/android_usb_browsertest.cc
index ca52178..5852546 100644
--- a/chrome/browser/devtools/device/usb/android_usb_browsertest.cc
+++ b/chrome/browser/devtools/device/usb/android_usb_browsertest.cc
@@ -12,9 +12,9 @@
 #include "chrome/test/base/in_process_browser_test.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/test/test_utils.h"
+#include "device/usb/usb_descriptors.h"
 #include "device/usb/usb_device.h"
 #include "device/usb/usb_device_handle.h"
-#include "device/usb/usb_interface.h"
 #include "device/usb/usb_service.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ -25,7 +25,6 @@ using device::UsbDeviceHandle;
 using device::UsbEndpointDescriptor;
 using device::UsbEndpointDirection;
 using device::UsbInterfaceDescriptor;
-using device::UsbInterfaceAltSettingDescriptor;
 using device::UsbService;
 using device::UsbSynchronizationType;
 using device::UsbTransferCallback;
@@ -104,125 +103,6 @@ const char* GetMockShellResponse(std::string command) {
   return "";
 }
 
-class MockUsbEndpointDescriptor : public UsbEndpointDescriptor {
- public:
-  virtual int GetAddress() const OVERRIDE { return address_; }
-
-  virtual UsbEndpointDirection GetDirection() const OVERRIDE {
-    return direction_;
-  }
-
-  virtual int GetMaximumPacketSize() const OVERRIDE {
-    return maximum_packet_size_;
-  }
-
-  virtual UsbSynchronizationType GetSynchronizationType() const OVERRIDE {
-    return usb_synchronization_type_;
-  }
-
-  virtual UsbTransferType GetTransferType() const OVERRIDE {
-    return usb_transfer_type_;
-  }
-  virtual UsbUsageType GetUsageType() const OVERRIDE { return usb_usage_type_; }
-
-  virtual int GetPollingInterval() const OVERRIDE { return polling_interval_; }
-
-  int address_;
-  UsbEndpointDirection direction_;
-  int maximum_packet_size_;
-  UsbSynchronizationType usb_synchronization_type_;
-  UsbTransferType usb_transfer_type_;
-  UsbUsageType usb_usage_type_;
-  int polling_interval_;
-
- private:
-  virtual ~MockUsbEndpointDescriptor() {}
-};
-
-template <class T>
-class MockUsbInterfaceAltSettingDescriptor
-    : public UsbInterfaceAltSettingDescriptor {
- public:
-  MockUsbInterfaceAltSettingDescriptor(int interface_number,
-                                       int alternate_setting)
-      : interface_number_(interface_number),
-        alternate_setting_(alternate_setting) {}
-
-  virtual size_t GetNumEndpoints() const OVERRIDE {
-    // See IsAndroidInterface function in android_usb_device.cc
-    return 2;
-  }
-
-  virtual scoped_refptr<const UsbEndpointDescriptor> GetEndpoint(
-      size_t index) const OVERRIDE {
-    EXPECT_GT(static_cast<size_t>(2), index);
-    MockUsbEndpointDescriptor* result = new MockUsbEndpointDescriptor();
-    result->address_ = index + 1;
-    result->usb_transfer_type_ = device::USB_TRANSFER_BULK;
-    result->direction_ = ((index == 0) ? device::USB_DIRECTION_INBOUND
-                                       : device::USB_DIRECTION_OUTBOUND);
-    result->maximum_packet_size_ = 1 << 20;  // 1Mb maximum packet size
-    return result;
-  }
-
-  virtual int GetInterfaceNumber() const OVERRIDE { return interface_number_; }
-
-  virtual int GetAlternateSetting() const OVERRIDE {
-    return alternate_setting_;
-  }
-
-  virtual int GetInterfaceClass() const OVERRIDE { return T::kClass; }
-
-  virtual int GetInterfaceSubclass() const OVERRIDE { return T::kSubclass; }
-
-  virtual int GetInterfaceProtocol() const OVERRIDE { return T::kProtocol; }
-
- protected:
-  virtual ~MockUsbInterfaceAltSettingDescriptor() {};
-
- private:
-  const int interface_number_;
-  const int alternate_setting_;
-};
-
-template <class T>
-class MockUsbInterfaceDescriptor : public UsbInterfaceDescriptor {
- public:
-  explicit MockUsbInterfaceDescriptor(int interface_number)
-      : interface_number_(interface_number) {}
-
-  virtual size_t GetNumAltSettings() const OVERRIDE {
-    // See IsAndroidInterface function in android_usb_device.cc
-    return 1;
-  }
-  virtual scoped_refptr<const UsbInterfaceAltSettingDescriptor> GetAltSetting(
-      size_t index) const OVERRIDE {
-    EXPECT_EQ(static_cast<size_t>(0), index);
-    return new MockUsbInterfaceAltSettingDescriptor<T>(interface_number_, 0);
-  }
-
- protected:
-  const int interface_number_;
-  virtual ~MockUsbInterfaceDescriptor() {}
-};
-
-template <class T>
-class MockUsbConfigDescriptor : public UsbConfigDescriptor {
- public:
-  MockUsbConfigDescriptor() {}
-
-  virtual size_t GetNumInterfaces() const OVERRIDE { return 1; }
-
-  virtual scoped_refptr<const UsbInterfaceDescriptor> GetInterface(
-      size_t index) const OVERRIDE {
-    EXPECT_EQ(static_cast<size_t>(0), index);
-    return new MockUsbInterfaceDescriptor<T>(index);
-  }
-
- protected:
-  virtual ~MockUsbConfigDescriptor() {};
-};
-
 template <class T>
 class MockUsbDevice;
 
@@ -467,14 +347,37 @@ class MockUsbDeviceHandle : public UsbDeviceHandle {
 template <class T>
 class MockUsbDevice : public UsbDevice {
  public:
-  MockUsbDevice() : UsbDevice(0, 0, 0) {}
+  MockUsbDevice() : UsbDevice(0, 0, 0) {
+    UsbEndpointDescriptor bulk_in;
+    bulk_in.address = 0x81;
+    bulk_in.direction = device::USB_DIRECTION_INBOUND;
+    bulk_in.maximum_packet_size = 512;
+    bulk_in.transfer_type = device::USB_TRANSFER_BULK;
+
+    UsbEndpointDescriptor bulk_out;
+    bulk_out.address = 0x01;
+    bulk_out.direction = device::USB_DIRECTION_OUTBOUND;
+    bulk_out.maximum_packet_size = 512;
+    bulk_out.transfer_type = device::USB_TRANSFER_BULK;
+
+    UsbInterfaceDescriptor interface_desc;
+    interface_desc.interface_number = 0;
+    interface_desc.alternate_setting = 0;
+    interface_desc.interface_class = T::kClass;
+    interface_desc.interface_subclass = T::kSubclass;
+    interface_desc.interface_protocol = T::kProtocol;
+    interface_desc.endpoints.push_back(bulk_in);
+    interface_desc.endpoints.push_back(bulk_out);
+
+    config_desc_.interfaces.push_back(interface_desc);
+  }
 
   virtual scoped_refptr<UsbDeviceHandle> Open() OVERRIDE {
     return new MockUsbDeviceHandle<T>(this);
   }
 
-  virtual scoped_refptr<UsbConfigDescriptor> ListInterfaces() OVERRIDE {
-    return new MockUsbConfigDescriptor<T>();
+  virtual const UsbConfigDescriptor& GetConfiguration() OVERRIDE {
+    return config_desc_;
   }
 
   virtual bool Close(scoped_refptr<UsbDeviceHandle> handle) OVERRIDE {
@@ -497,6 +400,9 @@ class MockUsbDevice : public UsbDevice {
 
  protected:
   virtual ~MockUsbDevice() {}
+
+ private:
+  UsbConfigDescriptor config_desc_;
 };
 
 class MockUsbService : public UsbService {
diff --git a/chrome/browser/devtools/device/usb/android_usb_device.cc b/chrome/browser/devtools/device/usb/android_usb_device.cc
index 8ef9416..55b47c7 100644
--- a/chrome/browser/devtools/device/usb/android_usb_device.cc
+++ b/chrome/browser/devtools/device/usb/android_usb_device.cc
@@ -19,8 +19,8 @@
 #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"
@@ -29,7 +29,6 @@
 using device::UsbConfigDescriptor;
 using device::UsbDevice;
 using device::UsbDeviceHandle;
-using device::UsbInterfaceAltSettingDescriptor;
 using device::UsbInterfaceDescriptor;
 using device::UsbEndpointDescriptor;
 using device::UsbService;
@@ -59,17 +58,12 @@ typedef std::set<scoped_refptr<UsbDevice> > UsbDeviceSet;
 base::LazyInstance<std::vector<AndroidUsbDevice*> >::Leaky g_devices =
     LAZY_INSTANCE_INITIALIZER;
 
-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) {
+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) {
     return false;
   }
   return true;
@@ -78,40 +72,40 @@ bool IsAndroidInterface(scoped_refptr<const UsbInterfaceDescriptor> interface) {
 scoped_refptr<AndroidUsbDevice> ClaimInterface(
     crypto::RSAPrivateKey* rsa_key,
     scoped_refptr<UsbDeviceHandle> usb_handle,
-    scoped_refptr<const UsbInterfaceDescriptor> interface,
-    int interface_id) {
-  scoped_refptr<const UsbInterfaceAltSettingDescriptor> idesc =
-      interface->GetAltSetting(0);
-
+    const UsbInterfaceDescriptor& interface) {
   int inbound_address = 0;
   int outbound_address = 0;
   int zero_mask = 0;
 
-  for (size_t i = 0; i < idesc->GetNumEndpoints(); ++i) {
-    scoped_refptr<const UsbEndpointDescriptor> edesc =
-        idesc->GetEndpoint(i);
-    if (edesc->GetTransferType() != device::USB_TRANSFER_BULK)
+  for (UsbEndpointDescriptor::Iterator endpointIt = interface.endpoints.begin();
+       endpointIt != interface.endpoints.end();
+       ++endpointIt) {
+    if (endpointIt->transfer_type != device::USB_TRANSFER_BULK)
       continue;
-    if (edesc->GetDirection() == device::USB_DIRECTION_INBOUND)
-      inbound_address = edesc->GetAddress();
+    if (endpointIt->direction == device::USB_DIRECTION_INBOUND)
+      inbound_address = endpointIt->address;
     else
-      outbound_address = edesc->GetAddress();
-    zero_mask = edesc->GetMaximumPacketSize() - 1;
+      outbound_address = endpointIt->address;
+    zero_mask = endpointIt->maximum_packet_size - 1;
   }
 
   if (inbound_address == 0 || outbound_address == 0)
     return NULL;
 
-  if (!usb_handle->ClaimInterface(interface_id))
+  if (!usb_handle->ClaimInterface(interface.interface_number))
     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_id);
+  return new AndroidUsbDevice(rsa_key,
+                              usb_handle,
+                              base::UTF16ToASCII(serial),
+                              inbound_address,
+                              outbound_address,
+                              zero_mask,
+                              interface.interface_number);
 }
 
 uint32 Checksum(const std::string& data) {
@@ -207,12 +201,11 @@ static void OpenAndroidDeviceOnFileThread(
     bool success) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   if (success) {
-    scoped_refptr<UsbConfigDescriptor> config = device->ListInterfaces();
+    const UsbConfigDescriptor& config = device->GetConfiguration();
     scoped_refptr<UsbDeviceHandle> usb_handle = device->Open();
     if (usb_handle.get()) {
       scoped_refptr<AndroidUsbDevice> android_device =
-        ClaimInterface(rsa_key, usb_handle, config->GetInterface(interface_id),
-                       interface_id);
+          ClaimInterface(rsa_key, usb_handle, config.interfaces[interface_id]);
       if (android_device.get())
         devices->push_back(android_device.get());
       else
@@ -229,15 +222,17 @@ static int CountOnFileThread() {
   if (service != NULL)
     service->GetDevices(&usb_devices);
   int device_count = 0;
-  for (UsbDevices::iterator it = usb_devices.begin(); it != usb_devices.end();
-       ++it) {
-    scoped_refptr<UsbConfigDescriptor> config = (*it)->ListInterfaces();
-    if (!config.get())
-      continue;
-
-    for (size_t j = 0; j < config->GetNumInterfaces(); ++j) {
-      if (IsAndroidInterface(config->GetInterface(j)))
+  for (UsbDevices::iterator deviceIt = usb_devices.begin();
+       deviceIt != usb_devices.end();
+       ++deviceIt) {
+    const UsbConfigDescriptor& config = (*deviceIt)->GetConfiguration();
+
+    for (UsbInterfaceDescriptor::Iterator ifaceIt = config.interfaces.begin();
+         ifaceIt != config.interfaces.end();
+         ++ifaceIt) {
+      if (IsAndroidInterface(*ifaceIt)) {
         ++device_count;
+      }
     }
   }
   return device_count;
@@ -264,16 +259,13 @@ static void EnumerateOnFileThread(
 
   for (UsbDevices::iterator it = usb_devices.begin(); it != usb_devices.end();
        ++it) {
-    scoped_refptr<UsbConfigDescriptor> config = (*it)->ListInterfaces();
-    if (!config.get()) {
-      barrier.Run();
-      continue;
-    }
+    const UsbConfigDescriptor& config = (*it)->GetConfiguration();
 
     bool has_android_interface = false;
-    for (size_t j = 0; j < config->GetNumInterfaces(); ++j) {
-      if (!IsAndroidInterface(config->GetInterface(j)))
+    for (size_t j = 0; j < config.interfaces.size(); ++j) {
+      if (!IsAndroidInterface(config.interfaces[j])) {
         continue;
+      }
 
       // Request permission on Chrome OS.
 #if defined(OS_CHROMEOS)