[inspector] cleanup all task related data when limit reached

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"
 #include "src/inspector/string-util.h"
 #include "src/inspector/v8-debugger-agent-impl.h"
 #include "src/inspector/v8-inspector-impl.h"
 #include "src/inspector/v8-internal-value-type.h"
 #include "src/inspector/v8-stack-trace-impl.h"
 #include "src/inspector/v8-value-copier.h"
 
 #include "include/v8-util.h"
 
 namespace v8_inspector {
 
 namespace {
 
-static const int kMaxAsyncTaskStacks = 1024 * 1024;
+static const int kMaxAsyncTaskStacks = 128 * 1024;
 
 inline v8::Local<v8::Boolean> v8Boolean(bool value, v8::Isolate* isolate) {
   return value ? v8::True(isolate) : v8::False(isolate);
 }
 
 V8DebuggerAgentImpl* agentForScript(V8InspectorImpl* inspector,
                                     v8::Local<v8::debug::Script> script) {
   v8::Local<v8::Value> contextData;
   if (!script->ContextData().ToLocal(&contextData) || !contextData->IsInt32()) {
     return nullptr;
@@ skipping 809 matching lines @@
 
 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);
   // Passing one as maxStackSize forces no async chain for the new stack.
   if (asyncCreation && !asyncCreation->isEmpty()) {
     m_asyncTaskCreationStacks[task] = asyncCreation;
-    m_allAsyncStacks.push_back(asyncCreation);
+    m_allAsyncStacks.push_back(std::move(asyncCreation));
     ++m_asyncStacksCount;
     collectOldAsyncStacksIfNeeded();
   }
 }
 
 void V8Debugger::asyncTaskScheduled(const StringView& taskName, void* task,
                                     bool recurring) {
   asyncTaskScheduledForStack(toString16(taskName), task, recurring);
   asyncTaskCandidateForStepping(task);
 }
@@ skipping 16 matching lines @@
 void V8Debugger::asyncTaskScheduledForStack(const String16& taskName,
                                             void* task, bool recurring) {
   if (!m_maxAsyncCallStackDepth) return;
   v8::HandleScope scope(m_isolate);
   std::shared_ptr<AsyncStackTrace> asyncStack =
       AsyncStackTrace::capture(this, currentContextGroupId(), taskName,
                                V8StackTraceImpl::maxCallStackSizeToCapture);
   if (asyncStack) {
     m_asyncTaskStacks[task] = asyncStack;
     if (recurring) m_recurringTasks.insert(task);
-
-    m_allAsyncStacks.push_back(asyncStack);
+    m_allAsyncStacks.push_back(std::move(asyncStack));
     ++m_asyncStacksCount;
     collectOldAsyncStacksIfNeeded();
   }
 }
 
 void V8Debugger::asyncTaskCanceledForStack(void* task) {
   if (!m_maxAsyncCallStackDepth) return;
   m_asyncTaskStacks.erase(task);
   m_recurringTasks.erase(task);
   m_parentTask.erase(task);
   m_asyncTaskCreationStacks.erase(task);
 }
 
 void V8Debugger::asyncTaskStartedForStack(void* task) {
   if (!m_maxAsyncCallStackDepth) return;
   m_currentTasks.push_back(task);
   auto parentIt = m_parentTask.find(task);
   AsyncTaskToStackTrace::iterator stackIt = m_asyncTaskStacks.find(
       parentIt == m_parentTask.end() ? task : parentIt->second);
   // Needs to support following order of events:
   // - asyncTaskScheduled
   //   <-- attached here -->
   // - asyncTaskStarted
   // - asyncTaskCanceled <-- canceled before finished
   //   <-- async stack requested here -->
   // - asyncTaskFinished
-  std::shared_ptr<AsyncStackTrace> asyncParent;
-  if (stackIt != m_asyncTaskStacks.end()) asyncParent = stackIt->second.lock();
+  std::weak_ptr<AsyncStackTrace> asyncParent;
+  if (stackIt != m_asyncTaskStacks.end()) asyncParent = stackIt->second;
   auto itCreation = m_asyncTaskCreationStacks.find(task);
-  if (asyncParent && itCreation != m_asyncTaskCreationStacks.end()) {
+  if (asyncParent.lock() && itCreation != m_asyncTaskCreationStacks.end()) {
     m_currentAsyncCreation.push_back(itCreation->second.lock());
   } else {
-    m_currentAsyncCreation.push_back(nullptr);
+    m_currentAsyncCreation.emplace_back();
   }
-  m_currentAsyncParent.push_back(asyncParent);
+  m_currentAsyncParent.push_back(asyncParent.lock());
 }
 
 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);
   m_currentTasks.pop_back();
 
   DCHECK(m_currentAsyncParent.size() == m_currentAsyncCreation.size());
@@ skipping 78 matching lines @@
 void V8Debugger::collectOldAsyncStacksIfNeeded() {
   if (m_asyncStacksCount <= m_maxAsyncCallStacks) return;
   int halfOfLimitRoundedUp =
       m_maxAsyncCallStacks / 2 + m_maxAsyncCallStacks % 2;
   while (m_asyncStacksCount > halfOfLimitRoundedUp) {
     m_allAsyncStacks.pop_front();
     --m_asyncStacksCount;
   }
   removeOldAsyncTasks(m_asyncTaskStacks);
   removeOldAsyncTasks(m_asyncTaskCreationStacks);
+  protocol::HashSet<void*> recurringLeft;
+  for (auto task : m_recurringTasks) {
+    if (m_asyncTaskStacks.find(task) == m_asyncTaskStacks.end()) continue;
+    recurringLeft.insert(task);
+  }
+  m_recurringTasks.swap(recurringLeft);
+  protocol::HashMap<void*, void*> parentLeft;
+  for (auto it : m_parentTask) {
+    if (m_asyncTaskCreationStacks.find(it.second) == m_asyncTaskStacks.end()) {

[dgozman, 2017/04/20 00:42:23]

You are comparing iterator from one map to another's end().

[kozy, 2017/04/20 00:59:02]

C++ is my best friend since it allows it :)
fixed: https://codereview.chromium.org/2828133002/

+      continue;
+    }
+    parentLeft.insert(it);
+  }
+  m_parentTask.swap(parentLeft);
 }
 
 void V8Debugger::removeOldAsyncTasks(AsyncTaskToStackTrace& map) {
   AsyncTaskToStackTrace cleanCopy;
   for (auto it : map) {
     if (!it.second.expired()) cleanCopy.insert(it);
   }
   map.swap(cleanCopy);
 }
 
 void V8Debugger::setMaxAsyncTaskStacksForTest(int limit) {
   m_maxAsyncCallStacks = 0;
   collectOldAsyncStacksIfNeeded();
   m_maxAsyncCallStacks = limit;
 }
 
 }  // namespace v8_inspector