X-Git-Url: https://git.saurik.com/apple/javascriptcore.git/blobdiff_plain/4be4e30906bcb8ee30b4d189205cb70bad6707ce..81345200c95645a1b0d2635520f96ad55dfde63f:/inspector/InjectedScript.cpp diff --git a/inspector/InjectedScript.cpp b/inspector/InjectedScript.cpp new file mode 100644 index 0000000..785dad0 --- /dev/null +++ b/inspector/InjectedScript.cpp @@ -0,0 +1,242 @@ +/* + * Copyright (C) 2013 Apple Inc. All rights reserved. + * 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 + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * 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 "config.h" +#include "InjectedScript.h" + +#if ENABLE(INSPECTOR) + +#include "InspectorValues.h" +#include "JSCInlines.h" +#include "ScriptFunctionCall.h" +#include "ScriptObject.h" +#include + +using Inspector::TypeBuilder::Array; + +namespace Inspector { + +InjectedScript::InjectedScript() + : InjectedScriptBase(ASCIILiteral("InjectedScript")) +{ +} + +InjectedScript::InjectedScript(Deprecated::ScriptObject injectedScriptObject, InspectorEnvironment* environment) + : InjectedScriptBase(ASCIILiteral("InjectedScript"), injectedScriptObject, environment) +{ +} + +InjectedScript::~InjectedScript() +{ +} + +void InjectedScript::evaluate(ErrorString* errorString, const String& expression, const String& objectGroup, bool includeCommandLineAPI, bool returnByValue, bool generatePreview, RefPtr* result, Inspector::TypeBuilder::OptOutput* wasThrown) +{ + Deprecated::ScriptFunctionCall function(injectedScriptObject(), ASCIILiteral("evaluate"), inspectorEnvironment()->functionCallHandler()); + function.appendArgument(expression); + function.appendArgument(objectGroup); + function.appendArgument(includeCommandLineAPI); + function.appendArgument(returnByValue); + function.appendArgument(generatePreview); + makeEvalCall(errorString, function, result, wasThrown); +} + +void InjectedScript::callFunctionOn(ErrorString* errorString, const String& objectId, const String& expression, const String& arguments, bool returnByValue, bool generatePreview, RefPtr* result, Inspector::TypeBuilder::OptOutput* wasThrown) +{ + Deprecated::ScriptFunctionCall function(injectedScriptObject(), ASCIILiteral("callFunctionOn"), inspectorEnvironment()->functionCallHandler()); + 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, const Deprecated::ScriptValue& callFrames, const String& callFrameId, const String& expression, const String& objectGroup, bool includeCommandLineAPI, bool returnByValue, bool generatePreview, RefPtr* result, Inspector::TypeBuilder::OptOutput* wasThrown) +{ + Deprecated::ScriptFunctionCall function(injectedScriptObject(), ASCIILiteral("evaluateOnCallFrame"), inspectorEnvironment()->functionCallHandler()); + function.appendArgument(callFrames); + function.appendArgument(callFrameId); + function.appendArgument(expression); + function.appendArgument(objectGroup); + function.appendArgument(includeCommandLineAPI); + function.appendArgument(returnByValue); + function.appendArgument(generatePreview); + makeEvalCall(errorString, function, result, wasThrown); +} + +void InjectedScript::getFunctionDetails(ErrorString* errorString, const String& functionId, RefPtr* result) +{ + Deprecated::ScriptFunctionCall function(injectedScriptObject(), ASCIILiteral("getFunctionDetails"), inspectorEnvironment()->functionCallHandler()); + function.appendArgument(functionId); + + RefPtr resultValue; + makeCall(function, &resultValue); + if (!resultValue || resultValue->type() != InspectorValue::TypeObject) { + if (!resultValue->asString(errorString)) + *errorString = ASCIILiteral("Internal error"); + return; + } + + *result = Inspector::TypeBuilder::Debugger::FunctionDetails::runtimeCast(resultValue); +} + +void InjectedScript::getProperties(ErrorString* errorString, const String& objectId, bool ownProperties, RefPtr>* properties) +{ + Deprecated::ScriptFunctionCall function(injectedScriptObject(), ASCIILiteral("getProperties"), inspectorEnvironment()->functionCallHandler()); + function.appendArgument(objectId); + function.appendArgument(ownProperties); + + RefPtr result; + makeCall(function, &result); + if (!result || result->type() != InspectorValue::TypeArray) { + *errorString = ASCIILiteral("Internal error"); + return; + } + + *properties = Array::runtimeCast(result); +} + +void InjectedScript::getInternalProperties(ErrorString* errorString, const String& objectId, RefPtr>* properties) +{ + Deprecated::ScriptFunctionCall function(injectedScriptObject(), ASCIILiteral("getInternalProperties"), inspectorEnvironment()->functionCallHandler()); + function.appendArgument(objectId); + + RefPtr result; + makeCall(function, &result); + if (!result || result->type() != InspectorValue::TypeArray) { + *errorString = ASCIILiteral("Internal error"); + return; + } + + RefPtr> array = Array::runtimeCast(result); + if (array->length() > 0) + *properties = array; +} + +PassRefPtr> InjectedScript::wrapCallFrames(const Deprecated::ScriptValue& callFrames) +{ + ASSERT(!hasNoValue()); + Deprecated::ScriptFunctionCall function(injectedScriptObject(), ASCIILiteral("wrapCallFrames"), inspectorEnvironment()->functionCallHandler()); + function.appendArgument(callFrames); + + bool hadException = false; + Deprecated::ScriptValue callFramesValue = callFunctionWithEvalEnabled(function, hadException); + ASSERT(!hadException); + RefPtr result = callFramesValue.toInspectorValue(scriptState()); + if (result->type() == InspectorValue::TypeArray) + return Array::runtimeCast(result); + + return Array::create(); +} + +PassRefPtr InjectedScript::wrapObject(const Deprecated::ScriptValue& value, const String& groupName, bool generatePreview) const +{ + ASSERT(!hasNoValue()); + Deprecated::ScriptFunctionCall wrapFunction(injectedScriptObject(), ASCIILiteral("wrapObject"), inspectorEnvironment()->functionCallHandler()); + wrapFunction.appendArgument(value); + wrapFunction.appendArgument(groupName); + wrapFunction.appendArgument(hasAccessToInspectedScriptState()); + wrapFunction.appendArgument(generatePreview); + + bool hadException = false; + Deprecated::ScriptValue r = callFunctionWithEvalEnabled(wrapFunction, hadException); + if (hadException) + return nullptr; + + RefPtr rawResult = r.toInspectorValue(scriptState())->asObject(); + return Inspector::TypeBuilder::Runtime::RemoteObject::runtimeCast(rawResult); +} + +PassRefPtr InjectedScript::wrapTable(const Deprecated::ScriptValue& table, const Deprecated::ScriptValue& columns) const +{ + ASSERT(!hasNoValue()); + Deprecated::ScriptFunctionCall wrapFunction(injectedScriptObject(), ASCIILiteral("wrapTable"), inspectorEnvironment()->functionCallHandler()); + wrapFunction.appendArgument(hasAccessToInspectedScriptState()); + wrapFunction.appendArgument(table); + if (columns.hasNoValue()) + wrapFunction.appendArgument(false); + else + wrapFunction.appendArgument(columns); + + bool hadException = false; + Deprecated::ScriptValue r = callFunctionWithEvalEnabled(wrapFunction, hadException); + if (hadException) + return nullptr; + + RefPtr rawResult = r.toInspectorValue(scriptState())->asObject(); + return Inspector::TypeBuilder::Runtime::RemoteObject::runtimeCast(rawResult); +} + +Deprecated::ScriptValue InjectedScript::findObjectById(const String& objectId) const +{ + ASSERT(!hasNoValue()); + Deprecated::ScriptFunctionCall function(injectedScriptObject(), ASCIILiteral("findObjectById"), inspectorEnvironment()->functionCallHandler()); + function.appendArgument(objectId); + + bool hadException = false; + Deprecated::ScriptValue resultValue = callFunctionWithEvalEnabled(function, hadException); + ASSERT(!hadException); + + return resultValue; +} + +void InjectedScript::inspectObject(Deprecated::ScriptValue value) +{ + ASSERT(!hasNoValue()); + Deprecated::ScriptFunctionCall function(injectedScriptObject(), ASCIILiteral("inspectObject"), inspectorEnvironment()->functionCallHandler()); + function.appendArgument(value); + RefPtr result; + makeCall(function, &result); +} + +void InjectedScript::releaseObject(const String& objectId) +{ + Deprecated::ScriptFunctionCall function(injectedScriptObject(), ASCIILiteral("releaseObject"), inspectorEnvironment()->functionCallHandler()); + function.appendArgument(objectId); + RefPtr result; + makeCall(function, &result); +} + +void InjectedScript::releaseObjectGroup(const String& objectGroup) +{ + ASSERT(!hasNoValue()); + Deprecated::ScriptFunctionCall releaseFunction(injectedScriptObject(), ASCIILiteral("releaseObjectGroup"), inspectorEnvironment()->functionCallHandler()); + releaseFunction.appendArgument(objectGroup); + + bool hadException = false; + callFunctionWithEvalEnabled(releaseFunction, hadException); + ASSERT(!hadException); +} + +} // namespace Inspector + +#endif // ENABLE(INSPECTOR)