[inspector] use creation stack trace as parent for async call chains

src/inspector/v8-debugger.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-debugger.h"
 
 #include "src/inspector/debugger-script.h"
 #include "src/inspector/inspected-context.h"
 #include "src/inspector/protocol/Protocol.h"
 #include "src/inspector/script-breakpoint.h"
@@ skipping 665 matching lines @@
       asyncTaskStartedForStepping(task);
       break;
     case v8::debug::kDebugDidHandle:
       asyncTaskFinishedForStack(task);
       asyncTaskFinishedForStepping(task);
       break;
   }
 }
 
 std::shared_ptr<AsyncStackTrace> V8Debugger::currentAsyncParent() {
+  // TODO(kozyatinskiy): implement creation chain as parent without hack.
+  if (!m_currentAsyncCreation.empty() && m_currentAsyncCreation.back()) {
+    return m_currentAsyncCreation.back();
+  }
   return m_currentAsyncParent.empty() ? nullptr : m_currentAsyncParent.back();
 }
 
 std::shared_ptr<AsyncStackTrace> V8Debugger::currentAsyncCreation() {
-  return m_currentAsyncCreation.empty() ? nullptr
-                                        : m_currentAsyncCreation.back();
+  return nullptr;
 }
 
 void V8Debugger::compileDebuggerScript() {
   if (!m_debuggerScript.IsEmpty()) {
     UNREACHABLE();
     return;
   }
 
   v8::HandleScope scope(m_isolate);
   v8::Context::Scope contextScope(debuggerContext());
@@ skipping 147 matching lines @@
   if (m_maxAsyncCallStackDepth == maxAsyncCallStackDepth) return;
   m_maxAsyncCallStackDepth = maxAsyncCallStackDepth;
   if (!maxAsyncCallStackDepth) allAsyncTasksCanceled();
 }
 
 void V8Debugger::asyncTaskCreatedForStack(void* task, void* parentTask) {
   if (!m_maxAsyncCallStackDepth) return;
   if (parentTask) m_parentTask[task] = parentTask;
   v8::HandleScope scope(m_isolate);
   std::shared_ptr<AsyncStackTrace> asyncCreation =
-      AsyncStackTrace::capture(this, currentContextGroupId(), String16(), 1);
+      AsyncStackTrace::capture(this, currentContextGroupId(), String16(),
+                               V8StackTraceImpl::maxCallStackSizeToCapture);
   // Passing one as maxStackSize forces no async chain for the new stack.
   if (asyncCreation && !asyncCreation->isEmpty()) {
     m_asyncTaskCreationStacks[task] = asyncCreation;
     m_allAsyncStacks.push_back(std::move(asyncCreation));
     ++m_asyncStacksCount;
     collectOldAsyncStacksIfNeeded();
   }
 }
 
 void V8Debugger::asyncTaskScheduled(const StringView& taskName, void* task,
@@ skipping 55 matching lines @@
   AsyncTaskToStackTrace::iterator stackIt = m_asyncTaskStacks.find(
       parentIt == m_parentTask.end() ? task : parentIt->second);
   if (stackIt != m_asyncTaskStacks.end()) {
     m_currentAsyncParent.push_back(stackIt->second.lock());
   } else {
     m_currentAsyncParent.emplace_back();
   }
   auto itCreation = m_asyncTaskCreationStacks.find(task);
   if (itCreation != m_asyncTaskCreationStacks.end()) {
     m_currentAsyncCreation.push_back(itCreation->second.lock());
+    // TODO(kozyatinskiy): implement it without hack.
+    if (m_currentAsyncParent.back()) {
+      m_currentAsyncCreation.back()->setDescription(
+          m_currentAsyncParent.back()->description());

[dgozman, 2017/05/05 23:24:31]

Also clear m_currentAsyncParent.back().

[kozy, 2017/05/09 06:29:13]

Done.

+    }
   } else {
     m_currentAsyncCreation.emplace_back();
   }
 }
 
 void V8Debugger::asyncTaskFinishedForStack(void* task) {
   if (!m_maxAsyncCallStackDepth) return;
   // We could start instrumenting half way and the stack is empty.
   if (!m_currentTasks.size()) return;
   DCHECK(m_currentTasks.back() == task);
@@ skipping 137 matching lines @@
   fprintf(stdout, "Async stacks count: %d\n", m_asyncStacksCount);
   fprintf(stdout, "Scheduled async tasks: %zu\n", m_asyncTaskStacks.size());
   fprintf(stdout, "Created async tasks: %zu\n",
           m_asyncTaskCreationStacks.size());
   fprintf(stdout, "Async tasks with parent: %zu\n", m_parentTask.size());
   fprintf(stdout, "Recurring async tasks: %zu\n", m_recurringTasks.size());
   fprintf(stdout, "\n");
 }
 
 }  // namespace v8_inspector