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

src/inspector/v8-stack-trace-impl.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/inspector/v8-stack-trace-impl.h"
 
 #include "src/inspector/string-util.h"
 #include "src/inspector/v8-debugger-agent-impl.h"
 #include "src/inspector/v8-debugger.h"
 #include "src/inspector/v8-inspector-impl.h"
@@ skipping 99 matching lines @@
 void V8StackTraceImpl::setCaptureStackTraceForUncaughtExceptions(
     v8::Isolate* isolate, bool capture) {
   isolate->SetCaptureStackTraceForUncaughtExceptions(
       capture, V8StackTraceImpl::maxCallStackSizeToCapture, stackTraceOptions);
 }
 
 // static
 std::unique_ptr<V8StackTraceImpl> V8StackTraceImpl::create(
     V8Debugger* debugger, int contextGroupId,
     v8::Local<v8::StackTrace> stackTrace, size_t maxStackSize,
-    const String16& description) {
+    const String16& description,
+    std::unique_ptr<V8StackTraceImpl> creationStackTrace) {
   v8::Isolate* isolate = v8::Isolate::GetCurrent();
   v8::HandleScope scope(isolate);
   std::vector<V8StackTraceImpl::Frame> frames;
   if (!stackTrace.IsEmpty())
     toFramesVector(stackTrace, frames, maxStackSize, isolate, debugger,
                    contextGroupId);
 
   int maxAsyncCallChainDepth = 1;
   V8StackTraceImpl* asyncCallChain = nullptr;
+  V8StackTraceImpl* creationCallChain = nullptr;

[dgozman, 2017/01/24 01:02:41]

Remove.

[kozy, 2017/01/24 21:43:39]

Done.

   if (debugger && maxStackSize > 1) {
     asyncCallChain = debugger->currentAsyncCallChain();
     maxAsyncCallChainDepth = debugger->maxAsyncCallChainDepth();
   }
   // Do not accidentally append async call chain from another group. This should
   // not
   // happen if we have proper instrumentation, but let's double-check to be
   // safe.
   if (contextGroupId && asyncCallChain && asyncCallChain->m_contextGroupId &&
       asyncCallChain->m_contextGroupId != contextGroupId) {
     asyncCallChain = nullptr;
     maxAsyncCallChainDepth = 1;
   }
 
   // Only the top stack in the chain may be empty, so ensure that second stack

[dgozman, 2017/01/24 01:02:41]

Amend the comment.

[kozy, 2017/01/24 21:43:39]

Done.

   // is non-empty (it's the top of appended chain).
-  if (asyncCallChain && asyncCallChain->isEmpty())
+  if (asyncCallChain && asyncCallChain->isEmpty() &&
+      !asyncCallChain->m_creation)
     asyncCallChain = asyncCallChain->m_parent.get();
 
-  if (stackTrace.IsEmpty() && !asyncCallChain) return nullptr;
+  if (stackTrace.IsEmpty() && !asyncCallChain && !creationCallChain)
+    return nullptr;
 
   std::unique_ptr<V8StackTraceImpl> result(new V8StackTraceImpl(
       contextGroupId, description, frames,
-      asyncCallChain ? asyncCallChain->cloneImpl() : nullptr));
+      asyncCallChain ? asyncCallChain->cloneImpl() : nullptr,
+      std::move(creationStackTrace)));
 
   // Crop to not exceed maxAsyncCallChainDepth.
   V8StackTraceImpl* deepest = result.get();
   while (deepest && maxAsyncCallChainDepth) {
     deepest = deepest->m_parent.get();
     maxAsyncCallChainDepth--;
   }
   if (deepest) deepest->m_parent.reset();
 
   return result;
 }
 
 // static
 std::unique_ptr<V8StackTraceImpl> V8StackTraceImpl::capture(
     V8Debugger* debugger, int contextGroupId, size_t maxStackSize,
-    const String16& description) {
+    const String16& description,
+    std::unique_ptr<V8StackTraceImpl> creationStackTrace) {
   v8::Isolate* isolate = v8::Isolate::GetCurrent();
   v8::HandleScope handleScope(isolate);
   v8::Local<v8::StackTrace> stackTrace;
   if (isolate->InContext()) {
     stackTrace = v8::StackTrace::CurrentStackTrace(
         isolate, static_cast<int>(maxStackSize), stackTraceOptions);
   }
   return V8StackTraceImpl::create(debugger, contextGroupId, stackTrace,
-                                  maxStackSize, description);
+                                  maxStackSize, description,
+                                  std::move(creationStackTrace));
 }
 
 std::unique_ptr<V8StackTraceImpl> V8StackTraceImpl::cloneImpl() {
   std::vector<Frame> framesCopy(m_frames);
   return std::unique_ptr<V8StackTraceImpl>(
       new V8StackTraceImpl(m_contextGroupId, m_description, framesCopy,
-                           m_parent ? m_parent->cloneImpl() : nullptr));
+                           m_parent ? m_parent->cloneImpl() : nullptr,
+                           m_creation ? m_creation->cloneImpl() : nullptr));
 }
 
 std::unique_ptr<V8StackTrace> V8StackTraceImpl::clone() {
   std::vector<Frame> frames;
   for (size_t i = 0; i < m_frames.size(); i++)
     frames.push_back(m_frames.at(i).clone());
-  return std::unique_ptr<V8StackTraceImpl>(
-      new V8StackTraceImpl(m_contextGroupId, m_description, frames, nullptr));
+  return std::unique_ptr<V8StackTraceImpl>(new V8StackTraceImpl(
+      m_contextGroupId, m_description, frames, nullptr, nullptr));
 }
 
 V8StackTraceImpl::V8StackTraceImpl(int contextGroupId,
                                    const String16& description,
                                    std::vector<Frame>& frames,
-                                   std::unique_ptr<V8StackTraceImpl> parent)
+                                   std::unique_ptr<V8StackTraceImpl> parent,
+                                   std::unique_ptr<V8StackTraceImpl> creation)
     : m_contextGroupId(contextGroupId),
       m_description(description),
