Move off of deprecated base::NonThreadSafe in device/

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 278 matching lines @@
   blocking_task_runner()->PostTask(
       FROM_HERE, base::Bind(&BlockingTaskHelper::EnumerateDevices,
                             base::Unretained(helper_.get())));
 }
 
 UsbServiceWin::~UsbServiceWin() {
   blocking_task_runner()->DeleteSoon(FROM_HERE, helper_.release());
 }
 
 void UsbServiceWin::GetDevices(const GetDevicesCallback& callback) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   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(&BlockingTaskHelper::EnumerateDevicePath,
                             base::Unretained(helper_.get()), device_path));
 }
 
 void UsbServiceWin::OnDeviceRemoved(const GUID& class_guid,
                                     const std::string& device_path) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   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;
   devices_by_path_.erase(by_path_it);
   device->OnDisconnect();
 
   auto by_guid_it = devices().find(device->guid());
   if (by_guid_it != devices().end() && enumeration_ready()) {
     USB_LOG(USER) << "USB device removed: path=" << device->device_path()
                   << " guid=" << device->guid();
 
     devices().erase(by_guid_it);
     NotifyDeviceRemoved(device);
   }
 }
 
 void UsbServiceWin::HelperStarted() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   helper_started_ = true;
   if (enumeration_ready()) {
     std::vector<scoped_refptr<UsbDevice>> result;
     result.reserve(devices().size());
     for (const auto& map_entry : devices())
       result.push_back(map_entry.second);
     for (const auto& callback : enumeration_callbacks_)
       callback.Run(result);
     enumeration_callbacks_.clear();
   }
@@ skipping 11 matching lines @@
 
   scoped_refptr<UsbDeviceWin> device(new UsbDeviceWin(
       device_path, hub_path, port_number, driver_name, blocking_task_runner()));
   devices_by_path_[device->device_path()] = device;
   device->ReadDescriptors(base::Bind(&UsbServiceWin::DeviceReady,
                                      weak_factory_.GetWeakPtr(), device));
 }
 
 void UsbServiceWin::DeviceReady(scoped_refptr<UsbDeviceWin> device,
                                 bool success) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   bool enumeration_became_ready = false;
   if (!enumeration_ready()) {
     DCHECK_GT(first_enumeration_countdown_, 0u);
     first_enumeration_countdown_--;
     if (enumeration_ready())
       enumeration_became_ready = true;
   }
 
   // If |device| was disconnected while descriptors were being read then it
@@ skipping 23 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