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