[sensors] Introduce Generic Sensor API interfaces

device/generic_sensor/sensor_provider_impl.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/sensor_provider_impl.h"
+
+#include <utility>
+
+#include "device/generic_sensor/platform_sensor_provider.h"
+#include "device/generic_sensor/sensor_impl.h"
+
+namespace device {
+
+namespace {
+
+const uint64_t kSharedBufferSizeInBytes =
+    mojom::SensorReadBuffer::kReadBufferSize *
+    static_cast<uint64_t>(mojom::SensorType::LAST);
+
+uint64_t GetBufferOffset(mojom::SensorType type) {
+  return (static_cast<uint64_t>(mojom::SensorType::LAST) -

[Reilly Grant (use Gerrit), 2016/08/11 20:59:37]

Why arrange offsets in the buffer in reverse order like this?

[Mikhail, 2016/08/12 10:21:48]

In practice it has no effect but IMO just looks a bit better than:
(static_cast<uint64_t>(type) - 1) * mojom::SensorReadBuffer::kReadBufferSize; //
mojom::SensorType::FIRST==1, as we wanted the sensor types count to come from
mojo (mojom::SensorType::LAST == types count)

[Reilly Grant (use Gerrit), 2016/08/12 18:01:58]

Why does mojom::SensorType start at 1 anyways?

+          static_cast<uint64_t>(type)) *
+         mojom::SensorReadBuffer::kReadBufferSize;
+}
+
+}  // namespace
+
+PlatformSensorProvider* SensorProviderImpl::s_provider_ = nullptr;
+
+// static
+void SensorProviderImpl::Create(
+    mojo::InterfaceRequest<mojom::SensorProvider> request) {
+  if (!s_provider_)
+    s_provider_ = PlatformSensorProvider::Create(kSharedBufferSizeInBytes);
+
+  if (s_provider_)
+    new SensorProviderImpl(std::move(request));
+}
+
+SensorProviderImpl::SensorProviderImpl(
+    mojo::InterfaceRequest<mojom::SensorProvider> request)
+    : binding_(this, std::move(request)) {}
+
+SensorProviderImpl::~SensorProviderImpl() {}
+
+void SensorProviderImpl::GetSensor(mojom::SensorType type,
+                                   mojom::SensorRequest sensor_request,
+                                   const GetSensorCallback& callback) {
+  auto cloned_handle = s_provider_->GetClonedSharedBufferHandle();
+  if (!cloned_handle.is_valid()) {
+    callback.Run(nullptr, nullptr);
+    return;
+  }
+
+  scoped_refptr<PlatformSensor> sensor = s_provider_->GetSensor(type);
+  if (!sensor) {
+    sensor = s_provider_->CreateSensor(
+        type, mojom::SensorReadBuffer::kReadBufferSize, GetBufferOffset(type));
+  }
+
+  if (!sensor) {
+    callback.Run(nullptr, nullptr);
+    return;
+  }
+
+  auto sensor_impl = new SensorImpl(std::move(sensor_request), sensor);
+
+  auto sensor_read_buffer = mojom::SensorReadBuffer::New();
+  sensor_read_buffer->memory = std::move(cloned_handle);
+  sensor_read_buffer->offset = GetBufferOffset(type);
+  sensor_read_buffer->mode = sensor->GetReportingMode();
+
+  callback.Run(std::move(sensor_read_buffer), sensor_impl->GetClient());
+}
+
+}  // namespace device