Move string descriptor getters from UsbDeviceHandle to UsbDevice.

apps/saved_devices_service_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 "apps/saved_devices_service.h"
 #include "base/run_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/test/values_test_util.h"
 #include "chrome/browser/extensions/test_extension_environment.h"
 #include "chrome/test/base/testing_profile.h"
 #include "device/usb/usb_device.h"
 #include "device/usb/usb_device_handle.h"
 #include "extensions/browser/extension_prefs.h"
 #include "extensions/common/extension.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace apps {
 
 namespace {
 
 using device::UsbDevice;
 using device::UsbDeviceHandle;
 using device::UsbEndpointDirection;
 using device::UsbTransferCallback;
 using testing::Return;
 
-class MockUsbDeviceHandle : public UsbDeviceHandle {
+class MockUsbDevice : public UsbDevice {
  public:
-  MockUsbDeviceHandle(const std::string& serial_number)
-      : UsbDeviceHandle(), serial_number_(serial_number) {}
+  MockUsbDevice(const std::string& serial_number, uint32 unique_id)
+      : UsbDevice(0, 0, unique_id), serial_number_(serial_number) {}
 
-  MOCK_CONST_METHOD0(GetDevice, scoped_refptr<UsbDevice>());
-  MOCK_METHOD0(Close, void());
+  MOCK_METHOD0(Open, scoped_refptr<UsbDeviceHandle>());
+  MOCK_METHOD1(Close, bool(scoped_refptr<UsbDeviceHandle>));
+#if defined(OS_CHROMEOS)
+  MOCK_METHOD2(RequestUsbAccess, void(int, const base::Callback<void(bool)>&));
+#endif
+  MOCK_METHOD0(GetConfiguration, const device::UsbConfigDescriptor&());
+  MOCK_METHOD1(GetManufacturer, bool(base::string16*));
+  MOCK_METHOD1(GetProduct, bool(base::string16*));
 
-  MOCK_METHOD10(ControlTransfer,
-                void(UsbEndpointDirection direction,
-                     TransferRequestType request_type,
-                     TransferRecipient recipient,
-                     uint8 request,
-                     uint16 value,
-                     uint16 index,
-                     net::IOBuffer* buffer,
-                     size_t length,
-                     unsigned int timeout,
-                     const UsbTransferCallback& callback));
-
-  MOCK_METHOD6(BulkTransfer,
-               void(UsbEndpointDirection direction,
-                    uint8 endpoint,
-                    net::IOBuffer* buffer,
-                    size_t length,
-                    unsigned int timeout,
-                    const UsbTransferCallback& callback));
-
-  MOCK_METHOD6(InterruptTransfer,
-               void(UsbEndpointDirection direction,
-                    uint8 endpoint,
-                    net::IOBuffer* buffer,
-                    size_t length,
-                    unsigned int timeout,
-                    const UsbTransferCallback& callback));
-
-  MOCK_METHOD8(IsochronousTransfer,
-               void(UsbEndpointDirection direction,
-                    uint8 endpoint,
-                    net::IOBuffer* buffer,
-                    size_t length,
-                    unsigned int packets,
-                    unsigned int packet_length,
-                    unsigned int timeout,
-                    const UsbTransferCallback& callback));
-
-  MOCK_METHOD0(ResetDevice, bool());
-  MOCK_METHOD1(ClaimInterface, bool(int interface_number));
-  MOCK_METHOD1(ReleaseInterface, bool(int interface_number));
-  MOCK_METHOD2(SetInterfaceAlternateSetting,
-               bool(int interface_number, int alternate_setting));
-  MOCK_METHOD1(GetManufacturer, bool(base::string16* manufacturer));
-  MOCK_METHOD1(GetProduct, bool(base::string16* product));
-
-  bool GetSerial(base::string16* serial) OVERRIDE {
+  bool GetSerialNumber(base::string16* serial) OVERRIDE {
     if (serial_number_.empty()) {
       return false;
     }
 
     *serial = base::UTF8ToUTF16(serial_number_);
     return true;
   }
 
- private:
-  virtual ~MockUsbDeviceHandle() {}
-
-  const std::string serial_number_;
-};
-
-class MockUsbDevice : public UsbDevice {
- public:
-  MockUsbDevice(const std::string& serial_number, uint32 unique_id)
-      : UsbDevice(0, 0, unique_id), serial_number_(serial_number) {}
-
-  MOCK_METHOD1(Close, bool(scoped_refptr<UsbDeviceHandle>));
-#if defined(OS_CHROMEOS)
-  MOCK_METHOD2(RequestUsbAccess, void(int, const base::Callback<void(bool)>&));
-#endif
-  MOCK_METHOD0(GetConfiguration, const device::UsbConfigDescriptor&());
-
-  scoped_refptr<UsbDeviceHandle> Open() OVERRIDE {
-    return new MockUsbDeviceHandle(serial_number_);
-  }
-
   void NotifyDisconnect() { UsbDevice::NotifyDisconnect(); }
 
  private:
   virtual ~MockUsbDevice() {}
 
   const std::string serial_number_;
 };
 }
 
 class SavedDevicesServiceTest : public testing::Test {
@@ skipping 82 matching lines @@
 
   SavedDevicesService::SavedDevices* saved_devices =
       service_->GetOrInsert(extension_->id());
   ASSERT_TRUE(saved_devices->IsRegistered(device0));
   ASSERT_FALSE(saved_devices->IsRegistered(device1));
   ASSERT_FALSE(saved_devices->IsRegistered(device2));
   ASSERT_FALSE(saved_devices->IsRegistered(device3));
 }
 
 }  // namespace apps