[apple/javascriptcore.git] / inspector / InjectedScript.cpp

/*
 * 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"

#include "InspectorValues.h"
#include "JSCInlines.h"
#include "ScriptFunctionCall.h"
#include "ScriptObject.h"
#include <wtf/text/WTFString.h>

using Inspector::Protocol::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, bool saveResult, RefPtr<Inspector::Protocol::Runtime::RemoteObject>* result, Inspector::Protocol::OptOutput<bool>* wasThrown, Inspector::Protocol::OptOutput<int>* savedResultIndex)
{
    Deprecated::ScriptFunctionCall function(injectedScriptObject(), ASCIILiteral("evaluate"), inspectorEnvironment()->functionCallHandler());
    function.appendArgument(expression);
    function.appendArgument(objectGroup);
    function.appendArgument(includeCommandLineAPI);
    function.appendArgument(returnByValue);
    function.appendArgument(generatePreview);
    function.appendArgument(saveResult);
    makeEvalCall(errorString, function, result, wasThrown, savedResultIndex);
}

void InjectedScript::callFunctionOn(ErrorString& errorString, const String& objectId, const String& expression, const String& arguments, bool returnByValue, bool generatePreview, RefPtr<Inspector::Protocol::Runtime::RemoteObject>* result, Inspector::Protocol::OptOutput<bool>* 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, bool saveResult, RefPtr<Inspector::Protocol::Runtime::RemoteObject>* result, Inspector::Protocol::OptOutput<bool>* wasThrown, Inspector::Protocol::OptOutput<int>* savedResultIndex)
{
    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);
    function.appendArgument(saveResult);
    makeEvalCall(errorString, function, result, wasThrown, savedResultIndex);
}

void InjectedScript::getFunctionDetails(ErrorString& errorString, const String& functionId, RefPtr<Inspector::Protocol::Debugger::FunctionDetails>* result)
{
    Deprecated::ScriptFunctionCall function(injectedScriptObject(), ASCIILiteral("getFunctionDetails"), inspectorEnvironment()->functionCallHandler());
    function.appendArgument(functionId);

    RefPtr<InspectorValue> resultValue;
    makeCall(function, &resultValue);
    if (!resultValue || resultValue->type() != InspectorValue::Type::Object) {
        if (!resultValue->asString(errorString))
            errorString = ASCIILiteral("Internal error");
        return;
    }

    *result = BindingTraits<Inspector::Protocol::Debugger::FunctionDetails>::runtimeCast(WTF::move(resultValue));
}

void InjectedScript::getProperties(ErrorString& errorString, const String& objectId, bool ownProperties, bool generatePreview, RefPtr<Array<Inspector::Protocol::Runtime::PropertyDescriptor>>* properties)
{
    Deprecated::ScriptFunctionCall function(injectedScriptObject(), ASCIILiteral("getProperties"), inspectorEnvironment()->functionCallHandler());
    function.appendArgument(objectId);
    function.appendArgument(ownProperties);
    function.appendArgument(generatePreview);

    RefPtr<InspectorValue> result;
    makeCall(function, &result);
    if (!result || result->type() != InspectorValue::Type::Array) {
        errorString = ASCIILiteral("Internal error");
        return;
    }

    *properties = BindingTraits<Array<Inspector::Protocol::Runtime::PropertyDescriptor>>::runtimeCast(WTF::move(result));
}

void InjectedScript::getDisplayableProperties(ErrorString& errorString, const String& objectId, bool generatePreview, RefPtr<Array<Inspector::Protocol::Runtime::PropertyDescriptor>>* properties)
{
    Deprecated::ScriptFunctionCall function(injectedScriptObject(), ASCIILiteral("getDisplayableProperties"), inspectorEnvironment()->functionCallHandler());
    function.appendArgument(objectId);
    function.appendArgument(generatePreview);

    RefPtr<InspectorValue> result;
    makeCall(function, &result);
    if (!result || result->type() != InspectorValue::Type::Array) {
        errorString = ASCIILiteral("Internal error");
        return;
    }

    *properties = BindingTraits<Array<Inspector::Protocol::Runtime::PropertyDescriptor>>::runtimeCast(WTF::move(result));
}

void InjectedScript::getInternalProperties(ErrorString& errorString, const String& objectId, bool generatePreview, RefPtr<Array<Inspector::Protocol::Runtime::InternalPropertyDescriptor>>* properties)
{
    Deprecated::ScriptFunctionCall function(injectedScriptObject(), ASCIILiteral("getInternalProperties"), inspectorEnvironment()->functionCallHandler());
    function.appendArgument(objectId);
    function.appendArgument(generatePreview);

    RefPtr<InspectorValue> result;
    makeCall(function, &result);
    if (!result || result->type() != InspectorValue::Type::Array) {
        errorString = ASCIILiteral("Internal error");
        return;
    }

    auto array = BindingTraits<Array<Inspector::Protocol::Runtime::InternalPropertyDescriptor>>::runtimeCast(WTF::move(result));
    *properties = array->length() > 0 ? array : nullptr;
}

void InjectedScript::getCollectionEntries(ErrorString& errorString, const String& objectId, const String& objectGroup, int startIndex, int numberToFetch, RefPtr<Protocol::Array<Protocol::Runtime::CollectionEntry>>* entries)
{
    Deprecated::ScriptFunctionCall function(injectedScriptObject(), ASCIILiteral("getCollectionEntries"), inspectorEnvironment()->functionCallHandler());
    function.appendArgument(objectId);
    function.appendArgument(objectGroup);
    function.appendArgument(startIndex);
    function.appendArgument(numberToFetch);

    RefPtr<InspectorValue> result;
    makeCall(function, &result);
    if (!result || result->type() != InspectorValue::Type::Array) {
        errorString = ASCIILiteral("Internal error");
        return;
    }

    *entries = BindingTraits<Array<Protocol::Runtime::CollectionEntry>>::runtimeCast(WTF::move(result));
}

void InjectedScript::saveResult(ErrorString& errorString, const String& callArgumentJSON, Inspector::Protocol::OptOutput<int>* savedResultIndex)
{
    Deprecated::ScriptFunctionCall function(injectedScriptObject(), ASCIILiteral("saveResult"), inspectorEnvironment()->functionCallHandler());
    function.appendArgument(callArgumentJSON);

    RefPtr<InspectorValue> result;
    makeCall(function, &result);
    if (!result || result->type() != InspectorValue::Type::Integer) {
        errorString = ASCIILiteral("Internal error");
        return;
    }

    int savedResultIndexInt = 0;
    if (result->asInteger(savedResultIndexInt) && savedResultIndexInt > 0)
        *savedResultIndex = savedResultIndexInt;
}

Ref<Array<Inspector::Protocol::Debugger::CallFrame>> 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<InspectorValue> result = callFramesValue.toInspectorValue(scriptState());
    if (result->type() == InspectorValue::Type::Array)
        return BindingTraits<Array<Inspector::Protocol::Debugger::CallFrame>>::runtimeCast(WTF::move(result)).releaseNonNull();

    return Array<Inspector::Protocol::Debugger::CallFrame>::create();
}

RefPtr<Inspector::Protocol::Runtime::RemoteObject> 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<InspectorObject> resultObject;
    bool castSucceeded = r.toInspectorValue(scriptState())->asObject(resultObject);
    ASSERT_UNUSED(castSucceeded, castSucceeded);

    return BindingTraits<Inspector::Protocol::Runtime::RemoteObject>::runtimeCast(resultObject);
}

RefPtr<Inspector::Protocol::Runtime::RemoteObject> 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<InspectorObject> resultObject;
    bool castSucceeded = r.toInspectorValue(scriptState())->asObject(resultObject);
    ASSERT_UNUSED(castSucceeded, castSucceeded);

    return BindingTraits<Inspector::Protocol::Runtime::RemoteObject>::runtimeCast(resultObject);
}

void InjectedScript::setExceptionValue(const Deprecated::ScriptValue& value)
{
    ASSERT(!hasNoValue());
    Deprecated::ScriptFunctionCall function(injectedScriptObject(), ASCIILiteral("setExceptionValue"), inspectorEnvironment()->functionCallHandler());
    function.appendArgument(value);
    RefPtr<InspectorValue> result;
    makeCall(function, &result);
}

void InjectedScript::clearExceptionValue()
{
    ASSERT(!hasNoValue());
    Deprecated::ScriptFunctionCall function(injectedScriptObject(), ASCIILiteral("clearExceptionValue"), inspectorEnvironment()->functionCallHandler());
    RefPtr<InspectorValue> result;
    makeCall(function, &result);
}

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<InspectorValue> result;
    makeCall(function, &result);
}

void InjectedScript::releaseObject(const String& objectId)
{
    Deprecated::ScriptFunctionCall function(injectedScriptObject(), ASCIILiteral("releaseObject"), inspectorEnvironment()->functionCallHandler());
    function.appendArgument(objectId);
    RefPtr<InspectorValue> 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
Commit	Line	Data
81345200 A	1	/*
	2	* Copyright (C) 2013 Apple Inc. All rights reserved.
	3	* Copyright (C) 2012 Google Inc. All rights reserved.
	4	*
	5	* Redistribution and use in source and binary forms, with or without
	6	* modification, are permitted provided that the following conditions are
	7	* met:
	8	*
	9	* * Redistributions of source code must retain the above copyright
	10	* notice, this list of conditions and the following disclaimer.
	11	* * Redistributions in binary form must reproduce the above
	12	* copyright notice, this list of conditions and the following disclaimer
	13	* in the documentation and/or other materials provided with the
	14	* distribution.
	15	* * Neither the name of Google Inc. nor the names of its
	16	* contributors may be used to endorse or promote products derived from
	17	* this software without specific prior written permission.
	18	*
	19	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
	20	* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
	21	* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
	22	* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
	23	* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	24	* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
	25	* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
	26	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
	27	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	28	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	29	* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	30	*/
	31
	32	#include "config.h"
	33	#include "InjectedScript.h"
	34
