[sensors] Introduce Generic Sensor API interfaces

device/sensors/platform_sensor.cc

Index: device/sensors/platform_sensor.cc
diff --git a/device/sensors/platform_sensor.cc b/device/sensors/platform_sensor.cc
new file mode 100644
index 0000000000000000000000000000000000000000..024f14c6c0dc00ec75e8263a0d2b199daa0e5209
--- /dev/null
+++ b/device/sensors/platform_sensor.cc
@@ -0,0 +1,96 @@
+// 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/sensors/platform_sensor.h"
+
+#include <utility>
+
+#include "device/sensors/platform_sensor_configuration.h"
+#include "device/sensors/platform_sensor_provider.h"
+
+namespace device {
+
+namespace {
+// Maximum allowed frequency is capped to 60Hz, if client requests higher
+// sensor polling frequency, StartListening would return error.
+bool IsAllowedFrequency(const PlatformSensorConfiguration& config) {
+  return config.frequency() <= 60.0;

[dcheng, 2016/07/08 14:22:00]

Can we do this check in the StructTraits? You can DCHECK() in the serialization
side that frequency <= 60, and deserialization side can just fail if frequency >
60.

[Tom Sepez, 2016/07/12 16:53:52]

You also want to check that frequency > 0, right?  Its a double and could be 0
or negative.

+}
+}
+
+PlatformSensor::PlatformSensor(SensorType type,
+                               mojo::ScopedSharedBufferMapping mapping,
+                               PlatformSensorProvider* provider)
+    : shared_buffer_mapping_(std::move(mapping)),
+      type_(type),
+      provider_(provider),
+      weak_factory_(this) {}
+
+PlatformSensor::~PlatformSensor() {
+  provider_->RemoveSensor(GetType());
+}
+
+SensorType PlatformSensor::GetType() const {
+  return type_;
+}
+
+bool PlatformSensor::StartListening(Client* client,
+                                    const PlatformSensorConfiguration& config) {
+  DCHECK(clients_.HasObserver(client));
+  if (!CheckSensorConfiguration(config) || !IsAllowedFrequency(config))
+    return false;
+
+  auto& config_list = config_map_[client];
+  config_list.push_back(config);
+
+  if (UpdateSensor(config_map_))
+    return true;
+
+  auto iterator = std::find(config_list.begin(), config_list.end(), config);
+  if (iterator != config_list.end())
+    config_list.erase(iterator);
+  return false;
+}
+
+bool PlatformSensor::StopListening(Client* client,
+                                   const PlatformSensorConfiguration& config) {
+  DCHECK(clients_.HasObserver(client));
+  auto client_entry = config_map_.find(client);
+  if (client_entry == config_map_.end())
+    return false;
+
+  auto& config_list = client_entry->second;
+  auto config_entry = std::find(config_list.begin(), config_list.end(), config);
+  if (config_entry == config_list.end())
+    return false;
+
+  config_list.erase(config_entry);
+
+  return UpdateSensor(config_map_);
+}
+
+void PlatformSensor::AddClient(Client* client) {
+  DCHECK(client);
+  clients_.AddObserver(client);
+}
+
+void PlatformSensor::RemoveClient(Client* client) {
+  DCHECK(client);
+  clients_.RemoveObserver(client);
+  auto client_entry = config_map_.find(client);
+  if (client_entry != config_map_.end()) {
+    config_map_.erase(client_entry);
+    UpdateSensor(config_map_);
+  }
+}
+
+void PlatformSensor::NotifySensorReadingChanged() {
+  FOR_EACH_OBSERVER(Client, clients_, OnSensorReadingChanged());
+}
+
+void PlatformSensor::NotifySensorError() {
+  FOR_EACH_OBSERVER(Client, clients_, OnSensorError());
+}
+
+}  // namespace device