[sensors] Generic Sensors Framework blink side

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

 // 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 Sensor_h
 #define Sensor_h
 
 #include "bindings/core/v8/ActiveScriptWrappable.h"
 #include "bindings/core/v8/ScriptWrappable.h"
 #include "core/dom/ActiveDOMObject.h"
 #include "core/dom/ContextLifecycleObserver.h"
 #include "core/frame/PlatformEventController.h"
+#include "core/page/PageVisibilityObserver.h"
 #include "modules/EventTargetModules.h"
 #include "modules/ModulesExport.h"
 #include "modules/sensor/SensorOptions.h"
-#include "modules/sensor/SensorState.h"
+#include "modules/sensor/SensorProxy.h"
 #include "platform/heap/Handle.h"
 
 namespace blink {
 
 class ExceptionState;
 class ScriptState;
 class SensorReading;
+class SensorPollingStrategy;
 
 class MODULES_EXPORT Sensor
     : public EventTargetWithInlineData
     , public ActiveScriptWrappable
     , public ActiveDOMObject
-    , public PlatformEventController {

[timvolodine, 2016/08/25 17:52:32]

can we actually re-use the PlatformEventController somehow?

[Mikhail, 2016/08/26 16:42:41]

PageVisibilityObserver is more convenient as we have our own classes wrapping
timer (SensorPollingStrategies).

[timvolodine, 2016/09/01 19:02:05]

in the PlatformEventController we have a special mechanism to ensure the sensor
values are immediately propagated if they are already available in blink. Is
there any similar approach in this code? i.e. if a new Sensor is created with
same/similar config can the existing data be reused immediately?

[Mikhail, 2016/09/02 08:23:43]

Yes. According to the spec (https://w3c.github.io/sensors/#sensor-reading) all
the sensors of same type are sharing reading data (which is owned by
SensorProxy). So all the sensors access the same up-to-date data.

+    , public PageVisibilityObserver
+    , public SensorProxy::Observer {
+    USING_PRE_FINALIZER(Sensor, dispose);
     USING_GARBAGE_COLLECTED_MIXIN(Sensor);
     DEFINE_WRAPPERTYPEINFO();
 
 public:
-    ~Sensor() override;
+    enum class SensorState {
+        IDLE,
+        ACTIVATING,
+        ACTIVE,
+        ERRORED
+    };
+
+    void dispose();
 
     void start(ScriptState*, ExceptionState&);
     void stop(ScriptState*, ExceptionState&);
-    void updateState(SensorState);
 
-    // EventTarget implementation.
+    // EventTarget overrides.
     const AtomicString& interfaceName() const override { return EventTargetNames::Sensor; }
     ExecutionContext* getExecutionContext() const override { return ContextLifecycleObserver::getExecutionContext(); }
 
     // Getters
     String state() const;
     // TODO(riju): crbug.com/614797 .
     SensorReading* reading() const;
 
     DEFINE_ATTRIBUTE_EVENT_LISTENER(error);
     DEFINE_ATTRIBUTE_EVENT_LISTENER(change);
     DEFINE_ATTRIBUTE_EVENT_LISTENER(statechange);
 
-    // ActiveDOMObject implementation.
-    void suspend() override;
-    void resume() override;
+    DECLARE_VIRTUAL_TRACE();
+
+    // ActiveScriptWrappable overrides.
+    bool hasPendingActivity() const override;
+
+protected:
+    Sensor(ExecutionContext*, const SensorOptions&, device::mojom::blink::SensorType);
+    virtual SensorReading* createSensorReading(ExecutionContext*) = 0;
+    virtual device::mojom::blink::SensorConfigurationPtr createSensorOptions(const SensorOptions&) = 0;
+
+private:
+    void initSensorProxyIfNeeded();
+
+    // EventTargetWithInlineData overrides.
+    void addedEventListener(const AtomicString& eventType, RegisteredEventListener&) override;
+    void removedEventListener(const AtomicString& eventType, const RegisteredEventListener&) override;
+
+    // ActiveDOMObject overrides.
     void stop() override;
 
-    // ScriptWrappable implementation.
-    bool hasPendingActivity() const override;
+    // SensorController::Observer overrides.
+    void onSensorInitialized() override;
+    void onSensorReadingChanged() override;
+    void onSensorError() override;
 
-    DECLARE_VIRTUAL_TRACE();
+    void onStartRequestCompleted(bool);
+    void onStopRequestCompleted(bool);
 
-protected:
-    Sensor(ExecutionContext*, const SensorOptions&);
-    void notifyStateChange();
+    // PageVisibilityObserver overrides.
+    void pageVisibilityChanged() override;
 
-    SensorState m_sensorState;
+    void startListening();
+    void stopListening();
+
+    // Makes sensor reading refresh its values from the shared buffer.
+    void pollForData();
+
+    void updateState(SensorState newState);
+    void reportError();
+
+    void updatePollingStatus();
+
+private:
     Member<SensorReading> m_sensorReading;
     SensorOptions m_sensorOptions;
+    device::mojom::blink::SensorType m_type;
+    SensorState m_state;
+    WeakMember<SensorProxy> m_sensorProxy;
+    Member<SensorPollingStrategy> m_polling;
 };
 
 } // namespace blink
 
 #endif // Sensor_h