DevTools: merge InjectedScriptBase into InjectedScript

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 16 matching lines @@
  * (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 "config.h"
 
 
 #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/InspectorInstrumentation.h"
+#include "core/inspector/InspectorTraceEvents.h"
 #include "core/inspector/JSONParser.h"
 #include "platform/JSONValues.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;
 using blink::TypeBuilder::Runtime::PropertyDescriptor;
 using blink::TypeBuilder::Runtime::InternalPropertyDescriptor;
 using blink::TypeBuilder::Runtime::RemoteObject;
 
 namespace blink {
 
+PassRefPtr<JSONValue> toJSONValue(const ScriptValue& value)
+{
+    ScriptState* scriptState = value.scriptState();
+    ASSERT(scriptState->contextIsValid());
+    ScriptState::Scope scope(scriptState);
+    NonThrowableExceptionState exceptionState;
+    return ScriptValue::to<JSONValuePtr>(scriptState->isolate(), value, exceptionState);
+}
+
+static PassRefPtr<TypeBuilder::Debugger::ExceptionDetails> toExceptionDetails(PassRefPtr<JSONObject> object)
+{
+    String text;
+    if (!object->getString("text", &text))
+        return nullptr;
+
+    RefPtr<TypeBuilder::Debugger::ExceptionDetails> exceptionDetails = TypeBuilder::Debugger::ExceptionDetails::create().setText(text);
+    String url;
+    if (object->getString("url", &url))
+        exceptionDetails->setUrl(url);
+    int line = 0;
+    if (object->getNumber("line", &line))
+        exceptionDetails->setLine(line);
+    int column = 0;
+    if (object->getNumber("column", &column))
+        exceptionDetails->setColumn(column);
+    int originScriptId = 0;
+    object->getNumber("scriptId", &originScriptId);
+
+    RefPtr<JSONArray> stackTrace = object->getArray("stackTrace");
+    if (stackTrace && stackTrace->length() > 0) {
+        RefPtr<TypeBuilder::Array<TypeBuilder::Console::CallFrame>> frames = TypeBuilder::Array<TypeBuilder::Console::CallFrame>::create();
+        for (unsigned i = 0; i < stackTrace->length(); ++i) {
+            RefPtr<JSONObject> stackFrame = stackTrace->get(i)->asObject();
+            int lineNumber = 0;
+            stackFrame->getNumber("lineNumber", &lineNumber);
+            int column = 0;
+            stackFrame->getNumber("column", &column);
+            int scriptId = 0;
+            stackFrame->getNumber("scriptId", &scriptId);
+            if (i == 0 && scriptId == originScriptId)
+                originScriptId = 0;
+
+            String sourceURL;
+            stackFrame->getString("scriptNameOrSourceURL", &sourceURL);
+            String functionName;
+            stackFrame->getString("functionName", &functionName);
+
+            RefPtr<TypeBuilder::Console::CallFrame> callFrame = TypeBuilder::Console::CallFrame::create()
+                .setFunctionName(functionName)
+                .setScriptId(String::number(scriptId))
+                .setUrl(sourceURL)
+                .setLineNumber(lineNumber)
+                .setColumnNumber(column);
+
+            frames->addItem(callFrame.release());
+        }
+        exceptionDetails->setStackTrace(frames.release());
+    }
+    if (originScriptId)
+        exceptionDetails->setScriptId(String::number(originScriptId));
+    return exceptionDetails.release();
+}
+
 InjectedScript::InjectedScript()
-    : InjectedScriptBase("InjectedScript")
+    : m_inspectedStateAccessCheck(nullptr)
 {
 }
 
 InjectedScript::InjectedScript(ScriptValue injectedScriptObject, InspectedStateAccessCheck accessCheck, PassRefPtr<InjectedScriptNative> injectedScriptNative)
-    : InjectedScriptBase("InjectedScript", injectedScriptObject, accessCheck)
+    : m_injectedScriptObject(injectedScriptObject)
+    , m_inspectedStateAccessCheck(accessCheck)
     , m_native(injectedScriptNative)
 {
 }
 
+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)
 {
     ScriptFunctionCall function(injectedScriptObject(), "evaluate");
     function.appendArgument(expression);
     function.appendArgument(objectGroup);
     function.appendArgument(includeCommandLineAPI);
     function.appendArgument(returnByValue);
     function.appendArgument(generatePreview);
     makeEvalCall(errorString, function, result, wasThrown, exceptionDetails);
 }
@@ skipping 311 matching lines @@
 
 void InjectedScript::setCustomObjectFormatterEnabled(bool enabled)
 {
     ASSERT(!isEmpty());
     ScriptFunctionCall function(injectedScriptObject(), "setCustomObjectFormatterEnabled");
     function.appendArgument(enabled);
     RefPtr<JSONValue> result;
     makeCall(function, &result);
 }
 
+void InjectedScript::initialize(ScriptValue injectedScriptObject, InspectedStateAccessCheck accessCheck)
+{
+    m_injectedScriptObject = injectedScriptObject;
+    m_inspectedStateAccessCheck = accessCheck;
+}
+
+bool InjectedScript::canAccessInspectedWindow() const
+{
+    ASSERT(!isEmpty());
+    return m_inspectedStateAccessCheck(m_injectedScriptObject.scriptState());
+}
+
+const ScriptValue& InjectedScript::injectedScriptObject() const
+{
+    return m_injectedScriptObject;
+}
+
+ScriptValue InjectedScript::callFunctionWithEvalEnabled(ScriptFunctionCall& function, bool& hadException) const
+{
+    ASSERT(!isEmpty());
+    ExecutionContext* executionContext = m_injectedScriptObject.scriptState()->executionContext();
+    ScriptState::Scope scope(m_injectedScriptObject.scriptState());
+    v8::Local<v8::Function> functionObj = function.function();
+    DevToolsFunctionInfo info(functionObj);
+    InspectorInstrumentationCookie cookie = InspectorInstrumentation::willCallFunction(executionContext, info);
+
+    ScriptState* scriptState = m_injectedScriptObject.scriptState();
+    bool evalIsDisabled = false;
+    if (scriptState) {
+        evalIsDisabled = !scriptState->evalEnabled();
+        // Temporarily enable allow evals for inspector.
+        if (evalIsDisabled)
+            scriptState->setEvalEnabled(true);
+    }
+
+    ScriptValue resultValue = function.call(hadException);
+
+    if (evalIsDisabled)
+        scriptState->setEvalEnabled(false);
+
+    InspectorInstrumentation::didCallFunction(cookie);
+    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 (isEmpty() || !canAccessInspectedWindow()) {
+        *result = JSONValue::null();
+        return;
+    }
+
+    bool hadException = false;
+    ScriptValue resultValue = callFunctionWithEvalEnabled(function, hadException);
+
+    ASSERT(!hadException);
+    if (!hadException) {
+        *result = toJSONValue(resultValue);
+        if (!*result)
+            *result = JSONString::create(String::format("Object has too long reference chain(must not be longer than %d)", JSONValue::maxDepth));
+    } else {
+        *result = JSONString::create("Exception while making a call.");
+    }
+}
+
+void InjectedScript::makeEvalCall(ErrorString* errorString, ScriptFunctionCall& function, RefPtr<TypeBuilder::Runtime::RemoteObject>* objectResult, TypeBuilder::OptOutput<bool>* wasThrown, RefPtr<TypeBuilder::Debugger::ExceptionDetails>* exceptionDetails)
+{
+    RefPtr<JSONValue> result;
+    makeCall(function, &result);
+    if (!result) {
+        *errorString = "Internal error: result value is empty";
+        return;
+    }
+    if (result->type() == JSONValue::TypeString) {
+        result->asString(errorString);
+        ASSERT(errorString->length());
+        return;
+    }
+    RefPtr<JSONObject> resultPair = result->asObject();
+    if (!resultPair) {
+        *errorString = "Internal error: result is not an Object";
+        return;
+    }
+    RefPtr<JSONObject> resultObj = resultPair->getObject("result");
+    bool wasThrownVal = false;
+    if (!resultObj || !resultPair->getBoolean("wasThrown", &wasThrownVal)) {
+        *errorString = "Internal error: result is not a pair of value and wasThrown flag";
+        return;
+    }
+    if (wasThrownVal) {
+        RefPtr<JSONObject> objectExceptionDetails = resultPair->getObject("exceptionDetails");
+        if (objectExceptionDetails)
+            *exceptionDetails = toExceptionDetails(objectExceptionDetails.release());
+    }
+    *objectResult = TypeBuilder::Runtime::RemoteObject::runtimeCast(resultObj);
+    *wasThrown = wasThrownVal;
+}
+
+void InjectedScript::makeCallWithExceptionDetails(ScriptFunctionCall& function, RefPtr<JSONValue>* result, RefPtr<TypeBuilder::Debugger::ExceptionDetails>* exceptionDetails)
+{
+    ScriptState::Scope scope(injectedScriptObject().scriptState());
+    v8::TryCatch tryCatch;
+    ScriptValue 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(resultValue);
+        if (!*result)
+            *result = JSONString::create(String::format("Object has too long reference chain(must not be longer than %d)", JSONValue::maxDepth));
+    }
+}
+
 } // namespace blink