Show stack traces in console for unhandled promise rejection messages.

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 140 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);
     }
 }
 
-typedef WillBeHeapDeque<ScriptValue> PromiseRejectMessageQueue;
+namespace {
+
+class PromiseRejectMessage {
+public:
+    PromiseRejectMessage(const ScriptValue& promise, PassRefPtrWillBeRawPtr<ScriptCallStack> callStack)
+        : m_promise(promise)
+        , m_callStack(callStack)
+    {
+    }
+
+    const ScriptValue m_promise;
+    const RefPtrWillBeMember<ScriptCallStack> m_callStack;
+};
+
+} // namespace
+
+typedef WillBeHeapDeque<PromiseRejectMessage> PromiseRejectMessageQueue;
 
 static PromiseRejectMessageQueue& promiseRejectMessageQueue()
 {
     DEFINE_STATIC_LOCAL(OwnPtrWillBePersistent<PromiseRejectMessageQueue>, queue, (adoptPtrWillBeNoop(new PromiseRejectMessageQueue())));
     return *queue;
 }
 
 void V8Initializer::reportRejectedPromises()
 {
     ASSERT(isMainThread());
 
     PromiseRejectMessageQueue& queue = promiseRejectMessageQueue();
     while (!queue.isEmpty()) {
-        ScriptValue promise = queue.takeFirst();
-        ScriptState* scriptState = promise.scriptState();
+        PromiseRejectMessage message = queue.takeFirst();
+        ScriptState* scriptState = message.m_promise.scriptState();
         if (!scriptState->contextIsValid())
             continue;
         ScriptState::Scope scope(scriptState);
 
-        ASSERT(!promise.isEmpty());
-        v8::Handle<v8::Value> value = promise.v8Value();
+        ASSERT(!message.m_promise.isEmpty());
+        v8::Handle<v8::Value> value = message.m_promise.v8Value();
         ASSERT(!value.IsEmpty() && value->IsPromise());
         if (v8::Handle<v8::Promise>::Cast(value)->HasHandler())
             continue;
 
         ExecutionContext* executionContext = scriptState->executionContext();
         if (!executionContext)
             continue;
 
         const String errorMessage = "Unhandled promise rejection";
         Vector<ScriptValue> args;
         args.append(ScriptValue(scriptState, v8String(scriptState->isolate(), errorMessage)));
-        args.append(promise);
+        args.append(message.m_promise);
         RefPtrWillBeRawPtr<ScriptArguments> arguments = ScriptArguments::create(scriptState, args);
 
-        RefPtrWillBeRawPtr<ConsoleMessage> consoleMessage = ConsoleMessage::create(JSMessageSource, ErrorMessageLevel, errorMessage, "", 0);
+        RefPtrWillBeRawPtr<ConsoleMessage> consoleMessage = ConsoleMessage::create(JSMessageSource, ErrorMessageLevel, errorMessage);
         consoleMessage->setScriptArguments(arguments);
+        consoleMessage->setCallStack(message.m_callStack);
         executionContext->addConsoleMessage(consoleMessage.release());
     }
 }
 
 static void promiseRejectHandlerInMainThread(v8::PromiseRejectMessage message)
 {
     ASSERT(isMainThread());
 
     if (message.GetEvent() != v8::kPromiseRejectWithNoHandler)
         return;
@@ skipping 10 matching lines @@
     v8::Isolate* isolate = promise->GetIsolate();
     v8::Handle<v8::Context> context = isolate->GetCurrentContext();
     if (context.IsEmpty())
         return;
     v8::Handle<v8::Value> global = V8Window::findInstanceInPrototypeChain(context->Global(), context->GetIsolate());
     if (global.IsEmpty())
         return;
     if (!toFrameIfNotDetached(context))
         return;
 
+    RefPtrWillBeRawPtr<ScriptCallStack> callStack = nullptr;
+    v8::Handle<v8::StackTrace> stackTrace = message.GetStackTrace();
+    if (!stackTrace.IsEmpty() && stackTrace->GetFrameCount() > 0)
+        callStack = createScriptCallStack(stackTrace, ScriptCallStack::maxCallStackSizeToCapture, isolate);
+
     ScriptState* scriptState = ScriptState::from(context);
-    promiseRejectMessageQueue().append(ScriptValue(scriptState, promise));
+    promiseRejectMessageQueue().append(PromiseRejectMessage(ScriptValue(scriptState, promise), callStack));
 }
 
 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();
 
@@ skipping 101 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