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

extensions/browser/api/usb/usb_apitest.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/extensions/extension_apitest.h"
 #include "chrome/browser/ui/browser.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/test/test_utils.h"
 #include "device/usb/usb_service.h"
 #include "extensions/browser/api/usb/usb_api.h"
 #include "net/base/io_buffer.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 using testing::AnyNumber;
 using testing::_;
 using testing::Return;
-using testing::ReturnRef;
 using content::BrowserThread;
 using device::UsbConfigDescriptor;
 using device::UsbDevice;
 using device::UsbDeviceHandle;
 using device::UsbEndpointDirection;
 using device::UsbInterfaceDescriptor;
 using device::UsbService;
 using device::UsbTransferCallback;
 
 namespace {
@@ skipping 72 matching lines @@
   }
 
   void set_device(UsbDevice* device) { device_ = device; }
 
  protected:
   UsbDevice* device_;
 
   virtual ~MockUsbDeviceHandle() {}
 };
 
+class MockUsbConfigDescriptor : public UsbConfigDescriptor {
+ public:
+  MOCK_CONST_METHOD0(GetNumInterfaces, size_t());
+  MOCK_CONST_METHOD1(GetInterface,
+                     scoped_refptr<const UsbInterfaceDescriptor>(size_t index));
+
+ protected:
+  virtual ~MockUsbConfigDescriptor() {}
+};
+
 class MockUsbDevice : public UsbDevice {
  public:
   explicit MockUsbDevice(MockUsbDeviceHandle* mock_handle)
       : UsbDevice(0, 0, 0), mock_handle_(mock_handle) {
     mock_handle->set_device(this);
   }
 
   virtual scoped_refptr<UsbDeviceHandle> Open() OVERRIDE {
     return mock_handle_;
   }
 
   virtual bool Close(scoped_refptr<UsbDeviceHandle> handle) OVERRIDE {
     EXPECT_TRUE(false) << "Should not be reached";
     return false;
   }
 
 #if defined(OS_CHROMEOS)
   virtual void RequestUsbAccess(
       int interface_id,
       const base::Callback<void(bool success)>& callback) OVERRIDE {
     BrowserThread::PostTask(
           BrowserThread::FILE, FROM_HERE, base::Bind(callback, true));
   }
 #endif  // OS_CHROMEOS
 
-  MOCK_METHOD0(GetConfiguration, const UsbConfigDescriptor&());
+  MOCK_METHOD0(ListInterfaces, scoped_refptr<UsbConfigDescriptor>());
 
  private:
   MockUsbDeviceHandle* mock_handle_;
   virtual ~MockUsbDevice() {}
 };
 
 class MockUsbService : public UsbService {
  public:
   explicit MockUsbService(scoped_refptr<UsbDevice> device) : device_(device) {}
 
@@ skipping 63 matching lines @@
   EXPECT_CALL(*mock_device_handle_.get(), ResetDevice())
       .WillOnce(Return(true))
       .WillOnce(Return(false));
   EXPECT_CALL(*mock_device_handle_.get(),
               InterruptTransfer(device::USB_DIRECTION_OUTBOUND, 2, _, 1, _, _))
       .WillOnce(InvokeUsbTransferCallback<5>(device::USB_TRANSFER_COMPLETED));
   ASSERT_TRUE(RunExtensionTest("usb/reset_device"));
 }
 
 IN_PROC_BROWSER_TEST_F(UsbApiTest, ListInterfaces) {
-  UsbConfigDescriptor config_descriptor;
+  scoped_refptr<MockUsbConfigDescriptor> mock_descriptor =
+      new MockUsbConfigDescriptor();
   EXPECT_CALL(*mock_device_handle_.get(), Close()).Times(AnyNumber());
-  EXPECT_CALL(*mock_device_.get(), GetConfiguration())
-      .WillOnce(ReturnRef(config_descriptor));
+  EXPECT_CALL(*mock_descriptor.get(), GetNumInterfaces()).WillOnce(Return(0));
+  EXPECT_CALL(*mock_device_.get(), ListInterfaces())
+      .WillOnce(Return(mock_descriptor));
   ASSERT_TRUE(RunExtensionTest("usb/list_interfaces"));
 }
 
 IN_PROC_BROWSER_TEST_F(UsbApiTest, TransferEvent) {
   EXPECT_CALL(*mock_device_handle_.get(),
               ControlTransfer(device::USB_DIRECTION_OUTBOUND,
                               UsbDeviceHandle::STANDARD,
                               UsbDeviceHandle::DEVICE,
                               1,
                               2,
@@ skipping 30 matching lines @@
       .WillOnce(InvokeUsbTransferCallback<5>(device::USB_TRANSFER_ERROR))
       .WillOnce(InvokeUsbTransferCallback<5>(device::USB_TRANSFER_TIMEOUT));
   EXPECT_CALL(*mock_device_handle_.get(), Close()).Times(AnyNumber());
   ASSERT_TRUE(RunExtensionTest("usb/transfer_failure"));
 }
 
 IN_PROC_BROWSER_TEST_F(UsbApiTest, InvalidLengthTransfer) {
   EXPECT_CALL(*mock_device_handle_.get(), Close()).Times(AnyNumber());
   ASSERT_TRUE(RunExtensionTest("usb/invalid_length_transfer"));
 }