[inspector] Create InjectedScript per session in each context

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 40 matching lines @@
 static const char privateKeyName[] = "v8-inspector#injectedScript";
 }
 
 using protocol::Array;
 using protocol::Runtime::PropertyDescriptor;
 using protocol::Runtime::InternalPropertyDescriptor;
 using protocol::Runtime::RemoteObject;
 using protocol::Maybe;
 
 std::unique_ptr<InjectedScript> InjectedScript::create(
-    InspectedContext* inspectedContext) {
+    InspectedContext* inspectedContext, int sessionId) {
   v8::Isolate* isolate = inspectedContext->isolate();
   v8::HandleScope handles(isolate);
   v8::Local<v8::Context> context = inspectedContext->context();
   v8::Context::Scope scope(context);
 
   // Inject javascript into the context. The compiled script is supposed to
   // evaluate into
   // a single anonymous function(it's anonymous to avoid cluttering the global
   // object with
   // inspector's stuff) the function is called a few lines below with
@@ skipping 27 matching lines @@
   V8InspectorImpl* inspector = inspectedContext->inspector();
   v8::Local<v8::Value> injectedScriptValue;
   if (!function->Call(context, windowGlobal, arraysize(info), info)
            .ToLocal(&injectedScriptValue))
     return nullptr;
   if (inspector->getContext(contextGroupId, contextId) != inspectedContext)
     return nullptr;
   if (!injectedScriptValue->IsObject()) return nullptr;
 
   std::unique_ptr<InjectedScript> injectedScript(new InjectedScript(
-      inspectedContext, injectedScriptValue.As<v8::Object>()));
+      inspectedContext, injectedScriptValue.As<v8::Object>(), sessionId));
   v8::Local<v8::Private> privateKey = v8::Private::ForApi(
       isolate, v8::String::NewFromUtf8(isolate, privateKeyName,
                                        v8::NewStringType::kInternalized)
                    .ToLocalChecked());
   scriptHostWrapper->SetPrivate(
       context, privateKey, v8::External::New(isolate, injectedScript.get()));
   return injectedScript;
 }
 
 InjectedScript::InjectedScript(InspectedContext* context,
-                               v8::Local<v8::Object> object)
-    : m_context(context), m_value(context->isolate(), object) {}
+                               v8::Local<v8::Object> object, int sessionId)
+    : m_context(context),
+      m_value(context->isolate(), object),
+      m_sessionId(sessionId) {}
 
 InjectedScript::~InjectedScript() {}
 
 Response InjectedScript::getProperties(
     v8::Local<v8::Object> object, const String16& groupName, bool ownProperties,
     bool accessorPropertiesOnly, bool generatePreview,
     std::unique_ptr<Array<PropertyDescriptor>>* properties,
     Maybe<protocol::Runtime::ExceptionDetails>* exceptionDetails) {
   v8::HandleScope handles(m_context->isolate());
   v8::Local<v8::Context> context = m_context->context();
@@ skipping 281 matching lines @@
     if (!response.isSuccess()) return response;
   }
   return Response::OK();
 }
 
 v8::Local<v8::Object> InjectedScript::commandLineAPI() {
   if (m_commandLineAPI.IsEmpty()) {
     m_commandLineAPI.Reset(
         m_context->isolate(),
         m_context->inspector()->console()->createCommandLineAPI(
-            m_context->context()));
+            m_context->context(), m_sessionId));
   }
   return m_commandLineAPI.Get(m_context->isolate());
 }
 
 InjectedScript::Scope::Scope(V8InspectorSessionImpl* session)
     : m_inspector(session->inspector()),
       m_injectedScript(nullptr),
       m_handleScope(m_inspector->isolate()),
       m_tryCatch(m_inspector->isolate()),
       m_ignoreExceptionsAndMuteConsole(false),
@@ skipping 139 matching lines @@
   }
   return id;
 }
 
 void InjectedScript::unbindObject(int id) {
   m_idToWrappedObject.erase(id);
   m_idToObjectGroupName.erase(id);
 }
 
 }  // namespace v8_inspector