[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 20 matching lines @@
 #include "platform/v8_inspector/InjectedScript.h"
 
 #include "platform/inspector_protocol/Parser.h"
 #include "platform/inspector_protocol/String16.h"
 #include "platform/inspector_protocol/Values.h"
 #include "platform/v8_inspector/InjectedScriptHost.h"
 #include "platform/v8_inspector/InjectedScriptManager.h"
 #include "platform/v8_inspector/RemoteObjectId.h"
 #include "platform/v8_inspector/V8DebuggerImpl.h"
 #include "platform/v8_inspector/V8FunctionCall.h"
+#include "platform/v8_inspector/V8StackTraceImpl.h"
 #include "platform/v8_inspector/V8StringUtil.h"
 #include "platform/v8_inspector/public/V8Debugger.h"
 #include "platform/v8_inspector/public/V8DebuggerClient.h"
 #include "platform/v8_inspector/public/V8ToProtocolValue.h"
 
 using blink::protocol::Array;
 using blink::protocol::Debugger::CallFrame;
 using blink::protocol::Debugger::CollectionEntry;
 using blink::protocol::Debugger::FunctionDetails;
 using blink::protocol::Debugger::GeneratorObjectDetails;
@@ skipping 97 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))
         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::commandLineAPI(ErrorString* errorString)
+{
+    V8FunctionCall function(m_manager->debugger(), context(), v8Value(), "commandLineAPI");
+    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;
+}
+
+PassOwnPtr<protocol::Runtime::ExceptionDetails> InjectedScript::createExceptionDetails(v8::Local<v8::Message> message)
+{
+    OwnPtr<protocol::Runtime::ExceptionDetails> exceptionDetailsObject = protocol::Runtime::ExceptionDetails::create().setText(toProtocolString(message->Get())).build();
+    exceptionDetailsObject->setUrl(toProtocolStringWithTypeCheck(message->GetScriptResourceName()));
+    exceptionDetailsObject->setScriptId(String16::number(message->GetScriptOrigin().ScriptID()->Value()));
+
+    v8::Maybe<int> lineNumber = message->GetLineNumber(context());
+    if (lineNumber.IsJust())
+        exceptionDetailsObject->setLine(lineNumber.FromJust());
+    v8::Maybe<int> columnNumber = message->GetStartColumn(context());
+    if (columnNumber.IsJust())
+        exceptionDetailsObject->setColumn(columnNumber.FromJust());
+
+    v8::Local<v8::StackTrace> stackTrace = message->GetStackTrace();
+    if (!stackTrace.IsEmpty() && stackTrace->GetFrameCount() > 0)
+        exceptionDetailsObject->setStack(m_manager->debugger()->createStackTrace(stackTrace, stackTrace->GetFrameCount())->buildInspectorObject());
+    return exceptionDetailsObject.release();
+}
+
+void InjectedScript::wrapEvaluateResult(ErrorString* errorString, v8::MaybeLocal<v8::Value> maybeResultValue, const v8::TryCatch& tryCatch, const String16& objectGroup, bool returnByValue, bool generatePreview, OwnPtr<protocol::Runtime::RemoteObject>* result, Maybe<bool>* wasThrown, Maybe<protocol::Runtime::ExceptionDetails>* exceptionDetails)
+{
+    v8::Local<v8::Value> resultValue;
+    if (!tryCatch.HasCaught()) {
+        if (!maybeResultValue.ToLocal(&resultValue)) {
+            *errorString = "Internal error";
+            return;
+        }
+        OwnPtr<RemoteObject> remoteObject = wrapObject(errorString, resultValue, objectGroup, returnByValue, generatePreview);
+        if (!remoteObject)
+            return;
+        if (objectGroup == "console" && !setLastEvaluationResult(errorString, resultValue))
+            return;
+        *result = remoteObject.release();
+        *wasThrown = false;
+    } else {
+        v8::Local<v8::Value> exception = tryCatch.Exception();
+        OwnPtr<RemoteObject> remoteObject = wrapObject(errorString, exception, objectGroup, false, generatePreview && !exception->IsNativeError());
+        if (!remoteObject)
+            return;
+        *result = remoteObject.release();
+        *exceptionDetails = createExceptionDetails(tryCatch.Message());
+        *wasThrown = true;
+    }
+}
+
 } // namespace blink