[sensors] Introduce Generic Sensor API interfaces

device/sensors/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/sensors/sensor_provider_impl.h"
+
+#include "device/sensors/platform_sensor_provider.h"
+#include "device/sensors/sensor_impl.h"
+#include "device/sensors/sensor_type_converters.h"
+
+namespace device {
+namespace mojom {
+
+namespace {
+const uint64_t kSharedBufferSizeInBytes =
+    SensorReadBuffer::kReadBufferSize * static_cast<uint64_t>(SensorType::LAST);
+}
+
+PlatformSensorProvider* SensorProviderImpl::s_provider_ = nullptr;
+
+// static
+void SensorProviderImpl::Create(
+    mojo::InterfaceRequest<SensorProvider> request) {
+  if (!s_provider_)
+    s_provider_ = PlatformSensorProvider::Create(kSharedBufferSizeInBytes);
+
+  if (s_provider_) {

[dcheng, 2016/07/01 09:17:24]

Shouldn't this theoretically be impossible if we actually implement
PlatformSensorProvider::Create()? Should we DCHECK() this instead, since this
should never be a valid condition in the real world?

[shalamov, 2016/07/01 14:22:47]

Actually, this codepath would be default for platforms that haven't implemented
PlatformSensorProvider class. On those platforms,
mojo service request will fail and blink side can handle failure gracefully and
report error according to the specification.

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