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