[inspector] deduplicate stack frames

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 956 matching lines @@
   m_taskWithScheduledBreak = nullptr;
 }
 
 void V8Debugger::allAsyncTasksCanceled() {
   m_asyncTaskStacks.clear();
   m_recurringTasks.clear();
   m_currentAsyncParent.clear();
   m_currentAsyncCreation.clear();
   m_currentTasks.clear();
   m_parentTask.clear();
   m_asyncTaskCreationStacks.clear();

[dgozman, 2017/04/19 20:29:04]

Let's cleanup frames cache here as well.

[kozy, 2017/04/20 00:06:49]

Done.

 
   m_allAsyncStacks.clear();
   m_asyncStacksCount = 0;
 }
 
 void V8Debugger::muteScriptParsedEvents() {
   ++m_ignoreScriptParsedEventsCounter;
 }
 
 void V8Debugger::unmuteScriptParsedEvents() {
@@ skipping 36 matching lines @@
     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);
+  std::map<int, std::weak_ptr<StackFrame>> framesCache;
+  for (auto it : m_framesCache) {
+    if (!it.second.expired()) framesCache.insert(it);
+  }
+  m_framesCache.swap(framesCache);
 }
 
 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