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

chrome/browser/devtools/device/usb/android_usb_browsertest.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 <algorithm>
 
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/devtools/device/devtools_android_bridge.h"
 #include "chrome/browser/devtools/device/usb/android_usb_device.h"
 #include "chrome/browser/devtools/device/usb/usb_device_provider.h"
 #include "chrome/browser/ui/browser.h"
 #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"
 
 using content::BrowserThread;
 using device::UsbConfigDescriptor;
 using device::UsbDevice;
 using device::UsbDeviceHandle;
 using device::UsbEndpointDescriptor;
 using device::UsbEndpointDirection;
 using device::UsbInterfaceDescriptor;
+using device::UsbInterfaceAltSettingDescriptor;
 using device::UsbService;
 using device::UsbSynchronizationType;
 using device::UsbTransferCallback;
 using device::UsbTransferType;
 using device::UsbUsageType;
 
 namespace {
 
 struct AndroidTraits {
   static const int kClass = 0xff;
@@ skipping 58 matching lines @@
     return kSampleListProcesses;
   } else if (command == kInstalledChromePackagesCommand) {
     return kSampleListPackages;
   }
 
   DCHECK(false) << "Should not be reached";
 
   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;
 
 template <class T>
 class MockUsbDeviceHandle : public UsbDeviceHandle {
  public:
   explicit MockUsbDeviceHandle(MockUsbDevice<T>* device)
       : device_(device),
         remaining_body_length_(0),
         next_local_socket_(0) {}
@@ skipping 224 matching lines @@
   uint32 remaining_body_length_;
   scoped_refptr<AdbMessage> current_message_;
   std::vector<char> output_buffer_;
   std::queue<Query> queries_;
   int next_local_socket_;
 };
 
 template <class T>
 class MockUsbDevice : public UsbDevice {
  public:
-  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);
-  }
+  MockUsbDevice() : UsbDevice(0, 0, 0) {}
 
   virtual scoped_refptr<UsbDeviceHandle> Open() OVERRIDE {
     return new MockUsbDeviceHandle<T>(this);
   }
 
-  virtual const UsbConfigDescriptor& GetConfiguration() OVERRIDE {
-    return config_desc_;
+  virtual scoped_refptr<UsbConfigDescriptor> ListInterfaces() OVERRIDE {
+    return new MockUsbConfigDescriptor<T>();
   }
 
   virtual bool Close(scoped_refptr<UsbDeviceHandle> handle) OVERRIDE {
     return true;
   }
 
 #if defined(OS_CHROMEOS)
   // On ChromeOS, if an interface of a claimed device is not claimed, the
   // permission broker can change the owner of the device so that the unclaimed
   // interfaces can be used. If this argument is missing, permission broker will
   // not be used and this method fails if the device is claimed.
   virtual void RequestUsbAccess(
       int interface_id,
       const base::Callback<void(bool success)>& callback) OVERRIDE {
     callback.Run(true);
   }
 #endif  // OS_CHROMEOS
 
   std::set<int> claimed_interfaces_;
 
  protected:
   virtual ~MockUsbDevice() {}
-
- private:
-  UsbConfigDescriptor config_desc_;
 };
 
 class MockUsbService : public UsbService {
  public:
   MockUsbService() {
     devices_.push_back(new MockUsbDevice<AndroidTraits>());
   }
 
   virtual ~MockUsbService() {}
 
@@ skipping 346 matching lines @@
   runner_->Run();
   EXPECT_EQ(2, listener.invoked_);
   EXPECT_EQ(listener.invoked_ - 1, scheduler_invoked_);
 }
 
 IN_PROC_BROWSER_TEST_F(AndroidUsbTraitsTest, TestDeviceCounting) {
   MockCountListenerForCheckingTraits listener(adb_bridge_);
   adb_bridge_->AddDeviceCountListener(&listener);
   runner_->Run();
 }