Move WebCore into Source
[WebKit-https.git] / Source / WebCore / bindings / js / ScriptFunctionCall.cpp
1 /*
2  * Copyright (C) 2009 Google Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions are
6  * met:
7  *
8  *     * Redistributions of source code must retain the above copyright
9  * notice, this list of conditions and the following disclaimer.
10  *     * Redistributions in binary form must reproduce the above
11  * copyright notice, this list of conditions and the following disclaimer
12  * in the documentation and/or other materials provided with the
13  * distribution.
14  *     * Neither the name of Google Inc. nor the names of its
15  * contributors may be used to endorse or promote products derived from
16  * this software without specific prior written permission.
17  *
18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
21  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
22  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
23  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
24  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
28  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29  */
30
31 #include "config.h"
32 #include "ScriptFunctionCall.h"
33
34 #include "JSDOMBinding.h"
35 #include "JSMainThreadExecState.h"
36 #include "ScriptValue.h"
37
38 #include <runtime/JSLock.h>
39 #include <runtime/UString.h>
40
41 using namespace JSC;
42
43 namespace WebCore {
44
45 void ScriptCallArgumentHandler::appendArgument(const ScriptObject& argument)
46 {
47     if (argument.scriptState() != m_exec) {
48         ASSERT_NOT_REACHED();
49         return;
50     }
51     m_arguments.append(argument.jsObject());
52 }
53
54 void ScriptCallArgumentHandler::appendArgument(const ScriptValue& argument)
55 {
56     m_arguments.append(argument.jsValue());
57 }
58
59 void ScriptCallArgumentHandler::appendArgument(const String& argument)
60 {
61     JSLock lock(SilenceAssertionsOnly);
62     m_arguments.append(jsString(m_exec, argument));
63 }
64
65 void ScriptCallArgumentHandler::appendArgument(const JSC::UString& argument)
66 {
67     JSLock lock(SilenceAssertionsOnly);
68     m_arguments.append(jsString(m_exec, argument));
69 }
70
71 void ScriptCallArgumentHandler::appendArgument(const char* argument)
72 {
73     JSLock lock(SilenceAssertionsOnly);
74     m_arguments.append(jsString(m_exec, UString(argument)));
75 }
76
77 void ScriptCallArgumentHandler::appendArgument(JSC::JSValue argument)
78 {
79     m_arguments.append(argument);
80 }
81
82 void ScriptCallArgumentHandler::appendArgument(long argument)
83 {
84     JSLock lock(SilenceAssertionsOnly);
85     m_arguments.append(jsNumber(argument));
86 }
87
88 void ScriptCallArgumentHandler::appendArgument(long long argument)
89 {
90     JSLock lock(SilenceAssertionsOnly);
91     m_arguments.append(jsNumber(argument));
92 }
93
94 void ScriptCallArgumentHandler::appendArgument(unsigned int argument)
95 {
96     JSLock lock(SilenceAssertionsOnly);
97     m_arguments.append(jsNumber(argument));
98 }
99
100 void ScriptCallArgumentHandler::appendArgument(unsigned long argument)
101 {
102     JSLock lock(SilenceAssertionsOnly);
103     m_arguments.append(jsNumber(argument));
104 }
105
106 void ScriptCallArgumentHandler::appendArgument(int argument)
107 {
108     JSLock lock(SilenceAssertionsOnly);
109     m_arguments.append(jsNumber(argument));
110 }
111
112 void ScriptCallArgumentHandler::appendArgument(bool argument)
113 {
114     m_arguments.append(jsBoolean(argument));
115 }
116
117 ScriptFunctionCall::ScriptFunctionCall(const ScriptObject& thisObject, const String& name)
118     : ScriptCallArgumentHandler(thisObject.scriptState())
119     , m_thisObject(thisObject)
120     , m_name(name)
121 {
122 }
123
124 ScriptValue ScriptFunctionCall::call(bool& hadException, bool reportExceptions)
125 {
126     JSObject* thisObject = m_thisObject.jsObject();
127
128     JSLock lock(SilenceAssertionsOnly);
129
130     JSValue function = thisObject->get(m_exec, Identifier(m_exec, stringToUString(m_name)));
131     if (m_exec->hadException()) {
132         if (reportExceptions)
133             reportException(m_exec, m_exec->exception());
134
135         hadException = true;
136         return ScriptValue();
137     }
138
139     CallData callData;
140     CallType callType = getCallData(function, callData);
141     if (callType == CallTypeNone)
142         return ScriptValue();
143
144     JSValue result = JSMainThreadExecState::call(m_exec, function, callType, callData, thisObject, m_arguments);
145     if (m_exec->hadException()) {
146         if (reportExceptions)
147             reportException(m_exec, m_exec->exception());
148
149         hadException = true;
150         return ScriptValue();
151     }
152
153     return ScriptValue(result);
154 }
155
156 ScriptValue ScriptFunctionCall::call()
157 {
158     bool hadException = false;
159     return call(hadException);
160 }
161
162 ScriptObject ScriptFunctionCall::construct(bool& hadException, bool reportExceptions)
163 {
164     JSObject* thisObject = m_thisObject.jsObject();
165
166     JSLock lock(SilenceAssertionsOnly);
167
168     JSObject* constructor = asObject(thisObject->get(m_exec, Identifier(m_exec, stringToUString(m_name))));
169     if (m_exec->hadException()) {
170         if (reportExceptions)
171             reportException(m_exec, m_exec->exception());
172
173         hadException = true;
174         return ScriptObject();
175     }
176
177     ConstructData constructData;
178     ConstructType constructType = constructor->getConstructData(constructData);
179     if (constructType == ConstructTypeNone)
180         return ScriptObject();
181
182     JSValue result = JSC::construct(m_exec, constructor, constructType, constructData, m_arguments);
183     if (m_exec->hadException()) {
184         if (reportExceptions)
185             reportException(m_exec, m_exec->exception());
186
187         hadException = true;
188         return ScriptObject();
189     }
190
191     return ScriptObject(m_exec, asObject(result));
192 }
193
194 ScriptCallback::ScriptCallback(ScriptState* state, ScriptValue function)
195     : ScriptCallArgumentHandler(state)
196     , m_function(function)
197 {
198 }
199
200 ScriptValue ScriptCallback::call()
201 {
202     bool hadException;
203     return call(hadException);
204 }
205
206 ScriptValue ScriptCallback::call(bool& hadException)
207 {
208     JSLock lock(SilenceAssertionsOnly);
209
210     CallData callData;
211     CallType callType = getCallData(m_function.jsValue(), callData);
212     if (callType == CallTypeNone)
213         return ScriptValue();
214
215     JSValue result = JSC::call(m_exec, m_function.jsValue(), callType, callData, m_function.jsValue(), m_arguments);
216     hadException = m_exec->hadException();
217
218     if (hadException) {
219         reportException(m_exec, m_exec->exception());
220         return ScriptValue();
221     }
222
223     return ScriptValue(result);
224 }
225
226 } // namespace WebCore