e70726ab07caf51bbd10f600984a0fe7f3599013
[WebKit-https.git] / Source / WebCore / bindings / scripts / test / JS / JSTestEventTarget.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 #include "JSTestEventTarget.h"
23
24 #include "Event.h"
25 #include "ExceptionCode.h"
26 #include "JSDOMBinding.h"
27 #include "JSEvent.h"
28 #include "JSEventListener.h"
29 #include "JSNode.h"
30 #include "Node.h"
31 #include "TestEventTarget.h"
32 #include "wtf/text/AtomicString.h"
33 #include <runtime/Error.h>
34 #include <runtime/PropertyNameArray.h>
35 #include <wtf/GetPtr.h>
36
37 using namespace JSC;
38
39 namespace WebCore {
40
41 /* Hash table */
42
43 static const HashTableValue JSTestEventTargetTableValues[] =
44 {
45     { "constructor", DontEnum | ReadOnly, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestEventTargetConstructor), (intptr_t)0, NoIntrinsic },
46     { 0, 0, 0, 0, NoIntrinsic }
47 };
48
49 static const HashTable JSTestEventTargetTable = { 2, 1, JSTestEventTargetTableValues, 0 };
50 /* Hash table for constructor */
51
52 static const HashTableValue JSTestEventTargetConstructorTableValues[] =
53 {
54     { 0, 0, 0, 0, NoIntrinsic }
55 };
56
57 static const HashTable JSTestEventTargetConstructorTable = { 1, 0, JSTestEventTargetConstructorTableValues, 0 };
58 const ClassInfo JSTestEventTargetConstructor::s_info = { "TestEventTargetConstructor", &Base::s_info, &JSTestEventTargetConstructorTable, 0, CREATE_METHOD_TABLE(JSTestEventTargetConstructor) };
59
60 JSTestEventTargetConstructor::JSTestEventTargetConstructor(Structure* structure, JSDOMGlobalObject* globalObject)
61     : DOMConstructorObject(structure, globalObject)
62 {
63 }
64
65 void JSTestEventTargetConstructor::finishCreation(ExecState* exec, JSDOMGlobalObject* globalObject)
66 {
67     Base::finishCreation(exec->globalData());
68     ASSERT(inherits(&s_info));
69     putDirect(exec->globalData(), exec->propertyNames().prototype, JSTestEventTargetPrototype::self(exec, globalObject), DontDelete | ReadOnly);
70 }
71
72 bool JSTestEventTargetConstructor::getOwnPropertySlot(JSCell* cell, ExecState* exec, PropertyName propertyName, PropertySlot& slot)
73 {
74     return getStaticValueSlot<JSTestEventTargetConstructor, JSDOMWrapper>(exec, &JSTestEventTargetConstructorTable, jsCast<JSTestEventTargetConstructor*>(cell), propertyName, slot);
75 }
76
77 bool JSTestEventTargetConstructor::getOwnPropertyDescriptor(JSObject* object, ExecState* exec, PropertyName propertyName, PropertyDescriptor& descriptor)
78 {
79     return getStaticValueDescriptor<JSTestEventTargetConstructor, JSDOMWrapper>(exec, &JSTestEventTargetConstructorTable, jsCast<JSTestEventTargetConstructor*>(object), propertyName, descriptor);
80 }
81
82 /* Hash table for prototype */
83
84 static const HashTableValue JSTestEventTargetPrototypeTableValues[] =
85 {
86     { "item", DontDelete | JSC::Function, (intptr_t)static_cast<NativeFunction>(jsTestEventTargetPrototypeFunctionItem), (intptr_t)1, NoIntrinsic },
87     { "addEventListener", DontDelete | JSC::Function, (intptr_t)static_cast<NativeFunction>(jsTestEventTargetPrototypeFunctionAddEventListener), (intptr_t)3, NoIntrinsic },
88     { "removeEventListener", DontDelete | JSC::Function, (intptr_t)static_cast<NativeFunction>(jsTestEventTargetPrototypeFunctionRemoveEventListener), (intptr_t)3, NoIntrinsic },
89     { "dispatchEvent", DontDelete | JSC::Function, (intptr_t)static_cast<NativeFunction>(jsTestEventTargetPrototypeFunctionDispatchEvent), (intptr_t)1, NoIntrinsic },
90     { 0, 0, 0, 0, NoIntrinsic }
91 };
92
93 static const HashTable JSTestEventTargetPrototypeTable = { 8, 7, JSTestEventTargetPrototypeTableValues, 0 };
94 const ClassInfo JSTestEventTargetPrototype::s_info = { "TestEventTargetPrototype", &Base::s_info, &JSTestEventTargetPrototypeTable, 0, CREATE_METHOD_TABLE(JSTestEventTargetPrototype) };
95
96 JSObject* JSTestEventTargetPrototype::self(ExecState* exec, JSGlobalObject* globalObject)
97 {
98     return getDOMPrototype<JSTestEventTarget>(exec, globalObject);
99 }
100
101 bool JSTestEventTargetPrototype::getOwnPropertySlot(JSCell* cell, ExecState* exec, PropertyName propertyName, PropertySlot& slot)
102 {
103     JSTestEventTargetPrototype* thisObject = jsCast<JSTestEventTargetPrototype*>(cell);
104     return getStaticFunctionSlot<JSObject>(exec, &JSTestEventTargetPrototypeTable, thisObject, propertyName, slot);
105 }
106
107 bool JSTestEventTargetPrototype::getOwnPropertyDescriptor(JSObject* object, ExecState* exec, PropertyName propertyName, PropertyDescriptor& descriptor)
108 {
109     JSTestEventTargetPrototype* thisObject = jsCast<JSTestEventTargetPrototype*>(object);
110     return getStaticFunctionDescriptor<JSObject>(exec, &JSTestEventTargetPrototypeTable, thisObject, propertyName, descriptor);
111 }
112
113 const ClassInfo JSTestEventTarget::s_info = { "TestEventTarget", &Base::s_info, &JSTestEventTargetTable, 0 , CREATE_METHOD_TABLE(JSTestEventTarget) };
114
115 JSTestEventTarget::JSTestEventTarget(Structure* structure, JSDOMGlobalObject* globalObject, PassRefPtr<TestEventTarget> impl)
116     : JSDOMWrapper(structure, globalObject)
117     , m_impl(impl.leakRef())
118 {
119 }
120
121 void JSTestEventTarget::finishCreation(JSGlobalData& globalData)
122 {
123     Base::finishCreation(globalData);
124     ASSERT(inherits(&s_info));
125 }
126
127 JSObject* JSTestEventTarget::createPrototype(ExecState* exec, JSGlobalObject* globalObject)
128 {
129     return JSTestEventTargetPrototype::create(exec->globalData(), globalObject, JSTestEventTargetPrototype::createStructure(globalObject->globalData(), globalObject, globalObject->objectPrototype()));
130 }
131
132 void JSTestEventTarget::destroy(JSC::JSCell* cell)
133 {
134     JSTestEventTarget* thisObject = static_cast<JSTestEventTarget*>(cell);
135     thisObject->JSTestEventTarget::~JSTestEventTarget();
136 }
137
138 JSTestEventTarget::~JSTestEventTarget()
139 {
140     releaseImplIfNotNull();
141 }
142
143 bool JSTestEventTarget::getOwnPropertySlot(JSCell* cell, ExecState* exec, PropertyName propertyName, PropertySlot& slot)
144 {
145     JSTestEventTarget* thisObject = jsCast<JSTestEventTarget*>(cell);
146     ASSERT_GC_OBJECT_INHERITS(thisObject, &s_info);
147     const HashEntry* entry = getStaticValueSlotEntryWithoutCaching<JSTestEventTarget>(exec, propertyName);
148     if (entry) {
149         slot.setCustom(thisObject, entry->propertyGetter());
150         return true;
151     }
152     unsigned index = propertyName.asIndex();
153     if (index != PropertyName::NotAnIndex && index < static_cast<TestEventTarget*>(thisObject->impl())->length()) {
154         slot.setCustomIndex(thisObject, index, indexGetter);
155         return true;
156     }
157     if (canGetItemsForName(exec, static_cast<TestEventTarget*>(thisObject->impl()), propertyName)) {
158         slot.setCustom(thisObject, thisObject->nameGetter);
159         return true;
160     }
161     return getStaticValueSlot<JSTestEventTarget, Base>(exec, &JSTestEventTargetTable, thisObject, propertyName, slot);
162 }
163
164 bool JSTestEventTarget::getOwnPropertyDescriptor(JSObject* object, ExecState* exec, PropertyName propertyName, PropertyDescriptor& descriptor)
165 {
166     JSTestEventTarget* thisObject = jsCast<JSTestEventTarget*>(object);
167     ASSERT_GC_OBJECT_INHERITS(thisObject, &s_info);
168     const HashEntry* entry = JSTestEventTargetTable.entry(exec, propertyName);
169     if (entry) {
170         PropertySlot slot;
171         slot.setCustom(thisObject, entry->propertyGetter());
172         descriptor.setDescriptor(slot.getValue(exec, propertyName), entry->attributes());
173         return true;
174     }
175     unsigned index = propertyName.asIndex();
176     if (index != PropertyName::NotAnIndex && index < static_cast<TestEventTarget*>(thisObject->impl())->length()) {
177         PropertySlot slot;
178         slot.setCustomIndex(thisObject, index, indexGetter);
179         descriptor.setDescriptor(slot.getValue(exec, propertyName), DontDelete | ReadOnly);
180         return true;
181     }
182     if (canGetItemsForName(exec, static_cast<TestEventTarget*>(thisObject->impl()), propertyName)) {
183         PropertySlot slot;
184         slot.setCustom(thisObject, nameGetter);
185         descriptor.setDescriptor(slot.getValue(exec, propertyName), ReadOnly | DontDelete | DontEnum);
186         return true;
187     }
188     return getStaticValueDescriptor<JSTestEventTarget, Base>(exec, &JSTestEventTargetTable, thisObject, propertyName, descriptor);
189 }
190
191 bool JSTestEventTarget::getOwnPropertySlotByIndex(JSCell* cell, ExecState* exec, unsigned index, PropertySlot& slot)
192 {
193     JSTestEventTarget* thisObject = jsCast<JSTestEventTarget*>(cell);
194     ASSERT_GC_OBJECT_INHERITS(thisObject, &s_info);
195     if (index < static_cast<TestEventTarget*>(thisObject->impl())->length()) {
196         slot.setCustomIndex(thisObject, index, thisObject->indexGetter);
197         return true;
198     }
199     PropertyName propertyName = Identifier::from(exec, index);
200     if (canGetItemsForName(exec, static_cast<TestEventTarget*>(thisObject->impl()), propertyName)) {
201         slot.setCustom(thisObject, thisObject->nameGetter);
202         return true;
203     }
204     return Base::getOwnPropertySlotByIndex(thisObject, exec, index, slot);
205 }
206
207 JSValue jsTestEventTargetConstructor(ExecState* exec, JSValue slotBase, PropertyName)
208 {
209     JSTestEventTarget* domObject = jsCast<JSTestEventTarget*>(asObject(slotBase));
210     return JSTestEventTarget::getConstructor(exec, domObject->globalObject());
211 }
212
213 void JSTestEventTarget::getOwnPropertyNames(JSObject* object, ExecState* exec, PropertyNameArray& propertyNames, EnumerationMode mode)
214 {
215     JSTestEventTarget* thisObject = jsCast<JSTestEventTarget*>(object);
216     ASSERT_GC_OBJECT_INHERITS(thisObject, &s_info);
217     for (unsigned i = 0; i < static_cast<TestEventTarget*>(thisObject->impl())->length(); ++i)
218         propertyNames.add(Identifier::from(exec, i));
219      Base::getOwnPropertyNames(thisObject, exec, propertyNames, mode);
220 }
221
222 JSValue JSTestEventTarget::getConstructor(ExecState* exec, JSGlobalObject* globalObject)
223 {
224     return getDOMConstructor<JSTestEventTargetConstructor>(exec, jsCast<JSDOMGlobalObject*>(globalObject));
225 }
226
227 EncodedJSValue JSC_HOST_CALL jsTestEventTargetPrototypeFunctionItem(ExecState* exec)
228 {
229     JSValue thisValue = exec->hostThisValue();
230     if (!thisValue.inherits(&JSTestEventTarget::s_info))
231         return throwVMTypeError(exec);
232     JSTestEventTarget* castedThis = jsCast<JSTestEventTarget*>(asObject(thisValue));
233     ASSERT_GC_OBJECT_INHERITS(castedThis, &JSTestEventTarget::s_info);
234     TestEventTarget* impl = static_cast<TestEventTarget*>(castedThis->impl());
235     if (exec->argumentCount() < 1)
236         return throwVMError(exec, createNotEnoughArgumentsError(exec));
237     int index(toUInt32(exec, exec->argument(0), NormalConversion));
238     if (index < 0) {
239         setDOMException(exec, INDEX_SIZE_ERR);
240         return JSValue::encode(jsUndefined());
241     }
242     if (exec->hadException())
243         return JSValue::encode(jsUndefined());
244
245     JSC::JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl->item(index)));
246     return JSValue::encode(result);
247 }
248
249 EncodedJSValue JSC_HOST_CALL jsTestEventTargetPrototypeFunctionAddEventListener(ExecState* exec)
250 {
251     JSValue thisValue = exec->hostThisValue();
252     if (!thisValue.inherits(&JSTestEventTarget::s_info))
253         return throwVMTypeError(exec);
254     JSTestEventTarget* castedThis = jsCast<JSTestEventTarget*>(asObject(thisValue));
255     ASSERT_GC_OBJECT_INHERITS(castedThis, &JSTestEventTarget::s_info);
256     TestEventTarget* impl = static_cast<TestEventTarget*>(castedThis->impl());
257     JSValue listener = exec->argument(1);
258     if (!listener.isObject())
259         return JSValue::encode(jsUndefined());
260     impl->addEventListener(exec->argument(0).toString(exec)->value(exec), JSEventListener::create(asObject(listener), castedThis, false, currentWorld(exec)), exec->argument(2).toBoolean(exec));
261     return JSValue::encode(jsUndefined());
262 }
263
264 EncodedJSValue JSC_HOST_CALL jsTestEventTargetPrototypeFunctionRemoveEventListener(ExecState* exec)
265 {
266     JSValue thisValue = exec->hostThisValue();
267     if (!thisValue.inherits(&JSTestEventTarget::s_info))
268         return throwVMTypeError(exec);
269     JSTestEventTarget* castedThis = jsCast<JSTestEventTarget*>(asObject(thisValue));
270     ASSERT_GC_OBJECT_INHERITS(castedThis, &JSTestEventTarget::s_info);
271     TestEventTarget* impl = static_cast<TestEventTarget*>(castedThis->impl());
272     JSValue listener = exec->argument(1);
273     if (!listener.isObject())
274         return JSValue::encode(jsUndefined());
275     impl->removeEventListener(exec->argument(0).toString(exec)->value(exec), JSEventListener::create(asObject(listener), castedThis, false, currentWorld(exec)).get(), exec->argument(2).toBoolean(exec));
276     return JSValue::encode(jsUndefined());
277 }
278
279 EncodedJSValue JSC_HOST_CALL jsTestEventTargetPrototypeFunctionDispatchEvent(ExecState* exec)
280 {
281     JSValue thisValue = exec->hostThisValue();
282     if (!thisValue.inherits(&JSTestEventTarget::s_info))
283         return throwVMTypeError(exec);
284     JSTestEventTarget* castedThis = jsCast<JSTestEventTarget*>(asObject(thisValue));
285     ASSERT_GC_OBJECT_INHERITS(castedThis, &JSTestEventTarget::s_info);
286     TestEventTarget* impl = static_cast<TestEventTarget*>(castedThis->impl());
287     if (exec->argumentCount() < 1)
288         return throwVMError(exec, createNotEnoughArgumentsError(exec));
289     ExceptionCode ec = 0;
290     Event* evt(toEvent(exec->argument(0)));
291     if (exec->hadException())
292         return JSValue::encode(jsUndefined());
293
294     JSC::JSValue result = jsBoolean(impl->dispatchEvent(evt, ec));
295     setDOMException(exec, ec);
296     return JSValue::encode(result);
297 }
298
299 void JSTestEventTarget::visitChildren(JSCell* cell, SlotVisitor& visitor)
300 {
301     JSTestEventTarget* thisObject = jsCast<JSTestEventTarget*>(cell);
302     ASSERT_GC_OBJECT_INHERITS(thisObject, &s_info);
303     COMPILE_ASSERT(StructureFlags & OverridesVisitChildren, OverridesVisitChildrenWithoutSettingFlag);
304     ASSERT(thisObject->structure()->typeInfo().overridesVisitChildren());
305     Base::visitChildren(thisObject, visitor);
306     thisObject->impl()->visitJSEventListeners(visitor);
307 }
308
309
310 JSValue JSTestEventTarget::indexGetter(ExecState* exec, JSValue slotBase, unsigned index)
311 {
312     JSTestEventTarget* thisObj = jsCast<JSTestEventTarget*>(asObject(slotBase));
313     ASSERT_GC_OBJECT_INHERITS(thisObj, &s_info);
314     return toJS(exec, thisObj->globalObject(), static_cast<TestEventTarget*>(thisObj->impl())->item(index));
315 }
316
317 static inline bool isObservable(JSTestEventTarget* jsTestEventTarget)
318 {
319     if (jsTestEventTarget->hasCustomProperties())
320         return true;
321     if (jsTestEventTarget->impl()->hasEventListeners())
322         return true;
323     return false;
324 }
325
326 bool JSTestEventTargetOwner::isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown> handle, void*, SlotVisitor& visitor)
327 {
328     JSTestEventTarget* jsTestEventTarget = jsCast<JSTestEventTarget*>(handle.get().asCell());
329     if (!isObservable(jsTestEventTarget))
330         return false;
331     UNUSED_PARAM(visitor);
332     return false;
333 }
334
335 void JSTestEventTargetOwner::finalize(JSC::Handle<JSC::Unknown> handle, void* context)
336 {
337     JSTestEventTarget* jsTestEventTarget = jsCast<JSTestEventTarget*>(handle.get().asCell());
338     DOMWrapperWorld* world = static_cast<DOMWrapperWorld*>(context);
339     uncacheWrapper(world, jsTestEventTarget->impl(), jsTestEventTarget);
340     jsTestEventTarget->releaseImpl();
341 }
342
343 #if ENABLE(BINDING_INTEGRITY)
344 #if PLATFORM(WIN)
345 #pragma warning(disable: 4483)
346 extern "C" { extern void (*const __identifier("??_7TestEventTarget@WebCore@@6B@")[])(); }
347 #else
348 extern "C" { extern void* _ZTVN7WebCore15TestEventTargetE[]; }
349 #endif
350 #endif
351 JSC::JSValue toJS(JSC::ExecState* exec, JSDOMGlobalObject* globalObject, TestEventTarget* impl)
352 {
353     if (!impl)
354         return jsNull();
355     if (JSValue result = getExistingWrapper<JSTestEventTarget>(exec, impl)) return result;
356
357 #if ENABLE(BINDING_INTEGRITY)
358     void* actualVTablePointer = *(reinterpret_cast<void**>(impl));
359 #if PLATFORM(WIN)
360     void* expectedVTablePointer = reinterpret_cast<void*>(__identifier("??_7TestEventTarget@WebCore@@6B@"));
361 #else
362     void* expectedVTablePointer = &_ZTVN7WebCore15TestEventTargetE[2];
363 #if COMPILER(CLANG)
364     COMPILE_ASSERT(__is_polymorphic(TestEventTarget), TestEventTarget_is_not_polymorphic);
365 #endif
366 #endif
367     RELEASE_ASSERT(actualVTablePointer == expectedVTablePointer);
368 #endif
369     return createNewWrapper<JSTestEventTarget>(exec, globalObject, impl);
370 }
371
372 TestEventTarget* toTestEventTarget(JSC::JSValue value)
373 {
374     return value.inherits(&JSTestEventTarget::s_info) ? jsCast<JSTestEventTarget*>(asObject(value))->impl() : 0;
375 }
376
377 }