[Sensors] Implement sensor data polling

third_party/WebKit/Source/modules/sensor/SensorPollingStrategy.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/SensorPollingStrategy.h"
 
+#include "wtf/CurrentTime.h"
+
 namespace blink {
 
+SensorPollingStrategy::SensorPollingStrategy(double pollingPeriod, std::unique_ptr<Function<void()>> func)
+    : m_pollingPeriod(pollingPeriod)
+    , m_pollFunc(std::move(func))
+    , m_timer(this, &SensorPollingStrategy::pollForData)
+{
+}
+
+SensorPollingStrategy::~SensorPollingStrategy() = default;
+
+// Polls the buffer continuously using the given 'pollingPeriod'.
+class ContiniousSensorPollingStrategy : public SensorPollingStrategy {
+public:
+    ContiniousSensorPollingStrategy(double pollingPeriod, std::unique_ptr<Function<void()>> func)
+        : SensorPollingStrategy(pollingPeriod, std::move(func)) {}
+private:
+    // SensorPollingStrategy overrides.
+    void startPolling() override;
+    void stopPolling() override;
+
+    void pollForData(TimerBase*) override;
+};
+
+void ContiniousSensorPollingStrategy::startPolling()
+{
+    (*m_pollFunc)();
+    m_timer.startRepeating(m_pollingPeriod, BLINK_FROM_HERE);
+}
+
+void ContiniousSensorPollingStrategy::stopPolling()
+{
+    m_timer.stop();
+}
+
+void ContiniousSensorPollingStrategy::pollForData(TimerBase*)
+{
+    (*m_pollFunc)();
+}
+
+// Polls the buffer on signal from platform but not more frequently
+// than the given 'pollingPeriod'.
+class OnChangeSensorPollingStrategy : public SensorPollingStrategy {
+public:
+    OnChangeSensorPollingStrategy(double pollingPeriod, std::unique_ptr<Function<void()>> func)
+        : SensorPollingStrategy(pollingPeriod, std::move(func))
+        , m_polling(false)
+        , m_lastPollingTimestamp(0.0) {}
+private:
+    // SensorPollingStrategy overrides.
+    void startPolling() override;
+    void stopPolling() override;
+    void onSensorReadingChanged() override;
+
+    void pollForData(TimerBase*) override;
+
+    bool m_polling;
+    double m_lastPollingTimestamp;
+};
+
+void OnChangeSensorPollingStrategy::startPolling()
+{
+    (*m_pollFunc)();
+    m_polling = true;
+}
+
+void OnChangeSensorPollingStrategy::stopPolling()
+{
+    m_polling = false;
+}
+
+void OnChangeSensorPollingStrategy::onSensorReadingChanged()
+{
+    if (!m_polling || m_timer.isActive())
+        return;
+    double elapsedTime = WTF::monotonicallyIncreasingTime() - m_lastPollingTimestamp;
+
+    if (elapsedTime >= m_pollingPeriod) {
+        m_lastPollingTimestamp = WTF::monotonicallyIncreasingTime();
+        (*m_pollFunc)();
+    } else {
+        m_timer.startOneShot(m_pollingPeriod - elapsedTime, BLINK_FROM_HERE);
+    }
+}
+
+void OnChangeSensorPollingStrategy::pollForData(TimerBase*)
+{
+    if (!m_polling)
+        return;
+    m_lastPollingTimestamp = WTF::monotonicallyIncreasingTime();
+    (*m_pollFunc)();
+}
+
 // static
-std::unique_ptr<SensorPollingStrategy> SensorPollingStrategy::create(double frequency, std::unique_ptr<Function<void()>> func, device::mojom::blink::ReportingMode mode)
+std::unique_ptr<SensorPollingStrategy> SensorPollingStrategy::create(double pollingPeriod, std::unique_ptr<Function<void()>> func, device::mojom::blink::ReportingMode mode)
 {
-    // TODO(Mikhail): Implement.
-    return nullptr;
+    if (mode == device::mojom::blink::ReportingMode::CONTINUOUS)
+        return std::unique_ptr<SensorPollingStrategy>(new ContiniousSensorPollingStrategy(pollingPeriod, std::move(func)));
+
+    return std::unique_ptr<SensorPollingStrategy>(new OnChangeSensorPollingStrategy(pollingPeriod, std::move(func)));
 }
 
 } // namespace blink