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