Enable USB gadget tests on OS X.

device/hid/hid_connection_unittest.cc

 // Copyright (c) 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 <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/run_loop.h"
 #include "base/scoped_observer.h"
+#include "base/test/test_io_thread.h"
 #include "device/hid/hid_connection.h"
 #include "device/hid/hid_service.h"
 #include "device/test/usb_test_gadget.h"
 #include "net/base/io_buffer.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace device {
 
 namespace {
 
 using net::IOBufferWithSize;
 
+void ClaimTestDevice(scoped_ptr<UsbTestGadget>* gadget) {
+  base::MessageLoop::ScopedNestableTaskAllower allow(
+      base::MessageLoop::current());
+  *gadget = UsbTestGadget::Claim();
+  ASSERT_TRUE(*gadget);
+  ASSERT_TRUE((*gadget)->SetType(UsbTestGadget::HID_ECHO));
+}
+
+void UnclaimTestDevice(scoped_ptr<UsbTestGadget> gadget) {
+  base::MessageLoop::ScopedNestableTaskAllower allow(
+      base::MessageLoop::current());
+  ASSERT_TRUE(gadget->Unclaim());
+}
+
 // Helper class that can be used to block until a HID device with a particular
 // serial number is available. Example usage:
 //
 //   DeviceCatcher device_catcher("ABC123");
 //   HidDeviceId device_id = device_catcher.WaitForDevice();
 //   /* Call HidService::Connect(device_id) to open the device. */
 //
 class DeviceCatcher : HidService::Observer {
  public:
   DeviceCatcher(const std::string& serial_number)
@@ skipping 104 matching lines @@
   HidConnection::WriteCallback write_callback_;
 };
 
 }  // namespace
 
 class HidConnectionTest : public testing::Test {
  protected:
   void SetUp() override {
     if (!UsbTestGadget::IsTestEnabled()) return;
 
-    message_loop_.reset(new base::MessageLoopForIO());
-    service_ = HidService::GetInstance(message_loop_->message_loop_proxy());
+    message_loop_.reset(new base::MessageLoopForUI());
+    io_thread_.reset(new base::TestIOThread(base::TestIOThread::kAutoStart));
+
+    service_ = HidService::GetInstance(io_thread_->task_runner());
     ASSERT_TRUE(service_);
 
-    test_gadget_ = UsbTestGadget::Claim();
+    io_thread_->PostTaskAndWait(FROM_HERE,
+                                base::Bind(&ClaimTestDevice, &test_gadget_));
     ASSERT_TRUE(test_gadget_);
-    ASSERT_TRUE(test_gadget_->SetType(UsbTestGadget::HID_ECHO));
 
     DeviceCatcher device_catcher(test_gadget_->GetSerialNumber());
     device_id_ = device_catcher.WaitForDevice();
     ASSERT_NE(device_id_, kInvalidHidDeviceId);
   }
 
-  scoped_ptr<base::MessageLoopForIO> message_loop_;
+  void TearDown() override {
+    if (io_thread_) {
+      io_thread_->PostTaskAndWait(
+          FROM_HERE,
+          base::Bind(&UnclaimTestDevice, base::Passed(&test_gadget_)));
+    }
+  }
+
+  scoped_ptr<base::MessageLoopForUI> message_loop_;
+  scoped_ptr<base::TestIOThread> io_thread_;
   HidService* service_;
   scoped_ptr<UsbTestGadget> test_gadget_;
   HidDeviceId device_id_;
 };
 
 TEST_F(HidConnectionTest, ReadWrite) {
   if (!UsbTestGadget::IsTestEnabled()) return;
 
   TestConnectCallback connect_callback;
   service_->Connect(device_id_, connect_callback.callback());
@@ skipping 19 matching lines @@
     ASSERT_EQ(0, read_callback.buffer()->data()[0]);
     for (unsigned char j = 1; j < kBufferSize; ++j) {
       ASSERT_EQ(i + j - 1, read_callback.buffer()->data()[j]);
     }
   }
 
   conn->Close();
 }
 
 }  // namespace device