[Sensors] Align sensor reading attribute implementation with the specification

third_party/WebKit/Source/modules/sensor/Sensor.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/Sensor.h"
 
 #include "core/dom/Document.h"
 #include "core/dom/ExceptionCode.h"
 #include "core/dom/ExecutionContextTask.h"
 #include "core/inspector/ConsoleMessage.h"
 #include "device/generic_sensor/public/interfaces/sensor.mojom-blink.h"
 #include "modules/sensor/SensorErrorEvent.h"
 #include "modules/sensor/SensorPollingStrategy.h"
 #include "modules/sensor/SensorProviderProxy.h"
 #include "modules/sensor/SensorReading.h"
-#include "modules/sensor/SensorReadingEvent.h"
 
 using namespace device::mojom::blink;
 
 namespace blink {
 
 Sensor::Sensor(ScriptState* scriptState,
                const SensorOptions& sensorOptions,
                ExceptionState& exceptionState,
                SensorType type)
     : ActiveScriptWrappable(this),
       ContextLifecycleObserver(scriptState->getExecutionContext()),
       PageVisibilityObserver(
           toDocument(scriptState->getExecutionContext())->page()),
       m_sensorOptions(sensorOptions),
       m_type(type),
-      m_state(Sensor::SensorState::IDLE),
-      m_storedData() {
+      m_state(Sensor::SensorState::IDLE) {
   // Check secure context.
   String errorMessage;
   if (!scriptState->getExecutionContext()->isSecureContext(errorMessage)) {
     exceptionState.throwDOMException(SecurityError, errorMessage);
     return;
   }
 
   // Check top-level browsing context.
   if (!scriptState->domWindow() || !scriptState->domWindow()->frame() ||
       !scriptState->domWindow()->frame()->isMainFrame()) {
@@ skipping 68 matching lines @@
   }
   return "idle";
 }
 
 // Getters
 String Sensor::state() const {
   return ToString(m_state);
 }
 
 SensorReading* Sensor::reading() const {
-  return m_sensorReading.get();
+  if (m_state != Sensor::SensorState::ACTIVE)
+    return nullptr;
+  DCHECK(m_sensorProxy);
+  return m_sensorProxy->sensorReading();
 }
 
 DEFINE_TRACE(Sensor) {
   visitor->trace(m_sensorProxy);
-  visitor->trace(m_sensorReading);
   ActiveScriptWrappable::trace(visitor);
   ContextLifecycleObserver::trace(visitor);
   PageVisibilityObserver::trace(visitor);
   EventTargetWithInlineData::trace(visitor);
 }
 
 bool Sensor::hasPendingActivity() const {
   if (m_state == Sensor::SensorState::IDLE ||
       m_state == Sensor::SensorState::ERRORED)
     return false;
   return hasEventListeners();
 }
 
 void Sensor::initSensorProxyIfNeeded() {
   if (m_sensorProxy)
     return;
 
   Document* document = toDocument(getExecutionContext());
   if (!document || !document->frame())
     return;
 
-  m_sensorProxy =
-      SensorProviderProxy::from(document->frame())->getOrCreateSensor(m_type);
+  auto provider = SensorProviderProxy::from(document->frame());
+  m_sensorProxy = provider->getSensor(m_type);
+
+  if (!m_sensorProxy) {
+    m_sensorProxy =
+        provider->createSensor(m_type, createSensorReadingFactory());
+  }
 }
 
 void Sensor::contextDestroyed() {
   if (m_state == Sensor::SensorState::ACTIVE ||
       m_state == Sensor::SensorState::ACTIVATING)
     stopListening();
 }
 
 void Sensor::onSensorInitialized() {
   if (m_state != Sensor::SensorState::ACTIVATING)
@@ skipping 54 matching lines @@
   if (page()->visibilityState() != PageVisibilityStateVisible) {
     m_sensorProxy->suspend();
   } else {
     m_sensorProxy->resume();
   }
 }
 
 void Sensor::startListening() {
   DCHECK(m_sensorProxy);
   updateState(Sensor::SensorState::ACTIVATING);
-  if (!m_sensorReading) {
-    m_sensorReading = createSensorReading(m_sensorProxy);
-    DCHECK(m_sensorReading);
-  }
 
   m_sensorProxy->addObserver(this);
   if (!m_sensorProxy->isInitialized()) {
     m_sensorProxy->initialize();
     return;
   }
 
   if (!m_configuration) {
     m_configuration =
         createSensorConfig(m_sensorOptions, *m_sensorProxy->defaultConfig());
     DCHECK(m_configuration);
   }
 
   auto startCallback =
       WTF::bind(&Sensor::onStartRequestCompleted, wrapWeakPersistent(this));
   m_sensorProxy->addConfiguration(m_configuration->Clone(),
                                   std::move(startCallback));
 }
 
 void Sensor::stopListening() {
   DCHECK(m_sensorProxy);
-  m_sensorReading = nullptr;
   updateState(Sensor::SensorState::IDLE);
 
   if (m_sensorProxy->isInitialized()) {
     auto callback =
         WTF::bind(&Sensor::onStopRequestCompleted, wrapWeakPersistent(this));
     DCHECK(m_configuration);
     m_sensorProxy->removeConfiguration(m_configuration->Clone(),
                                        std::move(callback));
   } else {
     m_sensorProxy->removeObserver(this);
   }
 }
 
 void Sensor::pollForData() {
   if (m_state != Sensor::SensorState::ACTIVE) {
     DCHECK(m_polling);
     m_polling->stopPolling();
     return;
   }
 
   DCHECK(m_sensorProxy);
   DCHECK(m_sensorProxy->isInitialized());
-  m_sensorProxy->updateInternalReading();
+  m_sensorProxy->updateSensorReading();
 
-  DCHECK(m_sensorReading);
+  DCHECK(m_sensorProxy->sensorReading());
   if (getExecutionContext() &&
-      m_sensorReading->isReadingUpdated(m_storedData)) {
+      m_sensorProxy->sensorReading()->isReadingUpdated(m_storedData)) {
     getExecutionContext()->postTask(
         BLINK_FROM_HERE,
         createSameThreadTask(&Sensor::notifySensorReadingChanged,
                              wrapWeakPersistent(this)));
   }
 
-  m_storedData = m_sensorProxy->reading();
+  m_storedData = m_sensorProxy->sensorReading()->data();
 }
 
 void Sensor::updateState(Sensor::SensorState newState) {
   if (newState == m_state)
     return;
   m_state = newState;
   if (getExecutionContext()) {
     getExecutionContext()->postTask(
         BLINK_FROM_HERE, createSameThreadTask(&Sensor::notifyStateChanged,
                                               wrapWeakPersistent(this)));
@@ skipping 22 matching lines @@
 
   if (m_state != Sensor::SensorState::ACTIVE ||
       page()->visibilityState() != PageVisibilityStateVisible) {
     m_polling->stopPolling();
   } else {
     m_polling->startPolling();
   }
 }
 
 void Sensor::notifySensorReadingChanged() {
-  dispatchEvent(
-      SensorReadingEvent::create(EventTypeNames::change, m_sensorReading));
+  dispatchEvent(Event::create(EventTypeNames::change));
 }
 
 void Sensor::notifyStateChanged() {
   dispatchEvent(Event::create(EventTypeNames::statechange));
 }
 
 void Sensor::notifyError(DOMException* error) {
   dispatchEvent(
       SensorErrorEvent::create(EventTypeNames::error, std::move(error)));
 }
 
 }  // namespace blink