[DevTools] Move evaluateOnCallFrame to native

third_party/WebKit/Source/platform/v8_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 137 matching lines @@
     v8::HandleScope handles(m_isolate);
     V8FunctionCall function(m_manager->debugger(), context(), v8Value(), "callFunctionOn");
     function.appendArgument(objectId);
     function.appendArgument(expression);
     function.appendArgument(arguments);
     function.appendArgument(returnByValue);
     function.appendArgument(generatePreview);
     *result = makeEvalCall(errorString, function, wasThrown);
 }
 
-void InjectedScript::evaluateOnCallFrame(ErrorString* errorString, v8::Local<v8::Object> callFrames, const String16& callFrameId, const String16& expression, const String16& objectGroup, bool includeCommandLineAPI, bool returnByValue, bool generatePreview, OwnPtr<RemoteObject>* result, Maybe<bool>* wasThrown, Maybe<protocol::Runtime::ExceptionDetails>* exceptionDetails)
-{
-    v8::HandleScope handles(m_isolate);
-    V8FunctionCall function(m_manager->debugger(), context(), v8Value(), "evaluateOnCallFrame");
-    function.appendArgument(callFrames);
-    function.appendArgument(callFrameId);
-    function.appendArgument(expression);
-    function.appendArgument(objectGroup);
-    function.appendArgument(includeCommandLineAPI);
-    function.appendArgument(returnByValue);
-    function.appendArgument(generatePreview);
-    *result = makeEvalCall(errorString, function, wasThrown, exceptionDetails);
-}
-
 void InjectedScript::getFunctionDetails(ErrorString* errorString, const String16& functionId, OwnPtr<FunctionDetails>* result)
 {
     v8::HandleScope handles(m_isolate);
     V8FunctionCall function(m_manager->debugger(), context(), v8Value(), "getFunctionDetails");
     function.appendArgument(functionId);
     OwnPtr<protocol::Value> resultValue = makeCall(function);
     protocol::ErrorSupport errors(errorString);
     *result = FunctionDetails::parse(resultValue.get(), &errors);
 }
 
@@ skipping 48 matching lines @@
         return;
     protocol::DictionaryValue* object = protocol::DictionaryValue::cast(parsedObjectId.get());
     if (!object)
         return;
     int boundId = 0;
     if (!object->getNumber("id", &boundId))
         return;
     m_native->unbind(boundId);
 }
 
-v8::MaybeLocal<v8::Value> InjectedScript::runCompiledScript(v8::Local<v8::Script> script, bool includeCommandLineAPI)
-{
-    v8::Local<v8::Symbol> commandLineAPISymbolValue = V8Debugger::commandLineAPISymbol(m_isolate);
-    v8::Local<v8::Object> global = context()->Global();
-    if (includeCommandLineAPI) {
-        V8FunctionCall function(m_manager->debugger(), context(), v8Value(), "commandLineAPI");
-        bool hadException = false;
-        v8::Local<v8::Value> commandLineAPI = function.call(hadException, false);
-        if (!hadException)
-            global->Set(commandLineAPISymbolValue, commandLineAPI);
-    }
-
-    v8::MaybeLocal<v8::Value> maybeValue = m_manager->debugger()->runCompiledScript(context(), script);
-    if (includeCommandLineAPI)
-        global->Delete(context(), commandLineAPISymbolValue);
-
-    return maybeValue;
-}
-
 PassOwnPtr<Array<CallFrame>> InjectedScript::wrapCallFrames(v8::Local<v8::Object> callFrames)
 {
     v8::HandleScope handles(m_isolate);
     V8FunctionCall function(m_manager->debugger(), context(), v8Value(), "wrapCallFrames");
     function.appendArgument(callFrames);
     bool hadException = false;
     v8::Local<v8::Value> callFramesValue = callFunctionWithEvalEnabled(function, hadException);
     ASSERT(!hadException);
     OwnPtr<protocol::Value> result = toProtocolValue(context(), callFramesValue);
     protocol::ErrorSupport errors;
     if (result && result->type() == protocol::Value::TypeArray)
         return Array<CallFrame>::parse(result.get(), &errors);
     return Array<CallFrame>::create();
 }
 
-PassOwnPtr<protocol::Runtime::RemoteObject> InjectedScript::wrapObject(v8::Local<v8::Value> value, const String16& groupName, bool generatePreview) const
+PassOwnPtr<protocol::Runtime::RemoteObject> InjectedScript::wrapObject(ErrorString* errorString, v8::Local<v8::Value> value, const String16& groupName, bool forceValueType, bool generatePreview) const
 {
     v8::HandleScope handles(m_isolate);
     V8FunctionCall function(m_manager->debugger(), context(), v8Value(), "wrapObject");
     v8::Local<v8::Value> wrappedObject;
-    ErrorString errorString;
-    if (!wrapValue(&errorString, value, groupName, generatePreview).ToLocal(&wrappedObject))
+    if (!wrapValue(errorString, value, groupName, forceValueType, generatePreview).ToLocal(&wrappedObject)) {
+        *errorString = "Internal error";

[dgozman, 2016/03/17 19:16:11]

wrapValue takes care of errorString.

[kozy, 2016/03/17 20:48:55]

Done.

         return nullptr;
+    }
     protocol::ErrorSupport errors;
-    return protocol::Runtime::RemoteObject::parse(toProtocolValue(context(), wrappedObject).get(), &errors);
+    OwnPtr<protocol::Runtime::RemoteObject> remoteObject = protocol::Runtime::RemoteObject::parse(toProtocolValue(context(), wrappedObject).get(), &errors);
+    if (!remoteObject)
+        *errorString = "Object has too long reference chain";
+    return remoteObject.release();
 }
 
