[inspector] Support multiple sessions per context group

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 329 matching lines @@
     v8::debug::DebugBreak(m_isolate);
   else
     v8::debug::CancelDebugBreak(m_isolate);
 }
 
 bool V8Debugger::canBreakProgram() {
   if (!m_breakpointsActivated) return false;
   return !v8::debug::AllFramesOnStackAreBlackboxed(m_isolate);
 }
 
-bool V8Debugger::breakProgram(int targetContextGroupId) {
+void V8Debugger::breakProgram(int targetContextGroupId) {
   // Don't allow nested breaks.
-  if (isPaused()) return true;
-  if (!canBreakProgram()) return true;
+  if (isPaused()) return;
+  if (!canBreakProgram()) return;
   DCHECK(targetContextGroupId);
   m_targetContextGroupId = targetContextGroupId;
   v8::debug::BreakRightNow(m_isolate);
-  V8InspectorSessionImpl* session =
-      m_inspector->sessionForContextGroup(targetContextGroupId);
-  return session && session->debuggerAgent()->enabled();
 }
 
 void V8Debugger::continueProgram(int targetContextGroupId) {
   if (m_pausedContextGroupId != targetContextGroupId) return;
   if (isPaused()) m_inspector->client()->quitMessageLoopOnPause();
   m_pausedContext.Clear();
   m_executionState.Clear();
 }
 
 void V8Debugger::stepIntoStatement(int targetContextGroupId) {
@@ skipping 223 matching lines @@
     v8::debug::PrepareStep(m_isolate, v8::debug::StepOut);
     return;
   }
   m_targetContextGroupId = 0;
   if (m_stepIntoAsyncCallback) {
     m_stepIntoAsyncCallback->sendFailure(
         Response::Error("No async tasks were scheduled before pause."));
     m_stepIntoAsyncCallback.reset();
   }
   m_breakRequested = false;
-  V8InspectorSessionImpl* session =
-      m_inspector->sessionForContextGroup(contextGroupId);
-  if (!session || !session->debuggerAgent()->enabled()) return;
-  if (!m_scheduledOOMBreak && session->debuggerAgent()->skipAllPauses()) return;
+
+  bool scheduledOOMBreak = m_scheduledOOMBreak;
+  auto agentCheck = [&scheduledOOMBreak](V8DebuggerAgentImpl* agent) {
+    return agent->enabled() && (scheduledOOMBreak || !agent->skipAllPauses());
+  };
+
+  bool hasAgents = false;
+  m_inspector->forEachSession(
+      contextGroupId,
+      [&agentCheck, &hasAgents](V8InspectorSessionImpl* session) {
+        if (agentCheck(session->debuggerAgent())) hasAgents = true;
+      });
+  if (!hasAgents) return;
 
   std::vector<String16> breakpointIds;
   if (!hitBreakpointNumbers.IsEmpty()) {
     breakpointIds.reserve(hitBreakpointNumbers->Length());
     for (uint32_t i = 0; i < hitBreakpointNumbers->Length(); i++) {
       v8::Local<v8::Value> hitBreakpointNumber =
           hitBreakpointNumbers->Get(debuggerContext(), i).ToLocalChecked();
       DCHECK(hitBreakpointNumber->IsInt32());
       breakpointIds.push_back(String16::fromInteger(
           hitBreakpointNumber->Int32Value(debuggerContext()).FromJust()));
     }
     if (breakpointIds.size() == 1 &&
         breakpointIds[0] == m_continueToLocationBreakpointId) {
       v8::Context::Scope contextScope(pausedContext);
       if (!shouldContinueToCurrentLocation()) return;
     }
   }
   clearContinueToLocation();
 
   DCHECK(contextGroupId);
   m_pausedContext = pausedContext;
   m_executionState = executionState;
   m_pausedContextGroupId = contextGroupId;
-  session->debuggerAgent()->didPause(
-      InspectedContext::contextId(pausedContext), exception, breakpointIds,
-      isPromiseRejection, isUncaught, m_scheduledOOMBreak);
+
+  m_inspector->forEachSession(
+      contextGroupId, [&agentCheck, &pausedContext, &exception, &breakpointIds,
+                       &isPromiseRejection, &isUncaught,
+                       &scheduledOOMBreak](V8InspectorSessionImpl* session) {
+        if (agentCheck(session->debuggerAgent())) {
+          session->debuggerAgent()->didPause(
+              InspectedContext::contextId(pausedContext), exception,
+              breakpointIds, isPromiseRejection, isUncaught, scheduledOOMBreak);
+        }
+      });
   {
     v8::Context::Scope scope(pausedContext);
     v8::Local<v8::Context> context = m_isolate->GetCurrentContext();
     CHECK(!context.IsEmpty() &&
           context != v8::debug::GetDebugContext(m_isolate));
     m_inspector->client()->runMessageLoopOnPause(contextGroupId);
     m_pausedContextGroupId = 0;
   }
-  // The agent may have been removed in the nested loop.
-  session = m_inspector->sessionForContextGroup(contextGroupId);
-  if (session && session->debuggerAgent()->enabled())
-    session->debuggerAgent()->didContinue();
+  m_inspector->forEachSession(contextGroupId,
+                              [](V8InspectorSessionImpl* session) {
+                                if (session->debuggerAgent()->enabled())
+                                  session->debuggerAgent()->didContinue();
+                              });
+
   if (m_scheduledOOMBreak) m_isolate->RestoreOriginalHeapLimit();
   m_scheduledOOMBreak = false;
   m_pausedContext.Clear();
   m_executionState.Clear();
 }
 
 void V8Debugger::v8OOMCallback(void* data) {
   V8Debugger* thisPtr = static_cast<V8Debugger*>(data);
   thisPtr->m_isolate->IncreaseHeapLimitForDebugging();
   thisPtr->m_scheduledOOMBreak = true;
   v8::Local<v8::Context> context = thisPtr->m_isolate->GetEnteredContext();
   DCHECK(!context.IsEmpty());
   thisPtr->setPauseOnNextStatement(
       true, thisPtr->m_inspector->contextGroupId(context));
 }
 
 void V8Debugger::ScriptCompiled(v8::Local<v8::debug::Script> script,
                                 bool has_compile_error) {
   int contextId;
   if (!script->ContextId().To(&contextId)) return;
-  V8InspectorSessionImpl* session = m_inspector->sessionForContextGroup(
-      m_inspector->contextGroupId(contextId));
-  if (!session || !session->debuggerAgent()->enabled()) return;
   if (script->IsWasm()) {
-    m_wasmTranslation.AddScript(script.As<v8::debug::WasmScript>(),
-                                session->debuggerAgent());
+    WasmTranslation* wasmTranslation = &m_wasmTranslation;
+    m_inspector->forEachSession(
+        m_inspector->contextGroupId(contextId),
+        [&script, &wasmTranslation](V8InspectorSessionImpl* session) {
+          if (!session->debuggerAgent()->enabled()) return;
+          wasmTranslation->AddScript(script.As<v8::debug::WasmScript>(),
+                                     session->debuggerAgent());
+        });
   } else if (m_ignoreScriptParsedEventsCounter == 0) {
-    session->debuggerAgent()->didParseSource(
-        V8DebuggerScript::Create(m_isolate, script, inLiveEditScope),
-        !has_compile_error);
+    v8::Isolate* isolate = m_isolate;
+    m_inspector->forEachSession(
+        m_inspector->contextGroupId(contextId),
+        [&isolate, &script,
+         &has_compile_error](V8InspectorSessionImpl* session) {
+          if (!session->debuggerAgent()->enabled()) return;
+          session->debuggerAgent()->didParseSource(
+              V8DebuggerScript::Create(isolate, script, inLiveEditScope),
+              !has_compile_error);
+        });
   }
 }
 
 void V8Debugger::BreakProgramRequested(v8::Local<v8::Context> pausedContext,
                                        v8::Local<v8::Object> execState,
                                        v8::Local<v8::Value> breakPointsHit) {
   v8::Local<v8::Value> argv[] = {breakPointsHit};
   v8::Local<v8::Value> hitBreakpoints;
   if (!callDebuggerMethod("getBreakpointNumbers", 1, argv, true)
            .ToLocal(&hitBreakpoints)) {
@@ skipping 12 matching lines @@
   bool isPromiseRejection = promise->IsPromise();
   handleProgramBreak(pausedContext, execState, exception,
                      v8::Local<v8::Array>(), isPromiseRejection, isUncaught);
 }
 
 bool V8Debugger::IsFunctionBlackboxed(v8::Local<v8::debug::Script> script,
                                       const v8::debug::Location& start,
                                       const v8::debug::Location& end) {
   int contextId;
   if (!script->ContextId().To(&contextId)) return false;
-  V8InspectorSessionImpl* session = m_inspector->sessionForContextGroup(
-      m_inspector->contextGroupId(contextId));
-  if (!session || !session->debuggerAgent()->enabled()) return false;
-  return session->debuggerAgent()->isFunctionBlackboxed(
-      String16::fromInteger(script->Id()), start, end);
+  bool hasAgents = false;
+  bool allBlackboxed = true;
+  String16 scriptId = String16::fromInteger(script->Id());
+  m_inspector->forEachSession(
+      m_inspector->contextGroupId(contextId),
+      [&hasAgents, &allBlackboxed, &scriptId, &start,
+       &end](V8InspectorSessionImpl* session) {
+        V8DebuggerAgentImpl* agent = session->debuggerAgent();
+        if (!agent->enabled()) return;
+        hasAgents = true;
+        allBlackboxed &= agent->isFunctionBlackboxed(scriptId, start, end);
+      });
+  return hasAgents && allBlackboxed;
 }
 
 void V8Debugger::PromiseEventOccurred(v8::debug::PromiseDebugActionType type,
                                       int id, int parentId,
                                       bool createdByUser) {
   // Async task events from Promises are given misaligned pointers to prevent
   // from overlapping with other Blink task identifiers.
   void* task = reinterpret_cast<void*>(id * 2 + 1);
   void* parentTask =
       parentId ? reinterpret_cast<void*>(parentId * 2 + 1) : nullptr;
@@ skipping 355 matching lines @@
 
 std::unique_ptr<V8StackTraceImpl> V8Debugger::captureStackTrace(
     bool fullStack) {
   if (!m_isolate->InContext()) return nullptr;
 
   v8::HandleScope handles(m_isolate);
   int contextGroupId = currentContextGroupId();
   if (!contextGroupId) return nullptr;
 
   int stackSize = 1;
-  V8InspectorSessionImpl* session =
-      m_inspector->sessionForContextGroup(contextGroupId);
-  if (fullStack || (session && session->runtimeAgent()->enabled())) {
+  if (fullStack) {
     stackSize = V8StackTraceImpl::maxCallStackSizeToCapture;
+  } else {
+    m_inspector->forEachSession(
+        contextGroupId, [&stackSize](V8InspectorSessionImpl* session) {
+          if (session->runtimeAgent()->enabled())
+            stackSize = V8StackTraceImpl::maxCallStackSizeToCapture;
+        });
   }
   return V8StackTraceImpl::capture(this, contextGroupId, stackSize);
 }
 
 int V8Debugger::currentContextGroupId() {
   if (!m_isolate->InContext()) return 0;
   return m_inspector->contextGroupId(m_isolate->GetCurrentContext());
 }
 
 void V8Debugger::collectOldAsyncStacksIfNeeded() {
@@ skipping 54 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