[Sensors] 'onerror' event implementation

third_party/WebKit/Source/modules/sensor/SensorProxy.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/SensorProxy.h"
 
 #include "core/frame/LocalFrame.h"
 #include "modules/sensor/SensorProviderProxy.h"
 #include "platform/mojo/MojoHelper.h"
 
@@ skipping 37 matching lines @@
   if (!m_provider->sensorProvider()) {
     handleSensorError();
     return;
   }
 
   m_state = Initializing;
   auto callback = convertToBaseCallback(
       WTF::bind(&SensorProxy::onSensorCreated, wrapWeakPersistent(this)));
   m_provider->sensorProvider()->GetSensor(m_type, mojo::GetProxy(&m_sensor),
                                           callback);
-  m_sensor.set_connection_error_handler(convertToBaseCallback(
-      WTF::bind(&SensorProxy::handleSensorError, wrapWeakPersistent(this))));
 }
 
 void SensorProxy::addConfiguration(
     SensorConfigurationPtr configuration,
     std::unique_ptr<Function<void(bool)>> callback) {
   DCHECK(isInitialized());
   m_sensor->AddConfiguration(std::move(configuration),
                              convertToBaseCallback(std::move(callback)));
 }
 
@@ skipping 37 matching lines @@
 
 void SensorProxy::RaiseError() {
   handleSensorError();
 }
 
 void SensorProxy::SensorReadingChanged() {
   for (Observer* observer : m_observers)
     observer->onSensorReadingChanged();
 }
 
-void SensorProxy::handleSensorError() {
+void SensorProxy::handleSensorError(ExceptionCode code,
+                                    const String& sanitizedMessage,
+                                    const String& unsanitizedMessage) {
   m_state = Uninitialized;
   m_sensor.reset();
   m_sharedBuffer.reset();
   m_sharedBufferHandle.reset();
   m_defaultConfig.reset();
   m_clientBinding.Close();
 
   for (Observer* observer : m_observers)
-    observer->onSensorError();
+    observer->onSensorError(code, sanitizedMessage, unsanitizedMessage);
 }
 
 void SensorProxy::onSensorCreated(SensorInitParamsPtr params,
                                   SensorClientRequest clientRequest) {
   DCHECK_EQ(Initializing, m_state);
   if (!params) {
-    handleSensorError();
+    handleSensorError(NotFoundError, "Sensor is not present on the platform.");
     return;
   }
 
   DCHECK_EQ(0u, params->buffer_offset % SensorInitParams::kReadBufferSize);
 
   m_mode = params->mode;
   m_defaultConfig = std::move(params->default_configuration);
   if (!m_defaultConfig) {
     handleSensorError();
     return;
   }
 
   DCHECK(m_sensor.is_bound());
   m_clientBinding.Bind(std::move(clientRequest));
 
   m_sharedBufferHandle = std::move(params->memory);
   DCHECK(!m_sharedBuffer);
   m_sharedBuffer = m_sharedBufferHandle->MapAtOffset(
       SensorInitParams::kReadBufferSize, params->buffer_offset);
 
   if (!m_sharedBuffer) {
     handleSensorError();
     return;
   }
 
+  auto errorCallback =
+      WTF::bind(&SensorProxy::handleSensorError, wrapWeakPersistent(this),
+                UnknownError, String("Internal error"), String());
+  m_sensor.set_connection_error_handler(
+      convertToBaseCallback(std::move(errorCallback)));
+
   m_state = Initialized;
   for (Observer* observer : m_observers)
     observer->onSensorInitialized();
 }
 
 }  // namespace blink