[Sensors] 'onerror' event implementation

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"
@@ skipping 150 matching lines @@
     return;
 
   startListening();
 }
 
 void Sensor::onSensorReadingChanged() {
   if (m_polling)
     m_polling->onSensorReadingChanged();
 }
 
-void Sensor::onSensorError() {
-  reportError();
+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)
     return;
 
   if (!result) {
-    reportError();
+    reportError(
+        OperationError,
+        "start() call has failed possibly due to inappropriate options.");
     return;
   }
 
   DCHECK(m_configuration);
   DCHECK(m_sensorProxy);
   auto pollCallback = WTF::bind(&Sensor::pollForData, wrapWeakPersistent(this));
   DCHECK_GT(m_configuration->frequency, 0);
   m_polling = SensorPollingStrategy::create(1 / m_configuration->frequency,
                                             std::move(pollCallback),
                                             m_sensorProxy->reportingMode());
   updateState(Sensor::SensorState::ACTIVE);
 }
 
 void Sensor::onStopRequestCompleted(bool result) {
   if (m_state == Sensor::SensorState::IDLE)
     return;
 
   if (!result)
-    reportError();
+    reportError(OperationError);
 
   DCHECK(m_sensorProxy);
   m_sensorProxy->removeObserver(this);
 }
 
 void Sensor::pageVisibilityChanged() {
   updatePollingStatus();
 
   if (!m_sensorProxy || !m_sensorProxy->isInitialized())
     return;
@@ skipping 76 matching lines @@
   m_state = newState;
   if (getExecutionContext()) {
     getExecutionContext()->postTask(
         BLINK_FROM_HERE, createSameThreadTask(&Sensor::notifyStateChanged,
                                               wrapWeakPersistent(this)));
   }
 
   updatePollingStatus();
 }
 
-void Sensor::reportError() {
+void Sensor::reportError(ExceptionCode code,
+                         const String& sanitizedMessage,
+                         const String& unsanitizedMessage) {
   updateState(Sensor::SensorState::ERRORED);
-  // TODO(Mikhail) : Dispatch Sensor Error event.
+  if (getExecutionContext()) {
+    auto error =
+        DOMException::create(code, sanitizedMessage, unsanitizedMessage);
+    getExecutionContext()->postTask(
+        BLINK_FROM_HERE,
+        createSameThreadTask(&Sensor::notifyError, wrapWeakPersistent(this),
+                             wrapPersistent(error)));
+  }
 }
 
 void Sensor::updatePollingStatus() {
   if (!m_polling)
     return;
 
   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));
 }
 
 void Sensor::notifyStateChanged() {
   dispatchEvent(Event::create(EventTypeNames::statechange));
 }
 
+void Sensor::notifyError(DOMException* error) {
+  dispatchEvent(
+      SensorErrorEvent::create(EventTypeNames::error, std::move(error)));
+}
+
 }  // namespace blink