Use the task scheduler for blocking tasks in the USB service on Linux

device/usb/usb_device_linux.cc

Index: device/usb/usb_device_linux.cc
diff --git a/device/usb/usb_device_linux.cc b/device/usb/usb_device_linux.cc
index 08a3329162ab703672631f3009ff8e508e12f6f7..e2986a939e767a98dd43565a53a9fda4617cedc0 100644
--- a/device/usb/usb_device_linux.cc
+++ b/device/usb/usb_device_linux.cc
@@ -14,6 +14,7 @@
 #include "base/posix/eintr_wrapper.h"
 #include "base/sequenced_task_runner.h"
 #include "base/strings/utf_string_conversions.h"
+#include "base/task_scheduler/post_task.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "components/device_event_log/device_event_log.h"
 #include "device/usb/usb_descriptors.h"
@@ -27,21 +28,30 @@
 
 namespace device {
 
-UsbDeviceLinux::UsbDeviceLinux(
-    const std::string& device_path,
-    const UsbDeviceDescriptor& descriptor,
-    const std::string& manufacturer_string,
-    const std::string& product_string,
-    const std::string& serial_number,
-    uint8_t active_configuration,
-    scoped_refptr<base::SequencedTaskRunner> blocking_task_runner)
+namespace {
+
+scoped_refptr<base::SequencedTaskRunner> CreateBlockingTaskRunner() {

[robliao, 2017/05/01 16:36:19]

It might be useful to have this in a shared header file to ensure the same
blocking task runner policy on all of the platforms.

[Reilly Grant (use Gerrit), 2017/05/01 20:57:43]

Done.

+  return base::CreateSequencedTaskRunnerWithTraits(
+      base::TaskTraits()
+          .MayBlock()
+          .WithPriority(base::TaskPriority::USER_VISIBLE)
+          .WithShutdownBehavior(
+              base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN));
+}
+
+}  // namespace
+
+UsbDeviceLinux::UsbDeviceLinux(const std::string& device_path,
+                               const UsbDeviceDescriptor& descriptor,
+                               const std::string& manufacturer_string,
+                               const std::string& product_string,
+                               const std::string& serial_number,
+                               uint8_t active_configuration)
     : UsbDevice(descriptor,
                 base::UTF8ToUTF16(manufacturer_string),
                 base::UTF8ToUTF16(product_string),
                 base::UTF8ToUTF16(serial_number)),
-      device_path_(device_path),
-      task_runner_(base::ThreadTaskRunnerHandle::Get()),
-      blocking_task_runner_(blocking_task_runner) {
+      device_path_(device_path) {
   ActiveConfigurationChanged(active_configuration);
 }
 
@@ -50,7 +60,7 @@ UsbDeviceLinux::~UsbDeviceLinux() {}
 #if defined(OS_CHROMEOS)
 
 void UsbDeviceLinux::CheckUsbAccess(const ResultCallback& callback) {
-  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
   chromeos::PermissionBrokerClient* client =
       chromeos::DBusThreadManager::Get()->GetPermissionBrokerClient();
   DCHECK(client) << "Could not get permission broker client.";
@@ -60,7 +70,7 @@ void UsbDeviceLinux::CheckUsbAccess(const ResultCallback& callback) {
 #endif  // defined(OS_CHROMEOS)
 
 void UsbDeviceLinux::Open(const OpenCallback& callback) {
-  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
 
 #if defined(OS_CHROMEOS)
   chromeos::PermissionBrokerClient* client =
@@ -71,9 +81,12 @@ void UsbDeviceLinux::Open(const OpenCallback& callback) {
       base::Bind(&UsbDeviceLinux::OnOpenRequestComplete, this, callback),
       base::Bind(&UsbDeviceLinux::OnOpenRequestError, this, callback));
 #else
-  blocking_task_runner_->PostTask(
+  scoped_refptr<base::SequencedTaskRunner> blocking_task_runner =
+      CreateBlockingTaskRunner();
+  blocking_task_runner->PostTask(
       FROM_HERE,
-      base::Bind(&UsbDeviceLinux::OpenOnBlockingThread, this, callback));
+      base::Bind(&UsbDeviceLinux::OpenOnBlockingThread, this, callback,
+                 base::ThreadTaskRunnerHandle::Get(), blocking_task_runner));
 #endif  // defined(OS_CHROMEOS)
 }
 
@@ -86,7 +99,7 @@ void UsbDeviceLinux::OnOpenRequestComplete(const OpenCallback& callback,
     callback.Run(nullptr);
     return;
   }
-  Opened(std::move(fd), callback);
+  Opened(std::move(fd), callback, CreateBlockingTaskRunner());
 }
 
 void UsbDeviceLinux::OnOpenRequestError(const OpenCallback& callback,
@@ -99,23 +112,30 @@ void UsbDeviceLinux::OnOpenRequestError(const OpenCallback& callback,
 
 #else
 
-void UsbDeviceLinux::OpenOnBlockingThread(const OpenCallback& callback) {
+void UsbDeviceLinux::OpenOnBlockingThread(
+    const OpenCallback& callback,
+    scoped_refptr<base::SequencedTaskRunner> task_runner,
+    scoped_refptr<base::SequencedTaskRunner> blocking_task_runner) {
   base::ScopedFD fd(HANDLE_EINTR(open(device_path_.c_str(), O_RDWR)));
   if (fd.is_valid()) {
-    task_runner_->PostTask(FROM_HERE, base::Bind(&UsbDeviceLinux::Opened, this,
-                                                 base::Passed(&fd), callback));
+    task_runner->PostTask(
+        FROM_HERE, base::Bind(&UsbDeviceLinux::Opened, this, base::Passed(&fd),
+                              callback, blocking_task_runner));
   } else {
     USB_PLOG(EVENT) << "Failed to open " << device_path_;
-    task_runner_->PostTask(FROM_HERE, base::Bind(callback, nullptr));
+    task_runner->PostTask(FROM_HERE, base::Bind(callback, nullptr));
   }
 }
 
 #endif  // defined(OS_CHROMEOS)
 
-void UsbDeviceLinux::Opened(base::ScopedFD fd, const OpenCallback& callback) {
-  DCHECK(thread_checker_.CalledOnValidThread());
+void UsbDeviceLinux::Opened(
+    base::ScopedFD fd,
+    const OpenCallback& callback,
+    scoped_refptr<base::SequencedTaskRunner> blocking_task_runner) {
+  DCHECK(sequence_checker_.CalledOnValidSequence());
   scoped_refptr<UsbDeviceHandle> device_handle =
-      new UsbDeviceHandleUsbfs(this, std::move(fd), blocking_task_runner_);
+      new UsbDeviceHandleUsbfs(this, std::move(fd), blocking_task_runner);
   handles().push_back(device_handle.get());
   callback.Run(device_handle);
 }