Web Inspector: Expanding event objects in console shows undefined for most values...
[WebKit-https.git] / Source / JavaScriptCore / inspector / InjectedScript.cpp
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
43 using Inspector::Protocol::Array;
44
45 namespace Inspector {
46
47 InjectedScript::InjectedScript()
48     : InjectedScriptBase(ASCIILiteral("InjectedScript"))
49 {
50 }
51
52 InjectedScript::InjectedScript(Deprecated::ScriptObject injectedScriptObject, InspectorEnvironment* environment)
53     : InjectedScriptBase(ASCIILiteral("InjectedScript"), injectedScriptObject, environment)
54 {
55 }
56
57 InjectedScript::~InjectedScript()
58 {
59 }
60
61 void InjectedScript::evaluate(ErrorString& errorString, const String& expression, const String& objectGroup, bool includeCommandLineAPI, bool returnByValue, bool generatePreview, RefPtr<Inspector::Protocol::Runtime::RemoteObject>* result, Inspector::Protocol::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
72 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)
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
83 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<Inspector::Protocol::Runtime::RemoteObject>* result, Inspector::Protocol::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
96 void InjectedScript::getFunctionDetails(ErrorString& errorString, const String& functionId, RefPtr<Inspector::Protocol::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::Type::Object) {
104         if (!resultValue->asString(errorString))
105             errorString = ASCIILiteral("Internal error");
106         return;
107     }
108
109     *result = BindingTraits<Inspector::Protocol::Debugger::FunctionDetails>::runtimeCast(WTF::move(resultValue));
110 }
111
112 void InjectedScript::getProperties(ErrorString& errorString, const String& objectId, bool ownProperties, bool ownAndGetterProperties, RefPtr<Array<Inspector::Protocol::Runtime::PropertyDescriptor>>* properties)
113 {
114     Deprecated::ScriptFunctionCall function(injectedScriptObject(), ASCIILiteral("getProperties"), inspectorEnvironment()->functionCallHandler());
115     function.appendArgument(objectId);
116     function.appendArgument(ownProperties);
117     function.appendArgument(ownAndGetterProperties);
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::getInternalProperties(ErrorString& errorString, const String& objectId, RefPtr<Array<Inspector::Protocol::Runtime::InternalPropertyDescriptor>>* properties)
130 {
131     Deprecated::ScriptFunctionCall function(injectedScriptObject(), ASCIILiteral("getInternalProperties"), inspectorEnvironment()->functionCallHandler());
132     function.appendArgument(objectId);
133
134     RefPtr<InspectorValue> result;
135     makeCall(function, &result);
136     if (!result || result->type() != InspectorValue::Type::Array) {
137         errorString = ASCIILiteral("Internal error");
138         return;
139     }
140
141     auto array = BindingTraits<Array<Inspector::Protocol::Runtime::InternalPropertyDescriptor>>::runtimeCast(WTF::move(result));
142     if (array->length() > 0)
143         *properties = array;
144 }
145
146 Ref<Array<Inspector::Protocol::Debugger::CallFrame>> InjectedScript::wrapCallFrames(const Deprecated::ScriptValue& callFrames)
147 {
148     ASSERT(!hasNoValue());
149     Deprecated::ScriptFunctionCall function(injectedScriptObject(), ASCIILiteral("wrapCallFrames"), inspectorEnvironment()->functionCallHandler());
150     function.appendArgument(callFrames);
151
152     bool hadException = false;
153     Deprecated::ScriptValue callFramesValue = callFunctionWithEvalEnabled(function, hadException);
154     ASSERT(!hadException);
155     RefPtr<InspectorValue> result = callFramesValue.toInspectorValue(scriptState());
156     if (result->type() == InspectorValue::Type::Array)
157         return BindingTraits<Array<Inspector::Protocol::Debugger::CallFrame>>::runtimeCast(WTF::move(result)).releaseNonNull();
158
159     return Array<Inspector::Protocol::Debugger::CallFrame>::create();
160 }
161
162 RefPtr<Inspector::Protocol::Runtime::RemoteObject> InjectedScript::wrapObject(const Deprecated::ScriptValue& value, const String& groupName, bool generatePreview) const
163 {
164     ASSERT(!hasNoValue());
165     Deprecated::ScriptFunctionCall wrapFunction(injectedScriptObject(), ASCIILiteral("wrapObject"), inspectorEnvironment()->functionCallHandler());
166     wrapFunction.appendArgument(value);
167     wrapFunction.appendArgument(groupName);
168     wrapFunction.appendArgument(hasAccessToInspectedScriptState());
169     wrapFunction.appendArgument(generatePreview);
170
171     bool hadException = false;
172     Deprecated::ScriptValue r = callFunctionWithEvalEnabled(wrapFunction, hadException);
173     if (hadException)
174         return nullptr;
175
176     RefPtr<InspectorObject> resultObject;
177     bool castSucceeded = r.toInspectorValue(scriptState())->asObject(resultObject);
178     ASSERT_UNUSED(castSucceeded, castSucceeded);
179
180     return BindingTraits<Inspector::Protocol::Runtime::RemoteObject>::runtimeCast(resultObject);
181 }
182
183 RefPtr<Inspector::Protocol::Runtime::RemoteObject> InjectedScript::wrapTable(const Deprecated::ScriptValue& table, const Deprecated::ScriptValue& columns) const
184 {
185     ASSERT(!hasNoValue());
186     Deprecated::ScriptFunctionCall wrapFunction(injectedScriptObject(), ASCIILiteral("wrapTable"), inspectorEnvironment()->functionCallHandler());
187     wrapFunction.appendArgument(hasAccessToInspectedScriptState());
188     wrapFunction.appendArgument(table);
189     if (columns.hasNoValue())
190         wrapFunction.appendArgument(false);
191     else
192         wrapFunction.appendArgument(columns);
193
194     bool hadException = false;
195     Deprecated::ScriptValue r = callFunctionWithEvalEnabled(wrapFunction, hadException);
196     if (hadException)
197         return nullptr;
198
199     RefPtr<InspectorObject> resultObject;
200     bool castSucceeded = r.toInspectorValue(scriptState())->asObject(resultObject);
201     ASSERT_UNUSED(castSucceeded, castSucceeded);
202
203     return BindingTraits<Inspector::Protocol::Runtime::RemoteObject>::runtimeCast(resultObject);
204 }
205
206 void InjectedScript::setExceptionValue(const Deprecated::ScriptValue& value)
207 {
208     ASSERT(!hasNoValue());
209     Deprecated::ScriptFunctionCall function(injectedScriptObject(), ASCIILiteral("setExceptionValue"), inspectorEnvironment()->functionCallHandler());
210     function.appendArgument(value);
211     RefPtr<InspectorValue> result;
212     makeCall(function, &result);
213 }
214
215 void InjectedScript::clearExceptionValue()
216 {
217     ASSERT(!hasNoValue());
218     Deprecated::ScriptFunctionCall function(injectedScriptObject(), ASCIILiteral("clearExceptionValue"), inspectorEnvironment()->functionCallHandler());
219     RefPtr<InspectorValue> result;
220     makeCall(function, &result);
221 }
222
223 Deprecated::ScriptValue InjectedScript::findObjectById(const String& objectId) const
224 {
225     ASSERT(!hasNoValue());
226     Deprecated::ScriptFunctionCall function(injectedScriptObject(), ASCIILiteral("findObjectById"), inspectorEnvironment()->functionCallHandler());
227     function.appendArgument(objectId);
228
229     bool hadException = false;
230     Deprecated::ScriptValue resultValue = callFunctionWithEvalEnabled(function, hadException);
231     ASSERT(!hadException);
232
233     return resultValue;
234 }
235
236 void InjectedScript::inspectObject(Deprecated::ScriptValue value)
237 {
238     ASSERT(!hasNoValue());
239     Deprecated::ScriptFunctionCall function(injectedScriptObject(), ASCIILiteral("inspectObject"), inspectorEnvironment()->functionCallHandler());
240     function.appendArgument(value);
241     RefPtr<InspectorValue> result;
242     makeCall(function, &result);
243 }
244
245 void InjectedScript::releaseObject(const String& objectId)
246 {
247     Deprecated::ScriptFunctionCall function(injectedScriptObject(), ASCIILiteral("releaseObject"), inspectorEnvironment()->functionCallHandler());
248     function.appendArgument(objectId);
249     RefPtr<InspectorValue> result;
250     makeCall(function, &result);
251 }
252
253 void InjectedScript::releaseObjectGroup(const String& objectGroup)
254 {
255     ASSERT(!hasNoValue());
256     Deprecated::ScriptFunctionCall releaseFunction(injectedScriptObject(), ASCIILiteral("releaseObjectGroup"), inspectorEnvironment()->functionCallHandler());
257     releaseFunction.appendArgument(objectGroup);
258
259     bool hadException = false;
260     callFunctionWithEvalEnabled(releaseFunction, hadException);
261     ASSERT(!hadException);
262 }
263
264 } // namespace Inspector
265
266 #endif // ENABLE(INSPECTOR)