[inspector] better stacks 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 <algorithm>
 
 #include "src/inspector/v8-debugger.h"
 #include "src/inspector/wasm-translation.h"
@@ skipping 45 matching lines @@
   // stack, so ensure that second stack is non-empty (it's the top of appended
   // chain).
   if (*asyncParent && !(*asyncCreation) && !(*asyncParent)->creation().lock() &&
       (*asyncParent)->isEmpty()) {
     *asyncParent = (*asyncParent)->parent().lock();
   }
 }
 
 std::unique_ptr<protocol::Runtime::StackTrace> buildInspectorObjectCommon(
     const std::vector<std::shared_ptr<StackFrame>>& frames,
+    const String16& description,
     const std::shared_ptr<AsyncStackTrace>& asyncParent,
     const std::shared_ptr<AsyncStackTrace>& asyncCreation, int maxAsyncDepth) {
   std::unique_ptr<protocol::Array<protocol::Runtime::CallFrame>>
       inspectorFrames = protocol::Array<protocol::Runtime::CallFrame>::create();
   for (size_t i = 0; i < frames.size(); i++) {
     inspectorFrames->addItem(frames[i]->buildInspectorObject());
   }
   std::unique_ptr<protocol::Runtime::StackTrace> stackTrace =
       protocol::Runtime::StackTrace::create()
           .setCallFrames(std::move(inspectorFrames))
           .build();
-  if (asyncParent && maxAsyncDepth > 0) {
+  if (!description.isEmpty()) stackTrace->setDescription(description);
+  if (asyncParent && maxAsyncDepth > 0 &&
+      (asyncParent->description() != description || !asyncParent->isEmpty() ||

[dgozman, 2017/04/27 22:37:22]

We should not return here, but just skip the parent, continuing with parent's
parent.

[kozy, 2017/04/28 16:13:30]

Done.

+       asyncCreation.get())) {
     stackTrace->setParent(asyncParent->buildInspectorObject(asyncCreation.get(),
                                                             maxAsyncDepth - 1));
   }
   return stackTrace;
 }
 
 }  //  namespace
 
 StackFrame::StackFrame(v8::Local<v8::StackFrame> v8Frame)
     : m_functionName(toProtocolString(v8Frame->GetFunctionName())),
@@ skipping 111 matching lines @@
 StringView V8StackTraceImpl::topScriptId() const {
   return toStringView(m_frames[0]->scriptId());
 }
 
 StringView V8StackTraceImpl::topFunctionName() const {
   return toStringView(m_frames[0]->functionName());
 }
 
 std::unique_ptr<protocol::Runtime::StackTrace>
 V8StackTraceImpl::buildInspectorObjectImpl() const {
-  return buildInspectorObjectCommon(m_frames, m_asyncParent.lock(),
+  return buildInspectorObjectCommon(m_frames, String16(), m_asyncParent.lock(),
                                     m_asyncCreation.lock(), m_maxAsyncDepth);
 }
 
 std::unique_ptr<protocol::Runtime::API::StackTrace>
 V8StackTraceImpl::buildInspectorObject() const {
   return buildInspectorObjectImpl();
 }
 
 std::unique_ptr<StringBuffer> V8StackTraceImpl::toString() const {
   String16Builder stackTrace;
@@ skipping 65 matching lines @@
       m_frames(std::move(frames)),
       m_asyncParent(asyncParent),
       m_asyncCreation(asyncCreation) {
   DCHECK(m_contextGroupId);
 }
 
 std::unique_ptr<protocol::Runtime::StackTrace>
 AsyncStackTrace::buildInspectorObject(AsyncStackTrace* asyncCreation,
                                       int maxAsyncDepth) const {
   std::unique_ptr<protocol::Runtime::StackTrace> stackTrace =
-      buildInspectorObjectCommon(m_frames, m_asyncParent.lock(),
+      buildInspectorObjectCommon(m_frames, m_description, m_asyncParent.lock(),
                                  m_asyncCreation.lock(), maxAsyncDepth);
-  if (!m_description.isEmpty()) stackTrace->setDescription(m_description);
   if (asyncCreation && !asyncCreation->isEmpty()) {
     stackTrace->setPromiseCreationFrame(
         asyncCreation->m_frames[0]->buildInspectorObject());
   }
   return stackTrace;
 }
 
 int AsyncStackTrace::contextGroupId() const { return m_contextGroupId; }
 
+const String16& AsyncStackTrace::description() const { return m_description; }
+
 std::weak_ptr<AsyncStackTrace> AsyncStackTrace::parent() const {
   return m_asyncParent;
 }
 
 std::weak_ptr<AsyncStackTrace> AsyncStackTrace::creation() const {
   return m_asyncCreation;
 }
 
 bool AsyncStackTrace::isEmpty() const { return m_frames.empty(); }
 
 }  // namespace v8_inspector