[sensors] Introduce Generic Sensor API interfaces

device/sensors/mojo/sensor_factory_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/mojo/sensor_factory_impl.h"
+
+#include "device/sensors/mojo/sensor_impl.h"
+#include "device/sensors/mojo/sensor_type_converters.h"
+#include "device/sensors/platform/platform_sensor_provider.h"
+
+namespace device {
+namespace sensors {
+
+namespace {
+const uint64_t kSensorReadingInBytes =
+    kSensorReadingFieldSize * kSensorReadingFieldsCount;
+const uint64_t kSharedBufferSizeInBytes =
+    kSensorReadingInBytes * static_cast<uint64_t>(SensorType::LAST);
+}
+
+PlatformSensorProvider* SensorFactoryImpl::s_provider_ = nullptr;
+
+// static
+void SensorFactoryImpl::Create(mojo::InterfaceRequest<SensorFactory> request) {
+  if (!s_provider_)
+    s_provider_ = PlatformSensorProvider::Create(kSharedBufferSizeInBytes);
+
+  if (s_provider_) {
+    new SensorFactoryImpl(std::move(request));
+  }
+}
+
+SensorFactoryImpl::SensorFactoryImpl(
+    mojo::InterfaceRequest<SensorFactory> request)
+    : binding_(this, std::move(request)) {}
+
+SensorFactoryImpl::~SensorFactoryImpl() {}
+
+namespace {
+
+void ReportError(const SensorFactory::CreateSensorCallback& callback) {
+  callback.Run(Result::FAILURE, mojo::ScopedSharedBufferHandle(), 0, 0,
+               ReportingMode::CONTINUOUS);
+}
+
+uint64_t GetBufferOffset(device::SensorType type) {
+  return (static_cast<uint64_t>(SensorType::LAST) -
+          static_cast<uint64_t>(type)) *
+         kSensorReadingInBytes;
+}
+
+}  // namespace
+
+void SensorFactoryImpl::CreateSensor(SensorType type,
+                                     SensorRequest sensor_request,
+                                     const CreateSensorCallback& 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, kSensorReadingInBytes,
+                                       GetBufferOffset(sensor_type));
+  if (!sensor) {
+    ReportError(callback);
+    return;
+  }
+
+  new SensorImpl(std::move(sensor_request), sensor);
+
+  callback.Run(Result::SUCCESS, std::move(cloned_handle),
+               GetBufferOffset(sensor_type), kSensorReadingInBytes,
+               mojo::ConvertTo<device::sensors::ReportingMode>(
+                   sensor->GetReportingMode()));
+}
+
+}  // namespace sensors
+}  // namespace device