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