Rename ExceptionCode-based exception handling to "legacy"
[WebKit-https.git] / Source / WebCore / bindings / scripts / test / JS / JSTestCallback.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 "JSTestCallback.h"
26
27 #include "JSDOMConstructor.h"
28 #include "JSDOMStringList.h"
29 #include "JSTestNode.h"
30 #include "ScriptExecutionContext.h"
31 #include "SerializedScriptValue.h"
32 #include "URL.h"
33 #include <runtime/JSLock.h>
34 #include <runtime/JSString.h>
35 #include <runtime/ObjectPrototype.h>
36
37 using namespace JSC;
38
39 namespace WebCore {
40
41 JSTestCallback::JSTestCallback(JSObject* callback, JSDOMGlobalObject* globalObject)
42     : TestCallback()
43     , ActiveDOMCallback(globalObject->scriptExecutionContext())
44     , m_data(new JSCallbackDataStrong(callback, this))
45 {
46 }
47
48 JSTestCallback::~JSTestCallback()
49 {
50     ScriptExecutionContext* context = scriptExecutionContext();
51     // When the context is destroyed, all tasks with a reference to a callback
52     // should be deleted. So if the context is 0, we are on the context thread.
53     if (!context || context->isContextThread())
54         delete m_data;
55     else
56         context->postTask(DeleteCallbackDataTask(m_data));
57 #ifndef NDEBUG
58     m_data = nullptr;
59 #endif
60 }
61
62 using JSTestCallbackConstructor = JSDOMConstructorNotConstructable<JSTestCallback>;
63
64 /* Hash table for constructor */
65
66 static const HashTableValue JSTestCallbackConstructorTableValues[] =
67 {
68     { "CONSTANT1", DontDelete | ReadOnly | ConstantInteger, NoIntrinsic, { (long long)(1) } },
69     { "CONSTANT2", DontDelete | ReadOnly | ConstantInteger, NoIntrinsic, { (long long)(2) } },
70 };
71
72 static_assert(TestCallback::CONSTANT1 == 1, "CONSTANT1 in TestCallback does not match value from IDL");
73 static_assert(TestCallback::CONSTANT2 == 2, "CONSTANT2 in TestCallback does not match value from IDL");
74
75 template<> JSValue JSTestCallbackConstructor::prototypeForStructure(JSC::VM& vm, const JSDOMGlobalObject& globalObject)
76 {
77     UNUSED_PARAM(vm);
78     return globalObject.objectPrototype();
79 }
80
81 template<> void JSTestCallbackConstructor::initializeProperties(VM& vm, JSDOMGlobalObject& globalObject)
82 {
83     UNUSED_PARAM(globalObject);
84     putDirect(vm, vm.propertyNames->name, jsNontrivialString(&vm, String(ASCIILiteral("TestCallback"))), ReadOnly | DontEnum);
85     putDirect(vm, vm.propertyNames->length, jsNumber(0), ReadOnly | DontEnum);
86     reifyStaticProperties(vm, JSTestCallbackConstructorTableValues, *this);
87 }
88
89 template<> const ClassInfo JSTestCallbackConstructor::s_info = { "TestCallback", &Base::s_info, 0, CREATE_METHOD_TABLE(JSTestCallbackConstructor) };
90
91 JSValue JSTestCallback::getConstructor(VM& vm, const JSGlobalObject* globalObject)
92 {
93     return getDOMConstructor<JSTestCallbackConstructor>(vm, *jsCast<const JSDOMGlobalObject*>(globalObject));
94 }
95
96
97 // Functions
98
99 bool JSTestCallback::callbackWithNoParam()
100 {
101     if (!canInvokeCallback())
102         return true;
103
104     Ref<JSTestCallback> protectedThis(*this);
105
106     JSLockHolder lock(m_data->globalObject()->vm());
107
108     ExecState* state = m_data->globalObject()->globalExec();
109     MarkedArgumentBuffer args;
110
111     NakedPtr<JSC::Exception> returnedException;
112     m_data->invokeCallback(args, JSCallbackData::CallbackType::Object, Identifier::fromString(state, "callbackWithNoParam"), returnedException);
113     if (returnedException)
114         reportException(state, returnedException);
115     return !returnedException;
116 }
117
118 bool JSTestCallback::callbackWithArrayParam(RefPtr<Float32Array> arrayParam)
119 {
120     if (!canInvokeCallback())
121         return true;
122
123     Ref<JSTestCallback> protectedThis(*this);
124
125     JSLockHolder lock(m_data->globalObject()->vm());
126
127     ExecState* state = m_data->globalObject()->globalExec();
128     MarkedArgumentBuffer args;
129     args.append(toJS(state, m_data->globalObject(), arrayParam));
130
131     NakedPtr<JSC::Exception> returnedException;
132     m_data->invokeCallback(args, JSCallbackData::CallbackType::Object, Identifier::fromString(state, "callbackWithArrayParam"), returnedException);
133     if (returnedException)
134         reportException(state, returnedException);
135     return !returnedException;
136 }
137
138 bool JSTestCallback::callbackWithSerializedScriptValueParam(RefPtr<SerializedScriptValue>&& srzParam, const String& strArg)
139 {
140     if (!canInvokeCallback())
141         return true;
142
143     Ref<JSTestCallback> protectedThis(*this);
144
145     JSLockHolder lock(m_data->globalObject()->vm());
146
147     ExecState* state = m_data->globalObject()->globalExec();
148     MarkedArgumentBuffer args;
149     args.append(srzParam ? srzParam->deserialize(state, m_data->globalObject(), 0) : jsNull());
150     args.append(jsStringWithCache(state, strArg));
151
152     NakedPtr<JSC::Exception> returnedException;
153     m_data->invokeCallback(args, JSCallbackData::CallbackType::Object, Identifier::fromString(state, "callbackWithSerializedScriptValueParam"), returnedException);
154     if (returnedException)
155         reportException(state, returnedException);
156     return !returnedException;
157 }
158
159 bool JSTestCallback::callbackWithStringList(DOMStringList* listParam)
160 {
161     if (!canInvokeCallback())
162         return true;
163
164     Ref<JSTestCallback> protectedThis(*this);
165
166     JSLockHolder lock(m_data->globalObject()->vm());
167
168     ExecState* state = m_data->globalObject()->globalExec();
169     MarkedArgumentBuffer args;
170     args.append(toJS(state, m_data->globalObject(), listParam));
171
172     NakedPtr<JSC::Exception> returnedException;
173     m_data->invokeCallback(args, JSCallbackData::CallbackType::Object, Identifier::fromString(state, "callbackWithStringList"), returnedException);
174     if (returnedException)
175         reportException(state, returnedException);
176     return !returnedException;
177 }
178
179 bool JSTestCallback::callbackWithBoolean(bool boolParam)
180 {
181     if (!canInvokeCallback())
182         return true;
183
184     Ref<JSTestCallback> protectedThis(*this);
185
186     JSLockHolder lock(m_data->globalObject()->vm());
187
188     ExecState* state = m_data->globalObject()->globalExec();
189     MarkedArgumentBuffer args;
190     args.append(jsBoolean(boolParam));
191
192     NakedPtr<JSC::Exception> returnedException;
193     m_data->invokeCallback(args, JSCallbackData::CallbackType::Object, Identifier::fromString(state, "callbackWithBoolean"), returnedException);
194     if (returnedException)
195         reportException(state, returnedException);
196     return !returnedException;
197 }
198
199 bool JSTestCallback::callbackRequiresThisToPass(int32_t longParam, TestNode* testNodeParam)
200 {
201     if (!canInvokeCallback())
202         return true;
203
204     Ref<JSTestCallback> protectedThis(*this);
205
206     JSLockHolder lock(m_data->globalObject()->vm());
207
208     ExecState* state = m_data->globalObject()->globalExec();
209     MarkedArgumentBuffer args;
210     args.append(jsNumber(longParam));
211     args.append(toJS(state, m_data->globalObject(), testNodeParam));
212
213     NakedPtr<JSC::Exception> returnedException;
214     m_data->invokeCallback(args, JSCallbackData::CallbackType::Object, Identifier::fromString(state, "callbackRequiresThisToPass"), returnedException);
215     if (returnedException)
216         reportException(state, returnedException);
217     return !returnedException;
218 }
219
220 JSC::JSValue toJS(JSC::ExecState*, JSDOMGlobalObject*, TestCallback& impl)
221 {
222     if (!static_cast<JSTestCallback&>(impl).callbackData())
223         return jsNull();
224
225     return static_cast<JSTestCallback&>(impl).callbackData()->callback();
226
227 }
228
229 }
230
231 #endif // ENABLE(SPEECH_SYNTHESIS)