Move off of deprecated base::NonThreadSafe in device/

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>
@@ skipping 218 matching lines @@
 }
 
 UsbServiceImpl::~UsbServiceImpl() {
   if (hotplug_enabled_)
     libusb_hotplug_deregister_callback(context_->context(), hotplug_handle_);
   for (auto* platform_device : ignored_devices_)
     libusb_unref_device(platform_device);
 }
 
 void UsbServiceImpl::GetDevices(const GetDevicesCallback& callback) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   if (usb_unavailable_) {
     task_runner()->PostTask(
         FROM_HERE,
         base::Bind(callback, std::vector<scoped_refptr<UsbDevice>>()));
     return;
   }
 
   if (hotplug_enabled_ && !enumeration_in_progress_) {
     // The device list is updated live when hotplug events are supported.
@@ skipping 51 matching lines @@
   RefreshDevices();
 
 #if defined(OS_WIN)
   DeviceMonitorWin* device_monitor = DeviceMonitorWin::GetForAllInterfaces();
   if (device_monitor)
     device_observer_.Add(device_monitor);
 #endif  // OS_WIN
 }
 
 void UsbServiceImpl::RefreshDevices() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   if (!context_ || enumeration_in_progress_)
     return;
 
   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();
   }
 
   base::PostTaskWithTraits(FROM_HERE, kBlockingTaskTraits,
                            base::Bind(&GetDeviceListOnBlockingThread,
                                       device_path, context_, task_runner(),
                                       base::Bind(&UsbServiceImpl::OnDeviceList,
                                                  weak_factory_.GetWeakPtr())));
 }
 
 void UsbServiceImpl::OnDeviceList(libusb_device** platform_devices,
                                   size_t device_count) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   if (!platform_devices) {
     RefreshDevicesComplete();
     return;
   }
 
   base::Closure refresh_complete =
       base::BarrierClosure(static_cast<int>(device_count),
                            base::Bind(&UsbServiceImpl::RefreshDevicesComplete,
                                       weak_factory_.GetWeakPtr()));
   std::list<PlatformUsbDevice> new_devices;
@@ skipping 43 matching lines @@
   }
 
   for (PlatformUsbDevice platform_device : new_devices) {
     EnumerateDevice(platform_device, refresh_complete);
   }
 
   libusb_free_device_list(platform_devices, true);
 }
 
 void UsbServiceImpl::RefreshDevicesComplete() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(enumeration_in_progress_);
 
   enumeration_ready_ = true;
   enumeration_in_progress_ = false;
   devices_being_enumerated_.clear();
 
   if (!pending_enumeration_callbacks_.empty()) {
     std::vector<scoped_refptr<UsbDevice>> result;
     result.reserve(devices().size());
     for (const auto& map_entry : devices())
@@ skipping 114 matching lines @@
                                 base::Unretained(self), device));
       break;
     default:
       NOTREACHED();
   }
 
   return 0;
 }
 
 void UsbServiceImpl::OnPlatformDeviceAdded(PlatformUsbDevice platform_device) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(!base::ContainsKey(platform_devices_, platform_device));
   EnumerateDevice(platform_device, base::Bind(&base::DoNothing));
   libusb_unref_device(platform_device);
 }
 
 void UsbServiceImpl::OnPlatformDeviceRemoved(
     PlatformUsbDevice platform_device) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   PlatformDeviceMap::iterator it = platform_devices_.find(platform_device);
   if (it != platform_devices_.end()) {
     RemoveDevice(it->second);
   } else {
     devices_being_enumerated_.erase(platform_device);
   }
   libusb_unref_device(platform_device);
 }
 
 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