Catch uncaught promise rejections from V8 and log to console.

Source/bindings/core/v8/V8Initializer.cpp

 /*
  * Copyright (C) 2009 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 12 matching lines @@
  * THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
 #include "bindings/core/v8/V8Initializer.h"
 
 #include "bindings/core/v8/DOMWrapperWorld.h"
 #include "bindings/core/v8/ScriptCallStackFactory.h"
 #include "bindings/core/v8/ScriptController.h"
 #include "bindings/core/v8/ScriptProfiler.h"
+#include "bindings/core/v8/ScriptValue.h"
+#include "bindings/core/v8/ScriptValueTraits.h"
 #include "bindings/core/v8/V8Binding.h"
 #include "bindings/core/v8/V8DOMException.h"
 #include "bindings/core/v8/V8ErrorEvent.h"
 #include "bindings/core/v8/V8ErrorHandler.h"
 #include "bindings/core/v8/V8GCController.h"
 #include "bindings/core/v8/V8History.h"
 #include "bindings/core/v8/V8Location.h"
 #include "bindings/core/v8/V8PerContextData.h"
 #include "bindings/core/v8/V8Window.h"
 #include "core/dom/Document.h"
 #include "core/dom/ExceptionCode.h"
+#include "core/dom/Microtask.h"
 #include "core/frame/ConsoleTypes.h"
 #include "core/frame/LocalDOMWindow.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/csp/ContentSecurityPolicy.h"
 #include "core/inspector/ScriptCallStack.h"
 #include "platform/EventDispatchForbiddenScope.h"
 #include "platform/TraceEvent.h"
 #include "public/platform/Platform.h"
 #include "wtf/RefPtr.h"
 #include "wtf/text/WTFString.h"
@@ skipping 94 matching lines @@
         // Allowing error events in private scripts is safe because error events don't propagate to
         // other isolated worlds (which means that the error events won't fire any event listeners
         // in user's scripts).
         EventDispatchForbiddenScope::AllowUserAgentEvents allowUserAgentEvents;
         enteredWindow->document()->reportException(event.release(), scriptId, callStack, corsStatus);
     } else {
         enteredWindow->document()->reportException(event.release(), scriptId, callStack, corsStatus);
     }
 }
 
+namespace {
+
+struct PromiseRejectMessage {

[yurys, 2014/10/03 15:08:06]

class?

[aandrey, 2014/10/06 10:52:57]

Done.

+    PromiseRejectMessage(const ScriptValue& promise, const ScriptValue& rejectValue)
+        : m_promise(promise)
+        , m_rejectValue(rejectValue)
+    {
+    }
+
+    ScriptValue m_promise;
+    ScriptValue m_rejectValue;
+};
+
+} // namespace
+
+typedef WillBeHeapHashMap<ScriptValue, OwnPtr<PromiseRejectMessage>, ScriptValueHash, ScriptValueHashTraits> PromiseRejectMessageMap;
+static bool promiseEndOfTurnTaskScheduled = false;
+
+static PromiseRejectMessageMap& promiseRejectMessageQueue()
+{
+    DEFINE_STATIC_LOCAL(OwnPtrWillBePersistent<PromiseRejectMessageMap>, map, (adoptPtrWillBeNoop(new PromiseRejectMessageMap())));
+    return *map;
+}
+
+static void firePromiseRejectMessages()

[yurys, 2014/10/03 15:08:06]

Please wrap the new code into a class.

[aandrey, 2014/10/06 10:52:57]

I'd rather put this code together with the exception message hook, and see later
how to refactor both together.

+{
+    ASSERT(isMainThread());
+
+    promiseEndOfTurnTaskScheduled = false;
+    v8::Isolate::GetCurrent()->RemoveCallCompletedCallback(&firePromiseRejectMessages);

[yurys, 2014/10/03 15:08:06]

Why not add this callback once on the isolate initialization?

[aandrey, 2014/10/06 10:52:57]

So that we should not affect common use cases: we need this callback very
rarely.

+
+    // FIXME: Send more data from V8.
+    int scriptId = 0;
+    AccessControlStatus corsStatus = SharableCrossOrigin;
+    Vector<ScriptCallFrame> callFrames;
+    RefPtrWillBeRawPtr<ScriptCallStack> callStack = ScriptCallStack::create(callFrames);

[yurys, 2014/10/03 15:08:05]

= nullptr?

[aandrey, 2014/10/06 10:52:57]

Done.

+
+    PromiseRejectMessageMap& map = promiseRejectMessageQueue();
+    while (!map.isEmpty()) {
+        PromiseRejectMessageMap::iterator it = map.begin();
+        ScriptValue promise = it->value->m_promise;
+        ScriptValue rejectValue = it->value->m_rejectValue;
+        map.remove(it);
+
+        ScriptState* scriptState = promise.scriptState();
+        if (scriptState->contextIsValid())
+            continue;
+        ScriptState::Scope scope(scriptState);
+
+        RefPtrWillBeRawPtr<ErrorEvent> event = ErrorEvent::createSanitizedError(&scriptState->world());
+        event->setUnsanitizedMessage("Uncaught promise reject");
+
+        v8::Handle<v8::Value> data = rejectValue.v8Value();

[yurys, 2014/10/03 15:08:06]

The whole idea we agreed on was to pass rejected value to DevTools console, we
should either convert it to string here or pass the value along with
corresponding console message.

Given that we don't support window.onerror reporting yet (waiting for spec) can
we create a ConsoleMessage here and pass rejected value as argument?

[aandrey, 2014/10/06 10:52:57]

Done. Passing ScriptArguments.

+        if (!data.IsEmpty() && V8DOMWrapper::isDOMWrapper(data)) {
+            v8::Handle<v8::Object> obj = v8::Handle<v8::Object>::Cast(data);
+            const WrapperTypeInfo* type = toWrapperTypeInfo(obj);
+            if (V8DOMException::wrapperTypeInfo.isSubclass(type)) {
+                DOMException* exception = V8DOMException::toImpl(obj);
+                if (exception && !exception->messageForConsole().isEmpty())
+                    event->setUnsanitizedMessage("Uncaught promise reject " + exception->toStringForConsole());
+            }
+        }
+
+        if (scriptState->world().isPrivateScriptIsolatedWorld()) {
+            // We allow a private script to dispatch error events even in a EventDispatchForbiddenScope scope.
+            // Without having this ability, it's hard to debug the private script because syntax errors

[yurys, 2014/10/03 15:08:05]

This code is shared between regular exception handler and promise rejections,
can you extract this into a method to avoid duplication?

[aandrey, 2014/10/06 10:52:57]

Acknowledged.

+            // in the private script are not reported to console (the private script just crashes silently).
+            // Allowing error events in private scripts is safe because error events don't propagate to
+            // other isolated worlds (which means that the error events won't fire any event listeners
+            // in user's scripts).
+            EventDispatchForbiddenScope::AllowUserAgentEvents allowUserAgentEvents;
+            scriptState->executionContext()->reportException(event.release(), scriptId, callStack, corsStatus, true);
+        } else {
+            scriptState->executionContext()->reportException(event.release(), scriptId, callStack, corsStatus, true);
+        }
+    }
+}
+
+static void promiseRejectHandlerInMainThread(v8::Handle<v8::Promise> promise, v8::Handle<v8::Value> value, v8::PromiseRejectEvent event)
+{
+    ASSERT(isMainThread());
+
+    // It's possible that promiseRejectHandlerInMainThread() is invoked while we're initializing a window.
+    // In that half-baked situation, we don't have a valid context nor a valid world,
+    // so just return immediately.
+    if (DOMWrapperWorld::windowIsBeingInitialized())
+        return;
+
+    v8::Isolate* isolate = v8::Isolate::GetCurrent();
+
+    // If called during context initialization, there will be no entered window.
+    LocalDOMWindow* enteredWindow = enteredDOMWindow(isolate);
+    if (!enteredWindow || !enteredWindow->isCurrentlyDisplayedInFrame())
+        return;
+
+    ScriptState* scriptState = ScriptState::current(isolate);
+    ScriptValue promiseValue(scriptState, promise);
+    PromiseRejectMessageMap& map = promiseRejectMessageQueue();
+    if (event == v8::kPromiseRejectWithNoHandler) {
+        ASSERT(!map.contains(promiseValue));
+        PromiseRejectMessage* data = new PromiseRejectMessage(promiseValue, ScriptValue(scriptState, value));

[yurys, 2014/10/03 15:08:05]

new should be wrapped with adoptPtr

[aandrey, 2014/10/06 10:52:57]

Done.

+        map.set(promiseValue, adoptPtr(data));
+    } else if (event == v8::kPromiseHandlerAddedAfterReject) {
+        PromiseRejectMessageMap::iterator it = map.find(promiseValue);
+        if (it != map.end()) {
+            map.remove(it);
+        } else {
+            // FIXME: Report revoke message to console.
+        }
+    } else {
+        ASSERT_NOT_REACHED();
+    }
+
+    if (!promiseEndOfTurnTaskScheduled && !map.isEmpty()) {
+        promiseEndOfTurnTaskScheduled = true;
+        isolate->AddCallCompletedCallback(&firePromiseRejectMessages);
+    }
+}
+
 static void failedAccessCheckCallbackInMainThread(v8::Local<v8::Object> host, v8::AccessType type, v8::Local<v8::Value> data)
 {
     v8::Isolate* isolate = v8::Isolate::GetCurrent();
     LocalFrame* target = findFrame(host, data, isolate);
     if (!target)
         return;
     LocalDOMWindow* targetWindow = target->domWindow();
 
     // FIXME: We should modify V8 to pass in more contextual information (context, property, and object).
     ExceptionState exceptionState(ExceptionState::UnknownContext, 0, 0, isolate->GetCurrentContext()->Global(), isolate);
@@ skipping 43 matching lines @@
     v8::Isolate* isolate = V8PerIsolateData::initialize();
 
     initializeV8Common(isolate);
 
     v8::V8::SetFatalErrorHandler(reportFatalErrorInMainThread);
     v8::V8::AddMessageListener(messageHandlerInMainThread);
     v8::V8::SetFailedAccessCheckCallbackFunction(failedAccessCheckCallbackInMainThread);
     v8::V8::SetAllowCodeGenerationFromStringsCallback(codeGenerationCheckCallbackInMainThread);
 
     isolate->SetEventLogger(timerTraceProfilerInMainThread);
+    isolate->SetPromiseRejectCallback(promiseRejectHandlerInMainThread);
 
     ScriptProfiler::initialize();
 }
 
 static void reportFatalErrorInWorker(const char* location, const char* message)
 {
     // FIXME: We temporarily deal with V8 internal error situations such as out-of-memory by crashing the worker.
     CRASH();
 }
 
@@ skipping 35 matching lines @@
     initializeV8Common(isolate);
 
     v8::V8::AddMessageListener(messageHandlerInWorker);
     v8::V8::SetFatalErrorHandler(reportFatalErrorInWorker);
 
     uint32_t here;
     isolate->SetStackLimit(reinterpret_cast<uintptr_t>(&here - kWorkerMaxStackSize / sizeof(uint32_t*)));
 }
 
 } // namespace blink