Extracted UsbService as interface.

chrome/browser/extensions/api/usb/usb_apitest.cc

 // Copyright (c) 2012 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/api/usb/usb_api.h"
 #include "chrome/browser/extensions/extension_apitest.h"
 #include "chrome/browser/ui/browser.h"
+#include "components/usb_service/usb_service.h"
 #include "content/public/browser/browser_thread.h"
+#include "content/public/test/test_utils.h"
 #include "net/base/io_buffer.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 using testing::AnyNumber;
 using testing::_;
 using testing::Return;
 using content::BrowserThread;
 using usb_service::UsbConfigDescriptor;
 using usb_service::UsbDevice;
 using usb_service::UsbDeviceHandle;
 using usb_service::UsbEndpointDirection;
+using usb_service::UsbService;
 using usb_service::UsbTransferCallback;
 
 namespace {
 
 ACTION_TEMPLATE(InvokeUsbTransferCallback,
                 HAS_1_TEMPLATE_PARAMS(int, k),
                 AND_1_VALUE_PARAMS(p1)) {
   ::std::tr1::get<k>(args).Run(p1, new net::IOBuffer(1), 1);
 }
 
@@ skipping 31 matching lines @@
       const unsigned int timeout, const UsbTransferCallback& callback));
 
   MOCK_METHOD0(ResetDevice, bool());
 
   void set_device(UsbDevice* device) { device_ = device; }
 
  protected:
   virtual ~MockUsbDeviceHandle() {}
 };
 
+class MockUsbConfigDescriptor : public UsbConfigDescriptor {
+ public:
+  MOCK_CONST_METHOD0(GetNumInterfaces, size_t());
+
+ protected:
+  virtual ~MockUsbConfigDescriptor() {}
+};
+
 class MockUsbDevice : public UsbDevice {
  public:
   explicit MockUsbDevice(MockUsbDeviceHandle* mock_handle)
      : UsbDevice(),
        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 RequestUsbAcess(
+      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(ListInterfaces, scoped_refptr<UsbConfigDescriptor>());
 
  private:
   MockUsbDeviceHandle* mock_handle_;
   virtual ~MockUsbDevice() {}
 };
 
+class MockUsbService : public UsbService {
+ public:
+  explicit MockUsbService(scoped_refptr<UsbDevice> device) : device_(device) {}
+
+ protected:
+  virtual scoped_refptr<UsbDevice> GetDeviceById(uint32 unique_id) OVERRIDE {
+    EXPECT_EQ(unique_id, 0U);
+    return device_;
+  }
+
+  virtual void GetDevices(
+      std::vector<scoped_refptr<UsbDevice> >* devices) OVERRIDE {
+    STLClearObject(devices);
+    devices->push_back(device_);
+  }
+
+  scoped_refptr<UsbDevice> device_;
+};
+
 #if defined(OS_WIN)
 #pragma warning(pop)
 #endif
 
 class UsbApiTest : public ExtensionApiTest {
  public:
   virtual void SetUpOnMainThread() OVERRIDE {
     mock_device_handle_ = new MockUsbDeviceHandle();
     mock_device_ = new MockUsbDevice(mock_device_handle_.get());
-    extensions::UsbGetDevicesFunction::SetDeviceForTest(mock_device_.get());
+    scoped_refptr<content::MessageLoopRunner> runner =
+        new content::MessageLoopRunner;
+    BrowserThread::PostTaskAndReply(BrowserThread::FILE,
+                                    FROM_HERE,
+                                    base::Bind(&UsbApiTest::SetUpService, this),
+                                    runner->QuitClosure());
+    runner->Run();
+  }
+
+  void SetUpService() {
+    UsbService::SetInstanceForTest(new MockUsbService(mock_device_));
+  }
+
+  virtual void CleanUpOnMainThread() OVERRIDE {
+    scoped_refptr<content::MessageLoopRunner> runner =
+        new content::MessageLoopRunner;
+    UsbService* service = NULL;
+    BrowserThread::PostTaskAndReply(
+        BrowserThread::FILE,
+        FROM_HERE,
+        base::Bind(&UsbService::SetInstanceForTest, service),
+        runner->QuitClosure());
+    runner->Run();
   }
 
  protected:
   scoped_refptr<MockUsbDeviceHandle> mock_device_handle_;
   scoped_refptr<MockUsbDevice> mock_device_;
 };
 
 }  // namespace
 
 IN_PROC_BROWSER_TEST_F(UsbApiTest, DeviceHandling) {
   EXPECT_CALL(*mock_device_handle_.get(), Close()).Times(4);
   ASSERT_TRUE(RunExtensionTest("usb/device_handling"));
 }
 
 IN_PROC_BROWSER_TEST_F(UsbApiTest, ResetDevice) {
   EXPECT_CALL(*mock_device_handle_.get(), Close()).Times(2);
   EXPECT_CALL(*mock_device_handle_.get(), ResetDevice())
       .WillOnce(Return(true))
       .WillOnce(Return(false));
   EXPECT_CALL(
       *mock_device_handle_.get(),
       InterruptTransfer(usb_service::USB_DIRECTION_OUTBOUND, 2, _, 1, _, _))
       .WillOnce(
           InvokeUsbTransferCallback<5>(usb_service::USB_TRANSFER_COMPLETED));
   ASSERT_TRUE(RunExtensionTest("usb/reset_device"));
 }
 
 IN_PROC_BROWSER_TEST_F(UsbApiTest, ListInterfaces) {
+  scoped_refptr<MockUsbConfigDescriptor> mock_descriptor =
+      new MockUsbConfigDescriptor();
+  EXPECT_CALL(*mock_device_handle_.get(), Close()).Times(AnyNumber());
+  EXPECT_CALL(*mock_descriptor.get(), GetNumInterfaces()).WillOnce(Return(0));
   EXPECT_CALL(*mock_device_.get(), ListInterfaces())
-      .WillOnce(Return(scoped_refptr<UsbConfigDescriptor>()));
-  EXPECT_CALL(*mock_device_handle_.get(), Close()).Times(AnyNumber());
+      .WillOnce(Return(mock_descriptor));
   ASSERT_TRUE(RunExtensionTest("usb/list_interfaces"));
 }
 
 IN_PROC_BROWSER_TEST_F(UsbApiTest, TransferEvent) {
   EXPECT_CALL(*mock_device_handle_.get(),
               ControlTransfer(usb_service::USB_DIRECTION_OUTBOUND,
                               UsbDeviceHandle::STANDARD,
                               UsbDeviceHandle::DEVICE,
                               1, 2, 3, _, 1, _, _))
       .WillOnce(
@@ skipping 32 matching lines @@
       .WillOnce(
           InvokeUsbTransferCallback<5>(usb_service::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"));
 }