[sensors] Ambient light sensor implementation for ChromeOS and Linux.

device/generic_sensor/platform_sensor_provider_iio.cc

Index: device/generic_sensor/platform_sensor_provider_iio.cc
diff --git a/device/generic_sensor/platform_sensor_provider_iio.cc b/device/generic_sensor/platform_sensor_provider_iio.cc
new file mode 100644
index 0000000000000000000000000000000000000000..210a7e880ed0517aca5be8c36e25160b32213c9d
--- /dev/null
+++ b/device/generic_sensor/platform_sensor_provider_iio.cc
@@ -0,0 +1,124 @@
+// 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.h"
+
+#include "base/memory/singleton.h"
+#include "base/task_runner_util.h"
+#include "base/threading/thread.h"
+#include "base/threading/thread_task_runner_handle.h"
+#include "device/generic_sensor/platform_sensor_ambient_light_iio.h"
+
+namespace base {
+class SingleThreadTaskRunner;
+}
+
+namespace device {
+
+namespace {
+
+using mojom::SensorType;
+
+}  // namespace
+
+class PlatformSensorProviderIio : public PlatformSensorProvider {
+ public:
+  PlatformSensorProviderIio();
+  ~PlatformSensorProviderIio() override;
+
+  static PlatformSensorProviderIio* GetInstance();
+
+ protected:
+  void CreateSensorInternal(mojom::SensorType type,
+                            mojo::ScopedSharedBufferMapping mapping,
+                            const CreateSensorCallback& callback) override;
+
+ private:
+  void DoCreateSensor(
+      mojom::SensorType type,
+      mojo::ScopedSharedBufferMapping mapping,
+      const PlatformSensorProviderBase::CreateSensorCallback& callback,
+      std::unique_ptr<SensorReader> sensor_reader);
+
+  std::unique_ptr<SensorReader> GetSensorReader(mojom::SensorType type);
+
+  std::unique_ptr<base::Thread> polling_thread_;
+
+  DISALLOW_COPY_AND_ASSIGN(PlatformSensorProviderIio);
+};
+
+PlatformSensorProvider* PlatformSensorProvider::GetInstance() {
+  return PlatformSensorProviderIio::GetInstance();
+}
+
+// static
+PlatformSensorProviderIio* PlatformSensorProviderIio::GetInstance() {
+  return base::Singleton<
+      PlatformSensorProviderIio,
+      base::LeakySingletonTraits<PlatformSensorProviderIio>>::get();
+}
+
+PlatformSensorProviderIio::PlatformSensorProviderIio() = default;
+
+PlatformSensorProviderIio::~PlatformSensorProviderIio() {
+  if (polling_thread_)
+    polling_thread_->Stop();

[Mikhail, 2016/10/11 14:46:47]

won't it be stopped automatically when deleted? 
We'd rather need a call when there are no sensors left at the provider (can add
a virtual method in the parent class to be invoked from
'PlatformSensorProviderBase::RemoveSensor'), and stop the thread inside such
call.

+}
+
+void PlatformSensorProviderIio::CreateSensorInternal(
+    mojom::SensorType type,
+    mojo::ScopedSharedBufferMapping mapping,
+    const CreateSensorCallback& callback) {
+  if (!polling_thread_) {
+    polling_thread_.reset(
+        new base::Thread("Sensors polling thread CrOS/Linux"));
+    if (!polling_thread_->StartWithOptions(
+            base::Thread::Options(base::MessageLoop::TYPE_IO, 0))) {
+      callback.Run(nullptr);
+      return;
+    }
+  }
+
+  base::PostTaskAndReplyWithResult(
+      polling_thread_->message_loop()->task_runner().get(), FROM_HERE,
+      base::Bind(&PlatformSensorProviderIio::GetSensorReader,
+                 base::Unretained(this), type),
+      base::Bind(&PlatformSensorProviderIio::DoCreateSensor,

[Mikhail, 2016/10/11 14:46:47]

s/DoCreateSensor/SensorReaderFound

[maksims (do not use this acc), 2016/10/14 12:31:45]

Done.

+                 base::Unretained(this), type, base::Passed(&mapping),
+                 callback));
+}
+
+void PlatformSensorProviderIio::DoCreateSensor(
+    mojom::SensorType type,
+    mojo::ScopedSharedBufferMapping mapping,
+    const PlatformSensorProviderBase::CreateSensorCallback& callback,
+    std::unique_ptr<SensorReader> sensor_reader) {
+  DCHECK(CalledOnValidThread());
+  if (!sensor_reader) {
+    callback.Run(nullptr);
+    return;
+  }
+
+  scoped_refptr<PlatformSensor> sensor = nullptr;
+  switch (type) {
+    case SensorType::AMBIENT_LIGHT:
+      sensor = new PlatformSensorAmbientLightIio(
+          type, move(mapping), this,
+          polling_thread_->message_loop()->task_runner(),
+          std::move(sensor_reader));
+      break;
+    default:
+      NOTIMPLEMENTED();
+      break;
+  }
+
+  callback.Run(sensor);
+}
+
+std::unique_ptr<SensorReader> PlatformSensorProviderIio::GetSensorReader(
+    mojom::SensorType type) {

[Mikhail, 2016/10/11 14:46:47]

thread check is missing

+  return SensorReader::Create(type);
+}
+
+}  // namespace device