[sensors](Linux) Fix tsan data race in sensor reader

device/generic_sensor/platform_sensor_provider_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_provider_linux.h"
 
 #include "base/memory/singleton.h"
+#include "base/task_runner_util.h"
 #include "base/threading/thread.h"
 #include "device/generic_sensor/linux/sensor_data_linux.h"
 #include "device/generic_sensor/platform_sensor_linux.h"
+#include "device/generic_sensor/platform_sensor_reader_linux.h"
 
 namespace device {
 
 // static
 PlatformSensorProviderLinux* PlatformSensorProviderLinux::GetInstance() {
   return base::Singleton<
       PlatformSensorProviderLinux,
       base::LeakySingletonTraits<PlatformSensorProviderLinux>>::get();
 }
 
@@ skipping 17 matching lines @@
     if (!sensor_nodes_enumeration_started_) {
       sensor_nodes_enumeration_started_ = file_task_runner_->PostTask(
           FROM_HERE,
           base::Bind(&SensorDeviceManager::Start,
                      base::Unretained(sensor_device_manager_.get()), this));
     }
     return;
   }
 
   SensorInfoLinux* sensor_device = GetSensorDevice(type);
-  if (!sensor_device) {
+  if (!sensor_device || !StartPollingThread()) {
     // If there are no sensors, stop polling thread.
     if (!HasSensors())
       AllSensorsRemoved();
     callback.Run(nullptr);
     return;
   }
-  SensorDeviceFound(type, std::move(mapping), callback, sensor_device);
+
+  base::PostTaskAndReplyWithResult(
+      polling_thread_->task_runner().get(), FROM_HERE,
+      base::Bind(SensorReader::Create, sensor_device,
+                 base::ThreadTaskRunnerHandle::Get()),
+      base::Bind(&PlatformSensorProviderLinux::SensorReaderCreated,
+                 base::Unretained(this), type, base::Passed(&mapping), callback,
+                 sensor_device));
 }
 
-void PlatformSensorProviderLinux::SensorDeviceFound(
+void PlatformSensorProviderLinux::SensorReaderCreated(
     mojom::SensorType type,
     mojo::ScopedSharedBufferMapping mapping,
     const PlatformSensorProviderBase::CreateSensorCallback& callback,
-    SensorInfoLinux* sensor_device) {
+    SensorInfoLinux* const sensor_device,
+    std::unique_ptr<SensorReader> sensor_reader) {
   DCHECK(CalledOnValidThread());
+  DCHECK(sensor_reader);
+  DCHECK(sensor_device);
 
-  if (!StartPollingThread()) {
-    callback.Run(nullptr);
-    return;
-  }
-
-  scoped_refptr<PlatformSensorLinux> sensor =
-      new PlatformSensorLinux(type, std::move(mapping), this, sensor_device,
-                              polling_thread_->task_runner());
+  scoped_refptr<PlatformSensorLinux> sensor = new PlatformSensorLinux(
+      type, std::move(mapping), this, sensor_device, std::move(sensor_reader),
+      polling_thread_->task_runner());
   callback.Run(sensor);
 }
 
 void PlatformSensorProviderLinux::SetFileTaskRunner(
     scoped_refptr<base::SingleThreadTaskRunner> file_task_runner) {
   DCHECK(CalledOnValidThread());
   if (!file_task_runner_)
     file_task_runner_ = file_task_runner;
 }
 
@@ skipping 64 matching lines @@
   DCHECK(CalledOnValidThread());
   file_task_runner_ = std::move(task_runner);
 }
 
 void PlatformSensorProviderLinux::ProcessStoredRequests() {
   DCHECK(CalledOnValidThread());
   std::vector<mojom::SensorType> request_types = GetPendingRequestTypes();
   if (request_types.empty())
     return;
 
+  mojom::SensorType previous_type;
   for (auto const& type : request_types) {
-    SensorInfoLinux* device = nullptr;
-    auto device_entry = sensor_devices_by_type_.find(type);
-    if (device_entry != sensor_devices_by_type_.end())
-      device = device_entry->second.get();
-    CreateSensorAndNotify(type, device);
+    DCHECK_NE(type, previous_type);
+    mojo::ScopedSharedBufferMapping mapping = MapSharedBufferForType(type);
+    CreateSensorInternal(
+        type, std::move(mapping),
+        base::Bind(&PlatformSensorProviderLinux::NotifySensorCreated,
+                   base::Unretained(this), type));
+    previous_type = type;
   }
 }
 
-void PlatformSensorProviderLinux::CreateSensorAndNotify(
-    mojom::SensorType type,
-    SensorInfoLinux* sensor_device) {
-  DCHECK(CalledOnValidThread());
-  scoped_refptr<PlatformSensorLinux> sensor;
-  mojo::ScopedSharedBufferMapping mapping = MapSharedBufferForType(type);
-  if (sensor_device && mapping && StartPollingThread()) {
-    sensor =
-        new PlatformSensorLinux(type, std::move(mapping), this, sensor_device,
-                                polling_thread_->task_runner());
-  }
-  NotifySensorCreated(type, sensor);
-}
-
 void PlatformSensorProviderLinux::OnSensorNodesEnumerated() {
   DCHECK(CalledOnValidThread());
   DCHECK(!sensor_nodes_enumerated_);
   sensor_nodes_enumerated_ = true;
   ProcessStoredRequests();
 }
 
 void PlatformSensorProviderLinux::OnDeviceAdded(
     mojom::SensorType type,
     std::unique_ptr<SensorInfoLinux> sensor_device) {
@@ skipping 11 matching lines @@
     mojom::SensorType type,
     const std::string& device_node) {
   DCHECK(CalledOnValidThread());
   auto it = sensor_devices_by_type_.find(type);
   if (it != sensor_devices_by_type_.end() &&
       it->second->device_node == device_node)
     sensor_devices_by_type_.erase(it);
 }
 
 }  // namespace device