InjectedScriptBase.cpp [plain text]
#include "config.h"
#include "InjectedScriptBase.h"
#include "DebuggerEvalEnabler.h"
#include "JSCInlines.h"
#include "JSGlobalObject.h"
#include "JSLock.h"
#include "JSNativeStdFunction.h"
#include "NativeStdFunctionCell.h"
#include "ScriptFunctionCall.h"
#include <wtf/JSONValues.h>
#include <wtf/text/WTFString.h>
namespace Inspector {
InjectedScriptBase::InjectedScriptBase(const String& name)
: m_name(name)
{
}
InjectedScriptBase::InjectedScriptBase(const String& name, Deprecated::ScriptObject injectedScriptObject, InspectorEnvironment* environment)
: m_name(name)
, m_injectedScriptObject(injectedScriptObject)
, m_environment(environment)
{
}
InjectedScriptBase::~InjectedScriptBase()
{
}
bool InjectedScriptBase::hasAccessToInspectedScriptState() const
{
return m_environment && m_environment->canAccessInspectedScriptState(m_injectedScriptObject.scriptState());
}
const Deprecated::ScriptObject& InjectedScriptBase::injectedScriptObject() const
{
return m_injectedScriptObject;
}
JSC::JSValue InjectedScriptBase::callFunctionWithEvalEnabled(Deprecated::ScriptFunctionCall& function, bool& hadException) const
{
JSC::ExecState* scriptState = m_injectedScriptObject.scriptState();
JSC::DebuggerEvalEnabler evalEnabler(scriptState);
return function.call(hadException);
}
Ref<JSON::Value> InjectedScriptBase::makeCall(Deprecated::ScriptFunctionCall& function)
{
if (hasNoValue() || !hasAccessToInspectedScriptState())
return JSON::Value::null();
bool hadException = false;
auto resultJSValue = callFunctionWithEvalEnabled(function, hadException);
ASSERT(!hadException);
if (hadException)
return JSON::Value::create("Exception while making a call.");
RefPtr<JSON::Value> resultJSONValue = toInspectorValue(*m_injectedScriptObject.scriptState(), resultJSValue);
if (!resultJSONValue)
return JSON::Value::create(String::format("Object has too long reference chain (must not be longer than %d)", JSON::Value::maxDepth));
return resultJSONValue.releaseNonNull();
}
void InjectedScriptBase::makeEvalCall(ErrorString& errorString, Deprecated::ScriptFunctionCall& function, RefPtr<Protocol::Runtime::RemoteObject>& out_resultObject, Optional<bool>& out_wasThrown, Optional<int>& out_savedResultIndex)
{
checkCallResult(errorString, makeCall(function), out_resultObject, out_wasThrown, out_savedResultIndex);
}
void InjectedScriptBase::makeAsyncCall(Deprecated::ScriptFunctionCall& function, AsyncCallCallback&& callback)
{
if (hasNoValue() || !hasAccessToInspectedScriptState()) {
checkAsyncCallResult(JSON::Value::null(), callback);
return;
}
auto* scriptState = m_injectedScriptObject.scriptState();
JSC::VM& vm = scriptState->vm();
JSC::JSNativeStdFunction* jsFunction;
{
JSC::JSLockHolder locker(vm);
jsFunction = JSC::JSNativeStdFunction::create(vm, scriptState->lexicalGlobalObject(), 1, String(), [&, callback = WTFMove(callback)] (JSC::ExecState* exec) {
if (!exec)
checkAsyncCallResult(JSON::Value::create("Exception while making a call."), callback);
if (auto resultJSONValue = toInspectorValue(*exec, exec->argument(0)))
checkAsyncCallResult(resultJSONValue, callback);
else
checkAsyncCallResult(JSON::Value::create(String::format("Object has too long reference chain (must not be longer than %d)", JSON::Value::maxDepth)), callback);
return JSC::JSValue::encode(JSC::jsUndefined());
});
}
function.appendArgument(JSC::JSValue(jsFunction));
bool hadException = false;
auto resultJSValue = callFunctionWithEvalEnabled(function, hadException);
ASSERT_UNUSED(resultJSValue, resultJSValue.isUndefined());
ASSERT(!hadException);
if (hadException) {
jsFunction->nativeStdFunctionCell()->function()(nullptr);
}
}
void InjectedScriptBase::checkCallResult(ErrorString& errorString, RefPtr<JSON::Value> result, RefPtr<Protocol::Runtime::RemoteObject>& out_resultObject, Optional<bool>& out_wasThrown, Optional<int>& out_savedResultIndex)
{
if (!result) {
errorString = "Internal error: result value is empty"_s;
return;
}
if (result->type() == JSON::Value::Type::String) {
result->asString(errorString);
ASSERT(errorString.length());
return;
}
RefPtr<JSON::Object> resultTuple;
if (!result->asObject(resultTuple)) {
errorString = "Internal error: result is not an Object"_s;
return;
}
RefPtr<JSON::Object> resultObject;
if (!resultTuple->getObject("result"_s, resultObject)) {
errorString = "Internal error: result is not a pair of value and wasThrown flag"_s;
return;
}
bool wasThrown = false;
if (!resultTuple->getBoolean("wasThrown"_s, wasThrown)) {
errorString = "Internal error: result is not a pair of value and wasThrown flag"_s;
return;
}
out_resultObject = BindingTraits<Protocol::Runtime::RemoteObject>::runtimeCast(resultObject);
if (wasThrown)
out_wasThrown = wasThrown;
int savedResultIndex;
if (resultTuple->getInteger("savedResultIndex"_s, savedResultIndex))
out_savedResultIndex = savedResultIndex;
}
void InjectedScriptBase::checkAsyncCallResult(RefPtr<JSON::Value> result, const AsyncCallCallback& callback)
{
ErrorString errorString;
RefPtr<Protocol::Runtime::RemoteObject> resultObject;
Optional<bool> wasThrown;
Optional<int> savedResultIndex;
checkCallResult(errorString, result, resultObject, wasThrown, savedResultIndex);
callback(errorString, WTFMove(resultObject), wasThrown, savedResultIndex);
}
}