Convert device::UsbConfigDescriptor and friends to structs.

device/usb/usb_device_filter_unittest.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 <vector>
 
 #include "base/memory/ref_counted.h"
+#include "device/usb/usb_descriptors.h"
 #include "device/usb/usb_device.h"
 #include "device/usb/usb_device_filter.h"
 #include "device/usb/usb_device_handle.h"
-#include "device/usb/usb_interface.h"
+#include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace device {
 
 namespace {
 
-class MockUsbInterfaceAltSettingDescriptor
-    : public UsbInterfaceAltSettingDescriptor {
- public:
-  MockUsbInterfaceAltSettingDescriptor(int interface_number,
-                                       int alternate_setting,
-                                       int interface_class,
-                                       int interface_subclass,
-                                       int interface_protocol)
-      : interface_number_(interface_number),
-        alternate_setting_(alternate_setting),
-        interface_class_(interface_class),
-        interface_subclass_(interface_subclass),
-        interface_protocol_(interface_protocol) {}
-
-  virtual size_t GetNumEndpoints() const OVERRIDE { return 0; }
-  virtual scoped_refptr<const UsbEndpointDescriptor> GetEndpoint(
-      size_t index) const OVERRIDE {
-    return NULL;
-  }
-  virtual int GetInterfaceNumber() const OVERRIDE { return interface_number_; }
-  virtual int GetAlternateSetting() const OVERRIDE {
-    return alternate_setting_;
-  }
-  virtual int GetInterfaceClass() const OVERRIDE { return interface_class_; }
-  virtual int GetInterfaceSubclass() const OVERRIDE {
-    return interface_subclass_;
-  }
-  virtual int GetInterfaceProtocol() const OVERRIDE {
-    return interface_protocol_;
-  }
-
- protected:
-  virtual ~MockUsbInterfaceAltSettingDescriptor() {}
-
- private:
-  int interface_number_;
-  int alternate_setting_;
-  int interface_class_;
-  int interface_subclass_;
-  int interface_protocol_;
-};
-
-typedef std::vector<scoped_refptr<UsbInterfaceAltSettingDescriptor> >
-    UsbInterfaceAltSettingDescriptorList;
-
-class MockUsbInterfaceDescriptor : public UsbInterfaceDescriptor {
- public:
-  MockUsbInterfaceDescriptor(
-      const UsbInterfaceAltSettingDescriptorList& alt_settings)
-      : alt_settings_(alt_settings) {}
-
-  virtual size_t GetNumAltSettings() const OVERRIDE {
-    return alt_settings_.size();
-  }
-  virtual scoped_refptr<const UsbInterfaceAltSettingDescriptor> GetAltSetting(
-      size_t index) const OVERRIDE {
-    return alt_settings_[index];
-  }
-
- protected:
-  virtual ~MockUsbInterfaceDescriptor() {}
-
- private:
-  UsbInterfaceAltSettingDescriptorList alt_settings_;
-};
-
-typedef std::vector<scoped_refptr<UsbInterfaceDescriptor> >
-    UsbInterfaceDescriptorList;
-
-class MockUsbConfigDescriptor : public UsbConfigDescriptor {
- public:
-  MockUsbConfigDescriptor(const UsbInterfaceDescriptorList& interfaces)
-      : interfaces_(interfaces) {}
-
-  virtual size_t GetNumInterfaces() const OVERRIDE {
-    return interfaces_.size();
-  }
-  virtual scoped_refptr<const UsbInterfaceDescriptor> GetInterface(
-      size_t index) const OVERRIDE {
-    return interfaces_[index];
-  }
-
- protected:
-  virtual ~MockUsbConfigDescriptor() {}
-
- private:
-  UsbInterfaceDescriptorList interfaces_;
-};
+using testing::NiceMock;
+using testing::ReturnRef;
 
 class MockUsbDevice : public UsbDevice {
  public:
-  MockUsbDevice(uint16 vendor_id,
-                uint16 product_id,
-                uint32 unique_id,
-                scoped_refptr<UsbConfigDescriptor> config_desc)
-      : UsbDevice(vendor_id, product_id, unique_id),
-        config_desc_(config_desc) {}
+  MockUsbDevice(uint16 vendor_id, uint16 product_id, uint32 unique_id)
+      : UsbDevice(vendor_id, product_id, unique_id) {}
 
-  virtual scoped_refptr<UsbDeviceHandle> Open() OVERRIDE { return NULL; }
-  virtual bool Close(scoped_refptr<UsbDeviceHandle> handle) OVERRIDE {
-    NOTREACHED();
-    return true;
-  }
+  MOCK_METHOD0(Open, scoped_refptr<UsbDeviceHandle>());
+  MOCK_METHOD1(Close, bool(scoped_refptr<UsbDeviceHandle>));
 #if defined(OS_CHROMEOS)
-  virtual void RequestUsbAccess(
-      int interface_id,
-      const base::Callback<void(bool success)>& callback) OVERRIDE {
-    NOTREACHED();
-  }
-#endif  // OS_CHROMEOS
-  virtual scoped_refptr<UsbConfigDescriptor> ListInterfaces() OVERRIDE {
-    return config_desc_;
-  }
-
- protected:
-  virtual ~MockUsbDevice() {}
+  MOCK_METHOD2(RequestUsbAccess, void(int, const base::Callback<void(bool)>&));
+#endif
+  MOCK_METHOD0(GetConfiguration, const UsbConfigDescriptor&());
 
  private:
-  scoped_refptr<UsbConfigDescriptor> config_desc_;
+  virtual ~MockUsbDevice() {}
 };
 
 class UsbFilterTest : public testing::Test {
  public:
   virtual void SetUp() OVERRIDE {
-    UsbInterfaceAltSettingDescriptorList alt_settings;
-    alt_settings.push_back(make_scoped_refptr(
-        new MockUsbInterfaceAltSettingDescriptor(1, 0, 0xFF, 0x42, 1)));
+    UsbInterfaceDescriptor interface;
+    interface.interface_number = 1;
+    interface.alternate_setting = 0;
+    interface.interface_class = 0xFF;
+    interface.interface_subclass = 0x42;
+    interface.interface_protocol = 0x01;
+    config_.interfaces.push_back(interface);
 
-    UsbInterfaceDescriptorList interfaces;
-    interfaces.push_back(
-        make_scoped_refptr(new MockUsbInterfaceDescriptor(alt_settings)));
-
-    scoped_refptr<UsbConfigDescriptor> config_desc(
-        new MockUsbConfigDescriptor(interfaces));
-
-    android_phone_ = new MockUsbDevice(0x18d1, 0x4ee2, 0, config_desc);
+    android_phone_ = new MockUsbDevice(0x18d1, 0x4ee2, 0);
+    ON_CALL(*android_phone_.get(), GetConfiguration())
+        .WillByDefault(ReturnRef(config_));
   }
 
  protected:
-  scoped_refptr<UsbDevice> android_phone_;
+  UsbConfigDescriptor config_;
+  scoped_refptr<MockUsbDevice> android_phone_;
 };
 
 TEST_F(UsbFilterTest, MatchAny) {
   UsbDeviceFilter filter;
   ASSERT_TRUE(filter.Matches(android_phone_));
 }
 
 TEST_F(UsbFilterTest, MatchVendorId) {
   UsbDeviceFilter filter;
   filter.SetVendorId(0x18d1);
@@ skipping 75 matching lines @@
 
 TEST_F(UsbFilterTest, MatchesAnyVendorIdNegative) {
   std::vector<UsbDeviceFilter> filters(1);
   filters.back().SetVendorId(0x1d6b);
   ASSERT_FALSE(UsbDeviceFilter::MatchesAny(android_phone_, filters));
 }
 
 }  // namespace
 
 }  // namespace device