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
35#if ENABLE(INSPECTOR)
36
37#include "InspectorValues.h"
38#include "JSCInlines.h"
39#include "ScriptFunctionCall.h"
40#include "ScriptObject.h"
41#include <wtf/text/WTFString.h>
42
43using Inspector::TypeBuilder::Array;
44
45namespace Inspector {
46
47InjectedScript::InjectedScript()
48    : InjectedScriptBase(ASCIILiteral("InjectedScript"))
49{
50}
51
52InjectedScript::InjectedScript(Deprecated::ScriptObject injectedScriptObject, InspectorEnvironment* environment)
53    : InjectedScriptBase(ASCIILiteral("InjectedScript"), injectedScriptObject, environment)
54{
55}
56
57InjectedScript::~InjectedScript()
58{
59}
60
61void InjectedScript::evaluate(ErrorString* errorString, const String& expression, const String& objectGroup, bool includeCommandLineAPI, bool returnByValue, bool generatePreview, RefPtr<Inspector::TypeBuilder::Runtime::RemoteObject>* result, Inspector::TypeBuilder::OptOutput<bool>* wasThrown)
62{
63    Deprecated::ScriptFunctionCall function(injectedScriptObject(), ASCIILiteral("evaluate"), inspectorEnvironment()->functionCallHandler());
64    function.appendArgument(expression);
65    function.appendArgument(objectGroup);
66    function.appendArgument(includeCommandLineAPI);
67    function.appendArgument(returnByValue);
68    function.appendArgument(generatePreview);
69    makeEvalCall(errorString, function, result, wasThrown);
70}
71
72void InjectedScript::callFunctionOn(ErrorString* errorString, const String& objectId, const String& expression, const String& arguments, bool returnByValue, bool generatePreview, RefPtr<Inspector::TypeBuilder::Runtime::RemoteObject>* result, Inspector::TypeBuilder::OptOutput<bool>* wasThrown)
73{
74    Deprecated::ScriptFunctionCall function(injectedScriptObject(), ASCIILiteral("callFunctionOn"), inspectorEnvironment()->functionCallHandler());
75    function.appendArgument(objectId);
76    function.appendArgument(expression);
77    function.appendArgument(arguments);
78    function.appendArgument(returnByValue);
79    function.appendArgument(generatePreview);
80    makeEvalCall(errorString, function, result, wasThrown);
81}
82
83void InjectedScript::evaluateOnCallFrame(ErrorString* errorString, const Deprecated::ScriptValue& callFrames, const String& callFrameId, const String& expression, const String& objectGroup, bool includeCommandLineAPI, bool returnByValue, bool generatePreview, RefPtr<Inspector::TypeBuilder::Runtime::RemoteObject>* result, Inspector::TypeBuilder::OptOutput<bool>* wasThrown)
84{
85    Deprecated::ScriptFunctionCall function(injectedScriptObject(), ASCIILiteral("evaluateOnCallFrame"), inspectorEnvironment()->functionCallHandler());
86    function.appendArgument(callFrames);
87    function.appendArgument(callFrameId);
88    function.appendArgument(expression);
89    function.appendArgument(objectGroup);
90    function.appendArgument(includeCommandLineAPI);
91    function.appendArgument(returnByValue);
92    function.appendArgument(generatePreview);
93    makeEvalCall(errorString, function, result, wasThrown);
94}
95
96void InjectedScript::getFunctionDetails(ErrorString* errorString, const String& functionId, RefPtr<Inspector::TypeBuilder::Debugger::FunctionDetails>* result)
97{
98    Deprecated::ScriptFunctionCall function(injectedScriptObject(), ASCIILiteral("getFunctionDetails"), inspectorEnvironment()->functionCallHandler());
99    function.appendArgument(functionId);
100
101    RefPtr<InspectorValue> resultValue;
102    makeCall(function, &resultValue);
103    if (!resultValue || resultValue->type() != InspectorValue::TypeObject) {
104        if (!resultValue->asString(errorString))
105            *errorString = ASCIILiteral("Internal error");
106        return;
107    }
108
109    *result = Inspector::TypeBuilder::Debugger::FunctionDetails::runtimeCast(resultValue);
110}
111
112void InjectedScript::getProperties(ErrorString* errorString, const String& objectId, bool ownProperties, RefPtr<Array<Inspector::TypeBuilder::Runtime::PropertyDescriptor>>* properties)
113{
114    Deprecated::ScriptFunctionCall function(injectedScriptObject(), ASCIILiteral("getProperties"), inspectorEnvironment()->functionCallHandler());
115    function.appendArgument(objectId);
116    function.appendArgument(ownProperties);
117
118    RefPtr<InspectorValue> result;
119    makeCall(function, &result);
120    if (!result || result->type() != InspectorValue::TypeArray) {
121        *errorString = ASCIILiteral("Internal error");
122        return;
123    }
124
125    *properties = Array<Inspector::TypeBuilder::Runtime::PropertyDescriptor>::runtimeCast(result);
126}
127
128void InjectedScript::getInternalProperties(ErrorString* errorString, const String& objectId, RefPtr<Array<Inspector::TypeBuilder::Runtime::InternalPropertyDescriptor>>* properties)
129{
130    Deprecated::ScriptFunctionCall function(injectedScriptObject(), ASCIILiteral("getInternalProperties"), inspectorEnvironment()->functionCallHandler());
131    function.appendArgument(objectId);
132
133    RefPtr<InspectorValue> result;
134    makeCall(function, &result);
135    if (!result || result->type() != InspectorValue::TypeArray) {
136        *errorString = ASCIILiteral("Internal error");
137        return;
138    }
139
140    RefPtr<Array<Inspector::TypeBuilder::Runtime::InternalPropertyDescriptor>> array = Array<Inspector::TypeBuilder::Runtime::InternalPropertyDescriptor>::runtimeCast(result);
141    if (array->length() > 0)
142        *properties = array;
143}
144
145PassRefPtr<Array<Inspector::TypeBuilder::Debugger::CallFrame>> InjectedScript::wrapCallFrames(const Deprecated::ScriptValue& callFrames)
146{
147    ASSERT(!hasNoValue());
148    Deprecated::ScriptFunctionCall function(injectedScriptObject(), ASCIILiteral("wrapCallFrames"), inspectorEnvironment()->functionCallHandler());
149    function.appendArgument(callFrames);
150
151    bool hadException = false;
152    Deprecated::ScriptValue callFramesValue = callFunctionWithEvalEnabled(function, hadException);
153    ASSERT(!hadException);
154    RefPtr<InspectorValue> result = callFramesValue.toInspectorValue(scriptState());
155    if (result->type() == InspectorValue::TypeArray)
156        return Array<Inspector::TypeBuilder::Debugger::CallFrame>::runtimeCast(result);
157
158    return Array<Inspector::TypeBuilder::Debugger::CallFrame>::create();
159}
160
161PassRefPtr<Inspector::TypeBuilder::Runtime::RemoteObject> InjectedScript::wrapObject(const Deprecated::ScriptValue& value, const String& groupName, bool generatePreview) const
162{
163    ASSERT(!hasNoValue());
164    Deprecated::ScriptFunctionCall wrapFunction(injectedScriptObject(), ASCIILiteral("wrapObject"), inspectorEnvironment()->functionCallHandler());
165    wrapFunction.appendArgument(value);
166    wrapFunction.appendArgument(groupName);
167    wrapFunction.appendArgument(hasAccessToInspectedScriptState());
168    wrapFunction.appendArgument(generatePreview);
169
170    bool hadException = false;
171    Deprecated::ScriptValue r = callFunctionWithEvalEnabled(wrapFunction, hadException);
172    if (hadException)
173        return nullptr;
174
175    RefPtr<InspectorObject> rawResult = r.toInspectorValue(scriptState())->asObject();
176    return Inspector::TypeBuilder::Runtime::RemoteObject::runtimeCast(rawResult);
177}
178
179PassRefPtr<Inspector::TypeBuilder::Runtime::RemoteObject> InjectedScript::wrapTable(const Deprecated::ScriptValue& table, const Deprecated::ScriptValue& columns) const
180{
181    ASSERT(!hasNoValue());
182    Deprecated::ScriptFunctionCall wrapFunction(injectedScriptObject(), ASCIILiteral("wrapTable"), inspectorEnvironment()->functionCallHandler());
183    wrapFunction.appendArgument(hasAccessToInspectedScriptState());
184    wrapFunction.appendArgument(table);
185    if (columns.hasNoValue())
186        wrapFunction.appendArgument(false);
187    else
188        wrapFunction.appendArgument(columns);
189
190    bool hadException = false;
191    Deprecated::ScriptValue r = callFunctionWithEvalEnabled(wrapFunction, hadException);
192    if (hadException)
193        return nullptr;
194
195    RefPtr<InspectorObject> rawResult = r.toInspectorValue(scriptState())->asObject();
196    return Inspector::TypeBuilder::Runtime::RemoteObject::runtimeCast(rawResult);
197}
198
199Deprecated::ScriptValue InjectedScript::findObjectById(const String& objectId) const
200{
201    ASSERT(!hasNoValue());
202    Deprecated::ScriptFunctionCall function(injectedScriptObject(), ASCIILiteral("findObjectById"), inspectorEnvironment()->functionCallHandler());
203    function.appendArgument(objectId);
204
205    bool hadException = false;
206    Deprecated::ScriptValue resultValue = callFunctionWithEvalEnabled(function, hadException);
207    ASSERT(!hadException);
208
209    return resultValue;
210}
211
212void InjectedScript::inspectObject(Deprecated::ScriptValue value)
213{
214    ASSERT(!hasNoValue());
215    Deprecated::ScriptFunctionCall function(injectedScriptObject(), ASCIILiteral("inspectObject"), inspectorEnvironment()->functionCallHandler());
216    function.appendArgument(value);
217    RefPtr<InspectorValue> result;
218    makeCall(function, &result);
219}
220
221void InjectedScript::releaseObject(const String& objectId)
222{
223    Deprecated::ScriptFunctionCall function(injectedScriptObject(), ASCIILiteral("releaseObject"), inspectorEnvironment()->functionCallHandler());
224    function.appendArgument(objectId);
225    RefPtr<InspectorValue> result;
226    makeCall(function, &result);
227}
228
229void InjectedScript::releaseObjectGroup(const String& objectGroup)
230{
231    ASSERT(!hasNoValue());
232    Deprecated::ScriptFunctionCall releaseFunction(injectedScriptObject(), ASCIILiteral("releaseObjectGroup"), inspectorEnvironment()->functionCallHandler());
233    releaseFunction.appendArgument(objectGroup);
234
235    bool hadException = false;
236    callFunctionWithEvalEnabled(releaseFunction, hadException);
237    ASSERT(!hadException);
238}
239
240} // namespace Inspector
241
242#endif // ENABLE(INSPECTOR)
243