[inspector] async stacks for Promise.then calls...

src/builtins/builtins-promise.cc

 // Copyright 2016 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/builtins/builtins-promise.h"
 #include "src/builtins/builtins-constructor.h"
 #include "src/builtins/builtins-utils.h"
 #include "src/builtins/builtins.h"
 #include "src/code-factory.h"
 #include "src/code-stub-assembler.h"
@@ skipping 776 matching lines @@
     Node* reject = nullptr;
     std::tie(resolve, reject) = CreatePromiseResolvingFunctions(
         promise, FalseConstant(), native_context);
 
     Node* const info = AllocatePromiseResolveThenableJobInfo(
         result, var_then.value(), resolve, reject, context);
 
     Label enqueue(this);
     GotoUnless(IsDebugActive(), &enqueue);
 
-    Node* const debug_id = CallRuntime(Runtime::kDebugNextMicrotaskId, context);
+    Node* const debug_id =
+        CallRuntime(Runtime::kDebugNextAsyncTaskId, context, promise);
     Node* const debug_name = SmiConstant(kDebugPromiseResolveThenableJob);
-    CallRuntime(Runtime::kDebugAsyncTaskEvent, context,
-                SmiConstant(kDebugEnqueue), debug_id, debug_name);
 
     StoreObjectField(info, PromiseResolveThenableJobInfo::kDebugIdOffset,
                      debug_id);
     StoreObjectField(info, PromiseResolveThenableJobInfo::kDebugNameOffset,
                      debug_name);
 
     GotoIf(TaggedIsSmi(result), &enqueue);
     GotoUnless(HasInstanceType(result, JS_PROMISE_TYPE), &enqueue);
 
     // Mark the dependency of the new promise on the resolution
@@ skipping 37 matching lines @@
                 TrueConstant());
     Goto(&out);
   }
 
   Bind(&out);
 }
 
 void PromiseBuiltinsAssembler::PromiseFulfill(
     Node* context, Node* promise, Node* result,
     v8::Promise::PromiseState status) {
-  Label do_promisereset(this);
+  Label do_promisereset(this), debug_async_event_enqueue_recurring(this);
 
   Node* const status_smi = SmiConstant(static_cast<int>(status));
   Node* const deferred_promise =
       LoadObjectField(promise, JSPromise::kDeferredPromiseOffset);
 
-  GotoIf(IsUndefined(deferred_promise), &do_promisereset);
+  GotoIf(IsUndefined(deferred_promise), &debug_async_event_enqueue_recurring);
 
   Node* const tasks =
       status == v8::Promise::kFulfilled
           ? LoadObjectField(promise, JSPromise::kFulfillReactionsOffset)
           : LoadObjectField(promise, JSPromise::kRejectReactionsOffset);
 
   Node* const deferred_on_resolve =
       LoadObjectField(promise, JSPromise::kDeferredOnResolveOffset);
   Node* const deferred_on_reject =
       LoadObjectField(promise, JSPromise::kDeferredOnRejectOffset);
 
   Node* const info = AllocatePromiseReactionJobInfo(
       promise, result, tasks, deferred_promise, deferred_on_resolve,
       deferred_on_reject, context);
+
   CallRuntime(Runtime::kEnqueuePromiseReactionJob, context, info, status_smi);
-  Goto(&do_promisereset);
+  Goto(&debug_async_event_enqueue_recurring);
+
+  Bind(&debug_async_event_enqueue_recurring);
+  {
+    GotoUnless(IsDebugActive(), &do_promisereset);
+    CallRuntime(Runtime::kDebugAsyncEventEnqueueRecurring, context, promise,
+                status_smi);
+    Goto(&do_promisereset);
+  }
 
   Bind(&do_promisereset);
   {
     StoreObjectField(promise, JSPromise::kStatusOffset, status_smi);
     StoreObjectField(promise, JSPromise::kResultOffset, result);
     StoreObjectFieldRoot(promise, JSPromise::kDeferredPromiseOffset,
                          Heap::kUndefinedValueRootIndex);
     StoreObjectFieldRoot(promise, JSPromise::kDeferredOnResolveOffset,
                          Heap::kUndefinedValueRootIndex);
     StoreObjectFieldRoot(promise, JSPromise::kDeferredOnRejectOffset,
@@ skipping 550 matching lines @@
 
     // 5. Return promiseCapability.[[Promise]].
     Node* const promise =
         LoadObjectField(capability, JSPromiseCapability::kPromiseOffset);
     Return(promise);
   }
 }
 
 }  // namespace internal
 }  // namespace v8