WIP : Generic Sensor API implementation

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

Index: third_party/WebKit/Source/modules/sensor/SensorController.h
diff --git a/third_party/WebKit/Source/modules/sensor/SensorController.h b/third_party/WebKit/Source/modules/sensor/SensorController.h
new file mode 100644
index 0000000000000000000000000000000000000000..ab1bcac2e2d191dd85d4fe0c182432a58a2c5735
--- /dev/null
+++ b/third_party/WebKit/Source/modules/sensor/SensorController.h
@@ -0,0 +1,125 @@
+// 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.
+
+#ifndef SensorController_h
+#define SensorController_h
+
+#include "core/frame/LocalFrameLifecycleObserver.h"
+#include "device/sensors/sensor.mojom-blink.h"
+#include "device/sensors/sensor_factory.mojom-blink.h"
+#include "modules/ModulesExport.h"
+#include "mojo/public/cpp/bindings/binding.h"
+#include "mojo/public/cpp/system/core.h"
+#include "platform/Supplementable.h"
+#include "platform/heap/Handle.h"
+
+namespace blink {
+
+class LocalFrame;
+class SensorProvider;
+
+class MODULES_EXPORT SensorController final
+    : public GarbageCollectedFinalized<SensorController>
+    , public device::sensors::blink::SensorClient {
+    USING_PRE_FINALIZER(SensorController, dispose);
+    WTF_MAKE_NONCOPYABLE(SensorController);
+public:
+    class Observer : public GarbageCollectedMixin {
+    public:
+        virtual void onSensorInitialized() {}
+        virtual void onSensorReadingChanged() {}
+        virtual void onSensorError() {}
+    };
+
+    ~SensorController();
+
+    void dispose();
+
+    void addObserver(Observer* observer);
+    void removeObserver(Observer* observer);
+
+    void initialize();
+
+    bool isInitializing() const { return m_state == Initializing; }
+    bool isInitialized() const { return m_state == Initialized; }
+
+    void startConfiguration(device::sensors::blink::SensorConfigurationPtr, std::unique_ptr<Function<void(bool)>>);
+    void stopConfiguration(device::sensors::blink::SensorConfigurationPtr, std::unique_ptr<Function<void(bool)>>);
+
+    device::sensors::blink::SensorType type() const { return m_type; }
+    device::sensors::blink::ReportingMode reportingMode() const { return m_mode; }
+
+    template <typename Reading>
+    const Reading* reading() const
+    {
+        ASSERT(m_sharedBuffer);
+        static_assert(sizeof(Reading) == sBufferSize, "Check reading size");
+        return static_cast<Reading*>(m_sharedBuffer);
+    }
+
+    DECLARE_VIRTUAL_TRACE();
+
+private:
+    SensorController(device::sensors::blink::SensorType, SensorProvider*);
+    // device::sensors::blink::SensorClient overrides.
+    void OnSensorError() override;
+    void OnSensorReadingChanged() override;
+    void handleSensorError();
+
+    void onSensorCreated(device::sensors::blink::Result result, mojo::ScopedSharedBufferHandle handle, uint64_t offset, uint64_t size, device::sensors::blink::ReportingMode mode);
+
+    device::sensors::blink::SensorType m_type;
+    device::sensors::blink::ReportingMode m_mode;
+    Member<SensorProvider> m_provider;
+    HeapHashSet<WeakMember<Observer>> m_observers;
+
+    device::sensors::blink::SensorPtr m_sensor;
+    mojo::Binding<device::sensors::blink::SensorClient> m_clientBinding;
+    enum State {
+        Uninitialized,
+        Initializing,
+        Initialized
+    };
+    State m_state;
+    mojo::ScopedSharedBufferHandle m_sharedBufferHandle;
+    void* m_sharedBuffer;
+    friend class SensorProvider;
+
+    static const size_t sBufferSize = device::sensors::blink::kSensorReadingFieldSize * device::sensors::blink::kSensorReadingFieldsCount;
+};
+
+class MODULES_EXPORT SensorProvider final
+    : public GarbageCollectedFinalized<SensorProvider>
+    , public Supplement<LocalFrame>
+    , public LocalFrameLifecycleObserver {
+    USING_GARBAGE_COLLECTED_MIXIN(SensorProvider);
+    WTF_MAKE_NONCOPYABLE(SensorProvider);
+public:
+    static SensorProvider* getOrCreateForFrame(LocalFrame&);
+
+    ~SensorProvider();
+
+    SensorController* getOrCreateSensor(device::sensors::blink::SensorType type);
+
+    DECLARE_VIRTUAL_TRACE();
+
+private:
+    SensorProvider(LocalFrame&);
+
+    // To be called by SensorController.
+    void removeSensor(SensorController*);
+    device::sensors::blink::SensorFactory* sensorFactory() const { return m_sensorFactory.get(); }
+    friend class SensorController;
+
+    void handleSensorError();
+
+    HeapVector<Member<SensorController>> m_sensors;
+    static constexpr const char* s_supplementKey = "SensorProvider";
+
+    device::sensors::blink::SensorFactoryPtr m_sensorFactory;
+};
+
+} // namespace blink
+
+#endif // SensorController_h