Revert of Move //device/generic_sensor to be part of the internal implementation of the Device Service.

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/single_thread_task_runner.h"
+#include "base/strings/string_number_conversions.h"
+#include "base/strings/string_util.h"
+#include "base/threading/thread_restrictions.h"
+#include "base/timer/timer.h"
+#include "device/generic_sensor/linux/sensor_data_linux.h"
+#include "device/generic_sensor/platform_sensor_linux.h"
+#include "device/generic_sensor/public/cpp/sensor_reading.h"
+
+namespace device {
+
+class PollingSensorReader : public SensorReader {
+ public:
+  PollingSensorReader(const SensorInfoLinux* sensor_device,
+                      base::WeakPtr<PlatformSensorLinux> sensor,
+                      scoped_refptr<base::SingleThreadTaskRunner> task_runner);
+  ~PollingSensorReader() override;
+
+  // SensorReader implements:
+  void StartFetchingData(
+      const PlatformSensorConfiguration& configuration) override;
+  void StopFetchingData() override;
+
+ private:
+  // Initializes a read timer.
+  void InitializeTimer(const PlatformSensorConfiguration& configuration);
+
+  // Polls data and sends it to a |sensor_|.
+  void PollForData();
+
+  // Paths to sensor read files.
+  const std::vector<base::FilePath> sensor_file_paths_;
+
+  // Scaling value that are applied to raw data from sensors.
+  const double scaling_value_;
+
+  // Offset value.
+  const double offset_value_;
+
+  // Used to apply scalings and invert signs if needed.
+  const SensorPathsLinux::ReaderFunctor apply_scaling_func_;
+
+  // Repeating timer for data polling.
+  base::RepeatingTimer timer_;
+
+  DISALLOW_COPY_AND_ASSIGN(PollingSensorReader);
+};
+
+PollingSensorReader::PollingSensorReader(
+    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_CALLED_ON_VALID_THREAD(thread_checker_);
+}
+
+void PollingSensorReader::StartFetchingData(
+    const PlatformSensorConfiguration& configuration) {
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
+  if (is_reading_active_)
+    StopFetchingData();
+  InitializeTimer(configuration);
+}
+
+void PollingSensorReader::StopFetchingData() {
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
+  is_reading_active_ = false;
+  timer_.Stop();
+}
+
+void PollingSensorReader::InitializeTimer(
+    const PlatformSensorConfiguration& configuration) {
+  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_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;
+    }
+
+    double new_value = 0;
+    base::TrimWhitespaceASCII(new_read_value, base::TRIM_ALL, &new_read_value);
+    if (!base::StringToDouble(new_read_value, &new_value)) {
+      NotifyReadError();
+      StopFetchingData();
+      return;
+    }
+    readings.values[i++] = new_value;
+  }
+  if (!apply_scaling_func_.is_null())
+    apply_scaling_func_.Run(scaling_value_, offset_value_, readings);
+
+  if (is_reading_active_) {
+    task_runner_->PostTask(
+        FROM_HERE, base::Bind(&PlatformSensorLinux::UpdatePlatformSensorReading,
+                              sensor_, readings));
+  }
+}
+
+// static
+std::unique_ptr<SensorReader> SensorReader::Create(
+    const SensorInfoLinux* sensor_device,
+    base::WeakPtr<PlatformSensorLinux> sensor,
+    scoped_refptr<base::SingleThreadTaskRunner> task_runner) {
+  base::ThreadRestrictions::AssertIOAllowed();
+  // TODO(maksims): implement triggered reading. At the moment,
+  // only polling read is supported.
+  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) {
+  DETACH_FROM_THREAD(thread_checker_);
+}
+
+SensorReader::~SensorReader() {
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
+}
+
+void SensorReader::NotifyReadError() {
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
+  if (is_reading_active_) {
+    task_runner_->PostTask(
+        FROM_HERE,
+        base::Bind(&PlatformSensorLinux::NotifyPlatformSensorError, sensor_));
+  }
+}
+
+}  // namespace device