[inspector] Prepare some methods in V8InspectorImpl to multiple sessions

src/inspector/injected-script.cc

 /*
  * Copyright (C) 2012 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 397 matching lines @@
 v8::Local<v8::Object> InjectedScript::commandLineAPI() {
   if (m_commandLineAPI.IsEmpty()) {
     m_commandLineAPI.Reset(
         m_context->isolate(),
         m_context->inspector()->console()->createCommandLineAPI(
             m_context->context()));
   }
   return m_commandLineAPI.Get(m_context->isolate());
 }
 
-InjectedScript::Scope::Scope(V8InspectorImpl* inspector, int contextGroupId)
-    : m_inspector(inspector),
-      m_contextGroupId(contextGroupId),
+InjectedScript::Scope::Scope(V8InspectorSessionImpl* session)
+    : m_inspector(session->inspector()),
       m_injectedScript(nullptr),
-      m_handleScope(inspector->isolate()),
-      m_tryCatch(inspector->isolate()),
+      m_handleScope(m_inspector->isolate()),
+      m_tryCatch(m_inspector->isolate()),
       m_ignoreExceptionsAndMuteConsole(false),
       m_previousPauseOnExceptionsState(v8::debug::NoBreakOnException),
-      m_userGesture(false) {}
+      m_userGesture(false),
+      m_contextGroupId(session->contextGroupId()),
+      m_sessionId(session->sessionId()) {}
 
 Response InjectedScript::Scope::initialize() {
   cleanup();
-  // TODO(dgozman): what if we reattach to the same context group during
-  // evaluate? Introduce a session id?
-  V8InspectorSessionImpl* session =
-      m_inspector->sessionForContextGroup(m_contextGroupId);
+  V8InspectorSessionImpl* session = m_inspector->sessionById(m_sessionId);
   if (!session) return Response::InternalError();
   Response response = findInjectedScript(session);
   if (!response.isSuccess()) return response;
   m_context = m_injectedScript->context()->context();
   m_context->Enter();
   return Response::OK();
 }
 
 void InjectedScript::Scope::installCommandLineAPI() {
   DCHECK(m_injectedScript && !m_context.IsEmpty() &&
@@ skipping 38 matching lines @@
 InjectedScript::Scope::~Scope() {
   if (m_ignoreExceptionsAndMuteConsole) {
     setPauseOnExceptionsState(m_previousPauseOnExceptionsState);
     m_inspector->client()->unmuteMetrics(m_contextGroupId);
     m_inspector->unmuteExceptions(m_contextGroupId);
   }
   if (m_userGesture) m_inspector->client()->endUserGesture();
   cleanup();
 }
 
-InjectedScript::ContextScope::ContextScope(V8InspectorImpl* inspector,
-                                           int contextGroupId,
+InjectedScript::ContextScope::ContextScope(V8InspectorSessionImpl* session,
                                            int executionContextId)
-    : InjectedScript::Scope(inspector, contextGroupId),
+    : InjectedScript::Scope(session),
       m_executionContextId(executionContextId) {}
 
 InjectedScript::ContextScope::~ContextScope() {}
 
 Response InjectedScript::ContextScope::findInjectedScript(
     V8InspectorSessionImpl* session) {
   return session->findInjectedScript(m_executionContextId, m_injectedScript);
 }
 
-InjectedScript::ObjectScope::ObjectScope(V8InspectorImpl* inspector,
-                                         int contextGroupId,
+InjectedScript::ObjectScope::ObjectScope(V8InspectorSessionImpl* session,
                                          const String16& remoteObjectId)
-    : InjectedScript::Scope(inspector, contextGroupId),
-      m_remoteObjectId(remoteObjectId) {}
+    : InjectedScript::Scope(session), m_remoteObjectId(remoteObjectId) {}
 
 InjectedScript::ObjectScope::~ObjectScope() {}
 
 Response InjectedScript::ObjectScope::findInjectedScript(
     V8InspectorSessionImpl* session) {
   std::unique_ptr<RemoteObjectId> remoteId;
   Response response = RemoteObjectId::parse(m_remoteObjectId, &remoteId);
   if (!response.isSuccess()) return response;
   InjectedScript* injectedScript = nullptr;
   response = session->findInjectedScript(remoteId.get(), injectedScript);
   if (!response.isSuccess()) return response;
   m_objectGroupName = injectedScript->objectGroupName(*remoteId);
   response = injectedScript->findObject(*remoteId, &m_object);
   if (!response.isSuccess()) return response;
   m_injectedScript = injectedScript;
   return Response::OK();
 }
 
-InjectedScript::CallFrameScope::CallFrameScope(V8InspectorImpl* inspector,
-                                               int contextGroupId,
+InjectedScript::CallFrameScope::CallFrameScope(V8InspectorSessionImpl* session,
                                                const String16& remoteObjectId)
-    : InjectedScript::Scope(inspector, contextGroupId),
-      m_remoteCallFrameId(remoteObjectId) {}
+    : InjectedScript::Scope(session), m_remoteCallFrameId(remoteObjectId) {}
 
 InjectedScript::CallFrameScope::~CallFrameScope() {}
 
 Response InjectedScript::CallFrameScope::findInjectedScript(
     V8InspectorSessionImpl* session) {
   std::unique_ptr<RemoteCallFrameId> remoteId;
   Response response = RemoteCallFrameId::parse(m_remoteCallFrameId, &remoteId);
   if (!response.isSuccess()) return response;
   m_frameOrdinal = static_cast<size_t>(remoteId->frameOrdinal());
   return session->findInjectedScript(remoteId.get(), m_injectedScript);
 }
 
 }  // namespace v8_inspector