Remove base::NonThreadSafe from //device/generic_sensor/

device/generic_sensor/platform_sensor_reader_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/generic_sensor/platform_sensor_reader_linux.h"
 
 #include "base/files/file_util.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
@@ skipping 46 matching lines @@
     const SensorInfoLinux* sensor_device,
     base::WeakPtr<PlatformSensorLinux> sensor,
     scoped_refptr<base::SingleThreadTaskRunner> task_runner)
     : SensorReader(sensor, std::move(task_runner)),
       sensor_file_paths_(sensor_device->device_reading_files),
       scaling_value_(sensor_device->device_scaling_value),
       offset_value_(sensor_device->device_offset_value),
       apply_scaling_func_(sensor_device->apply_scaling_func) {}
 
 PollingSensorReader::~PollingSensorReader() {
-  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
 }
 
 void PollingSensorReader::StartFetchingData(
     const PlatformSensorConfiguration& configuration) {
-  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   if (is_reading_active_)
     StopFetchingData();
   InitializeTimer(configuration);
 }
 
 void PollingSensorReader::StopFetchingData() {
-  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   is_reading_active_ = false;
   timer_.Stop();
 }
 
 void PollingSensorReader::InitializeTimer(
     const PlatformSensorConfiguration& configuration) {
-  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   DCHECK(!is_reading_active_);
   timer_.Start(FROM_HERE, base::TimeDelta::FromMicroseconds(
                               base::Time::kMicrosecondsPerSecond /
                               configuration.frequency()),
                this, &PollingSensorReader::PollForData);
   is_reading_active_ = true;
 }
 
 void PollingSensorReader::PollForData() {
-  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
 
   SensorReading readings;
   DCHECK_LE(sensor_file_paths_.size(), arraysize(readings.values));
   int i = 0;
   for (const auto& path : sensor_file_paths_) {
     std::string new_read_value;
     if (!base::ReadFileToString(path, &new_read_value)) {
       NotifyReadError();
       StopFetchingData();
       return;
@@ skipping 29 matching lines @@
   return base::MakeUnique<PollingSensorReader>(sensor_device, sensor,
                                                std::move(task_runner));
 }
 
 SensorReader::SensorReader(
     base::WeakPtr<PlatformSensorLinux> sensor,
     scoped_refptr<base::SingleThreadTaskRunner> task_runner)
     : sensor_(sensor),
       task_runner_(std::move(task_runner)),
       is_reading_active_(false) {
-  thread_checker_.DetachFromThread();
+  DETACH_FROM_THREAD(thread_checker_);
 }
 
 SensorReader::~SensorReader() {
-  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
 }
 
 void SensorReader::NotifyReadError() {
-  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   if (is_reading_active_) {
     task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&PlatformSensorLinux::NotifyPlatformSensorError, sensor_));
   }
 }
 
 }  // namespace device