Add stack trace to the promise reject callback.

src/isolate.cc

 // Copyright 2012 the V8 project 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 <stdlib.h>
 
 #include "src/v8.h"
 
 #include "src/ast.h"
 #include "src/base/platform/platform.h"
@@ skipping 2254 matching lines @@
 
 void Isolate::SetPromiseRejectCallback(PromiseRejectCallback callback) {
   promise_reject_callback_ = callback;
 }
 
 
 void Isolate::ReportPromiseReject(Handle<JSObject> promise,
                                   Handle<Object> value,
                                   v8::PromiseRejectEvent event) {
   if (promise_reject_callback_ == NULL) return;
-  promise_reject_callback_(v8::Utils::PromiseToLocal(promise),
-                           v8::Utils::ToLocal(value), event);
+  Handle<JSArray> stack_trace;
+  if (event == v8::kPromiseRejectWithNoHandler &&
+      capture_stack_trace_for_uncaught_exceptions_ && value->IsJSObject()) {

[aandrey, 2014/10/07 10:49:05]

I think we can drop the capture_stack_trace_for_uncaught_exceptions_ check:
1) will be still handled correctly below,
2) this flag may be false, but we could still have the stack collected.

+    Handle<JSObject> error_obj = Handle<JSObject>::cast(value);
+    Handle<Name> key = factory()->detailed_stack_trace_symbol();
+    Handle<Object> property = JSObject::GetDataProperty(error_obj, key);
+    if (property->IsJSArray()) stack_trace = Handle<JSArray>::cast(property);
+  }
+  promise_reject_callback_(v8::Utils::PromiseToLocal(promise), event,
+                           v8::Utils::ToLocal(value),
+                           v8::Utils::StackTraceToLocal(stack_trace));
 }
 
 
 void Isolate::EnqueueMicrotask(Handle<Object> microtask) {
   DCHECK(microtask->IsJSFunction() || microtask->IsCallHandlerInfo());
   Handle<FixedArray> queue(heap()->microtask_queue(), this);
   int num_tasks = pending_microtask_count();
   DCHECK(num_tasks <= queue->length());
   if (num_tasks == 0) {
     queue = factory()->NewFixedArray(8);
@@ skipping 99 matching lines @@
   if (prev_ && prev_->Intercept(flag)) return true;
   // Then check whether this scope intercepts.
   if ((flag & intercept_mask_)) {
     intercepted_flags_ |= flag;
     return true;
   }
   return false;
 }
 
 } }  // namespace v8::internal