DevTools: migrate injectedscript from ScriptValue to v8::Global.

third_party/WebKit/Source/core/inspector/InjectedScript.cpp

 /*
  * 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 15 matching lines @@
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "core/inspector/InjectedScript.h"
 
 #include "bindings/core/v8/ScriptFunctionCall.h"
 #include "bindings/core/v8/V8Binding.h"
 #include "core/inspector/InjectedScriptHost.h"
+#include "core/inspector/InjectedScriptManager.h"
 #include "core/inspector/InspectorTraceEvents.h"
 #include "core/inspector/JSONParser.h"
 #include "core/inspector/RemoteObjectId.h"
+#include "core/inspector/v8/V8Debugger.h"
 #include "core/inspector/v8/V8DebuggerClient.h"
 #include "platform/JSONValues.h"
 #include "platform/JSONValuesForV8.h"
 #include "wtf/text/WTFString.h"
 
 using blink::TypeBuilder::Array;
 using blink::TypeBuilder::Debugger::CallFrame;
 using blink::TypeBuilder::Debugger::CollectionEntry;
 using blink::TypeBuilder::Debugger::FunctionDetails;
 using blink::TypeBuilder::Debugger::GeneratorObjectDetails;
@@ skipping 50 matching lines @@
 
             frames->addItem(callFrame.release());
         }
         exceptionDetails->setStackTrace(frames.release());
     }
     if (originScriptId)
         exceptionDetails->setScriptId(String::number(originScriptId));
     return exceptionDetails.release();
 }
 
-InjectedScript::InjectedScript(v8::Local<v8::Object> injectedScriptObject, V8DebuggerClient* client, PassRefPtr<InjectedScriptNative> injectedScriptNative, int contextId)
-    : m_isolate(injectedScriptObject->CreationContext()->GetIsolate())
-    , m_injectedScriptObject(ScriptValue(ScriptState::from(injectedScriptObject->CreationContext()), injectedScriptObject))
+static void weakCallback(const v8::WeakCallbackInfo<InjectedScript>& data)
+{
+    data.GetParameter()->dispose();
+}
+
+InjectedScript::InjectedScript(InjectedScriptManager* manager, v8::Local<v8::Context> context, v8::Local<v8::Object> object, V8DebuggerClient* client, PassRefPtr<InjectedScriptNative> injectedScriptNative, int contextId)
+    : m_manager(manager)
+    , m_isolate(context->GetIsolate())
+    , m_context(m_isolate, context)
+    , m_value(m_isolate, object)
     , m_client(client)
     , m_native(injectedScriptNative)
     , m_contextId(contextId)
 {
+    m_context.SetWeak(this, &weakCallback, v8::WeakCallbackType::kParameter);

[dgozman, 2016/01/27 22:05:47]

You can pass context here as v8::Global already, and move weak callback and
disposing directly to InjectedScriptManager.

[pfeldman, 2016/01/27 22:15:45]

Not a fan of passing a weak global - it is not clear that it is already weak.

 }
 
 InjectedScript::~InjectedScript()
 {
 }
 
 void InjectedScript::evaluate(ErrorString* errorString, const String& expression, const String& objectGroup, bool includeCommandLineAPI, bool returnByValue, bool generatePreview, RefPtr<TypeBuilder::Runtime::RemoteObject>* result, TypeBuilder::OptOutput<bool>* wasThrown, RefPtr<TypeBuilder::Debugger::ExceptionDetails>* exceptionDetails)
 {
-    ScriptState::Scope scope(m_injectedScriptObject.scriptState());
-    ScriptFunctionCall function(m_client, v8Context(), v8Value(), "evaluate");
+    v8::HandleScope handles(m_isolate);
+    ScriptFunctionCall function(m_client, context(), v8Value(), "evaluate");
     function.appendArgument(expression);
     function.appendArgument(objectGroup);
     function.appendArgument(includeCommandLineAPI);
     function.appendArgument(returnByValue);
     function.appendArgument(generatePreview);
     makeEvalCall(errorString, function, result, wasThrown, exceptionDetails);
 }
 
 void InjectedScript::callFunctionOn(ErrorString* errorString, const String& objectId, const String& expression, const String& arguments, bool returnByValue, bool generatePreview, RefPtr<TypeBuilder::Runtime::RemoteObject>* result, TypeBuilder::OptOutput<bool>* wasThrown)
 {
-    ScriptState::Scope scope(m_injectedScriptObject.scriptState());
-    ScriptFunctionCall function(m_client, v8Context(), v8Value(), "callFunctionOn");
+    v8::HandleScope handles(m_isolate);
+    ScriptFunctionCall function(m_client, context(), v8Value(), "callFunctionOn");
     function.appendArgument(objectId);
     function.appendArgument(expression);
     function.appendArgument(arguments);
     function.appendArgument(returnByValue);
     function.appendArgument(generatePreview);
     makeEvalCall(errorString, function, result, wasThrown);
 }
 
 void InjectedScript::evaluateOnCallFrame(ErrorString* errorString, v8::Local<v8::Object> callFrames, bool isAsyncCallStack, const String& callFrameId, const String& expression, const String& objectGroup, bool includeCommandLineAPI, bool returnByValue, bool generatePreview, RefPtr<RemoteObject>* result, TypeBuilder::OptOutput<bool>* wasThrown, RefPtr<TypeBuilder::Debugger::ExceptionDetails>* exceptionDetails)
 {
-    ScriptState::Scope scope(m_injectedScriptObject.scriptState());
-    ScriptFunctionCall function(m_client, v8Context(), v8Value(), "evaluateOnCallFrame");
+    v8::HandleScope handles(m_isolate);
+    ScriptFunctionCall function(m_client, context(), v8Value(), "evaluateOnCallFrame");
     function.appendArgument(callFrames);
     function.appendArgument(isAsyncCallStack);
     function.appendArgument(callFrameId);
     function.appendArgument(expression);
     function.appendArgument(objectGroup);
     function.appendArgument(includeCommandLineAPI);
     function.appendArgument(returnByValue);
     function.appendArgument(generatePreview);
     makeEvalCall(errorString, function, result, wasThrown, exceptionDetails);
 }
 
 void InjectedScript::restartFrame(ErrorString* errorString, v8::Local<v8::Object> callFrames, const String& callFrameId)
 {
-    ScriptState::Scope scope(m_injectedScriptObject.scriptState());
-    ScriptFunctionCall function(m_client, v8Context(), v8Value(), "restartFrame");
+    v8::HandleScope handles(m_isolate);
+    ScriptFunctionCall function(m_client, context(), v8Value(), "restartFrame");
     function.appendArgument(callFrames);
     function.appendArgument(callFrameId);
     RefPtr<JSONValue> resultValue;
     makeCall(function, &resultValue);
     if (resultValue) {
         if (resultValue->type() == JSONValue::TypeString) {
             resultValue->asString(errorString);
         } else {
             bool value;
             ASSERT_UNUSED(value, resultValue->asBoolean(&value) && value);
         }
         return;
     }
     *errorString = "Internal error";
 }
 
 void InjectedScript::getStepInPositions(ErrorString* errorString, v8::Local<v8::Object> callFrames, const String& callFrameId, RefPtr<Array<TypeBuilder::Debugger::Location>>& positions)
 {
-    ScriptState::Scope scope(m_injectedScriptObject.scriptState());
-    ScriptFunctionCall function(m_client, v8Context(), v8Value(), "getStepInPositions");
+    v8::HandleScope handles(m_isolate);
+    ScriptFunctionCall function(m_client, context(), v8Value(), "getStepInPositions");
     function.appendArgument(callFrames);
     function.appendArgument(callFrameId);
     RefPtr<JSONValue> resultValue;
     makeCall(function, &resultValue);
     if (resultValue) {
         if (resultValue->type() == JSONValue::TypeString) {
             resultValue->asString(errorString);
             return;
         }
         if (resultValue->type() == JSONValue::TypeArray) {
             positions = Array<TypeBuilder::Debugger::Location>::runtimeCast(resultValue);
             return;
         }
     }
     *errorString = "Internal error";
 }
 
 void InjectedScript::setVariableValue(ErrorString* errorString, v8::Local<v8::Object> callFrames, const String* callFrameIdOpt, const String* functionObjectIdOpt, int scopeNumber, const String& variableName, const String& newValueStr)
 {
-    ScriptState::Scope scope(m_injectedScriptObject.scriptState());
-    ScriptFunctionCall function(m_client, v8Context(), v8Value(), "setVariableValue");
+    v8::HandleScope handles(m_isolate);
+    ScriptFunctionCall function(m_client, context(), v8Value(), "setVariableValue");
     if (callFrameIdOpt) {
         function.appendArgument(callFrames);
         function.appendArgument(*callFrameIdOpt);
     } else {
         function.appendArgument(false);
         function.appendArgument(false);
     }
     if (functionObjectIdOpt)
         function.appendArgument(*functionObjectIdOpt);
     else
         function.appendArgument(false);
     function.appendArgument(scopeNumber);
     function.appendArgument(variableName);
     function.appendArgument(newValueStr);
     RefPtr<JSONValue> resultValue;
     makeCall(function, &resultValue);
     if (!resultValue) {
         *errorString = "Internal error";
         return;
     }
     if (resultValue->type() == JSONValue::TypeString) {
         resultValue->asString(errorString);
         return;
     }
     // Normal return.
 }
 
 void InjectedScript::getFunctionDetails(ErrorString* errorString, const String& functionId, RefPtr<FunctionDetails>* result)
 {
-    ScriptState::Scope scope(m_injectedScriptObject.scriptState());
-    ScriptFunctionCall function(m_client, v8Context(), v8Value(), "getFunctionDetails");
+    v8::HandleScope handles(m_isolate);
+    ScriptFunctionCall function(m_client, context(), v8Value(), "getFunctionDetails");
     function.appendArgument(functionId);
     RefPtr<JSONValue> resultValue;
     makeCall(function, &resultValue);
     if (!resultValue || resultValue->type() != JSONValue::TypeObject) {
         if (!resultValue->asString(errorString))
             *errorString = "Internal error";
         return;
     }
     *result = FunctionDetails::runtimeCast(resultValue);
 }
 
 void InjectedScript::getGeneratorObjectDetails(ErrorString* errorString, const String& objectId, RefPtr<GeneratorObjectDetails>* result)
 {
-    ScriptState::Scope scope(m_injectedScriptObject.scriptState());
-    ScriptFunctionCall function(m_client, v8Context(), v8Value(), "getGeneratorObjectDetails");
+    v8::HandleScope handles(m_isolate);
+    ScriptFunctionCall function(m_client, context(), v8Value(), "getGeneratorObjectDetails");
     function.appendArgument(objectId);
     RefPtr<JSONValue> resultValue;
     makeCall(function, &resultValue);
     if (!resultValue || resultValue->type() != JSONValue::TypeObject) {
         if (!resultValue->asString(errorString))
             *errorString = "Internal error";
         return;
     }
     *result = GeneratorObjectDetails::runtimeCast(resultValue);
 }
 
 void InjectedScript::getCollectionEntries(ErrorString* errorString, const String& objectId, RefPtr<Array<CollectionEntry> >* result)
 {
-    ScriptState::Scope scope(m_injectedScriptObject.scriptState());
-    ScriptFunctionCall function(m_client, v8Context(), v8Value(), "getCollectionEntries");
+    v8::HandleScope handles(m_isolate);
+    ScriptFunctionCall function(m_client, context(), v8Value(), "getCollectionEntries");
     function.appendArgument(objectId);
     RefPtr<JSONValue> resultValue;
     makeCall(function, &resultValue);
     if (!resultValue || resultValue->type() != JSONValue::TypeArray) {
         if (!resultValue->asString(errorString))
             *errorString = "Internal error";
         return;
     }
     *result = Array<CollectionEntry>::runtimeCast(resultValue);
 }
 
 void InjectedScript::getProperties(ErrorString* errorString, const String& objectId, bool ownProperties, bool accessorPropertiesOnly, bool generatePreview, RefPtr<Array<PropertyDescriptor>>* properties, RefPtr<TypeBuilder::Debugger::ExceptionDetails>* exceptionDetails)
 {
-    ScriptState::Scope scope(m_injectedScriptObject.scriptState());
-    ScriptFunctionCall function(m_client, v8Context(), v8Value(), "getProperties");
+    v8::HandleScope handles(m_isolate);
+    ScriptFunctionCall function(m_client, context(), v8Value(), "getProperties");
     function.appendArgument(objectId);
     function.appendArgument(ownProperties);
     function.appendArgument(accessorPropertiesOnly);
     function.appendArgument(generatePreview);
 
     RefPtr<JSONValue> result;
     makeCallWithExceptionDetails(function, &result, exceptionDetails);
     if (*exceptionDetails) {
         // FIXME: make properties optional
         *properties = Array<PropertyDescriptor>::create();
         return;
     }
     if (!result || result->type() != JSONValue::TypeArray) {
         *errorString = "Internal error";
         return;
     }
     *properties = Array<PropertyDescriptor>::runtimeCast(result);
 }
 
 void InjectedScript::getInternalProperties(ErrorString* errorString, const String& objectId, RefPtr<Array<InternalPropertyDescriptor>>* properties, RefPtr<TypeBuilder::Debugger::ExceptionDetails>* exceptionDetails)
 {
-    ScriptState::Scope scope(m_injectedScriptObject.scriptState());
-    ScriptFunctionCall function(m_client, v8Context(), v8Value(), "getInternalProperties");
+    v8::HandleScope handles(m_isolate);
+    ScriptFunctionCall function(m_client, context(), v8Value(), "getInternalProperties");
     function.appendArgument(objectId);
 
     RefPtr<JSONValue> result;
     makeCallWithExceptionDetails(function, &result, exceptionDetails);
     if (*exceptionDetails)
         return;
     if (!result || result->type() != JSONValue::TypeArray) {
         *errorString = "Internal error";
         return;
     }
@@ skipping 11 matching lines @@
     if (!parsedObjectId->asObject(&object))
         return;
     int boundId = 0;
     if (!object->getNumber("id", &boundId))
         return;
     m_native->unbind(boundId);
 }
 
 PassRefPtr<Array<CallFrame>> InjectedScript::wrapCallFrames(v8::Local<v8::Object> callFrames, int asyncOrdinal)
 {
-    ScriptState::Scope scope(m_injectedScriptObject.scriptState());
-    v8::Local<v8::Context> context = v8Context();
-    ScriptFunctionCall function(m_client, context, v8Value(), "wrapCallFrames");
+    v8::HandleScope handles(m_isolate);
+    ScriptFunctionCall function(m_client, context(), v8Value(), "wrapCallFrames");
     function.appendArgument(callFrames);
     function.appendArgument(asyncOrdinal);
     bool hadException = false;
     v8::Local<v8::Value> callFramesValue = callFunctionWithEvalEnabled(function, hadException);
     ASSERT(!hadException);
-    RefPtr<JSONValue> result = toJSONValue(context, callFramesValue);
+    RefPtr<JSONValue> result = toJSONValue(context(), callFramesValue);
     if (result && result->type() == JSONValue::TypeArray)
         return Array<CallFrame>::runtimeCast(result);
     return Array<CallFrame>::create();
 }
 
 PassRefPtr<TypeBuilder::Runtime::RemoteObject> InjectedScript::wrapObject(v8::Local<v8::Value> value, const String& groupName, bool generatePreview) const
 {
-    ScriptState::Scope scope(m_injectedScriptObject.scriptState());
-    v8::Local<v8::Context> context = v8Context();
-    ScriptFunctionCall function(m_client, context, v8Value(), "wrapObject");
+    v8::HandleScope handles(m_isolate);
+    ScriptFunctionCall function(m_client, context(), v8Value(), "wrapObject");
     function.appendArgument(value);
     function.appendArgument(groupName);
     function.appendArgument(canAccessInspectedWindow());
     function.appendArgument(generatePreview);
     bool hadException = false;
     v8::Local<v8::Value> r = callFunctionWithEvalEnabled(function, hadException);
     if (hadException)
         return nullptr;
-    RefPtr<JSONObject> rawResult = toJSONValue(context, r)->asObject();
+    RefPtr<JSONObject> rawResult = toJSONValue(context(), r)->asObject();
     return TypeBuilder::Runtime::RemoteObject::runtimeCast(rawResult);
 }
 
 PassRefPtr<TypeBuilder::Runtime::RemoteObject> InjectedScript::wrapTable(v8::Local<v8::Value> table, v8::Local<v8::Value> columns) const
 {
-    ScriptState::Scope scope(m_injectedScriptObject.scriptState());
-    v8::Local<v8::Context> context = v8Context();
-    ScriptFunctionCall function(m_client, context, v8Value(), "wrapTable");
+    v8::HandleScope handles(m_isolate);
+    ScriptFunctionCall function(m_client, context(), v8Value(), "wrapTable");
     function.appendArgument(canAccessInspectedWindow());
     function.appendArgument(table);
     if (columns.IsEmpty())
         function.appendArgument(false);
     else
         function.appendArgument(columns);
     bool hadException = false;
     v8::Local<v8::Value>  r = callFunctionWithEvalEnabled(function, hadException);
     if (hadException)
         return nullptr;
-    RefPtr<JSONObject> rawResult = toJSONValue(context, r)->asObject();
+    RefPtr<JSONObject> rawResult = toJSONValue(context(), r)->asObject();
     return TypeBuilder::Runtime::RemoteObject::runtimeCast(rawResult);
 }
 
 v8::Local<v8::Value> InjectedScript::findObject(const RemoteObjectId& objectId) const
 {
     return m_native->objectForId(objectId.id());
 }
 
 String InjectedScript::objectIdToObjectGroupName(const String& objectId) const
 {
     RefPtr<JSONValue> parsedObjectId = parseJSON(objectId);
     if (!parsedObjectId)
         return String();
     RefPtr<JSONObject> object;
     if (!parsedObjectId->asObject(&object))
         return String();
     int boundId = 0;
     if (!object->getNumber("id", &boundId))
         return String();
     return m_native->groupName(boundId);
 }
 
 void InjectedScript::releaseObjectGroup(const String& objectGroup)
 {
-    ScriptState::Scope scope(m_injectedScriptObject.scriptState());
+    v8::HandleScope handles(m_isolate);
     m_native->releaseObjectGroup(objectGroup);
     if (objectGroup == "console") {
-        ScriptFunctionCall function(m_client, v8Context(), v8Value(), "clearLastEvaluationResult");
+        ScriptFunctionCall function(m_client, context(), v8Value(), "clearLastEvaluationResult");
         bool hadException = false;
         callFunctionWithEvalEnabled(function, hadException);
         ASSERT(!hadException);
     }
 }
 
 void InjectedScript::setCustomObjectFormatterEnabled(bool enabled)
 {
-    ScriptState::Scope scope(m_injectedScriptObject.scriptState());
-    ScriptFunctionCall function(m_client, v8Context(), v8Value(), "setCustomObjectFormatterEnabled");
+    v8::HandleScope handles(m_isolate);
+    ScriptFunctionCall function(m_client, context(), v8Value(), "setCustomObjectFormatterEnabled");
     function.appendArgument(enabled);
     RefPtr<JSONValue> result;
     makeCall(function, &result);
 }
 
 bool InjectedScript::canAccessInspectedWindow() const
 {
-    ScriptState* scriptState = m_injectedScriptObject.scriptState();
-    return scriptState && m_client->callingContextCanAccessContext(scriptState->context());
+    v8::Local<v8::Context> callingContext = m_isolate->GetCallingContext();
+    if (callingContext.IsEmpty())
+        return true;
+    return m_client->callingContextCanAccessContext(callingContext, context());
 }
 
-v8::Local<v8::Context> InjectedScript::v8Context() const
+v8::Local<v8::Context> InjectedScript::context() const
 {
-    return m_injectedScriptObject.context();
+    return m_context.Get(m_isolate);
 }
 
 v8::Local<v8::Value> InjectedScript::v8Value() const
 {
-    return m_injectedScriptObject.v8Value();
+    return m_value.Get(m_isolate);
 }
 
 v8::Local<v8::Value> InjectedScript::callFunctionWithEvalEnabled(ScriptFunctionCall& function, bool& hadException) const
 {
-    v8::Local<v8::Context> context = v8Context();
-    bool evalIsDisabled = !context->IsCodeGenerationFromStringsAllowed();
+    v8::Local<v8::Context> localContext = context();
+    v8::Context::Scope scope(localContext);
+    bool evalIsDisabled = !localContext->IsCodeGenerationFromStringsAllowed();
     // Temporarily enable allow evals for inspector.
     if (evalIsDisabled)
-        context->AllowCodeGenerationFromStrings(true);
+        localContext->AllowCodeGenerationFromStrings(true);
     v8::Local<v8::Value> resultValue = function.call(hadException);
     if (evalIsDisabled)
-        context->AllowCodeGenerationFromStrings(false);
+        localContext->AllowCodeGenerationFromStrings(false);
     TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("devtools.timeline"), "UpdateCounters", TRACE_EVENT_SCOPE_THREAD, "data", InspectorUpdateCountersEvent::data());
     return resultValue;
 }
 
 void InjectedScript::makeCall(ScriptFunctionCall& function, RefPtr<JSONValue>* result)
 {
     if (!canAccessInspectedWindow()) {
-        *result = JSONValue::null();
+        *result = JSONString::create("Can not access given context.");
         return;
     }
+    v8::TryCatch tryCatch(m_isolate);

[dgozman, 2016/01/27 22:05:47]

Why this?

[pfeldman, 2016/01/27 22:15:45]

I have no idea. I pasted it or multiple cursors of whatever. Removed.

 
     bool hadException = false;
     v8::Local<v8::Value> resultValue = callFunctionWithEvalEnabled(function, hadException);
 
     ASSERT(!hadException);
     if (!hadException) {
         *result = toJSONValue(function.context(), resultValue);
         if (!*result)
             *result = JSONString::create(String::format("Object has too long reference chain(must not be longer than %d)", JSONValue::maxDepth));
     } else {
@@ skipping 37 matching lines @@
 void InjectedScript::makeCallWithExceptionDetails(ScriptFunctionCall& function, RefPtr<JSONValue>* result, RefPtr<TypeBuilder::Debugger::ExceptionDetails>* exceptionDetails)
 {
     v8::TryCatch tryCatch(m_isolate);
     v8::Local<v8::Value> resultValue = function.callWithoutExceptionHandling();
     if (tryCatch.HasCaught()) {
         v8::Local<v8::Message> message = tryCatch.Message();
         String text = !message.IsEmpty() ? toCoreStringWithUndefinedOrNullCheck(message->Get()) : "Internal error";
         *exceptionDetails = TypeBuilder::Debugger::ExceptionDetails::create().setText(text);
     } else {
         *result = toJSONValue(function.context(), resultValue);
-        if (!*result)
+        if (!*result) {

[dgozman, 2016/01/27 22:05:47]

extra {}

[pfeldman, 2016/01/27 22:15:45]

Done.

             *result = JSONString::create(String::format("Object has too long reference chain(must not be longer than %d)", JSONValue::maxDepth));
+        }
     }
 }
 
+void InjectedScript::dispose()
+{
+    m_manager->discardInjectedScript(m_contextId);
+}
+
 } // namespace blink