Use the task scheduler in the new Windows USB backend

device/u2f/u2f_hid_device_unittest.cc

 // Copyright 2017 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 <list>
 
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
-#include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
-#include "base/test/test_io_thread.h"
-#include "base/threading/thread_task_runner_handle.h"
+#include "base/test/scoped_task_environment.h"
 #include "device/base/mock_device_client.h"
 #include "device/hid/hid_connection.h"
 #include "device/hid/hid_device_filter.h"
 #include "device/hid/mock_hid_service.h"
 #include "device/test/test_device_client.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "u2f_apdu_command.h"
 #include "u2f_apdu_response.h"
 #include "u2f_hid_device.h"
@@ skipping 135 matching lines @@
 
  private:
   std::unique_ptr<U2fApduResponse> response_;
   base::Closure closure_;
   U2fDevice::DeviceCallback callback_;
   base::RunLoop run_loop_;
 };
 
 class U2fHidDeviceTest : public testing::Test {
  public:
-  void SetUp() override {
-    message_loop_.reset(new base::MessageLoopForUI());
-    io_thread_.reset(new base::TestIOThread(base::TestIOThread::kAutoStart));
-    device_client_.reset(
-        new device::TestDeviceClient(io_thread_->task_runner()));
-  }
+  U2fHidDeviceTest()
+      : scoped_task_environment_(
+            base::test::ScopedTaskEnvironment::MainThreadType::UI) {}
 
- protected:
-  std::unique_ptr<base::MessageLoopForUI> message_loop_;
-  std::unique_ptr<base::TestIOThread> io_thread_;
-  std::unique_ptr<device::TestDeviceClient> device_client_;
+ private:
+  base::test::ScopedTaskEnvironment scoped_task_environment_;

[mcasas, 2017/05/16 21:24:24]

nit: probably const.

+  TestDeviceClient device_client_;
 };
 
 TEST_F(U2fHidDeviceTest, TestHidDeviceVersion) {
   if (!U2fHidDevice::IsTestEnabled())
     return;
 
   U2fDeviceEnumerate callback;
   HidService* hid_service = DeviceClient::Get()->GetHidService();
   hid_service->GetDevices(callback.callback());
   std::list<std::unique_ptr<U2fHidDevice>>& u2f_devices =
@@ skipping 120 matching lines @@
       U2fApduResponse::CreateFromMessage(std::vector<uint8_t>({0x0, 0x0})));
   device->DeviceTransact(U2fApduCommand::CreateVersion(),
                          base::Bind(&ResponseCallback, &response3));
   EXPECT_EQ(U2fHidDevice::State::DEVICE_ERROR, device->state_);
   EXPECT_EQ(nullptr, response1);
   EXPECT_EQ(nullptr, response2);
   EXPECT_EQ(nullptr, response3);
 };
 
 }  // namespace device