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