Use the task scheduler in the USB service on macOS and Windows

device/usb/usb_service_impl.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 "device/usb/usb_service_impl.h"
 
 #include <stdint.h>
 
 #include <list>
 #include <memory>
 #include <set>
 #include <utility>
 
 #include "base/barrier_closure.h"
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/memory/weak_ptr.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
+#include "base/task_scheduler/post_task.h"
 #include "build/build_config.h"
 #include "components/device_event_log/device_event_log.h"
 #include "device/usb/usb_device_handle.h"
 #include "device/usb/usb_error.h"
 #include "device/usb/webusb_descriptors.h"
 #include "net/base/io_buffer.h"
 #include "third_party/libusb/src/libusb/libusb.h"
 
 #if defined(OS_WIN)
 #define INITGUID
@@ skipping 177 matching lines @@
       ReadWebUsbDescriptors(device_handle, base::Bind(&OnReadBosDescriptor,
                                                       device_handle, barrier));
     }
   } else {
     failure_closure.Run();
   }
 }
 
 }  // namespace
 
-UsbServiceImpl::UsbServiceImpl(
-    scoped_refptr<base::SequencedTaskRunner> blocking_task_runner_in)
-    : UsbService(std::move(blocking_task_runner_in)),
+UsbServiceImpl::UsbServiceImpl()
+    : UsbService(nullptr),
 #if defined(OS_WIN)
       device_observer_(this),
 #endif
       weak_factory_(this) {
-  blocking_task_runner()->PostTask(
+  base::PostTaskWithTraits(

[robliao, 2017/05/02 14:32:59]

Calls to this API are done in parallel. If this task needs to run before the the
one below, it may be more robust to have a sequenced blocking task runner here
(or if RefreshDevices is guaranteed to not be called before this is complete,
then it's all good here).

[Reilly Grant (use Gerrit), 2017/05/02 23:41:44]

That's fine. RefreshDevices is guaranteed not to post its task until this task
is done.

       FROM_HERE,
+      base::TaskTraits()
+          .MayBlock()
+          .WithPriority(base::TaskPriority::USER_VISIBLE)
+          .WithShutdownBehavior(
+              base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN),
       base::Bind(&InitializeUsbContextOnBlockingThread, task_runner(),
                  base::Bind(&UsbServiceImpl::OnUsbContext,
                             weak_factory_.GetWeakPtr())));
 }
 
 UsbServiceImpl::~UsbServiceImpl() {
   if (hotplug_enabled_)
     libusb_hotplug_deregister_callback(context_->context(), hotplug_handle_);
   for (auto* platform_device : ignored_devices_)
     libusb_unref_device(platform_device);
@@ skipping 79 matching lines @@
 
   enumeration_in_progress_ = true;
   DCHECK(devices_being_enumerated_.empty());
 
   std::string device_path;
   if (!pending_path_enumerations_.empty()) {
     device_path = pending_path_enumerations_.front();
     pending_path_enumerations_.pop();
   }
 
-  blocking_task_runner()->PostTask(
+  base::PostTaskWithTraits(
       FROM_HERE,
+      base::TaskTraits()
+          .MayBlock()
+          .WithPriority(base::TaskPriority::USER_VISIBLE)
+          .WithShutdownBehavior(
+              base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN),
       base::Bind(&GetDeviceListOnBlockingThread, device_path, context_,
-                 task_runner(), base::Bind(&UsbServiceImpl::OnDeviceList,
-                                           weak_factory_.GetWeakPtr())));
+                 task_runner(),
+                 base::Bind(&UsbServiceImpl::OnDeviceList,
+                            weak_factory_.GetWeakPtr())));
 }
 
 void UsbServiceImpl::OnDeviceList(libusb_device** platform_devices,
                                   size_t device_count) {
   DCHECK(CalledOnValidThread());
   if (!platform_devices) {
     RefreshDevicesComplete();
     return;
   }
 
@@ skipping 88 matching lines @@
   int rv = libusb_get_device_descriptor(platform_device, &descriptor);
   if (rv == LIBUSB_SUCCESS) {
     if (descriptor.bDeviceClass == LIBUSB_CLASS_HUB) {
       // Don't try to enumerate hubs. We never want to connect to a hub.
       libusb_ref_device(platform_device);
       ignored_devices_.insert(platform_device);
       refresh_complete.Run();
       return;
     }
 
-    scoped_refptr<UsbDeviceImpl> device(new UsbDeviceImpl(
-        context_, platform_device, descriptor, blocking_task_runner()));
+    scoped_refptr<UsbDeviceImpl> device(
+        new UsbDeviceImpl(context_, platform_device, descriptor));
     base::Closure add_device =
         base::Bind(&UsbServiceImpl::AddDevice, weak_factory_.GetWeakPtr(),
                    refresh_complete, device);
     base::Closure enumeration_failed = base::Bind(
         &UsbServiceImpl::EnumerationFailed, weak_factory_.GetWeakPtr(),
         platform_device, refresh_complete);
     bool read_bos_descriptors = descriptor.bcdUSB >= kUsbVersion2_1;
 
     if (descriptor.iManufacturer == 0 && descriptor.iProduct == 0 &&
         descriptor.iSerialNumber == 0 && !read_bos_descriptors) {
@@ skipping 99 matching lines @@
 }
 
 void UsbServiceImpl::EnumerationFailed(PlatformUsbDevice platform_device,
                                        const base::Closure& refresh_complete) {
   libusb_ref_device(platform_device);
   ignored_devices_.insert(platform_device);
   refresh_complete.Run();
 }
 
 }  // namespace device