81345200 A	35	#include "InspectorValues.h"
	36	#include "JSCInlines.h"
	37	#include "ScriptFunctionCall.h"
	38	#include "ScriptObject.h"
	39	#include <wtf/text/WTFString.h>
	40
ed1e77d3	41	using Inspector::Protocol::Array;
81345200 A	42
	43	namespace Inspector {
	44
	45	InjectedScript::InjectedScript()
	46	: InjectedScriptBase(ASCIILiteral("InjectedScript"))
	47	{
	48	}
	49
	50	InjectedScript::InjectedScript(Deprecated::ScriptObject injectedScriptObject, InspectorEnvironment* environment)
	51	: InjectedScriptBase(ASCIILiteral("InjectedScript"), injectedScriptObject, environment)
	52	{
	53	}
	54
	55	InjectedScript::~InjectedScript()
	56	{
	57	}
	58
ed1e77d3	59	void InjectedScript::evaluate(ErrorString& errorString, const String& expression, const String& objectGroup, bool includeCommandLineAPI, bool returnByValue, bool generatePreview, bool saveResult, RefPtr<Inspector::Protocol::Runtime::RemoteObject>* result, Inspector::Protocol::OptOutput<bool>* wasThrown, Inspector::Protocol::OptOutput<int>* savedResultIndex)
81345200 A	60	{
	61	Deprecated::ScriptFunctionCall function(injectedScriptObject(), ASCIILiteral("evaluate"), inspectorEnvironment()->functionCallHandler());
	62	function.appendArgument(expression);
	63	function.appendArgument(objectGroup);
	64	function.appendArgument(includeCommandLineAPI);
	65	function.appendArgument(returnByValue);
	66	function.appendArgument(generatePreview);
ed1e77d3 A	67	function.appendArgument(saveResult);
ed1e77d3 A	68	makeEvalCall(errorString, function, result, wasThrown, savedResultIndex);
81345200 A	69	}
81345200 A	70
ed1e77d3	71	void InjectedScript::callFunctionOn(ErrorString& errorString, const String& objectId, const String& expression, const String& arguments, bool returnByValue, bool generatePreview, RefPtr<Inspector::Protocol::Runtime::RemoteObject>* result, Inspector::Protocol::OptOutput<bool>* wasThrown)
81345200 A	72	{
	73	Deprecated::ScriptFunctionCall function(injectedScriptObject(), ASCIILiteral("callFunctionOn"), inspectorEnvironment()->functionCallHandler());
	74	function.appendArgument(objectId);
	75	function.appendArgument(expression);
	76	function.appendArgument(arguments);
	77	function.appendArgument(returnByValue);
	78	function.appendArgument(generatePreview);
	79	makeEvalCall(errorString, function, result, wasThrown);
	80	}
	81
ed1e77d3	82	void InjectedScript::evaluateOnCallFrame(ErrorString& errorString, const Deprecated::ScriptValue& callFrames, const String& callFrameId, const String& expression, const String& objectGroup, bool includeCommandLineAPI, bool returnByValue, bool generatePreview, bool saveResult, RefPtr<Inspector::Protocol::Runtime::RemoteObject>* result, Inspector::Protocol::OptOutput<bool>* wasThrown, Inspector::Protocol::OptOutput<int>* savedResultIndex)
81345200 A	83	{
	84	Deprecated::ScriptFunctionCall function(injectedScriptObject(), ASCIILiteral("evaluateOnCallFrame"), inspectorEnvironment()->functionCallHandler());
	85	function.appendArgument(callFrames);
	86	function.appendArgument(callFrameId);
	87	function.appendArgument(expression);
	88	function.appendArgument(objectGroup);
	89	function.appendArgument(includeCommandLineAPI);
	90	function.appendArgument(returnByValue);
	91	function.appendArgument(generatePreview);
ed1e77d3 A	92	function.appendArgument(saveResult);
ed1e77d3 A	93	makeEvalCall(errorString, function, result, wasThrown, savedResultIndex);
81345200 A	94	}
81345200 A	95
ed1e77d3	96	void InjectedScript::getFunctionDetails(ErrorString& errorString, const String& functionId, RefPtr<Inspector::Protocol::Debugger::FunctionDetails>* result)
81345200 A	97	{
	98	Deprecated::ScriptFunctionCall function(injectedScriptObject(), ASCIILiteral("getFunctionDetails"), inspectorEnvironment()->functionCallHandler());
	99	function.appendArgument(functionId);
	100
	101	RefPtr<InspectorValue> resultValue;
	102	makeCall(function, &resultValue);
ed1e77d3	103	if (!resultValue \|\| resultValue->type() != InspectorValue::Type::Object) {
81345200	104	if (!resultValue->asString(errorString))
ed1e77d3	105	errorString = ASCIILiteral("Internal error");
81345200 A	106	return;
	107	}
	108
ed1e77d3	109	*result = BindingTraits<Inspector::Protocol::Debugger::FunctionDetails>::runtimeCast(WTF::move(resultValue));
81345200 A	110	}
81345200 A	111
ed1e77d3	112	void InjectedScript::getProperties(ErrorString& errorString, const String& objectId, bool ownProperties, bool generatePreview, RefPtr<Array<Inspector::Protocol::Runtime::PropertyDescriptor>>* properties)
81345200 A	113	{
	114	Deprecated::ScriptFunctionCall function(injectedScriptObject(), ASCIILiteral("getProperties"), inspectorEnvironment()->functionCallHandler());
	115	function.appendArgument(objectId);
	116	function.appendArgument(ownProperties);
ed1e77d3 A	117	function.appendArgument(generatePreview);
	118
	119	RefPtr<InspectorValue> result;
	120	makeCall(function, &result);
	121	if (!result \|\| result->type() != InspectorValue::Type::Array) {
	122	errorString = ASCIILiteral("Internal error");
	123	return;
	124	}
	125
	126	*properties = BindingTraits<Array<Inspector::Protocol::Runtime::PropertyDescriptor>>::runtimeCast(WTF::move(result));
	127	}
	128
	129	void InjectedScript::getDisplayableProperties(ErrorString& errorString, const String& objectId, bool generatePreview, RefPtr<Array<Inspector::Protocol::Runtime::PropertyDescriptor>>* properties)
	130	{
	131	Deprecated::ScriptFunctionCall function(injectedScriptObject(), ASCIILiteral("getDisplayableProperties"), inspectorEnvironment()->functionCallHandler());
	132	function.appendArgument(objectId);
	133	function.appendArgument(generatePreview);
81345200 A	134
	135	RefPtr<InspectorValue> result;
	136	makeCall(function, &result);
ed1e77d3 A	137	if (!result \|\| result->type() != InspectorValue::Type::Array) {
ed1e77d3 A	138	errorString = ASCIILiteral("Internal error");
81345200 A	139	return;
	140	}
	141
ed1e77d3	142	*properties = BindingTraits<Array<Inspector::Protocol::Runtime::PropertyDescriptor>>::runtimeCast(WTF::move(result));
81345200 A	143	}
81345200 A	144
ed1e77d3	145	void InjectedScript::getInternalProperties(ErrorString& errorString, const String& objectId, bool generatePreview, RefPtr<Array<Inspector::Protocol::Runtime::InternalPropertyDescriptor>>* properties)
81345200 A	146	{
	147	Deprecated::ScriptFunctionCall function(injectedScriptObject(), ASCIILiteral("getInternalProperties"), inspectorEnvironment()->functionCallHandler());
	148	function.appendArgument(objectId);
ed1e77d3	149	function.appendArgument(generatePreview);
81345200 A	150
	151	RefPtr<InspectorValue> result;
	152	makeCall(function, &result);
ed1e77d3 A	153	if (!result \|\| result->type() != InspectorValue::Type::Array) {
ed1e77d3 A	154	errorString = ASCIILiteral("Internal error");
81345200 A	155	return;
	156	}
	157
ed1e77d3 A	158	auto array = BindingTraits<Array<Inspector::Protocol::Runtime::InternalPropertyDescriptor>>::runtimeCast(WTF::move(result));
ed1e77d3 A	159	*properties = array->length() > 0 ? array : nullptr;
81345200 A	160	}
81345200 A	161
ed1e77d3 A	162	void InjectedScript::getCollectionEntries(ErrorString& errorString, const String& objectId, const String& objectGroup, int startIndex, int numberToFetch, RefPtr<Protocol::Array<Protocol::Runtime::CollectionEntry>>* entries)
	163	{
	164	Deprecated::ScriptFunctionCall function(injectedScriptObject(), ASCIILiteral("getCollectionEntries"), inspectorEnvironment()->functionCallHandler());
	165	function.appendArgument(objectId);
	166	function.appendArgument(objectGroup);
	167	function.appendArgument(startIndex);
	168	function.appendArgument(numberToFetch);
	169
	170	RefPtr<InspectorValue> result;
	171	makeCall(function, &result);
	172	if (!result \|\| result->type() != InspectorValue::Type::Array) {
	173	errorString = ASCIILiteral("Internal error");
	174	return;
	175	}
	176
	177	*entries = BindingTraits<Array<Protocol::Runtime::CollectionEntry>>::runtimeCast(WTF::move(result));
	178	}
	179
	180	void InjectedScript::saveResult(ErrorString& errorString, const String& callArgumentJSON, Inspector::Protocol::OptOutput<int>* savedResultIndex)
	181	{
	182	Deprecated::ScriptFunctionCall function(injectedScriptObject(), ASCIILiteral("saveResult"), inspectorEnvironment()->functionCallHandler());
	183	function.appendArgument(callArgumentJSON);
	184
	185	RefPtr<InspectorValue> result;
	186	makeCall(function, &result);
	187	if (!result \|\| result->type() != InspectorValue::Type::Integer) {
	188	errorString = ASCIILiteral("Internal error");
	189	return;
	190	}
	191
	192	int savedResultIndexInt = 0;
	193	if (result->asInteger(savedResultIndexInt) && savedResultIndexInt > 0)
	194	*savedResultIndex = savedResultIndexInt;
	195	}
	196
	197	Ref<Array<Inspector::Protocol::Debugger::CallFrame>> InjectedScript::wrapCallFrames(const Deprecated::ScriptValue& callFrames)
81345200 A	198	{
	199	ASSERT(!hasNoValue());
	200	Deprecated::ScriptFunctionCall function(injectedScriptObject(), ASCIILiteral("wrapCallFrames"), inspectorEnvironment()->functionCallHandler());
	201	function.appendArgument(callFrames);
	202
	203	bool hadException = false;
	204	Deprecated::ScriptValue callFramesValue = callFunctionWithEvalEnabled(function, hadException);
	205	ASSERT(!hadException);
	206	RefPtr<InspectorValue> result = callFramesValue.toInspectorValue(scriptState());
ed1e77d3 A	207	if (result->type() == InspectorValue::Type::Array)
ed1e77d3 A	208	return BindingTraits<Array<Inspector::Protocol::Debugger::CallFrame>>::runtimeCast(WTF::move(result)).releaseNonNull();
81345200	209
ed1e77d3	210	return Array<Inspector::Protocol::Debugger::CallFrame>::create();
81345200 A	211	}
81345200 A	212
ed1e77d3	213	RefPtr<Inspector::Protocol::Runtime::RemoteObject> InjectedScript::wrapObject(const Deprecated::ScriptValue& value, const String& groupName, bool generatePreview) const
81345200 A	214	{
	215	ASSERT(!hasNoValue());
	216	Deprecated::ScriptFunctionCall wrapFunction(injectedScriptObject(), ASCIILiteral("wrapObject"), inspectorEnvironment()->functionCallHandler());
	217	wrapFunction.appendArgument(value);
	218	wrapFunction.appendArgument(groupName);
	219	wrapFunction.appendArgument(hasAccessToInspectedScriptState());
	220	wrapFunction.appendArgument(generatePreview);
	221
	222	bool hadException = false;
	223	Deprecated::ScriptValue r = callFunctionWithEvalEnabled(wrapFunction, hadException);
	224	if (hadException)
	225	return nullptr;
	226
ed1e77d3 A	227	RefPtr<InspectorObject> resultObject;
	228	bool castSucceeded = r.toInspectorValue(scriptState())->asObject(resultObject);
	229	ASSERT_UNUSED(castSucceeded, castSucceeded);
	230
	231	return BindingTraits<Inspector::Protocol::Runtime::RemoteObject>::runtimeCast(resultObject);
81345200 A	232	}
81345200 A	233
ed1e77d3	234	RefPtr<Inspector::Protocol::Runtime::RemoteObject> InjectedScript::wrapTable(const Deprecated::ScriptValue& table, const Deprecated::ScriptValue& columns) const
81345200 A	235	{
	236	ASSERT(!hasNoValue());
	237	Deprecated::ScriptFunctionCall wrapFunction(injectedScriptObject(), ASCIILiteral("wrapTable"), inspectorEnvironment()->functionCallHandler());
	238	wrapFunction.appendArgument(hasAccessToInspectedScriptState());
	239	wrapFunction.appendArgument(table);
	240	if (columns.hasNoValue())
	241	wrapFunction.appendArgument(false);
	242	else
	243	wrapFunction.appendArgument(columns);
	244
	245	bool hadException = false;
	246	Deprecated::ScriptValue r = callFunctionWithEvalEnabled(wrapFunction, hadException);
	247	if (hadException)
	248	return nullptr;
	249
ed1e77d3 A	250	RefPtr<InspectorObject> resultObject;
	251	bool castSucceeded = r.toInspectorValue(scriptState())->asObject(resultObject);
	252	ASSERT_UNUSED(castSucceeded, castSucceeded);
	253
	254	return BindingTraits<Inspector::Protocol::Runtime::RemoteObject>::runtimeCast(resultObject);
	255	}
	256
	257	void InjectedScript::setExceptionValue(const Deprecated::ScriptValue& value)
	258	{
	259	ASSERT(!hasNoValue());
	260	Deprecated::ScriptFunctionCall function(injectedScriptObject(), ASCIILiteral("setExceptionValue"), inspectorEnvironment()->functionCallHandler());
	261	function.appendArgument(value);
	262	RefPtr<InspectorValue> result;
	263	makeCall(function, &result);
	264	}
	265
	266	void InjectedScript::clearExceptionValue()
	267	{
	268	ASSERT(!hasNoValue());
	269	Deprecated::ScriptFunctionCall function(injectedScriptObject(), ASCIILiteral("clearExceptionValue"), inspectorEnvironment()->functionCallHandler());
	270	RefPtr<InspectorValue> result;
	271	makeCall(function, &result);
81345200 A	272	}
	273
	274	Deprecated::ScriptValue InjectedScript::findObjectById(const String& objectId) const
	275	{
	276	ASSERT(!hasNoValue());
	277	Deprecated::ScriptFunctionCall function(injectedScriptObject(), ASCIILiteral("findObjectById"), inspectorEnvironment()->functionCallHandler());
	278	function.appendArgument(objectId);
	279
	280	bool hadException = false;
	281	Deprecated::ScriptValue resultValue = callFunctionWithEvalEnabled(function, hadException);
	282	ASSERT(!hadException);
	283
	284	return resultValue;
	285	}
	286
	287	void InjectedScript::inspectObject(Deprecated::ScriptValue value)
	288	{
	289	ASSERT(!hasNoValue());
	290	Deprecated::ScriptFunctionCall function(injectedScriptObject(), ASCIILiteral("inspectObject"), inspectorEnvironment()->functionCallHandler());
	291	function.appendArgument(value);
	292	RefPtr<InspectorValue> result;
	293	makeCall(function, &result);
	294	}
	295
	296	void InjectedScript::releaseObject(const String& objectId)
	297	{
	298	Deprecated::ScriptFunctionCall function(injectedScriptObject(), ASCIILiteral("releaseObject"), inspectorEnvironment()->functionCallHandler());
	299	function.appendArgument(objectId);
	300	RefPtr<InspectorValue> result;
	301	makeCall(function, &result);
	302	}
	303
	304	void InjectedScript::releaseObjectGroup(const String& objectGroup)
	305	{
	306	ASSERT(!hasNoValue());
	307	Deprecated::ScriptFunctionCall releaseFunction(injectedScriptObject(), ASCIILiteral("releaseObjectGroup"), inspectorEnvironment()->functionCallHandler());
	308	releaseFunction.appendArgument(objectGroup);
	309
	310	bool hadException = false;
	311	callFunctionWithEvalEnabled(releaseFunction, hadException);
	312	ASSERT(!hadException);
	313	}
	314
	315	} // namespace Inspector
	316