b2a06f0408aff5dce6cbc0b603112b39667a03b3
[WebKit-https.git] / Source / WebCore / bindings / scripts / test / JS / JSTestInterface.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(Condition1) || ENABLE(Condition2)
24
25 #include "JSTestInterface.h"
26
27 #include "ExceptionCode.h"
28 #include "JSDOMBinding.h"
29 #include "JSTestInterfaceCustom.h"
30 #include "JSTestObj.h"
31 #include "TestInterface.h"
32 #include "TestObj.h"
33 #include "TestSupplemental.h"
34 #include <runtime/Error.h>
35 #include <wtf/GetPtr.h>
36
37 #if ENABLE(Condition11) || ENABLE(Condition12)
38 #include "JSNode.h"
39 #include "KURL.h"
40 #include <runtime/JSString.h>
41 #endif
42
43 #if ENABLE(Condition11) || ENABLE(Condition12)
44 #include "Node.h"
45 #endif
46
47 using namespace JSC;
48
49 namespace WebCore {
50
51 /* Hash table */
52
53 static const HashTableValue JSTestInterfaceTableValues[] =
54 {
55 #if ENABLE(Condition11) || ENABLE(Condition12)
56     { "supplementalStr1", DontDelete | ReadOnly, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceSupplementalStr1), (intptr_t)0, NoIntrinsic },
57 #endif
58 #if ENABLE(Condition11) || ENABLE(Condition12)
59     { "supplementalStr2", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceSupplementalStr2), (intptr_t)setJSTestInterfaceSupplementalStr2, NoIntrinsic },
60 #endif
61 #if ENABLE(Condition11) || ENABLE(Condition12)
62     { "supplementalStr3", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceSupplementalStr3), (intptr_t)setJSTestInterfaceSupplementalStr3, NoIntrinsic },
63 #endif
64 #if ENABLE(Condition11) || ENABLE(Condition12)
65     { "supplementalNode", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceSupplementalNode), (intptr_t)setJSTestInterfaceSupplementalNode, NoIntrinsic },
66 #endif
67     { "constructor", DontEnum | ReadOnly, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceConstructor), (intptr_t)0, NoIntrinsic },
68     { 0, 0, 0, 0, NoIntrinsic }
69 };
70
71 static const HashTable JSTestInterfaceTable = { 16, 15, JSTestInterfaceTableValues, 0 };
72 /* Hash table for constructor */
73
74 static const HashTableValue JSTestInterfaceConstructorTableValues[] =
75 {
76 #if ENABLE(Condition11) || ENABLE(Condition12)
77     { "SUPPLEMENTALCONSTANT1", DontDelete | ReadOnly, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceSUPPLEMENTALCONSTANT1), (intptr_t)0, NoIntrinsic },
78 #endif
79 #if ENABLE(Condition11) || ENABLE(Condition12)
80     { "SUPPLEMENTALCONSTANT2", DontDelete | ReadOnly, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceSUPPLEMENTALCONSTANT2), (intptr_t)0, NoIntrinsic },
81 #endif
82 #if ENABLE(Condition11) || ENABLE(Condition12)
83     { "supplementalStaticReadOnlyAttr", DontDelete | ReadOnly, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceConstructorSupplementalStaticReadOnlyAttr), (intptr_t)0, NoIntrinsic },
84 #endif
85 #if ENABLE(Condition11) || ENABLE(Condition12)
86     { "supplementalStaticAttr", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceConstructorSupplementalStaticAttr), (intptr_t)setJSTestInterfaceConstructorSupplementalStaticAttr, NoIntrinsic },
87 #endif
88 #if ENABLE(Condition11) || ENABLE(Condition12)
89     { "supplementalMethod4", DontDelete | JSC::Function, (intptr_t)static_cast<NativeFunction>(jsTestInterfaceConstructorFunctionSupplementalMethod4), (intptr_t)0, NoIntrinsic },
90 #endif
91     { 0, 0, 0, 0, NoIntrinsic }
92 };
93
94 static const HashTable JSTestInterfaceConstructorTable = { 5, 3, JSTestInterfaceConstructorTableValues, 0 };
95
96 #if ENABLE(Condition11) || ENABLE(Condition12)
97 COMPILE_ASSERT(1 == TestSupplemental::SUPPLEMENTALCONSTANT1, TestInterfaceEnumSUPPLEMENTALCONSTANT1IsWrongUseDoNotCheckConstants);
98 #endif
99 #if ENABLE(Condition11) || ENABLE(Condition12)
100 COMPILE_ASSERT(2 == TestSupplemental::CONST_IMPL, TestInterfaceEnumCONST_IMPLIsWrongUseDoNotCheckConstants);
101 #endif
102
103 const ClassInfo JSTestInterfaceConstructor::s_info = { "TestInterfaceConstructor", &Base::s_info, &JSTestInterfaceConstructorTable, 0, CREATE_METHOD_TABLE(JSTestInterfaceConstructor) };
104
105 JSTestInterfaceConstructor::JSTestInterfaceConstructor(Structure* structure, JSDOMGlobalObject* globalObject)
106     : DOMConstructorObject(structure, globalObject)
107 {
108 }
109
110 void JSTestInterfaceConstructor::finishCreation(ExecState* exec, JSDOMGlobalObject* globalObject)
111 {
112     Base::finishCreation(exec->globalData());
113     ASSERT(inherits(&s_info));
114     putDirect(exec->globalData(), exec->propertyNames().prototype, JSTestInterfacePrototype::self(exec, globalObject), DontDelete | ReadOnly);
115     putDirect(exec->globalData(), exec->propertyNames().length, jsNumber(2), ReadOnly | DontDelete | DontEnum);
116 }
117
118 bool JSTestInterfaceConstructor::getOwnPropertySlot(JSCell* cell, ExecState* exec, PropertyName propertyName, PropertySlot& slot)
119 {
120     return getStaticPropertySlot<JSTestInterfaceConstructor, JSDOMWrapper>(exec, &JSTestInterfaceConstructorTable, jsCast<JSTestInterfaceConstructor*>(cell), propertyName, slot);
121 }
122
123 bool JSTestInterfaceConstructor::getOwnPropertyDescriptor(JSObject* object, ExecState* exec, PropertyName propertyName, PropertyDescriptor& descriptor)
124 {
125     return getStaticPropertyDescriptor<JSTestInterfaceConstructor, JSDOMWrapper>(exec, &JSTestInterfaceConstructorTable, jsCast<JSTestInterfaceConstructor*>(object), propertyName, descriptor);
126 }
127
128 EncodedJSValue JSC_HOST_CALL JSTestInterfaceConstructor::constructJSTestInterface(ExecState* exec)
129 {
130     JSTestInterfaceConstructor* castedThis = jsCast<JSTestInterfaceConstructor*>(exec->callee());
131     if (exec->argumentCount() < 1)
132         return throwVMError(exec, createNotEnoughArgumentsError(exec));
133     ExceptionCode ec = 0;
134     const String& str1(MAYBE_MISSING_PARAMETER(exec, 0, DefaultIsUndefined).isEmpty() ? String() : MAYBE_MISSING_PARAMETER(exec, 0, DefaultIsUndefined).toString(exec)->value(exec));
135     if (exec->hadException())
136         return JSValue::encode(jsUndefined());
137     const String& str2(MAYBE_MISSING_PARAMETER(exec, 1, DefaultIsUndefined).isEmpty() ? String() : MAYBE_MISSING_PARAMETER(exec, 1, DefaultIsUndefined).toString(exec)->value(exec));
138     if (exec->hadException())
139         return JSValue::encode(jsUndefined());
140     ScriptExecutionContext* context = castedThis->scriptExecutionContext();
141     if (!context)
142         return throwVMError(exec, createReferenceError(exec, "TestInterface constructor associated document is unavailable"));
143     RefPtr<TestInterface> object = TestInterface::create(context, str1, str2, ec);
144     if (ec) {
145         setDOMException(exec, ec);
146         return JSValue::encode(JSValue());
147     }
148     return JSValue::encode(asObject(toJS(exec, castedThis->globalObject(), object.get())));
149 }
150
151 ConstructType JSTestInterfaceConstructor::getConstructData(JSCell*, ConstructData& constructData)
152 {
153     constructData.native.function = constructJSTestInterface;
154     return ConstructTypeHost;
155 }
156
157 /* Hash table for prototype */
158
159 static const HashTableValue JSTestInterfacePrototypeTableValues[] =
160 {
161 #if ENABLE(Condition11) || ENABLE(Condition12)
162     { "SUPPLEMENTALCONSTANT1", DontDelete | ReadOnly, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceSUPPLEMENTALCONSTANT1), (intptr_t)0, NoIntrinsic },
163 #endif
164 #if ENABLE(Condition11) || ENABLE(Condition12)
165     { "SUPPLEMENTALCONSTANT2", DontDelete | ReadOnly, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceSUPPLEMENTALCONSTANT2), (intptr_t)0, NoIntrinsic },
166 #endif
167 #if ENABLE(Condition11) || ENABLE(Condition12)
168     { "supplementalMethod1", DontDelete | JSC::Function, (intptr_t)static_cast<NativeFunction>(jsTestInterfacePrototypeFunctionSupplementalMethod1), (intptr_t)0, NoIntrinsic },
169 #endif
170 #if ENABLE(Condition11) || ENABLE(Condition12)
171     { "supplementalMethod2", DontDelete | JSC::Function, (intptr_t)static_cast<NativeFunction>(jsTestInterfacePrototypeFunctionSupplementalMethod2), (intptr_t)2, NoIntrinsic },
172 #endif
173 #if ENABLE(Condition11) || ENABLE(Condition12)
174     { "supplementalMethod3", DontDelete | JSC::Function, (intptr_t)static_cast<NativeFunction>(jsTestInterfacePrototypeFunctionSupplementalMethod3), (intptr_t)0, NoIntrinsic },
175 #endif
176     { 0, 0, 0, 0, NoIntrinsic }
177 };
178
179 static const HashTable JSTestInterfacePrototypeTable = { 17, 15, JSTestInterfacePrototypeTableValues, 0 };
180 const ClassInfo JSTestInterfacePrototype::s_info = { "TestInterfacePrototype", &Base::s_info, &JSTestInterfacePrototypeTable, 0, CREATE_METHOD_TABLE(JSTestInterfacePrototype) };
181
182 JSObject* JSTestInterfacePrototype::self(ExecState* exec, JSGlobalObject* globalObject)
183 {
184     return getDOMPrototype<JSTestInterface>(exec, globalObject);
185 }
186
187 bool JSTestInterfacePrototype::getOwnPropertySlot(JSCell* cell, ExecState* exec, PropertyName propertyName, PropertySlot& slot)
188 {
189     JSTestInterfacePrototype* thisObject = jsCast<JSTestInterfacePrototype*>(cell);
190     return getStaticPropertySlot<JSTestInterfacePrototype, JSObject>(exec, &JSTestInterfacePrototypeTable, thisObject, propertyName, slot);
191 }
192
193 bool JSTestInterfacePrototype::getOwnPropertyDescriptor(JSObject* object, ExecState* exec, PropertyName propertyName, PropertyDescriptor& descriptor)
194 {
195     JSTestInterfacePrototype* thisObject = jsCast<JSTestInterfacePrototype*>(object);
196     return getStaticPropertyDescriptor<JSTestInterfacePrototype, JSObject>(exec, &JSTestInterfacePrototypeTable, thisObject, propertyName, descriptor);
197 }
198
199 const ClassInfo JSTestInterface::s_info = { "TestInterface", &Base::s_info, &JSTestInterfaceTable, 0 , CREATE_METHOD_TABLE(JSTestInterface) };
200
201 JSTestInterface::JSTestInterface(Structure* structure, JSDOMGlobalObject* globalObject, PassRefPtr<TestInterface> impl)
202     : JSDOMWrapper(structure, globalObject)
203     , m_impl(impl.leakRef())
204 {
205 }
206
207 void JSTestInterface::finishCreation(JSGlobalData& globalData)
208 {
209     Base::finishCreation(globalData);
210     ASSERT(inherits(&s_info));
211 }
212
213 JSObject* JSTestInterface::createPrototype(ExecState* exec, JSGlobalObject* globalObject)
214 {
215     return JSTestInterfacePrototype::create(exec->globalData(), globalObject, JSTestInterfacePrototype::createStructure(globalObject->globalData(), globalObject, globalObject->objectPrototype()));
216 }
217
218 void JSTestInterface::destroy(JSC::JSCell* cell)
219 {
220     JSTestInterface* thisObject = static_cast<JSTestInterface*>(cell);
221     thisObject->JSTestInterface::~JSTestInterface();
222 }
223
224 JSTestInterface::~JSTestInterface()
225 {
226     releaseImplIfNotNull();
227 }
228
229 bool JSTestInterface::getOwnPropertySlot(JSCell* cell, ExecState* exec, PropertyName propertyName, PropertySlot& slot)
230 {
231     JSTestInterface* thisObject = jsCast<JSTestInterface*>(cell);
232     ASSERT_GC_OBJECT_INHERITS(thisObject, &s_info);
233     return getStaticValueSlot<JSTestInterface, Base>(exec, &JSTestInterfaceTable, thisObject, propertyName, slot);
234 }
235
236 bool JSTestInterface::getOwnPropertyDescriptor(JSObject* object, ExecState* exec, PropertyName propertyName, PropertyDescriptor& descriptor)
237 {
238     JSTestInterface* thisObject = jsCast<JSTestInterface*>(object);
239     ASSERT_GC_OBJECT_INHERITS(thisObject, &s_info);
240     return getStaticValueDescriptor<JSTestInterface, Base>(exec, &JSTestInterfaceTable, thisObject, propertyName, descriptor);
241 }
242
243 #if ENABLE(Condition11) || ENABLE(Condition12)
244 JSValue jsTestInterfaceConstructorSupplementalStaticReadOnlyAttr(ExecState* exec, JSValue slotBase, PropertyName)
245 {
246     UNUSED_PARAM(slotBase);
247     UNUSED_PARAM(exec);
248     JSValue result = jsNumber(TestSupplemental::supplementalStaticReadOnlyAttr());
249     return result;
250 }
251
252 #endif
253
254 #if ENABLE(Condition11) || ENABLE(Condition12)
255 JSValue jsTestInterfaceConstructorSupplementalStaticAttr(ExecState* exec, JSValue slotBase, PropertyName)
256 {
257     UNUSED_PARAM(slotBase);
258     UNUSED_PARAM(exec);
259     JSValue result = jsStringWithCache(exec, TestSupplemental::supplementalStaticAttr());
260     return result;
261 }
262
263 #endif
264
265 #if ENABLE(Condition11) || ENABLE(Condition12)
266 JSValue jsTestInterfaceSupplementalStr1(ExecState* exec, JSValue slotBase, PropertyName)
267 {
268     JSTestInterface* castedThis = jsCast<JSTestInterface*>(asObject(slotBase));
269     UNUSED_PARAM(exec);
270     TestInterface* impl = static_cast<TestInterface*>(castedThis->impl());
271     JSValue result = jsStringWithCache(exec, TestSupplemental::supplementalStr1(impl));
272     return result;
273 }
274
275 #endif
276
277 #if ENABLE(Condition11) || ENABLE(Condition12)
278 JSValue jsTestInterfaceSupplementalStr2(ExecState* exec, JSValue slotBase, PropertyName)
279 {
280     JSTestInterface* castedThis = jsCast<JSTestInterface*>(asObject(slotBase));
281     UNUSED_PARAM(exec);
282     TestInterface* impl = static_cast<TestInterface*>(castedThis->impl());
283     JSValue result = jsStringWithCache(exec, TestSupplemental::supplementalStr2(impl));
284     return result;
285 }
286
287 #endif
288
289 #if ENABLE(Condition11) || ENABLE(Condition12)
290 JSValue jsTestInterfaceSupplementalStr3(ExecState* exec, JSValue slotBase, PropertyName)
291 {
292     JSTestInterface* castedThis = jsCast<JSTestInterface*>(asObject(slotBase));
293     return castedThis->supplementalStr3(exec);
294 }
295
296 #endif
297
298 #if ENABLE(Condition11) || ENABLE(Condition12)
299 JSValue jsTestInterfaceSupplementalNode(ExecState* exec, JSValue slotBase, PropertyName)
300 {
301     JSTestInterface* castedThis = jsCast<JSTestInterface*>(asObject(slotBase));
302     UNUSED_PARAM(exec);
303     TestInterface* impl = static_cast<TestInterface*>(castedThis->impl());
304     JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(TestSupplemental::supplementalNode(impl)));
305     return result;
306 }
307
308 #endif
309
310 JSValue jsTestInterfaceConstructor(ExecState* exec, JSValue slotBase, PropertyName)
311 {
312     JSTestInterface* domObject = jsCast<JSTestInterface*>(asObject(slotBase));
313     return JSTestInterface::getConstructor(exec, domObject->globalObject());
314 }
315
316 void JSTestInterface::put(JSCell* cell, ExecState* exec, PropertyName propertyName, JSValue value, PutPropertySlot& slot)
317 {
318     JSTestInterface* thisObject = jsCast<JSTestInterface*>(cell);
319     ASSERT_GC_OBJECT_INHERITS(thisObject, &s_info);
320     if (thisObject->putDelegate(exec, propertyName, value, slot))
321         return;
322     lookupPut<JSTestInterface, Base>(exec, propertyName, value, &JSTestInterfaceTable, thisObject, slot);
323 }
324
325 void JSTestInterface::putByIndex(JSCell* cell, ExecState* exec, unsigned index, JSValue value, bool shouldThrow)
326 {
327     JSTestInterface* thisObject = jsCast<JSTestInterface*>(cell);
328     ASSERT_GC_OBJECT_INHERITS(thisObject, &s_info);
329     PropertyName propertyName = Identifier::from(exec, index);
330     PutPropertySlot slot(shouldThrow);
331     if (thisObject->putDelegate(exec, propertyName, value, slot))
332         return;
333     Base::putByIndex(cell, exec, index, value, shouldThrow);
334 }
335
336 #if ENABLE(Condition11) || ENABLE(Condition12)
337 void setJSTestInterfaceConstructorSupplementalStaticAttr(ExecState* exec, JSObject*, JSValue value)
338 {
339     UNUSED_PARAM(exec);
340     TestSupplemental::setSupplementalStaticAttr(value.isEmpty() ? String() : value.toString(exec)->value(exec));
341 }
342
343 #endif
344
345 #if ENABLE(Condition11) || ENABLE(Condition12)
346 void setJSTestInterfaceSupplementalStr2(ExecState* exec, JSObject* thisObject, JSValue value)
347 {
348     UNUSED_PARAM(exec);
349     JSTestInterface* castedThis = jsCast<JSTestInterface*>(thisObject);
350     TestInterface* impl = static_cast<TestInterface*>(castedThis->impl());
351     TestSupplemental::setSupplementalStr2(impl, value.isEmpty() ? String() : value.toString(exec)->value(exec));
352 }
353
354 #endif
355
356 #if ENABLE(Condition11) || ENABLE(Condition12)
357 void setJSTestInterfaceSupplementalStr3(ExecState* exec, JSObject* thisObject, JSValue value)
358 {
359     UNUSED_PARAM(exec);
360     jsCast<JSTestInterface*>(thisObject)->setSupplementalStr3(exec, value);
361 }
362
363 #endif
364
365 #if ENABLE(Condition11) || ENABLE(Condition12)
366 void setJSTestInterfaceSupplementalNode(ExecState* exec, JSObject* thisObject, JSValue value)
367 {
368     UNUSED_PARAM(exec);
369     JSTestInterface* castedThis = jsCast<JSTestInterface*>(thisObject);
370     TestInterface* impl = static_cast<TestInterface*>(castedThis->impl());
371     TestSupplemental::setSupplementalNode(impl, toNode(value));
372 }
373
374 #endif
375
376 JSValue JSTestInterface::getConstructor(ExecState* exec, JSGlobalObject* globalObject)
377 {
378     return getDOMConstructor<JSTestInterfaceConstructor>(exec, jsCast<JSDOMGlobalObject*>(globalObject));
379 }
380
381 #if ENABLE(Condition11) || ENABLE(Condition12)
382 EncodedJSValue JSC_HOST_CALL jsTestInterfacePrototypeFunctionSupplementalMethod1(ExecState* exec)
383 {
384     JSValue thisValue = exec->hostThisValue();
385     if (!thisValue.inherits(&JSTestInterface::s_info))
386         return throwVMTypeError(exec);
387     JSTestInterface* castedThis = jsCast<JSTestInterface*>(asObject(thisValue));
388     ASSERT_GC_OBJECT_INHERITS(castedThis, &JSTestInterface::s_info);
389     TestInterface* impl = static_cast<TestInterface*>(castedThis->impl());
390     TestSupplemental::supplementalMethod1(impl);
391     return JSValue::encode(jsUndefined());
392 }
393
394 #endif
395
396 #if ENABLE(Condition11) || ENABLE(Condition12)
397 EncodedJSValue JSC_HOST_CALL jsTestInterfacePrototypeFunctionSupplementalMethod2(ExecState* exec)
398 {
399     JSValue thisValue = exec->hostThisValue();
400     if (!thisValue.inherits(&JSTestInterface::s_info))
401         return throwVMTypeError(exec);
402     JSTestInterface* castedThis = jsCast<JSTestInterface*>(asObject(thisValue));
403     ASSERT_GC_OBJECT_INHERITS(castedThis, &JSTestInterface::s_info);
404     TestInterface* impl = static_cast<TestInterface*>(castedThis->impl());
405     if (exec->argumentCount() < 2)
406         return throwVMError(exec, createNotEnoughArgumentsError(exec));
407     ExceptionCode ec = 0;
408     ScriptExecutionContext* scriptContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
409     if (!scriptContext)
410         return JSValue::encode(jsUndefined());
411     const String& strArg(MAYBE_MISSING_PARAMETER(exec, 0, DefaultIsUndefined).isEmpty() ? String() : MAYBE_MISSING_PARAMETER(exec, 0, DefaultIsUndefined).toString(exec)->value(exec));
412     if (exec->hadException())
413         return JSValue::encode(jsUndefined());
414     TestObj* objArg(toTestObj(MAYBE_MISSING_PARAMETER(exec, 1, DefaultIsUndefined)));
415     if (exec->hadException())
416         return JSValue::encode(jsUndefined());
417
418     JSC::JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(TestSupplemental::supplementalMethod2(impl, scriptContext, strArg, objArg, ec)));
419     setDOMException(exec, ec);
420     return JSValue::encode(result);
421 }
422
423 #endif
424
425 #if ENABLE(Condition11) || ENABLE(Condition12)
426 EncodedJSValue JSC_HOST_CALL jsTestInterfacePrototypeFunctionSupplementalMethod3(ExecState* exec)
427 {
428     JSValue thisValue = exec->hostThisValue();
429     if (!thisValue.inherits(&JSTestInterface::s_info))
430         return throwVMTypeError(exec);
431     JSTestInterface* castedThis = jsCast<JSTestInterface*>(asObject(thisValue));
432     ASSERT_GC_OBJECT_INHERITS(castedThis, &JSTestInterface::s_info);
433     return JSValue::encode(castedThis->supplementalMethod3(exec));
434 }
435
436 #endif
437
438 #if ENABLE(Condition11) || ENABLE(Condition12)
439 EncodedJSValue JSC_HOST_CALL jsTestInterfaceConstructorFunctionSupplementalMethod4(ExecState* exec)
440 {
441     TestSupplemental::supplementalMethod4();
442     return JSValue::encode(jsUndefined());
443 }
444
445 #endif
446
447 // Constant getters
448
449 #if ENABLE(Condition11) || ENABLE(Condition12)
450 JSValue jsTestInterfaceSUPPLEMENTALCONSTANT1(ExecState* exec, JSValue, PropertyName)
451 {
452     UNUSED_PARAM(exec);
453     return jsNumber(static_cast<int>(1));
454 }
455
456 #endif
457 #if ENABLE(Condition11) || ENABLE(Condition12)
458 JSValue jsTestInterfaceSUPPLEMENTALCONSTANT2(ExecState* exec, JSValue, PropertyName)
459 {
460     UNUSED_PARAM(exec);
461     return jsNumber(static_cast<int>(2));
462 }
463
464 #endif
465 static inline bool isObservable(JSTestInterface* jsTestInterface)
466 {
467     if (jsTestInterface->hasCustomProperties())
468         return true;
469     return false;
470 }
471
472 bool JSTestInterfaceOwner::isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown> handle, void*, SlotVisitor& visitor)
473 {
474     JSTestInterface* jsTestInterface = jsCast<JSTestInterface*>(handle.get().asCell());
475     if (jsTestInterface->impl()->hasPendingActivity())
476         return true;
477     if (!isObservable(jsTestInterface))
478         return false;
479     UNUSED_PARAM(visitor);
480     return false;
481 }
482
483 void JSTestInterfaceOwner::finalize(JSC::Handle<JSC::Unknown> handle, void* context)
484 {
485     JSTestInterface* jsTestInterface = jsCast<JSTestInterface*>(handle.get().asCell());
486     DOMWrapperWorld* world = static_cast<DOMWrapperWorld*>(context);
487     uncacheWrapper(world, jsTestInterface->impl(), jsTestInterface);
488     jsTestInterface->releaseImpl();
489 }
490
491 JSC::JSValue toJS(JSC::ExecState* exec, JSDOMGlobalObject* globalObject, TestInterface* impl)
492 {
493     return wrap<JSTestInterface>(exec, globalObject, impl);
494 }
495
496 TestInterface* toTestInterface(JSC::JSValue value)
497 {
498     return value.inherits(&JSTestInterface::s_info) ? jsCast<JSTestInterface*>(asObject(value))->impl() : 0;
499 }
500
501 }
502
503 #endif // ENABLE(Condition1) || ENABLE(Condition2)