[inspector] Prepare some methods in V8InspectorImpl to multiple sessions

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-inspector-session-impl.h"
 #include "src/inspector/v8-internal-value-type.h"
+#include "src/inspector/v8-runtime-agent-impl.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 = 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) {
-  int contextId;
-  if (!script->ContextId().To(&contextId)) return nullptr;
-  int contextGroupId = inspector->contextGroupId(contextId);
-  if (!contextGroupId) return nullptr;
-  return inspector->enabledDebuggerAgentForGroup(contextGroupId);
-}
-
 v8::MaybeLocal<v8::Array> collectionsEntries(v8::Local<v8::Context> context,
                                              v8::Local<v8::Value> value) {
   v8::Isolate* isolate = context->GetIsolate();
   v8::Local<v8::Array> entries;
   bool isKeyValue = false;
   if (!v8::debug::EntriesPreview(isolate, value, &isKeyValue).ToLocal(&entries))
     return v8::MaybeLocal<v8::Array>();
 
   v8::Local<v8::Array> wrappedEntries = v8::Array::New(isolate);
   CHECK(!isKeyValue || wrappedEntries->Length() % 2 == 0);
@@ skipping 305 matching lines @@
   return !v8::debug::AllFramesOnStackAreBlackboxed(m_isolate);
 }
 
 bool V8Debugger::breakProgram(int targetContextGroupId) {
   // Don't allow nested breaks.
   if (isPaused()) return true;
   if (!canBreakProgram()) return true;
   DCHECK(targetContextGroupId);
   m_targetContextGroupId = targetContextGroupId;
   v8::debug::BreakRightNow(m_isolate);
-  return m_inspector->enabledDebuggerAgentForGroup(targetContextGroupId);
+  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;
-  V8DebuggerAgentImpl* agent = m_inspector->enabledDebuggerAgentForGroup(
-      m_inspector->contextGroupId(pausedContext));
-  if (!agent || (agent->skipAllPauses() && !m_scheduledOOMBreak)) return;
+  V8InspectorSessionImpl* session =
+      m_inspector->sessionForContextGroup(contextGroupId);
+  if (!session || !session->debuggerAgent()->enabled()) return;
+  if (!m_scheduledOOMBreak && session->debuggerAgent()->skipAllPauses()) 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;
-  agent->didPause(InspectedContext::contextId(pausedContext), exception,
-                  breakpointIds, isPromiseRejection, isUncaught,
-                  m_scheduledOOMBreak);
-  int groupId = m_inspector->contextGroupId(pausedContext);
-  DCHECK(groupId);
+  session->debuggerAgent()->didPause(
+      InspectedContext::contextId(pausedContext), exception, breakpointIds,
+      isPromiseRejection, isUncaught, m_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(groupId);
+    m_inspector->client()->runMessageLoopOnPause(contextGroupId);
     m_pausedContextGroupId = 0;
   }
   // The agent may have been removed in the nested loop.
-  agent = m_inspector->enabledDebuggerAgentForGroup(groupId);
-  if (agent) agent->didContinue();
+  session = m_inspector->sessionForContextGroup(contextGroupId);
+  if (session && 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) {
-  V8DebuggerAgentImpl* agent = agentForScript(m_inspector, script);
-  if (!agent) return;
+  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>(), agent);
+    m_wasmTranslation.AddScript(script.As<v8::debug::WasmScript>(),
+                                session->debuggerAgent());
   } else if (m_ignoreScriptParsedEventsCounter == 0) {
-    agent->didParseSource(
+    session->debuggerAgent()->didParseSource(
         V8DebuggerScript::Create(m_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;
@@ skipping 12 matching lines @@
                                  v8::Local<v8::Value> promise,
                                  bool isUncaught) {
   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) {
-  V8DebuggerAgentImpl* agent = agentForScript(m_inspector, script);
-  if (!agent) return false;
-  return agent->isFunctionBlackboxed(String16::fromInteger(script->Id()), start,
-                                     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);
 }
 
 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;
-  if (fullStack || m_inspector->enabledRuntimeAgentForGroup(contextGroupId)) {
+  V8InspectorSessionImpl* session =
+      m_inspector->sessionForContextGroup(contextGroupId);
+  if (fullStack || (session && 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());
 }
 
@@ skipping 55 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