Use the task scheduler in the new Windows USB backend

This removes the last UsbService*::Create() method taking a
SequencedTaskRunner, allowing us to start cleaning up DeviceClient as
well.

BUG=None

Review-Url: https://codereview.chromium.org/2885143002
Cr-Commit-Position: refs/heads/master@{#472243}

chrome/browser/chrome_device_client.cc

@@ -31,10 +31,8 @@ void ChromeDeviceClient::Shutdown() {
 
 device::UsbService* ChromeDeviceClient::GetUsbService() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  if (!usb_service_) {
-    usb_service_ = device::UsbService::Create(
-        BrowserThread::GetTaskRunnerForThread(BrowserThread::FILE));
-  }
+  if (!usb_service_)
+    usb_service_ = device::UsbService::Create();
   return usb_service_.get();
 }
 

device/hid/hid_connection_unittest.cc

@@ -12,10 +12,10 @@
 
 #include "base/bind.h"
 #include "base/callback.h"
-#include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/scoped_observer.h"
 #include "base/strings/utf_string_conversions.h"
+#include "base/test/scoped_task_environment.h"
 #include "base/test/test_io_thread.h"
 #include "device/hid/hid_service.h"
 #include "device/test/test_device_client.h"
@@ -149,18 +149,20 @@ class TestIoCallback {
 }  // namespace
 
 class HidConnectionTest : public testing::Test {
+ public:
+  HidConnectionTest()
+      : scoped_task_environment_(
+            base::test::ScopedTaskEnvironment::MainThreadType::UI),
+        io_thread_(base::TestIOThread::kAutoStart) {}
+
  protected:
   void SetUp() override {
     if (!UsbTestGadget::IsTestEnabled()) return;
 
-    message_loop_.reset(new base::MessageLoopForUI());
-    io_thread_.reset(new base::TestIOThread(base::TestIOThread::kAutoStart));
-    device_client_.reset(new TestDeviceClient(io_thread_->task_runner()));
-
     service_ = DeviceClient::Get()->GetHidService();
     ASSERT_TRUE(service_);
 
-    test_gadget_ = UsbTestGadget::Claim(io_thread_->task_runner());
+    test_gadget_ = UsbTestGadget::Claim(io_thread_.task_runner());
     ASSERT_TRUE(test_gadget_);
     ASSERT_TRUE(test_gadget_->SetType(UsbTestGadget::HID_ECHO));
 
@@ -170,9 +172,9 @@ class HidConnectionTest : public testing::Test {
     ASSERT_NE(device_id_, kInvalidHidDeviceId);
   }
 
-  std::unique_ptr<base::MessageLoopForUI> message_loop_;
-  std::unique_ptr<base::TestIOThread> io_thread_;
-  std::unique_ptr<TestDeviceClient> device_client_;
+  base::test::ScopedTaskEnvironment scoped_task_environment_;
+  base::TestIOThread io_thread_;
+  TestDeviceClient device_client_;
   HidService* service_;
   std::unique_ptr<UsbTestGadget> test_gadget_;
   HidDeviceId device_id_;

device/test/test_device_client.cc

@@ -16,9 +16,7 @@
 
 namespace device {
 
-TestDeviceClient::TestDeviceClient(
-    scoped_refptr<base::SingleThreadTaskRunner> blocking_task_runner)
-    : blocking_task_runner_(blocking_task_runner) {}
+TestDeviceClient::TestDeviceClient() = default;
 
 TestDeviceClient::~TestDeviceClient() {
   if (hid_service_)
@@ -38,9 +36,8 @@ HidService* TestDeviceClient::GetHidService() {
 
 UsbService* TestDeviceClient::GetUsbService() {
 #if !defined(OS_ANDROID) && !defined(OS_IOS)
-  if (!usb_service_) {
-    usb_service_ = UsbService::Create(blocking_task_runner_);
-  }
+  if (!usb_service_)
+    usb_service_ = UsbService::Create();
 #endif
   return usb_service_.get();
 }

device/test/test_device_client.h

@@ -4,13 +4,8 @@
 
 #include <memory>
 
-#include "base/memory/ref_counted.h"
 #include "device/base/device_client.h"
 
-namespace base {
-class SingleThreadTaskRunner;
-}
-
 namespace device {
 
 class HidService;
@@ -18,7 +13,7 @@ class UsbService;
 
 class TestDeviceClient : public DeviceClient {
  public:
-  TestDeviceClient(scoped_refptr<base::SingleThreadTaskRunner> task_runner);
+  TestDeviceClient();
 
   // Must be destroyed when tasks can still be posted to |task_runner|.
   ~TestDeviceClient() override;
@@ -29,7 +24,6 @@ class TestDeviceClient : public DeviceClient {
  private:
   std::unique_ptr<HidService> hid_service_;
   std::unique_ptr<UsbService> usb_service_;
-  scoped_refptr<base::SingleThreadTaskRunner> blocking_task_runner_;
 };
 
 }  // namespace device

device/u2f/u2f_hid_device_unittest.cc

@@ -6,10 +6,8 @@
 
 #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"
@@ -165,17 +163,13 @@ class TestDeviceCallback {
 
 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_;
+  TestDeviceClient device_client_;
 };
 
 TEST_F(U2fHidDeviceTest, TestHidDeviceVersion) {

device/usb/usb_device_handle_unittest.cc

@@ -29,8 +29,7 @@ class UsbDeviceHandleTest : public ::testing::Test {
   UsbDeviceHandleTest()
       : io_thread_(base::TestIOThread::kAutoStart),
         scoped_task_environment_(
-            base::test::ScopedTaskEnvironment::MainThreadType::UI),
-        device_client_(io_thread_.task_runner()) {}
+            base::test::ScopedTaskEnvironment::MainThreadType::UI) {}
 
  protected:
   base::TestIOThread io_thread_;

device/usb/usb_service.cc

@@ -44,15 +44,14 @@ void UsbService::Observer::OnDeviceRemovedCleanup(
 void UsbService::Observer::WillDestroyUsbService() {}
 
 // static
-std::unique_ptr<UsbService> UsbService::Create(
-    scoped_refptr<base::SequencedTaskRunner> blocking_task_runner) {
+std::unique_ptr<UsbService> UsbService::Create() {
 #if defined(OS_ANDROID)
   return base::WrapUnique(new UsbServiceAndroid());
 #elif defined(USE_UDEV)
   return base::WrapUnique(new UsbServiceLinux());
 #elif defined(OS_WIN)
   if (base::FeatureList::IsEnabled(kNewUsbBackend))
-    return base::WrapUnique(new UsbServiceWin(blocking_task_runner));
+    return base::WrapUnique(new UsbServiceWin());
   else
     return base::WrapUnique(new UsbServiceImpl());
 #elif defined(OS_MACOSX)

device/usb/usb_service.h

@@ -49,10 +49,8 @@ class UsbService : public base::NonThreadSafe {
     virtual void WillDestroyUsbService();
   };
 
-  // The file task runner reference is used for blocking I/O operations.
   // Returns nullptr when initialization fails.
-  static std::unique_ptr<UsbService> Create(
-      scoped_refptr<base::SequencedTaskRunner> blocking_task_runner);
+  static std::unique_ptr<UsbService> Create();
 
   // Creates a SequencedTaskRunner appropriate for blocking I/O operations.
   static scoped_refptr<base::SequencedTaskRunner> CreateBlockingTaskRunner();

device/usb/usb_service_unittest.cc

@@ -27,11 +27,8 @@ class UsbServiceTest : public ::testing::Test {
   UsbServiceTest()
       : scoped_task_environment_(
             base::test::ScopedTaskEnvironment::MainThreadType::UI),
-        io_thread_(base::TestIOThread::kAutoStart) {}
-
-  void SetUp() override {
-    device_client_.reset(new TestDeviceClient(io_thread_.task_runner()));
-  }
+        io_thread_(base::TestIOThread::kAutoStart),
+        device_client_(new TestDeviceClient()) {}
 
  protected:
   base::test::ScopedTaskEnvironment scoped_task_environment_;

device/usb/usb_service_win.cc

@@ -170,12 +170,12 @@ bool GetHubDevicePath(const std::string& instance_id,
 
 }  // namespace
 
-class UsbServiceWin::BlockingThreadHelper {
+class UsbServiceWin::BlockingTaskHelper {
  public:
-  explicit BlockingThreadHelper(base::WeakPtr<UsbServiceWin> service)
+  explicit BlockingTaskHelper(base::WeakPtr<UsbServiceWin> service)
       : service_task_runner_(base::ThreadTaskRunnerHandle::Get()),
         service_(service) {}
-  ~BlockingThreadHelper() {}
+  ~BlockingTaskHelper() {}
 
   void EnumerateDevices() {
     ScopedDevInfo dev_info(
@@ -276,9 +276,8 @@ class UsbServiceWin::BlockingThreadHelper {
   base::WeakPtr<UsbServiceWin> service_;
 };
 
-UsbServiceWin::UsbServiceWin(
-    scoped_refptr<base::SequencedTaskRunner> blocking_task_runner)
-    : UsbService(blocking_task_runner),
+UsbServiceWin::UsbServiceWin()
+    : UsbService(CreateBlockingTaskRunner()),
       device_observer_(this),
       weak_factory_(this) {
   DeviceMonitorWin* device_monitor =
@@ -286,13 +285,20 @@ UsbServiceWin::UsbServiceWin(
   if (device_monitor)
     device_observer_.Add(device_monitor);
 
-  helper_ = new BlockingThreadHelper(weak_factory_.GetWeakPtr());
-  blocking_task_runner->PostTask(
-      FROM_HERE, base::Bind(&BlockingThreadHelper::EnumerateDevices,
-                            base::Unretained(helper_)));
+  helper_ = base::MakeUnique<BlockingTaskHelper>(weak_factory_.GetWeakPtr());
+  blocking_task_runner()->PostTask(
+      FROM_HERE, base::Bind(&BlockingTaskHelper::EnumerateDevices,
+                            base::Unretained(helper_.get())));
+}
+
+UsbServiceWin::~UsbServiceWin() {
+  DCHECK(!helper_);
 }
 
-UsbServiceWin::~UsbServiceWin() {}
+void UsbServiceWin::Shutdown() {
+  blocking_task_runner()->DeleteSoon(FROM_HERE, helper_.release());
+  UsbService::Shutdown();
+}
 
 void UsbServiceWin::GetDevices(const GetDevicesCallback& callback) {
   DCHECK(CalledOnValidThread());
@@ -305,8 +311,8 @@ void UsbServiceWin::GetDevices(const GetDevicesCallback& callback) {
 void UsbServiceWin::OnDeviceAdded(const GUID& class_guid,
                                   const std::string& device_path) {
   blocking_task_runner()->PostTask(
-      FROM_HERE, base::Bind(&BlockingThreadHelper::EnumerateDevicePath,
-                            base::Unretained(helper_), device_path));
+      FROM_HERE, base::Bind(&BlockingTaskHelper::EnumerateDevicePath,
+                            base::Unretained(helper_.get()), device_path));
 }
 
 void UsbServiceWin::OnDeviceRemoved(const GUID& class_guid,

device/usb/usb_service_win.h

@@ -13,22 +13,18 @@
 #include "device/base/device_monitor_win.h"
 #include "device/usb/usb_device_win.h"
 
-namespace base {
-class SequencedTaskRunner;
-}
-
 namespace device {
 
 class UsbServiceWin : public DeviceMonitorWin::Observer, public UsbService {
  public:
-  explicit UsbServiceWin(
-      scoped_refptr<base::SequencedTaskRunner> blocking_task_runner);
+  UsbServiceWin();
   ~UsbServiceWin() override;
 
  private:
-  class BlockingThreadHelper;
+  class BlockingTaskHelper;
 
   // device::UsbService implementation
+  void Shutdown() override;
   void GetDevices(const GetDevicesCallback& callback) override;
 
   // device::DeviceMonitorWin::Observer implementation
@@ -55,7 +51,7 @@ class UsbServiceWin : public DeviceMonitorWin::Observer, public UsbService {
   uint32_t first_enumeration_countdown_ = 0;
   std::list<GetDevicesCallback> enumeration_callbacks_;
 
-  BlockingThreadHelper* helper_;
+  std::unique_ptr<BlockingTaskHelper> helper_;
   std::unordered_map<std::string, scoped_refptr<UsbDeviceWin>> devices_by_path_;
 
   ScopedObserver<DeviceMonitorWin, DeviceMonitorWin::Observer> device_observer_;

extensions/shell/browser/shell_device_client.cc

@@ -32,11 +32,8 @@ void ShellDeviceClient::Shutdown() {
 
 device::UsbService* ShellDeviceClient::GetUsbService() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-
-  if (!usb_service_) {
-    usb_service_ = device::UsbService::Create(
-        BrowserThread::GetTaskRunnerForThread(BrowserThread::FILE));
-  }
+  if (!usb_service_)
+    usb_service_ = device::UsbService::Create();
   return usb_service_.get();
 }