WIP : Generic Sensor API implementation

third_party/WebKit/Source/modules/sensor/SensorController.cpp

+// 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 "modules/sensor/SensorController.h"
+
+#include "core/frame/LocalFrame.h"
+#include "platform/mojo/MojoHelper.h"
+#include "public/platform/ServiceRegistry.h"
+
+using namespace device::sensors::blink;
+
+namespace blink {
+
+SensorController::SensorController(SensorType sensorType, SensorProvider* provider)
+    : m_type(sensorType)
+    , m_mode(ReportingMode::CONTINUOUS)
+    , m_provider(provider)
+    , m_clientBinding(this)
+    , m_state(SensorController::Uninitialized)
+    , m_sharedBuffer(nullptr)
+{
+}
+
+SensorController::~SensorController()
+{
+}
+
+void SensorController::dispose()
+{
+    m_clientBinding.Close();
+}
+
+DEFINE_TRACE(SensorController)
+{
+    visitor->trace(m_observers);
+    visitor->trace(m_provider);
+}
+
+void SensorController::addObserver(Observer* observer)
+{
+    if (!m_observers.contains(observer))
+        m_observers.add(observer);
+}
+
+void SensorController::removeObserver(Observer* observer) {
+    if (m_observers.contains(observer))
+        m_observers.remove(observer);
+
+    if (m_observers.isEmpty()) {
+        m_provider->removeSensor(this);
+    }
+}
+
+void SensorController::initialize()
+{
+    if (m_state != Uninitialized)
+        return;
+    m_state = Initializing;
+
+    auto callback = createBaseCallback(bind<Result, mojo::ScopedSharedBufferHandle, uint64_t, uint64_t, ReportingMode>(&SensorController::onSensorCreated, WeakPersistentThisPointer<SensorController>(this)));
+    m_provider->sensorFactory()->CreateSensor(m_type, mojo::GetProxy(&m_sensor), callback);
+}
+
+void SensorController::startConfiguration(SensorConfigurationPtr configuration, std::unique_ptr<Function<void(bool)>> callback)
+{
+    ASSERT(isInitialized());
+    m_sensor->Start(std::move(configuration), createBaseCallback(std::move(callback)));
+}
+
+void SensorController::stopConfiguration(SensorConfigurationPtr configuration, std::unique_ptr<Function<void(bool)>> callback)
+{
+    ASSERT(isInitialized());
+    m_sensor->Stop(std::move(configuration), createBaseCallback(std::move(callback)));
+}
+
+void SensorController::OnSensorError()
+{
+    handleSensorError();
+}
+
+void SensorController::OnSensorReadingChanged()
+{
+    for (Observer* observer : m_observers)
+    {
+        if (observer)
+            observer->onSensorReadingChanged();
+    }
+}
+
+void SensorController::handleSensorError()
+{
+    m_state = Uninitialized;
+
+    HeapHashSet<WeakMember<Observer>> observersCopy(m_observers);
+    for (Observer* observer : observersCopy)
+    {
+        if (observer)
+            observer->onSensorError();
+    }
+
+    m_observers.clear();
+    m_provider->removeSensor(this);
+}
+
+void SensorController::onSensorCreated(Result result, mojo::ScopedSharedBufferHandle handle, uint64_t offset, uint64_t size, ReportingMode mode) {
+    if (result != Result::SUCCESS)
+    {
+        handleSensorError();
+        return;
+    }
+
+    if (size != sBufferSize || (offset % sBufferSize) != 0)
+    {
+        ASSERT_NOT_REACHED();
+        handleSensorError();
+        return;
+    }
+
+    m_mode = mode;
+
+    m_sensor->SetClient(m_clientBinding.CreateInterfacePtrAndBind());
+    m_sensor.set_connection_error_handler(createBaseCallback(bind(&SensorController::handleSensorError, WeakPersistentThisPointer<SensorController>(this))));
+
+    ASSERT(!m_sharedBuffer);
+
+    MojoResult mapResult = mojo::MapBuffer(handle.get(), offset, size, &m_sharedBuffer, MOJO_MAP_BUFFER_FLAG_NONE);
+    if (mapResult != MOJO_RESULT_OK || !m_sharedBuffer)
+    {
+        //WTFLogAlways("map has failed %llu %llu. \n", offset, size);
+        handleSensorError();
+        return;
+    }
+
+    m_sharedBufferHandle = std::move(handle);
+    m_state = Initialized;
+
+    HeapHashSet<WeakMember<Observer>> observersCopy(m_observers);
+    for (Observer* observer : observersCopy) {
+        if (observer)
+            observer->onSensorInitialized();
+    }
+}
+
+
+// SensorProvider
+SensorProvider::SensorProvider(LocalFrame& frame)
+    : LocalFrameLifecycleObserver(&frame)
+{
+    frame.serviceRegistry()->connectToRemoteService(mojo::GetProxy(&m_sensorFactory));
+    m_sensorFactory.set_connection_error_handler(createBaseCallback(bind(&SensorProvider::handleSensorError, WeakPersistentThisPointer<SensorProvider>(this))));
+}
+
+SensorProvider* SensorProvider::getOrCreateForFrame(LocalFrame& frame)
+{
+    SensorProvider* result = static_cast<SensorProvider*>(Supplement<LocalFrame>::from(frame, s_supplementKey));
+    if (!result) {
+        result = new SensorProvider(frame);
+        Supplement<LocalFrame>::provideTo(frame, s_supplementKey, result);
+    }
+    return result;
+}
+
+SensorProvider::~SensorProvider()
+{
+}
+
+DEFINE_TRACE(SensorProvider)
+{
+    visitor->trace(m_sensors);
+    Supplement<LocalFrame>::trace(visitor);
+    LocalFrameLifecycleObserver::trace(visitor);
+}
+
+void SensorProvider::removeSensor(SensorController* controller)
+{
+    auto it = std::find(m_sensors.begin(), m_sensors.end(), controller);
+    if (it != m_sensors.end())
+        return m_sensors.remove(std::distance(m_sensors.begin(), it));
+}
+
+SensorController* SensorProvider::getOrCreateSensor(device::sensors::blink::SensorType type)
+{
+    auto it = std::find_if(m_sensors.begin(), m_sensors.end(), [type] (SensorController* s) { return s->type() == type; });
+    if (it != m_sensors.end())
+        return *it;
+    SensorController* result = new SensorController(type, this);
+    m_sensors.append(result);
+
+    return result;
+}
+
+void SensorProvider::handleSensorError()
+{
+    HeapVector<Member<SensorController>> sensorsCopy(m_sensors);
+    for (SensorController* sensor : sensorsCopy) {
+        // All sensors are invalidated.
+        sensor->handleSensorError();
+    }
+    frame()->removeSupplement(s_supplementKey);
+}
+
+} // namespace blink