[sensors]: Introduce the Generic Sensor API.

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

Index: third_party/WebKit/Source/modules/sensor/Sensor.cpp
diff --git a/third_party/WebKit/Source/modules/sensor/Sensor.cpp b/third_party/WebKit/Source/modules/sensor/Sensor.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..3630a26b1a36e9be95b46eb0185c6a7f12195119
--- /dev/null
+++ b/third_party/WebKit/Source/modules/sensor/Sensor.cpp
@@ -0,0 +1,114 @@
+// 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/Sensor.h"
+
+#include "bindings/core/v8/ScriptPromise.h"
+#include "bindings/core/v8/ScriptPromiseResolver.h"
+#include "core/dom/Document.h"
+#include "core/dom/ExceptionCode.h"
+
+#include "modules/sensor/SensorReading.h"
+#include "modules/sensor/sensor_state_type.h"
+
+namespace blink {
+
+Sensor::~Sensor()
+{
+}
+
+Sensor::Sensor(ExecutionContext* executionContext, const SensorOptions& sensorOptions)
+    : ActiveScriptWrappable(this)
+    , ActiveDOMObject(executionContext)
+    , PlatformEventController(toDocument(executionContext)->page())
+    , m_sensorState(SensorState::Idle)
+    , m_sensorOptions(sensorOptions)
+{
+}
+
+// Getters
+String Sensor::state() const
+{
+    switch (m_sensorState) {
+    case SensorState::Idle:
+        return "idle";
+    case SensorState::Activating:
+        return "activating";
+    case SensorState::Active:
+        return "active";
+    case SensorState::Errored:
+        return "errored";
+    }
+    NOTREACHED();
+    return "idle";
+}
+
+SensorReading* Sensor::reading() const
+{
+    return m_sensorReading.get();
+}
+
+void Sensor::start(ScriptState* scriptState, ExceptionState& exceptionState)
+{
+    if (m_sensorState != SensorState::Idle && m_sensorState != SensorState::Errored)
+        exceptionState.throwDOMException(InvalidStateError, "Invalid State: SensorState is not idle or errored");
+
+    updateState(SensorState::Activating);
+
+    // TODO(riju) : Add Permissions stuff later.
+
+    m_hasEventListener = true;
+    startUpdating();
+}
+
+void Sensor::stop(ScriptState* scriptState, ExceptionState& exceptionState)
+{
+    if (m_sensorState == SensorState::Idle || m_sensorState == SensorState::Errored)
+        exceptionState.throwDOMException(InvalidStateError, "Invalid State: SensorState is either idle or errored");
+
+    m_hasEventListener = false;
+    stopUpdating();
+    updateState(SensorState::Idle);
+}
+
+void Sensor::updateState(SensorState newState)
+{
+    m_sensorState = newState;
+    dispatchEvent(Event::create(EventTypeNames::statechange));

[timvolodine, 2016/05/24 15:30:35]

this may need a bit of thinking regarding re-entrancy, is this safe? e.g.
imagine a user executing sensor.start and sensor.stop inside 'onstatechange'
event handler.

[riju_, 2016/05/25 15:07:17]

Adding,
if (m_sensorState == newState)
   return;

and with the state checks in start() and stop(), it will throw exceptions

[timvolodine, 2016/05/25 15:40:22]

don't think this is sufficient.
if I am not overlooking anything the situation would be as follows: stop is
executed in 'onstatechange' it will call stopUpdating and then 'return' and
proceed with Sensor::start calling startUpdating()...

[riju_, 2016/05/26 13:21:01]

Yes, you are right.
Now I have checked with adding start() / stop() in onstatechange event handler.
It throws an exception and halts.

+}
+
+void Sensor::suspend()
+{
+    m_hasEventListener = false;
+    stopUpdating();
+}
+
+void Sensor::resume()
+{
+    m_hasEventListener = true;
+    startUpdating();
+}
+
+void Sensor::stop()
+{
+    m_hasEventListener = false;
+    stopUpdating();

[timvolodine, 2016/05/24 15:30:35]

clear m_sensorReading?

[riju_, 2016/05/25 15:07:17]

for some sensors say geolocation, it is useful to have a
requestReading(cache:true) or just reading() method, asking for a reading from
cache, if its not stale for say more than 5 minutes. 
So within start() and stop(), i.e. sensor is active, preferred way is
event.reading.illuminance
and for a one-shot reading or when the sensor is not active (last useful
reading) , sensor.reading
That's why I did not want to clear sensorReading.

[timvolodine, 2016/05/25 15:40:22]

caching is nice, but I was thinking in terms of usage which can be confusing
IMO:
sensorA.stop() then after x hours the user does sensorA.reading... (forgetting
to sensorA.start) and gets stale data..

[riju_, 2016/05/26 13:21:01]

Ok, I am clearing the reading in sensor.stop() now.

+}
+
+bool Sensor::hasPendingActivity() const
+{
+    // Prevent V8 from garbage collecting the wrapper object if there are
+    // event listeners attached to it.
+    return hasEventListeners();
+}
+
+DEFINE_TRACE(Sensor)
+{
+    ActiveDOMObject::trace(visitor);
+    EventTargetWithInlineData::trace(visitor);
+    PlatformEventController::trace(visitor);
+    visitor->trace(m_sensorReading);
+}
+
+} // namespace blink