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