[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 981 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_asyncTaskStacks.find(it.first) == m_asyncTaskStacks.end()) 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);
 }
 
 std::shared_ptr<StackFrame> V8Debugger::lookupFrame(int frameId) {
   auto it = m_framesCache.find(frameId);
   if (it != m_framesCache.end()) return it->second.lock();
   return nullptr;
 }
 
 void V8Debugger::storeFrame(int frameId, std::shared_ptr<StackFrame> frame) {
   m_framesCache[frameId] = frame;
 }
 
 void V8Debugger::setMaxAsyncTaskStacksForTest(int limit) {
   m_maxAsyncCallStacks = 0;
   collectOldAsyncStacksIfNeeded();
   m_maxAsyncCallStacks = limit;
 }
 
 }  // namespace v8_inspector