[inspector] introduced stepIntoAsync for chained callbacks

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 385 matching lines @@
 void Debug::ThreadInit() {
   thread_local_.break_count_ = 0;
   thread_local_.break_id_ = 0;
   thread_local_.break_frame_id_ = StackFrame::NO_ID;
   thread_local_.last_step_action_ = StepNone;
   thread_local_.last_statement_position_ = kNoSourcePosition;
   thread_local_.last_fp_ = 0;
   thread_local_.target_fp_ = 0;
   thread_local_.return_value_ = Smi::kZero;
   thread_local_.async_task_count_ = 0;
+  thread_local_.non_breakable_async_events_ = false;
   clear_suspended_generator();
   thread_local_.restart_fp_ = nullptr;
   base::NoBarrier_Store(&thread_local_.current_debug_scope_,
                         static_cast<base::AtomicWord>(0));
   UpdateHookOnFunctionCall();
 }
 
 
 char* Debug::ArchiveDebug(char* storage) {
   // Simply reset state. Don't archive anything.
@@ skipping 1504 matching lines @@
   info.SetSecondPassCallback(&SendAsyncTaskEventCancel);
 }
 
 // In an async function, reuse the existing stack related to the outer
 // Promise. Otherwise, e.g. in a direct call to then, save a new stack.
 // Promises with multiple reactions with one or more of them being async
 // functions will not get a good stack trace, as async functions require
 // different stacks from direct Promise use, but we save and restore a
 // stack once for all reactions.
 //
-// If this isn't a case of async function, we return false, otherwise
-// we set the correct id and return true.
-//
 // TODO(littledan): Improve this case.
 int GetReferenceAsyncTaskId(Isolate* isolate, Handle<JSPromise> promise) {
   Handle<Symbol> handled_by_symbol =
       isolate->factory()->promise_handled_by_symbol();
   Handle<Object> handled_by_promise =
       JSObject::GetDataProperty(promise, handled_by_symbol);
   if (!handled_by_promise->IsJSPromise()) {
     return isolate->debug()->NextAsyncTaskId(promise);
   }
   Handle<JSPromise> handled_by_promise_js =
       Handle<JSPromise>::cast(handled_by_promise);
   Handle<Symbol> async_stack_id_symbol =
       isolate->factory()->promise_async_stack_id_symbol();
   Handle<Object> async_task_id =
       JSObject::GetDataProperty(handled_by_promise_js, async_stack_id_symbol);
   if (!async_task_id->IsSmi()) {
     return isolate->debug()->NextAsyncTaskId(promise);
   }
   return Handle<Smi>::cast(async_task_id)->value();
 }
 }  //  namespace
 
 void Debug::RunPromiseHook(PromiseHookType type, Handle<JSPromise> promise,
                            Handle<Object> parent) {
   if (!debug_delegate_) return;
   int id = GetReferenceAsyncTaskId(isolate_, promise);
   switch (type) {
     case PromiseHookType::kInit:
-      debug_delegate_->PromiseEventOccurred(
-          debug::kDebugPromiseCreated, id,
+      debug_delegate_->PromiseCreatedEvent(
+          id,
           parent->IsJSPromise() ? GetReferenceAsyncTaskId(
                                       isolate_, Handle<JSPromise>::cast(parent))
-                                : 0);
+                                : 0,
+          !thread_local_.non_breakable_async_events_);
       return;
     case PromiseHookType::kResolve:
       // We can't use this hook because it's called before promise object will
       // get resolved status.
       return;
     case PromiseHookType::kBefore:
       OnAsyncTaskEvent(debug::kDebugWillHandle, id);
       return;
     case PromiseHookType::kAfter:
       OnAsyncTaskEvent(debug::kDebugDidHandle, id);
@@ skipping 60 matching lines @@
     shared->set_debug_is_blackboxed(is_blackboxed);
     shared->set_computed_debug_is_blackboxed(true);
   }
   return shared->debug_is_blackboxed();
 }
 
 void Debug::OnAsyncTaskEvent(debug::PromiseDebugActionType type, int id) {
   if (in_debug_scope() || ignore_events()) return;
 
   if (debug_delegate_) {
-    debug_delegate_->PromiseEventOccurred(type, id, 0);
+    debug_delegate_->PromiseEventOccurred(type, id);
     if (!non_inspector_listener_exists()) return;
   }
 
   HandleScope scope(isolate_);
   DebugScope debug_scope(this);
   if (debug_scope.failed()) return;
 
   // Create the script collected state object.
   Handle<Object> event_data;
   // Bail out and don't call debugger if exception.
@@ skipping 370 matching lines @@
   return v8::Utils::ToLocal(callback_data_);
 }
 
 
 v8::Isolate* EventDetailsImpl::GetIsolate() const {
   return reinterpret_cast<v8::Isolate*>(exec_state_->GetIsolate());
 }
 
 }  // namespace internal
 }  // namespace v8