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