Add browser tests for USB device add/remove events.

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 "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 "extensions/shell/test/shell_apitest.h"
+#include "extensions/test/extension_test_message_listener.h"
 #include "net/base/io_buffer.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 using testing::_;
 using testing::AnyNumber;
 using testing::Invoke;
 using testing::Return;
 using content::BrowserThread;
 using device::UsbConfigDescriptor;
 using device::UsbDevice;
@@ skipping 98 matching lines @@
   MOCK_METHOD1(GetSerialNumber, bool(base::string16*));
 
  private:
   virtual ~MockUsbDevice() {}
 };
 
 class MockUsbService : public UsbService {
  public:
   explicit MockUsbService(scoped_refptr<UsbDevice> device) : device_(device) {}
 
+  // Public wrapper around the protected base class method.

[Yoyo Zhou, 2015/01/21 06:57:43]

Why not make the base class friend class UsbApiTest?

[Reilly Grant (use Gerrit), 2015/01/22 00:45:01]

I tried this and no one in my office could figure out why it wasn't working. I
also crashed clang a couple times.

+  void NotifyDeviceAdded(scoped_refptr<UsbDevice> device) {
+    UsbService::NotifyDeviceAdded(device);
+  }
+
+  // Public wrapper around the protected base class method.
+  void NotifyDeviceRemoved(scoped_refptr<UsbDevice> device) {
+    UsbService::NotifyDeviceRemoved(device);
+  }
+
  protected:
   scoped_refptr<UsbDevice> GetDeviceById(uint32 unique_id) override {
     EXPECT_EQ(unique_id, 0U);
     return device_;
   }
 
   void GetDevices(std::vector<scoped_refptr<UsbDevice>>* devices) override {
     STLClearObject(devices);
     devices->push_back(device_);
   }
 
   scoped_refptr<UsbDevice> device_;
 };
 
 class UsbApiTest : public ShellApiTest {
  public:
   void SetUpOnMainThread() override {
     ShellApiTest::SetUpOnMainThread();
+
+    mock_device_ = new MockUsbDevice(0, 0, 0);
+    EXPECT_CALL(*mock_device_.get(), GetSerialNumber(_))
+        .WillRepeatedly(Return(false));
+
     mock_device_handle_ = new MockUsbDeviceHandle();
-    mock_device_ = new MockUsbDevice(0, 0, 0);
     mock_device_handle_->set_device(mock_device_.get());
     EXPECT_CALL(*mock_device_.get(), RequestUsbAccess(_, _))
         .WillRepeatedly(Invoke(RequestUsbAccess));
     EXPECT_CALL(*mock_device_.get(), Open())
         .WillRepeatedly(Return(mock_device_handle_));
 
     base::RunLoop run_loop;
     BrowserThread::PostTaskAndReply(BrowserThread::FILE, FROM_HERE,
                                     base::Bind(&UsbApiTest::SetUpService, this),
                                     run_loop.QuitClosure());
     run_loop.Run();
   }
 
   void SetUpService() {
-    UsbService::SetInstanceForTest(new MockUsbService(mock_device_));
+    mock_service_ = new MockUsbService(mock_device_);
+    UsbService::SetInstanceForTest(mock_service_);
   }
 
-  void TearDownOnMainThread() override {
-    UsbService* service = NULL;
-    base::RunLoop run_loop;
-    BrowserThread::PostTaskAndReply(
-        BrowserThread::FILE, FROM_HERE,
-        base::Bind(&UsbService::SetInstanceForTest, service),
-        run_loop.QuitClosure());
-    run_loop.Run();
+  void AddTestDevices() {
+    scoped_refptr<MockUsbDevice> device(new MockUsbDevice(0x18D1, 0x58F0, 1));
+    EXPECT_CALL(*device.get(), GetSerialNumber(_))
+        .WillRepeatedly(Return(false));
+    mock_service_->NotifyDeviceAdded(device);
+
+    device = new MockUsbDevice(0x18D1, 0x58F1, 2);
+    EXPECT_CALL(*device.get(), GetSerialNumber(_))
+        .WillRepeatedly(Return(false));
+    mock_service_->NotifyDeviceAdded(device);
   }
 
  protected:
   scoped_refptr<MockUsbDeviceHandle> mock_device_handle_;
   scoped_refptr<MockUsbDevice> mock_device_;
+  MockUsbService* mock_service_;
 };
 
 }  // namespace
 
 IN_PROC_BROWSER_TEST_F(UsbApiTest, DeviceHandling) {
   EXPECT_CALL(*mock_device_handle_.get(), Close()).Times(4);
   ASSERT_TRUE(RunAppTest("api_test/usb/device_handling"));
 }
 
 IN_PROC_BROWSER_TEST_F(UsbApiTest, ResetDevice) {
@@ skipping 67 matching lines @@
       .WillOnce(InvokeUsbTransferCallback<5>(device::USB_TRANSFER_TIMEOUT));
   EXPECT_CALL(*mock_device_handle_.get(), Close()).Times(AnyNumber());
   ASSERT_TRUE(RunAppTest("api_test/usb/transfer_failure"));
 }
 
 IN_PROC_BROWSER_TEST_F(UsbApiTest, InvalidLengthTransfer) {
   EXPECT_CALL(*mock_device_handle_.get(), Close()).Times(AnyNumber());
   ASSERT_TRUE(RunAppTest("api_test/usb/invalid_length_transfer"));
 }
 
+IN_PROC_BROWSER_TEST_F(UsbApiTest, OnDeviceAdded) {
+  ExtensionTestMessageListener load_listener("loaded", false);
+  ExtensionTestMessageListener result_listener("success", false);
+  result_listener.set_failure_message("failure");
+
+  ASSERT_TRUE(LoadApp("api_test/usb/add_event"));
+  ASSERT_TRUE(load_listener.WaitUntilSatisfied());
+
+  base::RunLoop run_loop;
+  BrowserThread::PostTaskAndReply(
+      BrowserThread::FILE, FROM_HERE,
+      base::Bind(&UsbApiTest::AddTestDevices, base::Unretained(this)),
+      run_loop.QuitClosure());
+  run_loop.Run();
+
+  ASSERT_TRUE(result_listener.WaitUntilSatisfied());
+  ASSERT_EQ("success", result_listener.message());
+}
+
+IN_PROC_BROWSER_TEST_F(UsbApiTest, OnDeviceRemoved) {
+  ExtensionTestMessageListener load_listener("loaded", false);
+  ExtensionTestMessageListener result_listener("success", false);
+  result_listener.set_failure_message("failure");
+
+  ASSERT_TRUE(LoadApp("api_test/usb/remove_event"));
+  ASSERT_TRUE(load_listener.WaitUntilSatisfied());
+
+  base::RunLoop run_loop;
+  BrowserThread::PostTaskAndReply(
+      BrowserThread::FILE, FROM_HERE,
+      base::Bind(&MockUsbService::NotifyDeviceRemoved,
+                 base::Unretained(mock_service_), mock_device_),
+      run_loop.QuitClosure());
+  run_loop.Run();
+
+  ASSERT_TRUE(result_listener.WaitUntilSatisfied());
+  ASSERT_EQ("success", result_listener.message());
+}
+
 }  // namespace extensions