[inspector] Prepare some methods in V8InspectorImpl to multiple sessions

src/inspector/v8-runtime-agent-impl.cc

 /*
  * Copyright (C) 2011 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 43 matching lines @@
 static const char runtimeEnabled[] = "runtimeEnabled";
 };
 
 using protocol::Runtime::RemoteObject;
 
 namespace {
 
 template <typename Callback>
 class ProtocolPromiseHandler {
  public:
-  static void add(V8InspectorImpl* inspector, v8::Local<v8::Context> context,
+  static void add(V8InspectorSessionImpl* session,
+                  v8::Local<v8::Context> context,
                   v8::MaybeLocal<v8::Value> value,
-                  const String16& notPromiseError, int contextGroupId,
-                  int executionContextId, const String16& objectGroup,
-                  bool returnByValue, bool generatePreview,
-                  std::unique_ptr<Callback> callback) {
+                  const String16& notPromiseError, int executionContextId,
+                  const String16& objectGroup, bool returnByValue,
+                  bool generatePreview, std::unique_ptr<Callback> callback) {
     if (value.IsEmpty()) {
       callback->sendFailure(Response::InternalError());
       return;
     }
     if (!value.ToLocalChecked()->IsPromise()) {
       callback->sendFailure(Response::Error(notPromiseError));
       return;
     }
+    V8InspectorImpl* inspector = session->inspector();
     v8::MicrotasksScope microtasks_scope(inspector->isolate(),
                                          v8::MicrotasksScope::kRunMicrotasks);
     v8::Local<v8::Promise> promise =
         v8::Local<v8::Promise>::Cast(value.ToLocalChecked());
     Callback* rawCallback = callback.get();
     ProtocolPromiseHandler<Callback>* handler = new ProtocolPromiseHandler(
-        inspector, contextGroupId, executionContextId, objectGroup,
-        returnByValue, generatePreview, std::move(callback));
+        session, executionContextId, objectGroup, returnByValue,
+        generatePreview, std::move(callback));
     v8::Local<v8::Value> wrapper = handler->m_wrapper.Get(inspector->isolate());
 
     v8::Local<v8::Function> thenCallbackFunction =
         v8::Function::New(context, thenCallback, wrapper, 0,
                           v8::ConstructorBehavior::kThrow)
             .ToLocalChecked();
     if (promise->Then(context, thenCallbackFunction).IsEmpty()) {
       rawCallback->sendFailure(Response::InternalError());
       return;
     }
@@ skipping 51 matching lines @@
             .setException(wrappedValue->clone())
             .build();
     if (stack)
       exceptionDetails->setStackTrace(stack->buildInspectorObjectImpl());
     if (stack && !stack->isEmpty())
       exceptionDetails->setScriptId(toString16(stack->topScriptId()));
     handler->m_callback->sendSuccess(std::move(wrappedValue),
                                      std::move(exceptionDetails));
   }
 
-  ProtocolPromiseHandler(V8InspectorImpl* inspector, int contextGroupId,
+  ProtocolPromiseHandler(V8InspectorSessionImpl* session,
                          int executionContextId, const String16& objectGroup,
                          bool returnByValue, bool generatePreview,
                          std::unique_ptr<Callback> callback)
-      : m_inspector(inspector),
-        m_contextGroupId(contextGroupId),
+      : m_inspector(session->inspector()),
+        m_sessionId(session->sessionId()),
         m_executionContextId(executionContextId),
         m_objectGroup(objectGroup),
         m_returnByValue(returnByValue),
         m_generatePreview(generatePreview),
         m_callback(std::move(callback)),
-        m_wrapper(inspector->isolate(),
-                  v8::External::New(inspector->isolate(), this)) {
+        m_wrapper(m_inspector->isolate(),
+                  v8::External::New(m_inspector->isolate(), this)) {
     m_wrapper.SetWeak(this, cleanup, v8::WeakCallbackType::kParameter);
   }
 
   static void cleanup(
       const v8::WeakCallbackInfo<ProtocolPromiseHandler<Callback>>& data) {
     if (!data.GetParameter()->m_wrapper.IsEmpty()) {
       data.GetParameter()->m_wrapper.Reset();
       data.SetSecondPassCallback(cleanup);
     } else {
       data.GetParameter()->m_callback->sendFailure(
           Response::Error("Promise was collected"));
       delete data.GetParameter();
     }
   }
 
   std::unique_ptr<protocol::Runtime::RemoteObject> wrapObject(
       v8::Local<v8::Value> value) {
-    InjectedScript::ContextScope scope(m_inspector, m_contextGroupId,
-                                       m_executionContextId);
+    V8InspectorSessionImpl* session = m_inspector->sessionById(m_sessionId);
+    if (!session) {
+      m_callback->sendFailure(Response::Error("No session"));
+      return nullptr;
+    }
+    InjectedScript::ContextScope scope(session, m_executionContextId);
     Response response = scope.initialize();
     if (!response.isSuccess()) {
       m_callback->sendFailure(response);
       return nullptr;
     }
     std::unique_ptr<protocol::Runtime::RemoteObject> wrappedValue;
     response = scope.injectedScript()->wrapObject(
         value, m_objectGroup, m_returnByValue, m_generatePreview,
         &wrappedValue);
     if (!response.isSuccess()) {
       m_callback->sendFailure(response);
       return nullptr;
     }
     return wrappedValue;
   }
 
   V8InspectorImpl* m_inspector;
-  int m_contextGroupId;
+  int m_sessionId;
   int m_executionContextId;
   String16 m_objectGroup;
   bool m_returnByValue;
   bool m_generatePreview;
   std::unique_ptr<Callback> m_callback;
   v8::Global<v8::External> m_wrapper;
 };
 
 template <typename Callback>
 bool wrapEvaluateResultAsync(InjectedScript* injectedScript,
@@ skipping 52 matching lines @@
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("devtools.timeline"),
                "EvaluateScript");
   int contextId = 0;
   Response response = ensureContext(m_inspector, m_session->contextGroupId(),
                                     std::move(executionContextId), &contextId);
   if (!response.isSuccess()) {
     callback->sendFailure(response);
     return;
   }
 
-  InjectedScript::ContextScope scope(m_inspector, m_session->contextGroupId(),
-                                     contextId);
+  InjectedScript::ContextScope scope(m_session, contextId);
   response = scope.initialize();
   if (!response.isSuccess()) {
     callback->sendFailure(response);
     return;
   }
 
   if (silent.fromMaybe(false)) scope.ignoreExceptionsAndMuteConsole();
   if (userGesture.fromMaybe(false)) scope.pretendUserGesture();
 
   if (includeCommandLineAPI.fromMaybe(false)) scope.installCommandLineAPI();
@@ skipping 22 matching lines @@
   }
 
   if (!awaitPromise.fromMaybe(false) || scope.tryCatch().HasCaught()) {
     wrapEvaluateResultAsync(scope.injectedScript(), maybeResultValue,
                             scope.tryCatch(), objectGroup.fromMaybe(""),
                             returnByValue.fromMaybe(false),
                             generatePreview.fromMaybe(false), callback.get());
     return;
   }
   ProtocolPromiseHandler<EvaluateCallback>::add(
-      m_inspector, scope.context(), maybeResultValue,
-      "Result of the evaluation is not a promise", m_session->contextGroupId(),
+      m_session, scope.context(), maybeResultValue,
+      "Result of the evaluation is not a promise",
       scope.injectedScript()->context()->contextId(), objectGroup.fromMaybe(""),
       returnByValue.fromMaybe(false), generatePreview.fromMaybe(false),
       std::move(callback));
 }
 
 void V8RuntimeAgentImpl::awaitPromise(
     const String16& promiseObjectId, Maybe<bool> returnByValue,
     Maybe<bool> generatePreview,
     std::unique_ptr<AwaitPromiseCallback> callback) {
-  InjectedScript::ObjectScope scope(m_inspector, m_session->contextGroupId(),
-                                    promiseObjectId);
+  InjectedScript::ObjectScope scope(m_session, promiseObjectId);
   Response response = scope.initialize();
   if (!response.isSuccess()) {
     callback->sendFailure(response);
     return;
   }
   ProtocolPromiseHandler<AwaitPromiseCallback>::add(
-      m_inspector, scope.context(), scope.object(),
-      "Could not find promise with given id", m_session->contextGroupId(),
+      m_session, scope.context(), scope.object(),
+      "Could not find promise with given id",
       scope.injectedScript()->context()->contextId(), scope.objectGroupName(),
       returnByValue.fromMaybe(false), generatePreview.fromMaybe(false),
       std::move(callback));
 }
 
 void V8RuntimeAgentImpl::callFunctionOn(
     const String16& objectId, const String16& expression,
     Maybe<protocol::Array<protocol::Runtime::CallArgument>> optionalArguments,
     Maybe<bool> silent, Maybe<bool> returnByValue, Maybe<bool> generatePreview,
     Maybe<bool> userGesture, Maybe<bool> awaitPromise,
     std::unique_ptr<CallFunctionOnCallback> callback) {
-  InjectedScript::ObjectScope scope(m_inspector, m_session->contextGroupId(),
-                                    objectId);
+  InjectedScript::ObjectScope scope(m_session, objectId);
   Response response = scope.initialize();
   if (!response.isSuccess()) {
     callback->sendFailure(response);
     return;
   }
 
   std::unique_ptr<v8::Local<v8::Value>[]> argv = nullptr;
   int argc = 0;
   if (optionalArguments.isJust()) {
     protocol::Array<protocol::Runtime::CallArgument>* arguments =
@@ skipping 64 matching lines @@
 
   if (!awaitPromise.fromMaybe(false) || scope.tryCatch().HasCaught()) {
     wrapEvaluateResultAsync(scope.injectedScript(), maybeResultValue,
                             scope.tryCatch(), scope.objectGroupName(),
                             returnByValue.fromMaybe(false),
                             generatePreview.fromMaybe(false), callback.get());
     return;
   }
 
   ProtocolPromiseHandler<CallFunctionOnCallback>::add(
-      m_inspector, scope.context(), maybeResultValue,
+      m_session, scope.context(), maybeResultValue,
       "Result of the function call is not a promise",
-      m_session->contextGroupId(),
       scope.injectedScript()->context()->contextId(), scope.objectGroupName(),
       returnByValue.fromMaybe(false), generatePreview.fromMaybe(false),
       std::move(callback));
 }
 
 Response V8RuntimeAgentImpl::getProperties(
     const String16& objectId, Maybe<bool> ownProperties,
     Maybe<bool> accessorPropertiesOnly, Maybe<bool> generatePreview,
     std::unique_ptr<protocol::Array<protocol::Runtime::PropertyDescriptor>>*
         result,
     Maybe<protocol::Array<protocol::Runtime::InternalPropertyDescriptor>>*
         internalProperties,
     Maybe<protocol::Runtime::ExceptionDetails>* exceptionDetails) {
   using protocol::Runtime::InternalPropertyDescriptor;
 
-  InjectedScript::ObjectScope scope(m_inspector, m_session->contextGroupId(),
-                                    objectId);
+  InjectedScript::ObjectScope scope(m_session, objectId);
   Response response = scope.initialize();
   if (!response.isSuccess()) return response;
 
   scope.ignoreExceptionsAndMuteConsole();
   if (!scope.object()->IsObject())
     return Response::Error("Value with given id is not an object");
 
   v8::Local<v8::Object> object = scope.object().As<v8::Object>();
   response = scope.injectedScript()->getProperties(
       object, scope.objectGroupName(), ownProperties.fromMaybe(false),
@@ skipping 29 matching lines @@
             .setName(toProtocolString(name.As<v8::String>()))
             .setValue(std::move(wrappedValue))
             .build());
   }
   if (propertiesProtocolArray->length())
     *internalProperties = std::move(propertiesProtocolArray);
   return Response::OK();
 }
 
 Response V8RuntimeAgentImpl::releaseObject(const String16& objectId) {
-  InjectedScript::ObjectScope scope(m_inspector, m_session->contextGroupId(),
-                                    objectId);
+  InjectedScript::ObjectScope scope(m_session, objectId);
   Response response = scope.initialize();
   if (!response.isSuccess()) return response;
   scope.injectedScript()->releaseObject(objectId);
   return Response::OK();
 }
 
 Response V8RuntimeAgentImpl::releaseObjectGroup(const String16& objectGroup) {
   m_session->releaseObjectGroup(objectGroup);
   return Response::OK();
 }
@@ skipping 21 matching lines @@
 Response V8RuntimeAgentImpl::compileScript(
     const String16& expression, const String16& sourceURL, bool persistScript,
     Maybe<int> executionContextId, Maybe<String16>* scriptId,
     Maybe<protocol::Runtime::ExceptionDetails>* exceptionDetails) {
   if (!m_enabled) return Response::Error("Runtime agent is not enabled");
 
   int contextId = 0;
   Response response = ensureContext(m_inspector, m_session->contextGroupId(),
                                     std::move(executionContextId), &contextId);
   if (!response.isSuccess()) return response;
-  InjectedScript::ContextScope scope(m_inspector, m_session->contextGroupId(),
-                                     contextId);
+  InjectedScript::ContextScope scope(m_session, contextId);
   response = scope.initialize();
   if (!response.isSuccess()) return response;
 
   if (!persistScript) m_inspector->debugger()->muteScriptParsedEvents();
   v8::Local<v8::Script> script;
   bool isOk = m_inspector->compileScript(scope.context(), expression, sourceURL)
                   .ToLocal(&script);
   if (!persistScript) m_inspector->debugger()->unmuteScriptParsedEvents();
   if (!isOk) {
     if (scope.tryCatch().HasCaught()) {
@@ skipping 35 matching lines @@
   }
 
   int contextId = 0;
   Response response = ensureContext(m_inspector, m_session->contextGroupId(),
                                     std::move(executionContextId), &contextId);
   if (!response.isSuccess()) {
     callback->sendFailure(response);
     return;
   }
 
-  InjectedScript::ContextScope scope(m_inspector, m_session->contextGroupId(),
-                                     contextId);
+  InjectedScript::ContextScope scope(m_session, contextId);
   response = scope.initialize();
   if (!response.isSuccess()) {
     callback->sendFailure(response);
     return;
   }
 
   if (silent.fromMaybe(false)) scope.ignoreExceptionsAndMuteConsole();
 
   std::unique_ptr<v8::Global<v8::Script>> scriptWrapper = std::move(it->second);
   m_compiledScripts.erase(it);
@@ skipping 21 matching lines @@
   }
 
   if (!awaitPromise.fromMaybe(false) || scope.tryCatch().HasCaught()) {
     wrapEvaluateResultAsync(scope.injectedScript(), maybeResultValue,
                             scope.tryCatch(), objectGroup.fromMaybe(""),
                             returnByValue.fromMaybe(false),
                             generatePreview.fromMaybe(false), callback.get());
     return;
   }
   ProtocolPromiseHandler<RunScriptCallback>::add(
-      m_inspector, scope.context(), maybeResultValue.ToLocalChecked(),
+      m_session, scope.context(), maybeResultValue.ToLocalChecked(),
       "Result of the script execution is not a promise",
-      m_session->contextGroupId(),
       scope.injectedScript()->context()->contextId(), objectGroup.fromMaybe(""),
       returnByValue.fromMaybe(false), generatePreview.fromMaybe(false),
       std::move(callback));
 }
 
 void V8RuntimeAgentImpl::restore() {
   if (!m_state->booleanProperty(V8RuntimeAgentImplState::runtimeEnabled, false))
     return;
   m_frontend.executionContextsCleared();
   enable();
@@ skipping 27 matching lines @@
   m_session->setCustomObjectFormatterEnabled(false);
   reset();
   m_inspector->client()->endEnsureAllContextsInGroup(
       m_session->contextGroupId());
   return Response::OK();
 }
 
 void V8RuntimeAgentImpl::reset() {
   m_compiledScripts.clear();
   if (m_enabled) {
-    if (const V8InspectorImpl::ContextByIdMap* contexts =
-            m_inspector->contextGroup(m_session->contextGroupId())) {
-      for (auto& idContext : *contexts) idContext.second->setReported(false);
-    }
+    m_inspector->forEachContext(
+        m_session->contextGroupId(),
+        [](InspectedContext* context) { context->setReported(false); });
     m_frontend.executionContextsCleared();
   }
 }
 
 void V8RuntimeAgentImpl::reportExecutionContextCreated(
     InspectedContext* context) {
   if (!m_enabled) return;
   context->setReported(true);
   std::unique_ptr<protocol::Runtime::ExecutionContextDescription> description =
       protocol::Runtime::ExecutionContextDescription::create()
@@ skipping 27 matching lines @@
 }
 
 bool V8RuntimeAgentImpl::reportMessage(V8ConsoleMessage* message,
                                        bool generatePreview) {
   message->reportToFrontend(&m_frontend, m_session, generatePreview);
   m_frontend.flush();
   return m_inspector->hasConsoleMessageStorage(m_session->contextGroupId());
 }
 
 }  // namespace v8_inspector