[Sensors] Stop exposing sensor state

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/TaskRunnerHelper.h"
 #include "core/inspector/ConsoleMessage.h"
 #include "core/timing/DOMWindowPerformance.h"
 #include "core/timing/Performance.h"
 #include "device/generic_sensor/public/interfaces/sensor.mojom-blink.h"
 #include "modules/sensor/SensorErrorEvent.h"
 #include "modules/sensor/SensorProviderProxy.h"
 
 using namespace device::mojom::blink;
 
 namespace blink {
 
 Sensor::Sensor(ExecutionContext* executionContext,
                const SensorOptions& sensorOptions,
                ExceptionState& exceptionState,
                SensorType type)
     : ContextLifecycleObserver(executionContext),
       m_sensorOptions(sensorOptions),
       m_type(type),
-      m_state(Sensor::SensorState::Unconnected),
+      m_state(SensorState::Idle),
       m_lastUpdateTimestamp(0.0) {
   // Check secure context.
   String errorMessage;
   if (!executionContext->isSecureContext(errorMessage)) {
     exceptionState.throwDOMException(SecurityError, errorMessage);
     return;
   }
 
   // Check top-level browsing context.
   if (!toDocument(executionContext)->domWindow()->frame() ||
@@ skipping 11 matching lines @@
       ConsoleMessage* consoleMessage = ConsoleMessage::create(
           JSMessageSource, InfoMessageLevel, "Frequency is limited to 60 Hz.");
       executionContext->addConsoleMessage(consoleMessage);
     }
   }
 }
 
 Sensor::~Sensor() = default;
 
 void Sensor::start() {
-  if (m_state != Sensor::SensorState::Unconnected &&
-      m_state != Sensor::SensorState::Idle &&
-      m_state != Sensor::SensorState::Errored)
+  if (m_state != Sensor::SensorState::Idle)
     return;
 
   initSensorProxyIfNeeded();
   if (!m_sensorProxy) {
     reportError(InvalidStateError,
                 "The Sensor is no longer associated to a frame.");
     return;
   }
 
   m_lastUpdateTimestamp = WTF::monotonicallyIncreasingTime();
   startListening();
 }
 
 void Sensor::stop() {
-  if (m_state == Sensor::SensorState::Unconnected ||
-      m_state == Sensor::SensorState::Idle ||
-      m_state == Sensor::SensorState::Errored)
+  if (m_state == Sensor::SensorState::Idle)
     return;
 
   stopListening();
 }
 
-static String ToString(Sensor::SensorState state) {
-  switch (state) {
-    case Sensor::SensorState::Unconnected:
-      return "unconnected";
-    case Sensor::SensorState::Activating:
-      return "activating";
-    case Sensor::SensorState::Activated:
-      return "activated";
-    case Sensor::SensorState::Idle:
-      return "idle";
-    case Sensor::SensorState::Errored:
-      return "errored";
-    default:
-      NOTREACHED();
-  }
-  return "idle";
-}
-
 // Getters
-String Sensor::state() const {
-  return ToString(m_state);
+bool Sensor::activated() const {
+  return m_state == SensorState::Activated;
 }
 
 DOMHighResTimeStamp Sensor::timestamp(ScriptState* scriptState,
                                       bool& isNull) const {
   if (!canReturnReadings()) {
     isNull = true;
     return 0.0;
   }
 
   LocalDOMWindow* window = scriptState->domWindow();
@@ skipping 12 matching lines @@
 }
 
 DEFINE_TRACE(Sensor) {
   visitor->trace(m_sensorProxy);
   ActiveScriptWrappable::trace(visitor);
   ContextLifecycleObserver::trace(visitor);
   EventTargetWithInlineData::trace(visitor);
 }
 
 bool Sensor::hasPendingActivity() const {
-  if (m_state == Sensor::SensorState::Unconnected ||
-      m_state == Sensor::SensorState::Idle ||
-      m_state == Sensor::SensorState::Errored)
+  if (m_state == Sensor::SensorState::Idle)
     return false;
   return getExecutionContext() && hasEventListeners();
 }
 
 auto Sensor::createSensorConfig() -> SensorConfigurationPtr {
   auto result = SensorConfiguration::New();
 
   double defaultFrequency = m_sensorProxy->defaultConfig()->frequency;
   double minimumFrequency = m_sensorProxy->frequencyLimits().first;
   double maximumFrequency = m_sensorProxy->frequencyLimits().second;
@@ skipping 63 matching lines @@
   }
 }
 
 void Sensor::onSensorError(ExceptionCode code,
                            const String& sanitizedMessage,
                            const String& unsanitizedMessage) {
   reportError(code, sanitizedMessage, unsanitizedMessage);
 }
 
 void Sensor::onStartRequestCompleted(bool result) {
-  if (m_state != Sensor::SensorState::Activating)
+  if (m_state != SensorState::Activating)
     return;
 
   if (!result) {
-    reportError(
-        OperationError,
-        "start() call has failed possibly due to inappropriate options.");
+    reportError(NotReadableError, "start() call has failed.");
     return;
   }
 
   updateState(Sensor::SensorState::Activated);
 }
 
 void Sensor::startListening() {
   DCHECK(m_sensorProxy);
   updateState(Sensor::SensorState::Activating);
 
@@ skipping 42 matching lines @@
         ->postTask(BLINK_FROM_HERE, WTF::bind(&Sensor::notifyOnActivate,
                                               wrapWeakPersistent(this)));
   }
 
   m_state = newState;
 }
 
 void Sensor::reportError(ExceptionCode code,
                          const String& sanitizedMessage,
                          const String& unsanitizedMessage) {
-  updateState(Sensor::SensorState::Errored);
+  updateState(SensorState::Idle);
   if (getExecutionContext()) {
     auto error =
         DOMException::create(code, sanitizedMessage, unsanitizedMessage);
     TaskRunnerHelper::get(TaskType::Sensor, getExecutionContext())
         ->postTask(BLINK_FROM_HERE,
                    WTF::bind(&Sensor::notifyError, wrapWeakPersistent(this),
                              wrapPersistent(error)));
   }
 }
 
@@ skipping 16 matching lines @@
 }
 
 bool Sensor::canReturnReadings() const {
   if (!isActivated())
     return false;
   DCHECK(m_sensorProxy);
   return m_sensorProxy->reading().timestamp != 0.0;
 }
 
 }  // namespace blink