-      m_parent(std::move(parent)) {
+      m_parent(std::move(parent)),
+      m_creation(std::move(creation)) {
   m_frames.swap(frames);
 }
 
 V8StackTraceImpl::~V8StackTraceImpl() {}
 
 StringView V8StackTraceImpl::topSourceURL() const {
   DCHECK(m_frames.size());
   return toStringView(m_frames[0].m_scriptName);
 }
 
@@ skipping 23 matching lines @@
       protocol::Array<protocol::Runtime::CallFrame>::create();
   for (size_t i = 0; i < m_frames.size(); i++)
     frames->addItem(m_frames.at(i).buildInspectorObject());
 
   std::unique_ptr<protocol::Runtime::StackTrace> stackTrace =
       protocol::Runtime::StackTrace::create()
           .setCallFrames(std::move(frames))
           .build();
   if (!m_description.isEmpty()) stackTrace->setDescription(m_description);
   if (m_parent) stackTrace->setParent(m_parent->buildInspectorObjectImpl());
+  if (m_creation && m_creation->m_frames.size()) {
+    stackTrace->setCreationFrame(
+        m_creation->m_frames[0].buildInspectorObject());
+  }
   return stackTrace;
 }
 
 std::unique_ptr<protocol::Runtime::StackTrace>
 V8StackTraceImpl::buildInspectorObjectForTail(V8Debugger* debugger) const {
   v8::HandleScope handleScope(v8::Isolate::GetCurrent());
   // Next call collapses possible empty stack and ensures
   // maxAsyncCallChainDepth.
   std::unique_ptr<V8StackTraceImpl> fullChain = V8StackTraceImpl::create(
       debugger, m_contextGroupId, v8::Local<v8::StackTrace>(),
@@ skipping 20 matching lines @@
     stackTrace.append(String16::fromInteger(frame.lineNumber()));
     stackTrace.append(':');
     stackTrace.append(String16::fromInteger(frame.columnNumber()));
     stackTrace.append(')');
   }
   String16 string = stackTrace.toString();
   return StringBufferImpl::adopt(string);
 }
 
 }  // namespace v8_inspector