Use the task scheduler in the new Windows USB backend

device/usb/usb_service_win.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 "device/usb/usb_service_win.h"
 
 #include <setupapi.h>
 #include <stdint.h>
 #include <usbiodef.h>
 
@@ skipping 152 matching lines @@
     USB_PLOG(ERROR) << "SetupDiEnumDeviceInterfaces";
     return false;
   }
 
   return GetDeviceInterfaceDetails(dev_info.get(), &device_interface_data,
                                    device_path, nullptr, nullptr, nullptr);
 }
 
 }  // 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(
         SetupDiGetClassDevs(&GUID_DEVINTERFACE_USB_DEVICE, nullptr, 0,
                             DIGCF_DEVICEINTERFACE | DIGCF_PRESENT));
     if (!dev_info.is_valid()) {
       USB_PLOG(ERROR) << "Failed to set up device enumeration";
       service_task_runner_->PostTask(
           FROM_HERE, base::Bind(&UsbServiceWin::HelperStarted, service_));
       return;
@@ skipping 80 matching lines @@
 
  private:
   std::unordered_map<std::string, std::string> hub_paths_;
 
   // Calls back to |service_| must be posted to |service_task_runner_|, which
   // runs tasks on the thread where that object lives.
   scoped_refptr<base::SingleThreadTaskRunner> service_task_runner_;
   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 =
       DeviceMonitorWin::GetForDeviceInterface(GUID_DEVINTERFACE_USB_DEVICE);
   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() {}
+UsbServiceWin::~UsbServiceWin() {
+  DCHECK(!helper_);
+}
+
+void UsbServiceWin::Shutdown() {
+  blocking_task_runner()->DeleteSoon(FROM_HERE, helper_.release());
+  UsbService::Shutdown();
+}
 
 void UsbServiceWin::GetDevices(const GetDevicesCallback& callback) {
   DCHECK(CalledOnValidThread());
   if (enumeration_ready())
     UsbService::GetDevices(callback);
   else
     enumeration_callbacks_.push_back(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,
                                     const std::string& device_path) {
   DCHECK(CalledOnValidThread());
   auto by_path_it = devices_by_path_.find(device_path);
   if (by_path_it == devices_by_path_.end())
     return;
 
   scoped_refptr<UsbDeviceWin> device = by_path_it->second;
@@ skipping 80 matching lines @@
       result.push_back(map_entry.second);
     for (const auto& callback : enumeration_callbacks_)
       callback.Run(result);
     enumeration_callbacks_.clear();
   } else if (success && enumeration_ready()) {
     NotifyDeviceAdded(device);
   }
 }
 
 }  // namespace device