[inspector] added creation frame for async call chains for promises

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 24 matching lines @@
 Node* PromiseBuiltinsAssembler::AllocateAndInitJSPromise(Node* context) {
   return AllocateAndInitJSPromise(context, UndefinedConstant());
 }
 
 Node* PromiseBuiltinsAssembler::AllocateAndInitJSPromise(Node* context,
                                                          Node* parent) {
   Node* const instance = AllocateJSPromise(context);
   PromiseInit(instance);
 
   Label out(this);
-  GotoUnless(IsPromiseHookEnabled(), &out);
+  GotoUnless(IsPromiseHookEnabledOrDebugIsActive(), &out);
   CallRuntime(Runtime::kPromiseHookInit, context, instance, parent);
   Goto(&out);
 
   Bind(&out);
   return instance;
 }
 
 Node* PromiseBuiltinsAssembler::AllocateAndSetJSPromise(Node* context,
                                                         Node* status,
                                                         Node* result) {
   CSA_ASSERT(this, TaggedIsSmi(status));
 
   Node* const instance = AllocateJSPromise(context);
 
   StoreObjectFieldNoWriteBarrier(instance, JSPromise::kStatusOffset, status);
   StoreObjectFieldNoWriteBarrier(instance, JSPromise::kResultOffset, result);
   StoreObjectFieldNoWriteBarrier(instance, JSPromise::kFlagsOffset,
                                  SmiConstant(0));
 
   Label out(this);
-  GotoUnless(IsPromiseHookEnabled(), &out);
+  GotoUnless(IsPromiseHookEnabledOrDebugIsActive(), &out);
   CallRuntime(Runtime::kPromiseHookInit, context, instance,
               UndefinedConstant());
   Goto(&out);
 
   Bind(&out);
   return instance;
 }
 
 std::pair<Node*, Node*>
 PromiseBuiltinsAssembler::CreatePromiseResolvingFunctions(
@@ skipping 50 matching lines @@
         capability, JSPromiseCapability::kPromiseOffset, promise);
 
     Node* resolve = nullptr;
     Node* reject = nullptr;
 
     std::tie(resolve, reject) =
         CreatePromiseResolvingFunctions(promise, debug_event, native_context);
     StoreObjectField(capability, JSPromiseCapability::kResolveOffset, resolve);
     StoreObjectField(capability, JSPromiseCapability::kRejectOffset, reject);
 
-    GotoUnless(IsPromiseHookEnabled(), &out);
+    GotoUnless(IsPromiseHookEnabledOrDebugIsActive(), &out);
     CallRuntime(Runtime::kPromiseHookInit, context, promise,
                 UndefinedConstant());
     Goto(&out);
   }
 
   Bind(&if_custom_promise);
   {
     Label if_notcallable(this, Label::kDeferred);
     Node* executor_context =
         CreatePromiseGetCapabilitiesExecutorContext(capability, native_context);
@@ skipping 919 matching lines @@
   }
 
   Bind(&if_targetismodified);
   {
     ConstructorBuiltinsAssembler constructor_assembler(this->state());
     Node* const instance = constructor_assembler.EmitFastNewObject(
         context, promise_fun, new_target);
     PromiseInit(instance);
     var_result.Bind(instance);
 
-    GotoUnless(IsPromiseHookEnabled(), &debug_push);
+    GotoUnless(IsPromiseHookEnabledOrDebugIsActive(), &debug_push);
     CallRuntime(Runtime::kPromiseHookInit, context, instance,
                 UndefinedConstant());
     Goto(&debug_push);
   }
 
   Bind(&debug_push);
   {
     GotoUnless(is_debug_active, &run_executor);
     CallRuntime(Runtime::kDebugPushPromise, context, var_result.value());
     Goto(&run_executor);
@@ skipping 449 matching lines @@
   Node* const reason = Parameter(2);
   Node* const debug_event = Parameter(3);
   Node* const context = Parameter(6);
 
   InternalPromiseReject(context, promise, reason, debug_event);
   Return(UndefinedConstant());
 }
 
 }  // namespace internal
 }  // namespace v8