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

device/usb/usb_device_handle_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_device_handle_impl.h"
 
 #include <algorithm>
 #include <memory>
 #include <numeric>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/macros.h"
+#include "base/sequence_checker.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/string16.h"
-#include "base/synchronization/lock.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "components/device_event_log/device_event_log.h"
 #include "device/usb/usb_context.h"
 #include "device/usb/usb_descriptors.h"
 #include "device/usb/usb_device_impl.h"
 #include "device/usb/usb_error.h"
 #include "device/usb/usb_service.h"
 #include "net/base/io_buffer.h"
 #include "third_party/libusb/src/libusb/libusb.h"
 
@@ skipping 112 matching lines @@
 
 }  // namespace
 
 class UsbDeviceHandleImpl::InterfaceClaimer
     : public base::RefCountedThreadSafe<UsbDeviceHandleImpl::InterfaceClaimer> {
  public:
   InterfaceClaimer(scoped_refptr<UsbDeviceHandleImpl> handle,
                    int interface_number,
                    scoped_refptr<base::SingleThreadTaskRunner> task_runner);
 
   int interface_number() const { return interface_number_; }

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

Should these accessors also be DCHECK'ing the sequence?

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

DCHECKing in inline accessors is frowned upon. The important bit is that the
destructor is called on the correct thread as that is the method that does real
work.

   int alternate_setting() const { return alternate_setting_; }
   void set_alternate_setting(const int alternate_setting) {
     alternate_setting_ = alternate_setting;
   }
 
   void set_release_callback(const ResultCallback& callback) {
     release_callback_ = callback;
   }
 
  private:
   friend class base::RefCountedThreadSafe<InterfaceClaimer>;
   ~InterfaceClaimer();
 
   const scoped_refptr<UsbDeviceHandleImpl> handle_;
   const int interface_number_;
   int alternate_setting_;
   const scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
   ResultCallback release_callback_;
-  base::ThreadChecker thread_checker_;
+  base::SequenceChecker sequence_checker_;
 
   DISALLOW_COPY_AND_ASSIGN(InterfaceClaimer);
 };
 
 UsbDeviceHandleImpl::InterfaceClaimer::InterfaceClaimer(
     scoped_refptr<UsbDeviceHandleImpl> handle,
     int interface_number,
     scoped_refptr<base::SingleThreadTaskRunner> task_runner)
     : handle_(handle),
       interface_number_(interface_number),
       alternate_setting_(0),
       task_runner_(task_runner) {}
 
 UsbDeviceHandleImpl::InterfaceClaimer::~InterfaceClaimer() {
-  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
   int rc = libusb_release_interface(handle_->handle(), interface_number_);
   if (rc != LIBUSB_SUCCESS) {
     USB_LOG(DEBUG) << "Failed to release interface: "
                    << ConvertPlatformUsbErrorToString(rc);
   }
   if (!release_callback_.is_null()) {
     task_runner_->PostTask(FROM_HERE,
                            base::Bind(release_callback_, rc == LIBUSB_SUCCESS));
   }
 }
@@ skipping 948 matching lines @@
   } else {
     transfer->callback_task_runner()->PostTask(FROM_HERE, callback);
   }
 
   // libusb_free_transfer races with libusb_submit_transfer and only work-
   // around is to make sure to call them on the same thread.
   blocking_task_runner_->DeleteSoon(FROM_HERE, transfer);
 }
 
 }  // namespace device