-bool InjectedScript::wrapObjectProperty(ErrorString* error, v8::Local<v8::Object> object, v8::Local<v8::Value> key, const String16& groupName, bool generatePreview) const
+bool InjectedScript::wrapObjectProperty(ErrorString* error, v8::Local<v8::Object> object, v8::Local<v8::Value> key, const String16& groupName, bool forceValueType, bool generatePreview) const
 {
     v8::Local<v8::Value> property;
     if (!object->Get(context(), key).ToLocal(&property)) {
         *error = "Internal error.";
         return false;
     }
     v8::Local<v8::Value> wrappedProperty;
-    if (!wrapValue(error, property, groupName, generatePreview).ToLocal(&wrappedProperty))
+    if (!wrapValue(error, property, groupName, forceValueType, generatePreview).ToLocal(&wrappedProperty))
         return false;
     v8::Maybe<bool> success = object->Set(context(), key, wrappedProperty);
     if (success.IsNothing() || !success.FromJust()) {
         *error = "Internal error.";
         return false;
     }
     return true;
 }
 
-v8::MaybeLocal<v8::Value> InjectedScript::wrapValue(ErrorString* error, v8::Local<v8::Value> value, const String16& groupName, bool generatePreview) const
+v8::MaybeLocal<v8::Value> InjectedScript::wrapValue(ErrorString* error, v8::Local<v8::Value> value, const String16& groupName, bool forceValueType, bool generatePreview) const
 {
     V8FunctionCall function(m_manager->debugger(), context(), v8Value(), "wrapObject");
     function.appendArgument(value);
     function.appendArgument(groupName);
     function.appendArgument(canAccessInspectedWindow());
+    function.appendArgument(forceValueType);
     function.appendArgument(generatePreview);
     bool hadException = false;
     v8::Local<v8::Value> r = callFunctionWithEvalEnabled(function, hadException);
     if (hadException) {
         *error = "Internal error.";
         return v8::MaybeLocal<v8::Value>();
     }
     return r;
 }
 
@@ skipping 149 matching lines @@
             result = protocol::StringValue::create("Object has too long reference chain");
     }
     return result.release();
 }
 
 void InjectedScript::dispose()
 {
     m_manager->discardInjectedScript(m_contextId);
 }
 
+bool InjectedScript::setLastEvaluationResult(ErrorString* errorString, v8::Local<v8::Value> value)
+{
+    V8FunctionCall function(m_manager->debugger(), context(), v8Value(), "setLastEvaluationResult");
+    function.appendArgument(value);
+    bool hadException = false;
+    function.call(hadException, false);
+    if (hadException)
+        *errorString = "Internal error";
+    return !hadException;
+}
+
 v8::MaybeLocal<v8::Value> InjectedScript::resolveCallArgument(ErrorString* errorString, protocol::Runtime::CallArgument* callArgument)
 {
     if (callArgument->hasObjectId()) {
         OwnPtr<RemoteObjectId> remoteObjectId = RemoteObjectId::parse(errorString, callArgument->getObjectId(""));
         if (!remoteObjectId)
             return v8::MaybeLocal<v8::Value>();
         if (remoteObjectId->contextId() != m_contextId) {
             *errorString = "Argument should belong to the same JavaScript world as target object";
             return v8::MaybeLocal<v8::Value>();
         }
@@ skipping 11 matching lines @@
         v8::Local<v8::Value> object;
         if (!m_manager->debugger()->compileAndRunInternalScript(context(), toV8String(m_isolate, value)).ToLocal(&object)) {
             *errorString = "Couldn't parse value object in call argument";
             return v8::MaybeLocal<v8::Value>();
         }
         return object;
     }
     return v8::Undefined(m_isolate);
 }
 
+v8::MaybeLocal<v8::Object> InjectedScript::scopeExtensionByName(ErrorString* errorString, const String16& name)
+{
+    V8FunctionCall function(m_manager->debugger(), context(), v8Value(), name);
+    bool hadException = false;
+    v8::Local<v8::Value> scopeExtensionValue = function.call(hadException, false);
+    v8::Local<v8::Object> scopeExtensionObject;
+    if (hadException || scopeExtensionValue.IsEmpty() || !scopeExtensionValue->ToObject(context()).ToLocal(&scopeExtensionObject)) {
+        *errorString = "Internal error";
+        return v8::MaybeLocal<v8::Object>();
+    }
+    return scopeExtensionObject;
+}
+
 } // namespace blink