[WebIDL] Remove some unnecessary specialization for enum types
[WebKit.git] / Source / WebCore / bindings / scripts / test / JS / JSTestCallbackInterface.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(TEST_CONDITIONAL)
24
25 #include "JSTestCallbackInterface.h"
26
27 #include "JSDOMConstructorNotConstructable.h"
28 #include "JSDOMExceptionHandling.h"
29 #include "JSDOMStringList.h"
30 #include "JSTestNode.h"
31 #include "ScriptExecutionContext.h"
32 #include "SerializedScriptValue.h"
33 #include <runtime/FunctionPrototype.h>
34 #include <runtime/JSLock.h>
35 #include <runtime/JSString.h>
36 #include <wtf/NeverDestroyed.h>
37
38 using namespace JSC;
39
40 namespace WebCore {
41
42 template<> JSString* convertEnumerationToJS(ExecState& state, TestCallbackInterface::Enum enumerationValue)
43 {
44     static NeverDestroyed<const String> values[] = {
45         ASCIILiteral("value1"),
46         ASCIILiteral("value2"),
47     };
48     static_assert(static_cast<size_t>(TestCallbackInterface::Enum::Value1) == 0, "TestCallbackInterface::Enum::Value1 is not 0 as expected");
49     static_assert(static_cast<size_t>(TestCallbackInterface::Enum::Value2) == 1, "TestCallbackInterface::Enum::Value2 is not 1 as expected");
50     ASSERT(static_cast<size_t>(enumerationValue) < WTF_ARRAY_LENGTH(values));
51     return jsStringWithCache(&state, values[static_cast<size_t>(enumerationValue)]);
52 }
53
54 template<> std::optional<TestCallbackInterface::Enum> parseEnumeration<TestCallbackInterface::Enum>(ExecState& state, JSValue value)
55 {
56     auto stringValue = value.toWTFString(&state);
57     if (stringValue == "value1")
58         return TestCallbackInterface::Enum::Value1;
59     if (stringValue == "value2")
60         return TestCallbackInterface::Enum::Value2;
61     return std::nullopt;
62 }
63
64 template<> const char* expectedEnumerationValues<TestCallbackInterface::Enum>()
65 {
66     return "\"value1\", \"value2\"";
67 }
68
69 template<> TestCallbackInterface::Dictionary convertDictionary<TestCallbackInterface::Dictionary>(ExecState& state, JSValue value)
70 {
71     VM& vm = state.vm();
72     auto throwScope = DECLARE_THROW_SCOPE(vm);
73     bool isNullOrUndefined = value.isUndefinedOrNull();
74     auto* object = isNullOrUndefined ? nullptr : value.getObject();
75     if (UNLIKELY(!isNullOrUndefined && !object)) {
76         throwTypeError(&state, throwScope);
77         return { };
78     }
79     if (UNLIKELY(object && object->type() == RegExpObjectType)) {
80         throwTypeError(&state, throwScope);
81         return { };
82     }
83     TestCallbackInterface::Dictionary result;
84     JSValue optionalMemberValue = isNullOrUndefined ? jsUndefined() : object->get(&state, Identifier::fromString(&state, "optionalMember"));
85     if (!optionalMemberValue.isUndefined()) {
86         result.optionalMember = convert<IDLLong>(state, optionalMemberValue);
87         RETURN_IF_EXCEPTION(throwScope, { });
88     }
89     JSValue requiredMemberValue = isNullOrUndefined ? jsUndefined() : object->get(&state, Identifier::fromString(&state, "requiredMember"));
90     if (!requiredMemberValue.isUndefined()) {
91         result.requiredMember = convert<IDLUSVString>(state, requiredMemberValue);
92         RETURN_IF_EXCEPTION(throwScope, { });
93     } else {
94         throwRequiredMemberTypeError(state, throwScope, "requiredMember", "TestCallbackInterfaceDictionary", "USVString");
95         return { };
96     }
97     return result;
98 }
99
100 JSTestCallbackInterface::JSTestCallbackInterface(JSObject* callback, JSDOMGlobalObject* globalObject)
101     : TestCallbackInterface()
102     , ActiveDOMCallback(globalObject->scriptExecutionContext())
103     , m_data(new JSCallbackDataStrong(callback, globalObject, this))
104 {
105 }
106
107 JSTestCallbackInterface::~JSTestCallbackInterface()
108 {
109     ScriptExecutionContext* context = scriptExecutionContext();
110     // When the context is destroyed, all tasks with a reference to a callback
111     // should be deleted. So if the context is 0, we are on the context thread.
112     if (!context || context->isContextThread())
113         delete m_data;
114     else
115         context->postTask(DeleteCallbackDataTask(m_data));
116 #ifndef NDEBUG
117     m_data = nullptr;
118 #endif
119 }
120
121 using JSTestCallbackInterfaceConstructor = JSDOMConstructorNotConstructable<JSTestCallbackInterface>;
122
123 /* Hash table for constructor */
124
125 static const HashTableValue JSTestCallbackInterfaceConstructorTableValues[] =
126 {
127     { "CONSTANT1", DontDelete | ReadOnly | ConstantInteger, NoIntrinsic, { (long long)(1) } },
128     { "CONSTANT2", DontDelete | ReadOnly | ConstantInteger, NoIntrinsic, { (long long)(2) } },
129 };
130
131 static_assert(TestCallbackInterface::CONSTANT1 == 1, "CONSTANT1 in TestCallbackInterface does not match value from IDL");
132 static_assert(TestCallbackInterface::CONSTANT2 == 2, "CONSTANT2 in TestCallbackInterface does not match value from IDL");
133
134 template<> JSValue JSTestCallbackInterfaceConstructor::prototypeForStructure(JSC::VM& vm, const JSDOMGlobalObject& globalObject)
135 {
136     UNUSED_PARAM(vm);
137     return globalObject.functionPrototype();
138 }
139
140 template<> void JSTestCallbackInterfaceConstructor::initializeProperties(VM& vm, JSDOMGlobalObject& globalObject)
141 {
142     UNUSED_PARAM(globalObject);
143     putDirect(vm, vm.propertyNames->name, jsNontrivialString(&vm, String(ASCIILiteral("TestCallbackInterface"))), ReadOnly | DontEnum);
144     putDirect(vm, vm.propertyNames->length, jsNumber(0), ReadOnly | DontEnum);
145     reifyStaticProperties(vm, JSTestCallbackInterfaceConstructorTableValues, *this);
146 }
147
148 template<> const ClassInfo JSTestCallbackInterfaceConstructor::s_info = { "TestCallbackInterface", &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSTestCallbackInterfaceConstructor) };
149
150 JSValue JSTestCallbackInterface::getConstructor(VM& vm, const JSGlobalObject* globalObject)
151 {
152     return getDOMConstructor<JSTestCallbackInterfaceConstructor>(vm, *jsCast<const JSDOMGlobalObject*>(globalObject));
153 }
154
155 CallbackResult<typename IDLVoid::ImplementationType> JSTestCallbackInterface::callbackWithNoParam()
156 {
157     if (!canInvokeCallback())
158         return CallbackResultType::UnableToExecute;
159
160     Ref<JSTestCallbackInterface> protectedThis(*this);
161
162     auto& globalObject = *m_data->globalObject();
163     auto& vm = globalObject.vm();
164
165     JSLockHolder lock(vm);
166     auto& state = *globalObject.globalExec();
167     MarkedArgumentBuffer args;
168
169     NakedPtr<JSC::Exception> returnedException;
170     m_data->invokeCallback(args, JSCallbackData::CallbackType::Object, Identifier::fromString(&vm, "callbackWithNoParam"), returnedException);
171     if (returnedException) {
172         reportException(&state, returnedException);
173         return CallbackResultType::ExceptionThrown;
174      }
175
176     return { };
177 }
178
179 CallbackResult<typename IDLVoid::ImplementationType> JSTestCallbackInterface::callbackWithArrayParam(typename IDLInterface<Float32Array>::ParameterType arrayParam)
180 {
181     if (!canInvokeCallback())
182         return CallbackResultType::UnableToExecute;
183
184     Ref<JSTestCallbackInterface> protectedThis(*this);
185
186     auto& globalObject = *m_data->globalObject();
187     auto& vm = globalObject.vm();
188
189     JSLockHolder lock(vm);
190     auto& state = *globalObject.globalExec();
191     MarkedArgumentBuffer args;
192     args.append(toJS<IDLInterface<Float32Array>>(state, globalObject, arrayParam));
193
194     NakedPtr<JSC::Exception> returnedException;
195     m_data->invokeCallback(args, JSCallbackData::CallbackType::Object, Identifier::fromString(&vm, "callbackWithArrayParam"), returnedException);
196     if (returnedException) {
197         reportException(&state, returnedException);
198         return CallbackResultType::ExceptionThrown;
199      }
200
201     return { };
202 }
203
204 CallbackResult<typename IDLVoid::ImplementationType> JSTestCallbackInterface::callbackWithSerializedScriptValueParam(typename IDLSerializedScriptValue<SerializedScriptValue>::ParameterType srzParam, typename IDLDOMString::ParameterType strParam)
205 {
206     if (!canInvokeCallback())
207         return CallbackResultType::UnableToExecute;
208
209     Ref<JSTestCallbackInterface> protectedThis(*this);
210
211     auto& globalObject = *m_data->globalObject();
212     auto& vm = globalObject.vm();
213
214     JSLockHolder lock(vm);
215     auto& state = *globalObject.globalExec();
216     MarkedArgumentBuffer args;
217     args.append(toJS<IDLSerializedScriptValue<SerializedScriptValue>>(state, globalObject, srzParam));
218     args.append(toJS<IDLDOMString>(state, strParam));
219
220     NakedPtr<JSC::Exception> returnedException;
221     m_data->invokeCallback(args, JSCallbackData::CallbackType::Object, Identifier::fromString(&vm, "callbackWithSerializedScriptValueParam"), returnedException);
222     if (returnedException) {
223         reportException(&state, returnedException);
224         return CallbackResultType::ExceptionThrown;
225      }
226
227     return { };
228 }
229
230 CallbackResult<typename IDLVoid::ImplementationType> JSTestCallbackInterface::callbackWithStringList(typename IDLInterface<DOMStringList>::ParameterType listParam)
231 {
232     if (!canInvokeCallback())
233         return CallbackResultType::UnableToExecute;
234
235     Ref<JSTestCallbackInterface> protectedThis(*this);
236
237     auto& globalObject = *m_data->globalObject();
238     auto& vm = globalObject.vm();
239
240     JSLockHolder lock(vm);
241     auto& state = *globalObject.globalExec();
242     MarkedArgumentBuffer args;
243     args.append(toJS<IDLInterface<DOMStringList>>(state, globalObject, listParam));
244
245     NakedPtr<JSC::Exception> returnedException;
246     m_data->invokeCallback(args, JSCallbackData::CallbackType::Object, Identifier::fromString(&vm, "callbackWithStringList"), returnedException);
247     if (returnedException) {
248         reportException(&state, returnedException);
249         return CallbackResultType::ExceptionThrown;
250      }
251
252     return { };
253 }
254
255 CallbackResult<typename IDLVoid::ImplementationType> JSTestCallbackInterface::callbackWithBoolean(typename IDLBoolean::ParameterType boolParam)
256 {
257     if (!canInvokeCallback())
258         return CallbackResultType::UnableToExecute;
259
260     Ref<JSTestCallbackInterface> protectedThis(*this);
261
262     auto& globalObject = *m_data->globalObject();
263     auto& vm = globalObject.vm();
264
265     JSLockHolder lock(vm);
266     auto& state = *globalObject.globalExec();
267     MarkedArgumentBuffer args;
268     args.append(toJS<IDLBoolean>(boolParam));
269
270     NakedPtr<JSC::Exception> returnedException;
271     m_data->invokeCallback(args, JSCallbackData::CallbackType::Object, Identifier::fromString(&vm, "callbackWithBoolean"), returnedException);
272     if (returnedException) {
273         reportException(&state, returnedException);
274         return CallbackResultType::ExceptionThrown;
275      }
276
277     return { };
278 }
279
280 CallbackResult<typename IDLVoid::ImplementationType> JSTestCallbackInterface::callbackRequiresThisToPass(typename IDLLong::ParameterType longParam, typename IDLInterface<TestNode>::ParameterType testNodeParam)
281 {
282     if (!canInvokeCallback())
283         return CallbackResultType::UnableToExecute;
284
285     Ref<JSTestCallbackInterface> protectedThis(*this);
286
287     auto& globalObject = *m_data->globalObject();
288     auto& vm = globalObject.vm();
289
290     JSLockHolder lock(vm);
291     auto& state = *globalObject.globalExec();
292     MarkedArgumentBuffer args;
293     args.append(toJS<IDLLong>(longParam));
294     args.append(toJS<IDLInterface<TestNode>>(state, globalObject, testNodeParam));
295
296     NakedPtr<JSC::Exception> returnedException;
297     m_data->invokeCallback(args, JSCallbackData::CallbackType::Object, Identifier::fromString(&vm, "callbackRequiresThisToPass"), returnedException);
298     if (returnedException) {
299         reportException(&state, returnedException);
300         return CallbackResultType::ExceptionThrown;
301      }
302
303     return { };
304 }
305
306 CallbackResult<typename IDLDOMString::ImplementationType> JSTestCallbackInterface::callbackWithAReturnValue()
307 {
308     if (!canInvokeCallback())
309         return CallbackResultType::UnableToExecute;
310
311     Ref<JSTestCallbackInterface> protectedThis(*this);
312
313     auto& globalObject = *m_data->globalObject();
314     auto& vm = globalObject.vm();
315
316     JSLockHolder lock(vm);
317     auto& state = *globalObject.globalExec();
318     MarkedArgumentBuffer args;
319
320     NakedPtr<JSC::Exception> returnedException;
321     auto jsResult = m_data->invokeCallback(args, JSCallbackData::CallbackType::Object, Identifier::fromString(&vm, "callbackWithAReturnValue"), returnedException);
322     if (returnedException) {
323         reportException(&state, returnedException);
324         return CallbackResultType::ExceptionThrown;
325      }
326
327     auto throwScope = DECLARE_THROW_SCOPE(vm);
328     auto returnValue = convert<IDLDOMString>(state, jsResult);
329     RETURN_IF_EXCEPTION(throwScope, CallbackResultType::ExceptionThrown);
330     return WTFMove(returnValue);
331 }
332
333 CallbackResult<typename IDLDOMString::ImplementationType> JSTestCallbackInterface::callbackThatRethrowsExceptions(typename IDLEnumeration<TestCallbackInterface::Enum>::ParameterType enumParam)
334 {
335     if (!canInvokeCallback())
336         return CallbackResultType::UnableToExecute;
337
338     Ref<JSTestCallbackInterface> protectedThis(*this);
339
340     auto& globalObject = *m_data->globalObject();
341     auto& vm = globalObject.vm();
342
343     JSLockHolder lock(vm);
344     auto& state = *globalObject.globalExec();
345     MarkedArgumentBuffer args;
346     args.append(toJS<IDLEnumeration<TestCallbackInterface::Enum>>(state, enumParam));
347
348     NakedPtr<JSC::Exception> returnedException;
349     auto jsResult = m_data->invokeCallback(args, JSCallbackData::CallbackType::Object, Identifier::fromString(&vm, "callbackThatRethrowsExceptions"), returnedException);
350     if (returnedException) {
351         auto throwScope = DECLARE_THROW_SCOPE(vm);
352         throwException(&state, throwScope, returnedException);
353         return CallbackResultType::ExceptionThrown;
354      }
355
356     auto throwScope = DECLARE_THROW_SCOPE(vm);
357     auto returnValue = convert<IDLDOMString>(state, jsResult);
358     RETURN_IF_EXCEPTION(throwScope, CallbackResultType::ExceptionThrown);
359     return WTFMove(returnValue);
360 }
361
362 CallbackResult<typename IDLDOMString::ImplementationType> JSTestCallbackInterface::callbackThatSkipsInvokeCheck(typename IDLDictionary<TestCallbackInterface::Dictionary>::ParameterType dictionaryParam)
363 {
364     Ref<JSTestCallbackInterface> protectedThis(*this);
365
366     auto& globalObject = *m_data->globalObject();
367     auto& vm = globalObject.vm();
368
369     JSLockHolder lock(vm);
370     auto& state = *globalObject.globalExec();
371     MarkedArgumentBuffer args;
372     args.append(toJS<IDLDictionary<TestCallbackInterface::Dictionary>>(state, globalObject, dictionaryParam));
373
374     NakedPtr<JSC::Exception> returnedException;
375     auto jsResult = m_data->invokeCallback(args, JSCallbackData::CallbackType::Object, Identifier::fromString(&vm, "callbackThatSkipsInvokeCheck"), returnedException);
376     if (returnedException) {
377         reportException(&state, returnedException);
378         return CallbackResultType::ExceptionThrown;
379      }
380
381     auto throwScope = DECLARE_THROW_SCOPE(vm);
382     auto returnValue = convert<IDLDOMString>(state, jsResult);
383     RETURN_IF_EXCEPTION(throwScope, CallbackResultType::ExceptionThrown);
384     return WTFMove(returnValue);
385 }
386
387 JSC::JSValue toJS(TestCallbackInterface& impl)
388 {
389     if (!static_cast<JSTestCallbackInterface&>(impl).callbackData())
390         return jsNull();
391
392     return static_cast<JSTestCallbackInterface&>(impl).callbackData()->callback();
393
394 }
395
396 } // namespace WebCore
397
398 #endif // ENABLE(TEST_CONDITIONAL)