[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 554 matching lines @@
     {
       Label reject(this);
       Node* const result = LoadObjectField(promise, JSPromise::kResultOffset);
       GotoUnless(WordEqual(status, SmiConstant(v8::Promise::kFulfilled)),
                  &reject);
 
       Node* info = AllocatePromiseReactionJobInfo(
           promise, result, var_on_resolve.value(), deferred_promise,
           deferred_on_resolve, deferred_on_reject, context);
       // TODO(gsathya): Move this to TF
-      CallRuntime(Runtime::kEnqueuePromiseReactionJob, context, info,
+      CallRuntime(Runtime::kEnqueuePromiseReactionJob, context, info, promise,
                   SmiConstant(v8::Promise::kFulfilled));
       Goto(&out);
 
       Bind(&reject);
       {
         Node* const has_handler = PromiseHasHandler(promise);
         Label enqueue(this);
 
         // TODO(gsathya): Fold these runtime calls and move to TF.
         GotoIf(has_handler, &enqueue);
         CallRuntime(Runtime::kPromiseRevokeReject, context, promise);
         Goto(&enqueue);
 
         Bind(&enqueue);
         {
           Node* info = AllocatePromiseReactionJobInfo(
               promise, result, var_on_reject.value(), deferred_promise,
               deferred_on_resolve, deferred_on_reject, context);
           // TODO(gsathya): Move this to TF
           CallRuntime(Runtime::kEnqueuePromiseReactionJob, context, info,
-                      SmiConstant(v8::Promise::kRejected));
+                      promise, SmiConstant(v8::Promise::kRejected));
           Goto(&out);
         }
       }
     }
   }
 
   Bind(&out);
   PromiseSetHasHandler(promise);
   return deferred_promise;
 }
@@ skipping 180 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);
+
+  CallRuntime(Runtime::kEnqueuePromiseReactionJob, context, info, promise,
+              status_smi);
+  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