[inspector] introduced Debugger.scheduleStepIntoAsync

src/debug/debug.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 "src/debug/debug.h"
 
 #include <memory>
 
 #include "src/api.h"
 #include "src/arguments.h"
@@ skipping 1706 matching lines @@
 }
 }  // anonymous namespace
 
 bool Debug::IsExceptionBlackboxed(bool uncaught) {
   JavaScriptFrameIterator it(isolate_);
   if (it.done()) return false;
   // Uncaught exception is blackboxed if all current frames are blackboxed,
   // caught exception if top frame is blackboxed.
   bool is_top_frame_blackboxed = IsFrameBlackboxed(it.frame());
   if (!uncaught || !is_top_frame_blackboxed) return is_top_frame_blackboxed;
-  it.Advance();
-  while (!it.done()) {
-    if (!IsFrameBlackboxed(it.frame())) return false;
-    it.Advance();
-  }
-  return true;
+  return !HasNonBlackboxedFrameOnStack();
 }
 
 bool Debug::IsFrameBlackboxed(JavaScriptFrame* frame) {
   HandleScope scope(isolate_);
   if (!frame->HasInlinedFrames()) {
     Handle<SharedFunctionInfo> shared(frame->function()->shared(), isolate_);
     return IsBlackboxed(shared);
   }
   List<Handle<SharedFunctionInfo>> infos;
   frame->GetFunctions(&infos);
@@ skipping 234 matching lines @@
         is_blackboxed = debug_delegate_->IsFunctionBlackboxed(
             ToApiHandle<debug::Script>(script), start, end);
       }
     }
     shared->set_debug_is_blackboxed(is_blackboxed);
     shared->set_computed_debug_is_blackboxed(true);
   }
   return shared->debug_is_blackboxed();
 }
 
+bool Debug::HasNonBlackboxedFrameOnStack() {
+  HandleScope scope(isolate_);
+  for (StackTraceFrameIterator it(isolate_); !it.done(); it.Advance()) {
+    if (!it.is_javascript()) continue;
+    if (!IsFrameBlackboxed(it.javascript_frame())) return true;
+  }
+  return false;
+}
+
 void Debug::OnAsyncTaskEvent(debug::PromiseDebugActionType type, int id,
                              int parent_id) {
   if (in_debug_scope() || ignore_events()) return;
   if (!debug_delegate_) return;
   SuppressDebug while_processing(this);
   DebugScope debug_scope(isolate_->debug());
   if (debug_scope.failed()) return;
   HandleScope scope(isolate_);
   PostponeInterruptsScope no_interrupts(isolate_);
   DisableBreak no_recursive_break(this);
-  debug_delegate_->PromiseEventOccurred(type, id, parent_id);
+  bool created_by_user = false;
+  if (type == debug::kDebugPromiseCreated) {
+    JavaScriptFrameIterator it(isolate_);
+    // We need to skip top frame which contains instrumentation.

[dgozman, 2017/03/03 19:47:06]

Looks a bit sketchy, as it heavily relies on the implementation of Promise.all
and Promise.race. Not sure how to make it better though.

[kozy, 2017/03/03 20:17:02]

We skip not a Promise.all or Promise.race here, we skip .then call and it looks
fine to me. It's rely only on idea that promise created instrumentation placed
inside of .then implementation.

+    it.Advance();
+    created_by_user =
+        !it.done() &&
+        it.frame()->function()->shared()->IsSubjectToDebugging() &&
+        !IsFrameBlackboxed(it.frame());
+  }
+  debug_delegate_->PromiseEventOccurred(
+      Utils::ToLocal(debug_scope.GetContext()), type, id, parent_id,
+      created_by_user);
 }
 
 void Debug::ProcessCompileEvent(v8::DebugEvent event, Handle<Script> script) {
   if (ignore_events()) return;
   if (script->type() != i::Script::TYPE_NORMAL &&
       script->type() != i::Script::TYPE_WASM) {
     return;
   }
   if (!debug_delegate_) return;
   SuppressDebug while_processing(this);
@@ skipping 259 matching lines @@
   DCHECK(isolate_->needs_side_effect_check());
   if (DebugEvaluate::CallbackHasNoSideEffect(function)) return true;
   side_effect_check_failed_ = true;
   // Throw an uncatchable termination exception.
   isolate_->TerminateExecution();
   isolate_->OptionalRescheduleException(false);
   return false;
 }
 
 void LegacyDebugDelegate::PromiseEventOccurred(
-    v8::debug::PromiseDebugActionType type, int id, int parent_id) {
+    v8::Local<v8::Context> context, v8::debug::PromiseDebugActionType type,
+    int id, int parent_id, bool created_by_user) {
   Handle<Object> event_data;
   if (isolate_->debug()->MakeAsyncTaskEvent(type, id).ToHandle(&event_data)) {
     ProcessDebugEvent(v8::AsyncTaskEvent, Handle<JSObject>::cast(event_data));
   }
 }
 
 void LegacyDebugDelegate::ScriptCompiled(v8::Local<v8::debug::Script> script,
                                          bool is_compile_error) {
   Handle<Object> event_data;
   v8::DebugEvent event = is_compile_error ? v8::CompileError : v8::AfterCompile;
@@ skipping 133 matching lines @@
     isolate_->Throw(*isolate_->factory()->NewEvalError(
         MessageTemplate::kNoSideEffectDebugEvaluate));
   }
   isolate_->set_needs_side_effect_check(old_needs_side_effect_check_);
   isolate_->debug()->UpdateHookOnFunctionCall();
   isolate_->debug()->side_effect_check_failed_ = false;
 }
 
 }  // namespace internal
 }  // namespace v8