[inspector] Support multiple sessions per context group

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 143 matching lines @@
     handler->m_callback->sendSuccess(std::move(wrappedValue),
                                      std::move(exceptionDetails));
   }
 
   ProtocolPromiseHandler(V8InspectorSessionImpl* session,
                          int executionContextId, const String16& objectGroup,
                          bool returnByValue, bool generatePreview,
                          std::unique_ptr<Callback> callback)
       : m_inspector(session->inspector()),
         m_sessionId(session->sessionId()),
+        m_contextGroupId(session->contextGroupId()),
         m_executionContextId(executionContextId),
         m_objectGroup(objectGroup),
         m_returnByValue(returnByValue),
         m_generatePreview(generatePreview),
         m_callback(std::move(callback)),
         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) {
-    V8InspectorSessionImpl* session = m_inspector->sessionById(m_sessionId);
+    V8InspectorSessionImpl* session =
+        m_inspector->sessionById(m_contextGroupId, 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_sessionId;
+  int m_contextGroupId;
   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 467 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) {
-    m_inspector->forEachContext(
-        m_session->contextGroupId(),
-        [](InspectedContext* context) { context->setReported(false); });
+    int sessionId = m_session->sessionId();
+    m_inspector->forEachContext(m_session->contextGroupId(),
+                                [&sessionId](InspectedContext* context) {
+                                  context->setReported(sessionId, false);
+                                });
     m_frontend.executionContextsCleared();
   }
 }
 
 void V8RuntimeAgentImpl::reportExecutionContextCreated(
     InspectedContext* context) {
   if (!m_enabled) return;
-  context->setReported(true);
+  context->setReported(m_session->sessionId(), true);
   std::unique_ptr<protocol::Runtime::ExecutionContextDescription> description =
       protocol::Runtime::ExecutionContextDescription::create()
           .setId(context->contextId())
           .setName(context->humanReadableName())
           .setOrigin(context->origin())
           .build();
   if (!context->auxData().isEmpty())
     description->setAuxData(protocol::DictionaryValue::cast(
         protocol::StringUtil::parseJSON(context->auxData())));
   m_frontend.executionContextCreated(std::move(description));
 }
 
 void V8RuntimeAgentImpl::reportExecutionContextDestroyed(
     InspectedContext* context) {
-  if (m_enabled && context->isReported()) {
-    context->setReported(false);
+  if (m_enabled && context->isReported(m_session->sessionId())) {
+    context->setReported(m_session->sessionId(), false);
     m_frontend.executionContextDestroyed(context->contextId());
   }
 }
 
 void V8RuntimeAgentImpl::inspect(
     std::unique_ptr<protocol::Runtime::RemoteObject> objectToInspect,
     std::unique_ptr<protocol::DictionaryValue> hints) {
   if (m_enabled)
     m_frontend.inspectRequested(std::move(objectToInspect), std::move(hints));
 }
 
 void V8RuntimeAgentImpl::messageAdded(V8ConsoleMessage* message) {
   if (m_enabled) reportMessage(message, true);
 }
 
 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