Move off of deprecated base::NonThreadSafe in device/

device/usb/usb_service_linux.cc

 // Copyright 2016 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_linux.h"
 
 #include <stdint.h>
 
 #include <utility>
 
@@ skipping 175 matching lines @@
   blocking_task_runner()->PostTask(
       FROM_HERE,
       base::Bind(&FileThreadHelper::Start, base::Unretained(helper_.get())));
 }
 
 UsbServiceLinux::~UsbServiceLinux() {
   blocking_task_runner()->DeleteSoon(FROM_HERE, helper_.release());
 }
 
 void UsbServiceLinux::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 UsbServiceLinux::OnDeviceAdded(const std::string& device_path,
                                     const UsbDeviceDescriptor& descriptor,
                                     const std::string& manufacturer,
                                     const std::string& product,
                                     const std::string& serial_number,
                                     uint8_t active_configuration) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   if (ContainsKey(devices_by_path_, device_path)) {
     USB_LOG(ERROR) << "Got duplicate add event for path: " << device_path;
     return;
   }
 
   // Devices that appear during initial enumeration are gathered into the first
   // result returned by GetDevices() and prevent device add/remove notifications
   // from being sent.
   if (!enumeration_ready())
     ++first_enumeration_countdown_;
 
   scoped_refptr<UsbDeviceLinux> device(
       new UsbDeviceLinux(device_path, descriptor, manufacturer, product,
                          serial_number, active_configuration));
   devices_by_path_[device->device_path()] = device;
   if (device->usb_version() >= kUsbVersion2_1) {
     device->Open(base::Bind(&OnDeviceOpenedToReadDescriptors,
                             base::Bind(&UsbServiceLinux::DeviceReady,
                                        weak_factory_.GetWeakPtr(), device)));
   } else {
     DeviceReady(device, true /* success */);
   }
 }
 
 void UsbServiceLinux::DeviceReady(scoped_refptr<UsbDeviceLinux> 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 22 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);
   }
 }
 
 void UsbServiceLinux::OnDeviceRemoved(const std::string& path) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   auto by_path_it = devices_by_path_.find(path);
   if (by_path_it == devices_by_path_.end())
     return;
 
   scoped_refptr<UsbDeviceLinux> 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 UsbServiceLinux::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();
   }
 }
 
 }  // namespace device