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

device/generic_sensor/platform_sensor_provider_iio.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.h"
+
+#include "base/memory/singleton.h"
+#include "base/task_runner_util.h"
+#include "base/threading/thread.h"
+#include "device/generic_sensor/iio/platform_sensor_utils_iio.h"
+#include "device/generic_sensor/iio/sensor_data_iio.h"
+#include "device/generic_sensor/platform_sensor_iio.h"
+
+namespace base {
+class SingleThreadTaskRunner;
+}
+
+namespace device {
+
+class PlatformSensorProviderIio : public PlatformSensorProvider {
+ public:
+  static PlatformSensorProviderIio* GetInstance();
+
+ protected:
+  void CreateSensorInternal(mojom::SensorType type,
+                            mojo::ScopedSharedBufferMapping mapping,
+                            const CreateSensorCallback& callback) override;
+
+ private:
+  friend struct base::DefaultSingletonTraits<PlatformSensorProviderIio>;
+  PlatformSensorProviderIio();
+  ~PlatformSensorProviderIio() override;
+
+  void SensorReaderFound(
+      mojom::SensorType type,
+      mojo::ScopedSharedBufferMapping mapping,
+      const PlatformSensorProviderBase::CreateSensorCallback& callback,
+      const SensorDataIio& data,
+      std::unique_ptr<base::Thread> polling_thread,
+      std::unique_ptr<SensorReader> sensor_reader);
+
+  // Helper function that gets a new sensor reader with a sensor type specific
+  // options taken from SensorDataIio.
+  std::unique_ptr<SensorReader> GetSensorReader(
+      const SensorDataIio& data,
+      scoped_refptr<base::SingleThreadTaskRunner> task_runner);
+
+  // TODO(maksims): make this as a separate class Manager that will
+  // create threads for new sensors, check sensors existence and notify provider
+  // if a new sensor has appeared and it can be created if a request comes
+  // again for the same sensor.
+  // A use case example: a request for a sensor X comes, manager checks if the
+  // sensor exists on a platform and notifies a provider it is not found.
+  // The provider stores this information into its cache and doesn't try to
+  // create this specific sensor if a request comes. But when, for example,
+  // the sensor X is plugged into a usb port, the manager notices that and
+  // notifies the provider, which updates its cache and starts handling requests
+  // for the sensor X.
+  //
+  // Right now, it is only used to delete polling threads if a new sensor
+  // is not created and the thread cannot be passed to it.
+  std::unique_ptr<base::Thread> manager_thread_;

[Reilly Grant (use Gerrit), 2016/10/26 21:53:42]

Can you explain why a separate thread for this is necessary and the browser's
usual FILE or IO thread isn't good?

[maksims (do not use this acc), 2016/10/27 05:29:19]

Yes, sure.

First of all, BrowserThread is located in content/ and it's not possible to
access it directly from device/ due gn layering. Of course, this entire code
runs on Browser's IO thread, but it disallows IO and we cannot block browser 
anyway.

Secondly, this manager thread is being used to delete io threads, which are
created to 1) find out if sensor's files exist 2) create a sensor reader on that
thread 3) pass an ownership of the thread to a concrete sensor that will poll
data using that thread. If a sensor doesn't exist, the thread must be removed,
but it cannot be removed on browser's IO thread (it disallows IO and basically
this an IPC thread as you know) and cannot be removed/stopped on a self running
thread (join will crash, of course).

+
+  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() = default;
+
+void PlatformSensorProviderIio::CreateSensorInternal(
+    mojom::SensorType type,
+    mojo::ScopedSharedBufferMapping mapping,
+    const CreateSensorCallback& callback) {
+  SensorDataIio data;
+  if (!InitSensorData(type, &data)) {
+    callback.Run(nullptr);
+    return;
+  }
+
+  if (!manager_thread_) {
+    manager_thread_.reset(new base::Thread("Linux/CrOS manager thread"));
+    if (!manager_thread_->StartWithOptions(
+            base::Thread::Options(base::MessageLoop::TYPE_IO, 0))) {
+      callback.Run(nullptr);
+      return;
+    }
+  }
+
+  std::unique_ptr<base::Thread> polling_thread(
+      new base::Thread("Linux/CrOS polling sensor thread."));
+
+  if (!polling_thread->StartWithOptions(
+          base::Thread::Options(base::MessageLoop::TYPE_IO, 0))) {
+    callback.Run(nullptr);
+    return;
+  }
+
+  base::PostTaskAndReplyWithResult(
+      polling_thread->task_runner().get(), FROM_HERE,
+      base::Bind(SensorReader::Create, data),
+      base::Bind(&PlatformSensorProviderIio::SensorReaderFound,
+                 base::Unretained(this), type, base::Passed(&mapping), callback,
+                 data, base::Passed(&polling_thread)));
+}
+
+void PlatformSensorProviderIio::SensorReaderFound(
+    mojom::SensorType type,
+    mojo::ScopedSharedBufferMapping mapping,
+    const PlatformSensorProviderBase::CreateSensorCallback& callback,
+    const SensorDataIio& data,
+    std::unique_ptr<base::Thread> polling_thread,
+    std::unique_ptr<SensorReader> sensor_reader) {
+  DCHECK(CalledOnValidThread());
+
+  if (!sensor_reader) {
+    manager_thread_->task_runner()->DeleteSoon(FROM_HERE,
+                                               polling_thread.release());
+    callback.Run(nullptr);
+    return;
+  }
+
+  callback.Run(new PlatformSensorIio(type, std::move(mapping), this, data,
+                                     std::move(polling_thread),
+                                     std::move(sensor_reader)));
+}
+
+}  // namespace device