Propagate error/exception information for rejected Promises in Service workers.

Source/modules/serviceworkers/WaitUntilObserver.cpp

 // Copyright 2014 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 "config.h"
 #include "modules/serviceworkers/WaitUntilObserver.h"
 
 #include "bindings/core/v8/ScriptFunction.h"
 #include "bindings/core/v8/ScriptPromise.h"
 #include "bindings/core/v8/ScriptValue.h"
 #include "bindings/core/v8/V8Binding.h"
+#include "bindings/core/v8/V8ErrorEvent.h"
 #include "core/dom/ExecutionContext.h"
+#include "core/events/ErrorEvent.h"
 #include "platform/NotImplemented.h"
 #include "public/platform/WebServiceWorkerEventResult.h"
 #include "wtf/Assertions.h"
 #include "wtf/RefCounted.h"
 #include "wtf/RefPtr.h"
+#include "core/workers/WorkerGlobalScope.h"
+#include "core/workers/WorkerThread.h"
+#include "core/workers/WorkerReportingProxy.h"
+#include "core/dom/ExecutionContext.h"
 #include <v8.h>
 
+#include "base/logging.h"
+
 namespace blink {
 
 class WaitUntilObserver::ThenFunction FINAL : public ScriptFunction {
 public:
     enum ResolveType {
         Fulfilled,
         Rejected,
     };
 
     static v8::Handle<v8::Function> createFunction(ScriptState* scriptState, WaitUntilObserver* observer, ResolveType type)
@@ skipping 58 matching lines @@
     : ContextLifecycleObserver(context)
     , m_type(type)
     , m_eventID(eventID)
     , m_pendingActivity(0)
     , m_hasError(false)
 {
 }
 
 void WaitUntilObserver::reportError(const ScriptValue& value)
 {
-    // FIXME: Propagate error message to the client for onerror handling.
-    notImplemented();
+    VLOG(1) <<__FUNCTION__;
+    if(V8ErrorEvent::hasInstance(value.v8Value(), toIsolate(executionContext()))) {
+        ErrorEvent* errEvent = V8ErrorEvent::toImplWithTypeCheck(toIsolate(executionContext()), value.v8Value());
+        toWorkerGlobalScope(executionContext())->thread()->workerReportingProxy()
+        .reportException(errEvent->message(),
+                        errEvent->lineno(),
+                        errEvent->colno(),
+                        errEvent->filename());
+        VLOG(1) << errEvent->message().ascii().data();
+        VLOG(1) << errEvent->filename().ascii().data()<< " : "<< errEvent->lineno() << " : " << errEvent->colno();
+    }
 
     m_hasError = true;
 }
 
 void WaitUntilObserver::incrementPendingActivity()
 {
     ++m_pendingActivity;
 }
 
 void WaitUntilObserver::decrementPendingActivity()
 {
     ASSERT(m_pendingActivity > 0);
     if (!executionContext() || (!m_hasError && --m_pendingActivity))
         return;
 
     ServiceWorkerGlobalScopeClient* client = ServiceWorkerGlobalScopeClient::from(executionContext());
     WebServiceWorkerEventResult result = m_hasError ? WebServiceWorkerEventResultRejected : WebServiceWorkerEventResultCompleted;
     switch (m_type) {
     case Activate:
         client->didHandleActivateEvent(m_eventID, result);
         break;
     case Install:
         client->didHandleInstallEvent(m_eventID, result);
         break;
     }
     observeContext(0);
 }
 
 } // namespace blink