Rename ExceptionCode-based exception handling to "legacy"
[WebKit-https.git] / Source / WebCore / bindings / scripts / test / JS / JSTestCallbackFunction.cpp
1 /*
2     This file is part of the WebKit open source project.
3     This file has been generated by generate-bindings.pl. DO NOT MODIFY!
4
5     This library is free software; you can redistribute it and/or
6     modify it under the terms of the GNU Library General Public
7     License as published by the Free Software Foundation; either
8     version 2 of the License, or (at your option) any later version.
9
10     This library is distributed in the hope that it will be useful,
11     but WITHOUT ANY WARRANTY; without even the implied warranty of
12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13     Library General Public License for more details.
14
15     You should have received a copy of the GNU Library General Public License
16     along with this library; see the file COPYING.LIB.  If not, write to
17     the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
18     Boston, MA 02110-1301, USA.
19 */
20
21 #include "config.h"
22
23 #if ENABLE(SPEECH_SYNTHESIS)
24
25 #include "JSTestCallbackFunction.h"
26
27 #include "JSDOMStringList.h"
28 #include "JSTestNode.h"
29 #include "ScriptExecutionContext.h"
30 #include "SerializedScriptValue.h"
31 #include "URL.h"
32 #include <runtime/JSLock.h>
33 #include <runtime/JSString.h>
34
35 using namespace JSC;
36
37 namespace WebCore {
38
39 JSTestCallbackFunction::JSTestCallbackFunction(JSObject* callback, JSDOMGlobalObject* globalObject)
40     : TestCallbackFunction()
41     , ActiveDOMCallback(globalObject->scriptExecutionContext())
42     , m_data(new JSCallbackDataStrong(callback, this))
43 {
44 }
45
46 JSTestCallbackFunction::~JSTestCallbackFunction()
47 {
48     ScriptExecutionContext* context = scriptExecutionContext();
49     // When the context is destroyed, all tasks with a reference to a callback
50     // should be deleted. So if the context is 0, we are on the context thread.
51     if (!context || context->isContextThread())
52         delete m_data;
53     else
54         context->postTask(DeleteCallbackDataTask(m_data));
55 #ifndef NDEBUG
56     m_data = nullptr;
57 #endif
58 }
59
60
61 // Functions
62
63 bool JSTestCallbackFunction::callbackWithNoParam()
64 {
65     if (!canInvokeCallback())
66         return true;
67
68     Ref<JSTestCallbackFunction> protectedThis(*this);
69
70     JSLockHolder lock(m_data->globalObject()->vm());
71
72     ExecState* state = m_data->globalObject()->globalExec();
73     MarkedArgumentBuffer args;
74
75     NakedPtr<JSC::Exception> returnedException;
76     UNUSED_PARAM(state);
77     m_data->invokeCallback(args, JSCallbackData::CallbackType::Function, Identifier(), returnedException);
78     if (returnedException)
79         reportException(state, returnedException);
80     return !returnedException;
81 }
82
83 bool JSTestCallbackFunction::callbackWithArrayParam(RefPtr<Float32Array> arrayParam)
84 {
85     if (!canInvokeCallback())
86         return true;
87
88     Ref<JSTestCallbackFunction> protectedThis(*this);
89
90     JSLockHolder lock(m_data->globalObject()->vm());
91
92     ExecState* state = m_data->globalObject()->globalExec();
93     MarkedArgumentBuffer args;
94     args.append(toJS(state, m_data->globalObject(), arrayParam));
95
96     NakedPtr<JSC::Exception> returnedException;
97     UNUSED_PARAM(state);
98     m_data->invokeCallback(args, JSCallbackData::CallbackType::Function, Identifier(), returnedException);
99     if (returnedException)
100         reportException(state, returnedException);
101     return !returnedException;
102 }
103
104 bool JSTestCallbackFunction::callbackWithSerializedScriptValueParam(RefPtr<SerializedScriptValue>&& srzParam, const String& strArg)
105 {
106     if (!canInvokeCallback())
107         return true;
108
109     Ref<JSTestCallbackFunction> protectedThis(*this);
110
111     JSLockHolder lock(m_data->globalObject()->vm());
112
113     ExecState* state = m_data->globalObject()->globalExec();
114     MarkedArgumentBuffer args;
115     args.append(srzParam ? srzParam->deserialize(state, m_data->globalObject(), 0) : jsNull());
116     args.append(jsStringWithCache(state, strArg));
117
118     NakedPtr<JSC::Exception> returnedException;
119     UNUSED_PARAM(state);
120     m_data->invokeCallback(args, JSCallbackData::CallbackType::Function, Identifier(), returnedException);
121     if (returnedException)
122         reportException(state, returnedException);
123     return !returnedException;
124 }
125
126 bool JSTestCallbackFunction::callbackWithStringList(DOMStringList* listParam)
127 {
128     if (!canInvokeCallback())
129         return true;
130
131     Ref<JSTestCallbackFunction> protectedThis(*this);
132
133     JSLockHolder lock(m_data->globalObject()->vm());
134
135     ExecState* state = m_data->globalObject()->globalExec();
136     MarkedArgumentBuffer args;
137     args.append(toJS(state, m_data->globalObject(), listParam));
138
139     NakedPtr<JSC::Exception> returnedException;
140     UNUSED_PARAM(state);
141     m_data->invokeCallback(args, JSCallbackData::CallbackType::Function, Identifier(), returnedException);
142     if (returnedException)
143         reportException(state, returnedException);
144     return !returnedException;
145 }
146
147 bool JSTestCallbackFunction::callbackWithBoolean(bool boolParam)
148 {
149     if (!canInvokeCallback())
150         return true;
151
152     Ref<JSTestCallbackFunction> protectedThis(*this);
153
154     JSLockHolder lock(m_data->globalObject()->vm());
155
156     ExecState* state = m_data->globalObject()->globalExec();
157     MarkedArgumentBuffer args;
158     args.append(jsBoolean(boolParam));
159
160     NakedPtr<JSC::Exception> returnedException;
161     UNUSED_PARAM(state);
162     m_data->invokeCallback(args, JSCallbackData::CallbackType::Function, Identifier(), returnedException);
163     if (returnedException)
164         reportException(state, returnedException);
165     return !returnedException;
166 }
167
168 bool JSTestCallbackFunction::callbackRequiresThisToPass(int32_t longParam, TestNode* testNodeParam)
169 {
170     if (!canInvokeCallback())
171         return true;
172
173     Ref<JSTestCallbackFunction> protectedThis(*this);
174
175     JSLockHolder lock(m_data->globalObject()->vm());
176
177     ExecState* state = m_data->globalObject()->globalExec();
178     MarkedArgumentBuffer args;
179     args.append(jsNumber(longParam));
180     args.append(toJS(state, m_data->globalObject(), testNodeParam));
181
182     NakedPtr<JSC::Exception> returnedException;
183     UNUSED_PARAM(state);
184     m_data->invokeCallback(args, JSCallbackData::CallbackType::Function, Identifier(), returnedException);
185     if (returnedException)
186         reportException(state, returnedException);
187     return !returnedException;
188 }
189
190 JSC::JSValue toJS(JSC::ExecState*, JSDOMGlobalObject*, TestCallbackFunction& impl)
191 {
192     if (!static_cast<JSTestCallbackFunction&>(impl).callbackData())
193         return jsNull();
194
195     return static_cast<JSTestCallbackFunction&>(impl).callbackData()->callback();
196
197 }
198
199 }
200
201 #endif // ENABLE(SPEECH_SYNTHESIS)