Rewrite Function.bind as a builtin
[WebKit.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 "JSTestObj.h"
30 #include "ScriptExecutionContext.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) || ENABLE(Condition22) || ENABLE(Condition23)
38 #include "JSNode.h"
39 #include "URL.h"
40 #include <runtime/JSString.h>
41 #endif
42
43 #if ENABLE(Condition11) || ENABLE(Condition12) || ENABLE(Condition22) || ENABLE(Condition23)
44 #include "Node.h"
45 #endif
46
47 using namespace JSC;
48
49 namespace WebCore {
50
51 /* Hash table */
52
53 static const struct CompactHashIndex JSTestInterfaceTableIndex[4] = {
54     { -1, -1 },
55     { 0, -1 },
56     { -1, -1 },
57     { 1, -1 },
58 };
59
60
61 static const HashTableValue JSTestInterfaceTableValues[] =
62 {
63 #if ENABLE(Condition22) || ENABLE(Condition23)
64     { "implementsStr3", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceImplementsStr3), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestInterfaceImplementsStr3) },
65 #else
66     { 0, 0, NoIntrinsic, 0, 0 },
67 #endif
68 #if ENABLE(Condition11) || ENABLE(Condition12)
69     { "supplementalStr3", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceSupplementalStr3), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestInterfaceSupplementalStr3) },
70 #else
71     { 0, 0, NoIntrinsic, 0, 0 },
72 #endif
73 };
74
75 static const HashTable JSTestInterfaceTable = { 2, 3, true, JSTestInterfaceTableValues, 0, JSTestInterfaceTableIndex };
76 /* Hash table for constructor */
77
78 static const struct CompactHashIndex JSTestInterfaceConstructorTableIndex[11] = {
79     { 8, -1 },
80     { 5, -1 },
81     { -1, -1 },
82     { 0, 9 },
83     { 6, 10 },
84     { 7, -1 },
85     { 2, -1 },
86     { 1, 8 },
87     { 3, -1 },
88     { 4, -1 },
89     { 9, -1 },
90 };
91
92
93 static const HashTableValue JSTestInterfaceConstructorTableValues[] =
94 {
95 #if ENABLE(Condition22) || ENABLE(Condition23)
96     { "IMPLEMENTSCONSTANT1", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceIMPLEMENTSCONSTANT1), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
97 #else
98     { 0, 0, NoIntrinsic, 0, 0 },
99 #endif
100 #if ENABLE(Condition22) || ENABLE(Condition23)
101     { "IMPLEMENTSCONSTANT2", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceIMPLEMENTSCONSTANT2), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
102 #else
103     { 0, 0, NoIntrinsic, 0, 0 },
104 #endif
105 #if ENABLE(Condition11) || ENABLE(Condition12)
106     { "SUPPLEMENTALCONSTANT1", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceSUPPLEMENTALCONSTANT1), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
107 #else
108     { 0, 0, NoIntrinsic, 0, 0 },
109 #endif
110 #if ENABLE(Condition11) || ENABLE(Condition12)
111     { "SUPPLEMENTALCONSTANT2", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceSUPPLEMENTALCONSTANT2), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
112 #else
113     { 0, 0, NoIntrinsic, 0, 0 },
114 #endif
115 #if ENABLE(Condition22) || ENABLE(Condition23)
116     { "implementsStaticReadOnlyAttr", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceConstructorImplementsStaticReadOnlyAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
117 #else
118     { 0, 0, NoIntrinsic, 0, 0 },
119 #endif
120 #if ENABLE(Condition22) || ENABLE(Condition23)
121     { "implementsStaticAttr", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceConstructorImplementsStaticAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestInterfaceConstructorImplementsStaticAttr) },
122 #else
123     { 0, 0, NoIntrinsic, 0, 0 },
124 #endif
125 #if ENABLE(Condition11) || ENABLE(Condition12)
126     { "supplementalStaticReadOnlyAttr", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceConstructorSupplementalStaticReadOnlyAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
127 #else
128     { 0, 0, NoIntrinsic, 0, 0 },
129 #endif
130 #if ENABLE(Condition11) || ENABLE(Condition12)
131     { "supplementalStaticAttr", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceConstructorSupplementalStaticAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestInterfaceConstructorSupplementalStaticAttr) },
132 #else
133     { 0, 0, NoIntrinsic, 0, 0 },
134 #endif
135 #if ENABLE(Condition22) || ENABLE(Condition23)
136     { "implementsMethod4", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestInterfaceConstructorFunctionImplementsMethod4), (intptr_t) (0) },
137 #else
138     { 0, 0, NoIntrinsic, 0, 0 },
139 #endif
140 #if ENABLE(Condition11) || ENABLE(Condition12)
141     { "supplementalMethod4", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestInterfaceConstructorFunctionSupplementalMethod4), (intptr_t) (0) },
142 #else
143     { 0, 0, NoIntrinsic, 0, 0 },
144 #endif
145 };
146
147 static const HashTable JSTestInterfaceConstructorTable = { 10, 7, true, JSTestInterfaceConstructorTableValues, 0, JSTestInterfaceConstructorTableIndex };
148
149 #if ENABLE(Condition22) || ENABLE(Condition23)
150 COMPILE_ASSERT(1 == TestInterface::IMPLEMENTSCONSTANT1, TestInterfaceEnumIMPLEMENTSCONSTANT1IsWrongUseDoNotCheckConstants);
151 #endif
152 #if ENABLE(Condition22) || ENABLE(Condition23)
153 COMPILE_ASSERT(2 == TestInterface::CONST_IMPL, TestInterfaceEnumCONST_IMPLIsWrongUseDoNotCheckConstants);
154 #endif
155 #if ENABLE(Condition11) || ENABLE(Condition12)
156 COMPILE_ASSERT(1 == TestSupplemental::SUPPLEMENTALCONSTANT1, TestInterfaceEnumSUPPLEMENTALCONSTANT1IsWrongUseDoNotCheckConstants);
157 #endif
158 #if ENABLE(Condition11) || ENABLE(Condition12)
159 COMPILE_ASSERT(2 == TestSupplemental::CONST_IMPL, TestInterfaceEnumCONST_IMPLIsWrongUseDoNotCheckConstants);
160 #endif
161
162 EncodedJSValue JSC_HOST_CALL JSTestInterfaceConstructor::constructJSTestInterface(ExecState* exec)
163 {
164     JSTestInterfaceConstructor* castedThis = jsCast<JSTestInterfaceConstructor*>(exec->callee());
165     if (exec->argumentCount() < 1)
166         return throwVMError(exec, createNotEnoughArgumentsError(exec));
167     ExceptionCode ec = 0;
168     const String& str1(exec->argument(0).isEmpty() ? String() : exec->argument(0).toString(exec)->value(exec));
169     if (UNLIKELY(exec->hadException()))
170         return JSValue::encode(jsUndefined());
171     const String& str2(exec->argument(1).isEmpty() ? String() : exec->argument(1).toString(exec)->value(exec));
172     if (UNLIKELY(exec->hadException()))
173         return JSValue::encode(jsUndefined());
174     ScriptExecutionContext* context = castedThis->scriptExecutionContext();
175     if (!context)
176         return throwConstructorDocumentUnavailableError(*exec, "TestInterface");
177     RefPtr<TestInterface> object = TestInterface::create(*context, str1, str2, ec);
178     if (ec) {
179         setDOMException(exec, ec);
180         return JSValue::encode(JSValue());
181     }
182     return JSValue::encode(asObject(toJS(exec, castedThis->globalObject(), object.get())));
183 }
184
185 const ClassInfo JSTestInterfaceConstructor::s_info = { "TestInterfaceConstructor", &Base::s_info, &JSTestInterfaceConstructorTable, 0, CREATE_METHOD_TABLE(JSTestInterfaceConstructor) };
186
187 JSTestInterfaceConstructor::JSTestInterfaceConstructor(Structure* structure, JSDOMGlobalObject* globalObject)
188     : DOMConstructorObject(structure, globalObject)
189 {
190 }
191
192 void JSTestInterfaceConstructor::finishCreation(VM& vm, JSDOMGlobalObject* globalObject)
193 {
194     Base::finishCreation(vm);
195     ASSERT(inherits(info()));
196     putDirectPrototypeProperty(vm, JSTestInterfacePrototype::self(vm, globalObject), DontDelete | ReadOnly);
197     putDirect(vm, vm.propertyNames->length, jsNumber(1), ReadOnly | DontDelete | DontEnum);
198 }
199
200 bool JSTestInterfaceConstructor::getOwnPropertySlot(JSObject* object, ExecState* exec, PropertyName propertyName, PropertySlot& slot)
201 {
202     return getStaticPropertySlot<JSTestInterfaceConstructor, JSDOMWrapper>(exec, JSTestInterfaceConstructorTable, jsCast<JSTestInterfaceConstructor*>(object), propertyName, slot);
203 }
204
205 #if ENABLE(TEST_INTERFACE)
206 ConstructType JSTestInterfaceConstructor::getConstructData(JSCell*, ConstructData& constructData)
207 {
208     constructData.native.function = constructJSTestInterface;
209     return ConstructTypeHost;
210 }
211 #endif // ENABLE(TEST_INTERFACE)
212
213 /* Hash table for prototype */
214
215 static const struct CompactHashIndex JSTestInterfacePrototypeTableIndex[65] = {
216     { -1, -1 },
217     { 3, 64 },
218     { 14, -1 },
219     { -1, -1 },
220     { -1, -1 },
221     { -1, -1 },
222     { -1, -1 },
223     { -1, -1 },
224     { -1, -1 },
225     { -1, -1 },
226     { -1, -1 },
227     { 13, -1 },
228     { -1, -1 },
229     { -1, -1 },
230     { -1, -1 },
231     { 10, -1 },
232     { -1, -1 },
233     { 5, -1 },
234     { -1, -1 },
235     { -1, -1 },
236     { -1, -1 },
237     { -1, -1 },
238     { -1, -1 },
239     { 4, -1 },
240     { -1, -1 },
241     { 0, -1 },
242     { -1, -1 },
243     { 7, -1 },
244     { -1, -1 },
245     { -1, -1 },
246     { 15, -1 },
247     { 1, -1 },
248     { 6, -1 },
249     { -1, -1 },
250     { -1, -1 },
251     { -1, -1 },
252     { -1, -1 },
253     { -1, -1 },
254     { -1, -1 },
255     { -1, -1 },
256     { -1, -1 },
257     { -1, -1 },
258     { 11, -1 },
259     { -1, -1 },
260     { -1, -1 },
261     { -1, -1 },
262     { -1, -1 },
263     { 8, -1 },
264     { -1, -1 },
265     { -1, -1 },
266     { -1, -1 },
267     { -1, -1 },
268     { -1, -1 },
269     { -1, -1 },
270     { -1, -1 },
271     { -1, -1 },
272     { -1, -1 },
273     { 16, -1 },
274     { -1, -1 },
275     { -1, -1 },
276     { -1, -1 },
277     { 2, -1 },
278     { 9, -1 },
279     { -1, -1 },
280     { 12, -1 },
281 };
282
283
284 static const HashTableValue JSTestInterfacePrototypeTableValues[] =
285 {
286     { "constructor", DontEnum | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
287 #if ENABLE(Condition22) || ENABLE(Condition23)
288     { "implementsStr1", DontDelete | ReadOnly | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceImplementsStr1), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
289 #else
290     { 0, 0, NoIntrinsic, 0, 0 },
291 #endif
292 #if ENABLE(Condition22) || ENABLE(Condition23)
293     { "implementsStr2", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceImplementsStr2), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestInterfaceImplementsStr2) },
294 #else
295     { 0, 0, NoIntrinsic, 0, 0 },
296 #endif
297 #if ENABLE(Condition22) || ENABLE(Condition23)
298     { "implementsNode", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceImplementsNode), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestInterfaceImplementsNode) },
299 #else
300     { 0, 0, NoIntrinsic, 0, 0 },
301 #endif
302 #if ENABLE(Condition11) || ENABLE(Condition12)
303     { "supplementalStr1", DontDelete | ReadOnly | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceSupplementalStr1), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
304 #else
305     { 0, 0, NoIntrinsic, 0, 0 },
306 #endif
307 #if ENABLE(Condition11) || ENABLE(Condition12)
308     { "supplementalStr2", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceSupplementalStr2), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestInterfaceSupplementalStr2) },
309 #else
310     { 0, 0, NoIntrinsic, 0, 0 },
311 #endif
312 #if ENABLE(Condition11) || ENABLE(Condition12)
313     { "supplementalNode", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceSupplementalNode), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestInterfaceSupplementalNode) },
314 #else
315     { 0, 0, NoIntrinsic, 0, 0 },
316 #endif
317 #if ENABLE(Condition22) || ENABLE(Condition23)
318     { "IMPLEMENTSCONSTANT1", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceIMPLEMENTSCONSTANT1), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
319 #else
320     { 0, 0, NoIntrinsic, 0, 0 },
321 #endif
322 #if ENABLE(Condition22) || ENABLE(Condition23)
323     { "IMPLEMENTSCONSTANT2", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceIMPLEMENTSCONSTANT2), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
324 #else
325     { 0, 0, NoIntrinsic, 0, 0 },
326 #endif
327 #if ENABLE(Condition11) || ENABLE(Condition12)
328     { "SUPPLEMENTALCONSTANT1", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceSUPPLEMENTALCONSTANT1), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
329 #else
330     { 0, 0, NoIntrinsic, 0, 0 },
331 #endif
332 #if ENABLE(Condition11) || ENABLE(Condition12)
333     { "SUPPLEMENTALCONSTANT2", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceSUPPLEMENTALCONSTANT2), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
334 #else
335     { 0, 0, NoIntrinsic, 0, 0 },
336 #endif
337 #if ENABLE(Condition22) || ENABLE(Condition23)
338     { "implementsMethod1", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestInterfacePrototypeFunctionImplementsMethod1), (intptr_t) (0) },
339 #else
340     { 0, 0, NoIntrinsic, 0, 0 },
341 #endif
342 #if ENABLE(Condition22) || ENABLE(Condition23)
343     { "implementsMethod2", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestInterfacePrototypeFunctionImplementsMethod2), (intptr_t) (2) },
344 #else
345     { 0, 0, NoIntrinsic, 0, 0 },
346 #endif
347 #if ENABLE(Condition22) || ENABLE(Condition23)
348     { "implementsMethod3", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestInterfacePrototypeFunctionImplementsMethod3), (intptr_t) (0) },
349 #else
350     { 0, 0, NoIntrinsic, 0, 0 },
351 #endif
352 #if ENABLE(Condition11) || ENABLE(Condition12)
353     { "supplementalMethod1", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestInterfacePrototypeFunctionSupplementalMethod1), (intptr_t) (0) },
354 #else
355     { 0, 0, NoIntrinsic, 0, 0 },
356 #endif
357 #if ENABLE(Condition11) || ENABLE(Condition12)
358     { "supplementalMethod2", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestInterfacePrototypeFunctionSupplementalMethod2), (intptr_t) (2) },
359 #else
360     { 0, 0, NoIntrinsic, 0, 0 },
361 #endif
362 #if ENABLE(Condition11) || ENABLE(Condition12)
363     { "supplementalMethod3", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestInterfacePrototypeFunctionSupplementalMethod3), (intptr_t) (0) },
364 #else
365     { 0, 0, NoIntrinsic, 0, 0 },
366 #endif
367 };
368
369 static const HashTable JSTestInterfacePrototypeTable = { 17, 63, true, JSTestInterfacePrototypeTableValues, 0, JSTestInterfacePrototypeTableIndex };
370 const ClassInfo JSTestInterfacePrototype::s_info = { "TestInterfacePrototype", &Base::s_info, &JSTestInterfacePrototypeTable, 0, CREATE_METHOD_TABLE(JSTestInterfacePrototype) };
371
372 JSObject* JSTestInterfacePrototype::self(VM& vm, JSGlobalObject* globalObject)
373 {
374     return getDOMPrototype<JSTestInterface>(vm, globalObject);
375 }
376
377 bool JSTestInterfacePrototype::getOwnPropertySlot(JSObject* object, ExecState* exec, PropertyName propertyName, PropertySlot& slot)
378 {
379     JSTestInterfacePrototype* thisObject = jsCast<JSTestInterfacePrototype*>(object);
380     return getStaticPropertySlot<JSTestInterfacePrototype, JSObject>(exec, JSTestInterfacePrototypeTable, thisObject, propertyName, slot);
381 }
382
383 const ClassInfo JSTestInterface::s_info = { "TestInterface", &Base::s_info, &JSTestInterfaceTable, 0 , CREATE_METHOD_TABLE(JSTestInterface) };
384
385 JSTestInterface::JSTestInterface(Structure* structure, JSDOMGlobalObject* globalObject, PassRefPtr<TestInterface> impl)
386     : JSDOMWrapper(structure, globalObject)
387     , m_impl(impl.leakRef())
388 {
389 }
390
391 JSObject* JSTestInterface::createPrototype(VM& vm, JSGlobalObject* globalObject)
392 {
393     return JSTestInterfacePrototype::create(vm, globalObject, JSTestInterfacePrototype::createStructure(vm, globalObject, globalObject->objectPrototype()));
394 }
395
396 void JSTestInterface::destroy(JSC::JSCell* cell)
397 {
398     JSTestInterface* thisObject = static_cast<JSTestInterface*>(cell);
399     thisObject->JSTestInterface::~JSTestInterface();
400 }
401
402 JSTestInterface::~JSTestInterface()
403 {
404     releaseImplIfNotNull();
405 }
406
407 bool JSTestInterface::getOwnPropertySlot(JSObject* object, ExecState* exec, PropertyName propertyName, PropertySlot& slot)
408 {
409     JSTestInterface* thisObject = jsCast<JSTestInterface*>(object);
410     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
411     return getStaticValueSlot<JSTestInterface, Base>(exec, JSTestInterfaceTable, thisObject, propertyName, slot);
412 }
413
414 #if ENABLE(Condition22) || ENABLE(Condition23)
415 EncodedJSValue jsTestInterfaceConstructorImplementsStaticReadOnlyAttr(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
416 {
417     UNUSED_PARAM(thisValue);
418     UNUSED_PARAM(slotBase);
419     JSValue result = jsNumber(TestInterface::implementsStaticReadOnlyAttr());
420     return JSValue::encode(result);
421 }
422
423 #endif
424
425 #if ENABLE(Condition22) || ENABLE(Condition23)
426 EncodedJSValue jsTestInterfaceConstructorImplementsStaticAttr(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
427 {
428     UNUSED_PARAM(thisValue);
429     UNUSED_PARAM(slotBase);
430     JSValue result = jsStringWithCache(exec, TestInterface::implementsStaticAttr());
431     return JSValue::encode(result);
432 }
433
434 #endif
435
436 #if ENABLE(Condition22) || ENABLE(Condition23)
437 EncodedJSValue jsTestInterfaceImplementsStr1(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
438 {
439     JSTestInterface* castedThis = jsDynamicCast<JSTestInterface*>(JSValue::decode(thisValue));
440     if (UNLIKELY(!castedThis)) {
441         if (jsDynamicCast<JSTestInterfacePrototype*>(slotBase))
442             return reportDeprecatedGetterError(*exec, "TestInterface", "implementsStr1");
443         return throwGetterTypeError(*exec, "TestInterface", "implementsStr1");
444     }
445     TestInterface& impl = castedThis->impl();
446     JSValue result = jsStringWithCache(exec, impl.implementsStr1());
447     return JSValue::encode(result);
448 }
449
450 #endif
451
452 #if ENABLE(Condition22) || ENABLE(Condition23)
453 EncodedJSValue jsTestInterfaceImplementsStr2(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
454 {
455     JSTestInterface* castedThis = jsDynamicCast<JSTestInterface*>(JSValue::decode(thisValue));
456     if (UNLIKELY(!castedThis)) {
457         if (jsDynamicCast<JSTestInterfacePrototype*>(slotBase))
458             return reportDeprecatedGetterError(*exec, "TestInterface", "implementsStr2");
459         return throwGetterTypeError(*exec, "TestInterface", "implementsStr2");
460     }
461     TestInterface& impl = castedThis->impl();
462     JSValue result = jsStringWithCache(exec, impl.implementsStr2());
463     return JSValue::encode(result);
464 }
465
466 #endif
467
468 #if ENABLE(Condition22) || ENABLE(Condition23)
469 EncodedJSValue jsTestInterfaceImplementsStr3(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
470 {
471     JSTestInterface* castedThis = jsDynamicCast<JSTestInterface*>(JSValue::decode(thisValue));
472     if (UNLIKELY(!castedThis)) {
473         if (jsDynamicCast<JSTestInterfacePrototype*>(slotBase))
474             return reportDeprecatedGetterError(*exec, "TestInterface", "implementsStr3");
475         return throwGetterTypeError(*exec, "TestInterface", "implementsStr3");
476     }
477     return JSValue::encode(castedThis->implementsStr3(exec));
478 }
479
480 #endif
481
482 #if ENABLE(Condition22) || ENABLE(Condition23)
483 EncodedJSValue jsTestInterfaceImplementsNode(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
484 {
485     JSTestInterface* castedThis = jsDynamicCast<JSTestInterface*>(JSValue::decode(thisValue));
486     if (UNLIKELY(!castedThis)) {
487         if (jsDynamicCast<JSTestInterfacePrototype*>(slotBase))
488             return reportDeprecatedGetterError(*exec, "TestInterface", "implementsNode");
489         return throwGetterTypeError(*exec, "TestInterface", "implementsNode");
490     }
491     TestInterface& impl = castedThis->impl();
492     JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.implementsNode()));
493     return JSValue::encode(result);
494 }
495
496 #endif
497
498 #if ENABLE(Condition11) || ENABLE(Condition12)
499 EncodedJSValue jsTestInterfaceConstructorSupplementalStaticReadOnlyAttr(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
500 {
501     UNUSED_PARAM(thisValue);
502     UNUSED_PARAM(slotBase);
503     JSValue result = jsNumber(TestSupplemental::supplementalStaticReadOnlyAttr());
504     return JSValue::encode(result);
505 }
506
507 #endif
508
509 #if ENABLE(Condition11) || ENABLE(Condition12)
510 EncodedJSValue jsTestInterfaceConstructorSupplementalStaticAttr(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
511 {
512     UNUSED_PARAM(thisValue);
513     UNUSED_PARAM(slotBase);
514     JSValue result = jsStringWithCache(exec, TestSupplemental::supplementalStaticAttr());
515     return JSValue::encode(result);
516 }
517
518 #endif
519
520 #if ENABLE(Condition11) || ENABLE(Condition12)
521 EncodedJSValue jsTestInterfaceSupplementalStr1(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
522 {
523     JSTestInterface* castedThis = jsDynamicCast<JSTestInterface*>(JSValue::decode(thisValue));
524     if (UNLIKELY(!castedThis)) {
525         if (jsDynamicCast<JSTestInterfacePrototype*>(slotBase))
526             return reportDeprecatedGetterError(*exec, "TestInterface", "supplementalStr1");
527         return throwGetterTypeError(*exec, "TestInterface", "supplementalStr1");
528     }
529     TestInterface& impl = castedThis->impl();
530     JSValue result = jsStringWithCache(exec, TestSupplemental::supplementalStr1(&impl));
531     return JSValue::encode(result);
532 }
533
534 #endif
535
536 #if ENABLE(Condition11) || ENABLE(Condition12)
537 EncodedJSValue jsTestInterfaceSupplementalStr2(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
538 {
539     JSTestInterface* castedThis = jsDynamicCast<JSTestInterface*>(JSValue::decode(thisValue));
540     if (UNLIKELY(!castedThis)) {
541         if (jsDynamicCast<JSTestInterfacePrototype*>(slotBase))
542             return reportDeprecatedGetterError(*exec, "TestInterface", "supplementalStr2");
543         return throwGetterTypeError(*exec, "TestInterface", "supplementalStr2");
544     }
545     TestInterface& impl = castedThis->impl();
546     JSValue result = jsStringWithCache(exec, TestSupplemental::supplementalStr2(&impl));
547     return JSValue::encode(result);
548 }
549
550 #endif
551
552 #if ENABLE(Condition11) || ENABLE(Condition12)
553 EncodedJSValue jsTestInterfaceSupplementalStr3(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
554 {
555     JSTestInterface* castedThis = jsDynamicCast<JSTestInterface*>(JSValue::decode(thisValue));
556     if (UNLIKELY(!castedThis)) {
557         if (jsDynamicCast<JSTestInterfacePrototype*>(slotBase))
558             return reportDeprecatedGetterError(*exec, "TestInterface", "supplementalStr3");
559         return throwGetterTypeError(*exec, "TestInterface", "supplementalStr3");
560     }
561     return JSValue::encode(castedThis->supplementalStr3(exec));
562 }
563
564 #endif
565
566 #if ENABLE(Condition11) || ENABLE(Condition12)
567 EncodedJSValue jsTestInterfaceSupplementalNode(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
568 {
569     JSTestInterface* castedThis = jsDynamicCast<JSTestInterface*>(JSValue::decode(thisValue));
570     if (UNLIKELY(!castedThis)) {
571         if (jsDynamicCast<JSTestInterfacePrototype*>(slotBase))
572             return reportDeprecatedGetterError(*exec, "TestInterface", "supplementalNode");
573         return throwGetterTypeError(*exec, "TestInterface", "supplementalNode");
574     }
575     TestInterface& impl = castedThis->impl();
576     JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(TestSupplemental::supplementalNode(&impl)));
577     return JSValue::encode(result);
578 }
579
580 #endif
581
582 EncodedJSValue jsTestInterfaceConstructor(ExecState* exec, JSObject* baseValue, EncodedJSValue, PropertyName)
583 {
584     JSTestInterfacePrototype* domObject = jsDynamicCast<JSTestInterfacePrototype*>(baseValue);
585     if (!domObject)
586         return throwVMTypeError(exec);
587     return JSValue::encode(JSTestInterface::getConstructor(exec->vm(), domObject->globalObject()));
588 }
589
590 void JSTestInterface::put(JSCell* cell, ExecState* exec, PropertyName propertyName, JSValue value, PutPropertySlot& slot)
591 {
592     JSTestInterface* thisObject = jsCast<JSTestInterface*>(cell);
593     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
594     if (thisObject->putDelegate(exec, propertyName, value, slot))
595         return;
596     Base::put(thisObject, exec, propertyName, value, slot);
597 }
598
599 void JSTestInterface::putByIndex(JSCell* cell, ExecState* exec, unsigned index, JSValue value, bool shouldThrow)
600 {
601     JSTestInterface* thisObject = jsCast<JSTestInterface*>(cell);
602     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
603     PropertyName propertyName = Identifier::from(exec, index);
604     PutPropertySlot slot(thisObject, shouldThrow);
605     if (thisObject->putDelegate(exec, propertyName, value, slot))
606         return;
607     Base::putByIndex(cell, exec, index, value, shouldThrow);
608 }
609
610 #if ENABLE(Condition22) || ENABLE(Condition23)
611 void setJSTestInterfaceConstructorImplementsStaticAttr(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue, EncodedJSValue encodedValue)
612 {
613     JSValue value = JSValue::decode(encodedValue);
614     const String& nativeValue(value.isEmpty() ? String() : value.toString(exec)->value(exec));
615     if (UNLIKELY(exec->hadException()))
616         return;
617     TestInterface::setImplementsStaticAttr(nativeValue);
618 }
619
620 #endif
621
622 #if ENABLE(Condition22) || ENABLE(Condition23)
623 void setJSTestInterfaceImplementsStr2(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
624 {
625     JSValue value = JSValue::decode(encodedValue);
626     JSTestInterface* castedThis = jsDynamicCast<JSTestInterface*>(JSValue::decode(thisValue));
627     if (UNLIKELY(!castedThis)) {
628         throwSetterTypeError(*exec, "TestInterface", "implementsStr2");
629         return;
630     }
631     TestInterface& impl = castedThis->impl();
632     const String& nativeValue(value.isEmpty() ? String() : value.toString(exec)->value(exec));
633     if (UNLIKELY(exec->hadException()))
634         return;
635     impl.setImplementsStr2(nativeValue);
636 }
637
638 #endif
639
640 #if ENABLE(Condition22) || ENABLE(Condition23)
641 void setJSTestInterfaceImplementsStr3(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
642 {
643     JSValue value = JSValue::decode(encodedValue);
644     JSTestInterface* castedThis = jsDynamicCast<JSTestInterface*>(JSValue::decode(thisValue));
645     if (UNLIKELY(!castedThis)) {
646         throwSetterTypeError(*exec, "TestInterface", "implementsStr3");
647         return;
648     }
649     castedThis->setImplementsStr3(exec, value);
650 }
651
652 #endif
653
654 #if ENABLE(Condition22) || ENABLE(Condition23)
655 void setJSTestInterfaceImplementsNode(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
656 {
657     JSValue value = JSValue::decode(encodedValue);
658     JSTestInterface* castedThis = jsDynamicCast<JSTestInterface*>(JSValue::decode(thisValue));
659     if (UNLIKELY(!castedThis)) {
660         throwSetterTypeError(*exec, "TestInterface", "implementsNode");
661         return;
662     }
663     TestInterface& impl = castedThis->impl();
664     Node* nativeValue(toNode(value));
665     if (UNLIKELY(exec->hadException()))
666         return;
667     impl.setImplementsNode(nativeValue);
668 }
669
670 #endif
671
672 #if ENABLE(Condition11) || ENABLE(Condition12)
673 void setJSTestInterfaceConstructorSupplementalStaticAttr(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue, EncodedJSValue encodedValue)
674 {
675     JSValue value = JSValue::decode(encodedValue);
676     const String& nativeValue(value.isEmpty() ? String() : value.toString(exec)->value(exec));
677     if (UNLIKELY(exec->hadException()))
678         return;
679     TestSupplemental::setSupplementalStaticAttr(nativeValue);
680 }
681
682 #endif
683
684 #if ENABLE(Condition11) || ENABLE(Condition12)
685 void setJSTestInterfaceSupplementalStr2(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
686 {
687     JSValue value = JSValue::decode(encodedValue);
688     JSTestInterface* castedThis = jsDynamicCast<JSTestInterface*>(JSValue::decode(thisValue));
689     if (UNLIKELY(!castedThis)) {
690         throwSetterTypeError(*exec, "TestInterface", "supplementalStr2");
691         return;
692     }
693     TestInterface& impl = castedThis->impl();
694     const String& nativeValue(value.isEmpty() ? String() : value.toString(exec)->value(exec));
695     if (UNLIKELY(exec->hadException()))
696         return;
697     TestSupplemental::setSupplementalStr2(&impl, nativeValue);
698 }
699
700 #endif
701
702 #if ENABLE(Condition11) || ENABLE(Condition12)
703 void setJSTestInterfaceSupplementalStr3(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
704 {
705     JSValue value = JSValue::decode(encodedValue);
706     JSTestInterface* castedThis = jsDynamicCast<JSTestInterface*>(JSValue::decode(thisValue));
707     if (UNLIKELY(!castedThis)) {
708         throwSetterTypeError(*exec, "TestInterface", "supplementalStr3");
709         return;
710     }
711     castedThis->setSupplementalStr3(exec, value);
712 }
713
714 #endif
715
716 #if ENABLE(Condition11) || ENABLE(Condition12)
717 void setJSTestInterfaceSupplementalNode(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
718 {
719     JSValue value = JSValue::decode(encodedValue);
720     JSTestInterface* castedThis = jsDynamicCast<JSTestInterface*>(JSValue::decode(thisValue));
721     if (UNLIKELY(!castedThis)) {
722         throwSetterTypeError(*exec, "TestInterface", "supplementalNode");
723         return;
724     }
725     TestInterface& impl = castedThis->impl();
726     Node* nativeValue(toNode(value));
727     if (UNLIKELY(exec->hadException()))
728         return;
729     TestSupplemental::setSupplementalNode(&impl, nativeValue);
730 }
731
732 #endif
733
734 JSValue JSTestInterface::getConstructor(VM& vm, JSGlobalObject* globalObject)
735 {
736     return getDOMConstructor<JSTestInterfaceConstructor>(vm, jsCast<JSDOMGlobalObject*>(globalObject));
737 }
738
739 #if ENABLE(Condition22) || ENABLE(Condition23)
740 EncodedJSValue JSC_HOST_CALL jsTestInterfacePrototypeFunctionImplementsMethod1(ExecState* exec)
741 {
742     JSValue thisValue = exec->thisValue();
743     JSTestInterface* castedThis = jsDynamicCast<JSTestInterface*>(thisValue);
744     if (UNLIKELY(!castedThis))
745         return throwThisTypeError(*exec, "TestInterface", "implementsMethod1");
746     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestInterface::info());
747     TestInterface& impl = castedThis->impl();
748     impl.implementsMethod1();
749     return JSValue::encode(jsUndefined());
750 }
751
752 #endif
753
754 #if ENABLE(Condition22) || ENABLE(Condition23)
755 EncodedJSValue JSC_HOST_CALL jsTestInterfacePrototypeFunctionImplementsMethod2(ExecState* exec)
756 {
757     JSValue thisValue = exec->thisValue();
758     JSTestInterface* castedThis = jsDynamicCast<JSTestInterface*>(thisValue);
759     if (UNLIKELY(!castedThis))
760         return throwThisTypeError(*exec, "TestInterface", "implementsMethod2");
761     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestInterface::info());
762     TestInterface& impl = castedThis->impl();
763     if (exec->argumentCount() < 2)
764         return throwVMError(exec, createNotEnoughArgumentsError(exec));
765     ExceptionCode ec = 0;
766     ScriptExecutionContext* scriptContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
767     if (!scriptContext)
768         return JSValue::encode(jsUndefined());
769     const String& strArg(exec->argument(0).isEmpty() ? String() : exec->argument(0).toString(exec)->value(exec));
770     if (UNLIKELY(exec->hadException()))
771         return JSValue::encode(jsUndefined());
772     TestObj* objArg(toTestObj(exec->argument(1)));
773     if (UNLIKELY(exec->hadException()))
774         return JSValue::encode(jsUndefined());
775     JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.implementsMethod2(scriptContext, strArg, objArg, ec)));
776
777     setDOMException(exec, ec);
778     return JSValue::encode(result);
779 }
780
781 #endif
782
783 #if ENABLE(Condition22) || ENABLE(Condition23)
784 EncodedJSValue JSC_HOST_CALL jsTestInterfacePrototypeFunctionImplementsMethod3(ExecState* exec)
785 {
786     JSValue thisValue = exec->thisValue();
787     JSTestInterface* castedThis = jsDynamicCast<JSTestInterface*>(thisValue);
788     if (UNLIKELY(!castedThis))
789         return throwThisTypeError(*exec, "TestInterface", "implementsMethod3");
790     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestInterface::info());
791     return JSValue::encode(castedThis->implementsMethod3(exec));
792 }
793
794 #endif
795
796 #if ENABLE(Condition22) || ENABLE(Condition23)
797 EncodedJSValue JSC_HOST_CALL jsTestInterfaceConstructorFunctionImplementsMethod4(ExecState* exec)
798 {
799     TestInterface::implementsMethod4();
800     return JSValue::encode(jsUndefined());
801 }
802
803 #endif
804
805 #if ENABLE(Condition11) || ENABLE(Condition12)
806 EncodedJSValue JSC_HOST_CALL jsTestInterfacePrototypeFunctionSupplementalMethod1(ExecState* exec)
807 {
808     JSValue thisValue = exec->thisValue();
809     JSTestInterface* castedThis = jsDynamicCast<JSTestInterface*>(thisValue);
810     if (UNLIKELY(!castedThis))
811         return throwThisTypeError(*exec, "TestInterface", "supplementalMethod1");
812     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestInterface::info());
813     TestInterface& impl = castedThis->impl();
814     TestSupplemental::supplementalMethod1(&impl);
815     return JSValue::encode(jsUndefined());
816 }
817
818 #endif
819
820 #if ENABLE(Condition11) || ENABLE(Condition12)
821 EncodedJSValue JSC_HOST_CALL jsTestInterfacePrototypeFunctionSupplementalMethod2(ExecState* exec)
822 {
823     JSValue thisValue = exec->thisValue();
824     JSTestInterface* castedThis = jsDynamicCast<JSTestInterface*>(thisValue);
825     if (UNLIKELY(!castedThis))
826         return throwThisTypeError(*exec, "TestInterface", "supplementalMethod2");
827     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestInterface::info());
828     TestInterface& impl = castedThis->impl();
829     if (exec->argumentCount() < 2)
830         return throwVMError(exec, createNotEnoughArgumentsError(exec));
831     ExceptionCode ec = 0;
832     ScriptExecutionContext* scriptContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
833     if (!scriptContext)
834         return JSValue::encode(jsUndefined());
835     const String& strArg(exec->argument(0).isEmpty() ? String() : exec->argument(0).toString(exec)->value(exec));
836     if (UNLIKELY(exec->hadException()))
837         return JSValue::encode(jsUndefined());
838     TestObj* objArg(toTestObj(exec->argument(1)));
839     if (UNLIKELY(exec->hadException()))
840         return JSValue::encode(jsUndefined());
841     JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(TestSupplemental::supplementalMethod2(&impl, scriptContext, strArg, objArg, ec)));
842
843     setDOMException(exec, ec);
844     return JSValue::encode(result);
845 }
846
847 #endif
848
849 #if ENABLE(Condition11) || ENABLE(Condition12)
850 EncodedJSValue JSC_HOST_CALL jsTestInterfacePrototypeFunctionSupplementalMethod3(ExecState* exec)
851 {
852     JSValue thisValue = exec->thisValue();
853     JSTestInterface* castedThis = jsDynamicCast<JSTestInterface*>(thisValue);
854     if (UNLIKELY(!castedThis))
855         return throwThisTypeError(*exec, "TestInterface", "supplementalMethod3");
856     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestInterface::info());
857     return JSValue::encode(castedThis->supplementalMethod3(exec));
858 }
859
860 #endif
861
862 #if ENABLE(Condition11) || ENABLE(Condition12)
863 EncodedJSValue JSC_HOST_CALL jsTestInterfaceConstructorFunctionSupplementalMethod4(ExecState* exec)
864 {
865     TestSupplemental::supplementalMethod4();
866     return JSValue::encode(jsUndefined());
867 }
868
869 #endif
870
871 // Constant getters
872
873 #if ENABLE(Condition22) || ENABLE(Condition23)
874 EncodedJSValue jsTestInterfaceIMPLEMENTSCONSTANT1(ExecState*, JSObject*, EncodedJSValue, PropertyName)
875 {
876     return JSValue::encode(jsNumber(1));
877 }
878
879 #endif
880 #if ENABLE(Condition22) || ENABLE(Condition23)
881 EncodedJSValue jsTestInterfaceIMPLEMENTSCONSTANT2(ExecState*, JSObject*, EncodedJSValue, PropertyName)
882 {
883     return JSValue::encode(jsNumber(2));
884 }
885
886 #endif
887 #if ENABLE(Condition11) || ENABLE(Condition12)
888 EncodedJSValue jsTestInterfaceSUPPLEMENTALCONSTANT1(ExecState*, JSObject*, EncodedJSValue, PropertyName)
889 {
890     return JSValue::encode(jsNumber(1));
891 }
892
893 #endif
894 #if ENABLE(Condition11) || ENABLE(Condition12)
895 EncodedJSValue jsTestInterfaceSUPPLEMENTALCONSTANT2(ExecState*, JSObject*, EncodedJSValue, PropertyName)
896 {
897     return JSValue::encode(jsNumber(2));
898 }
899
900 #endif
901 bool JSTestInterfaceOwner::isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown> handle, void*, SlotVisitor& visitor)
902 {
903     JSTestInterface* jsTestInterface = jsCast<JSTestInterface*>(handle.slot()->asCell());
904     if (jsTestInterface->impl().hasPendingActivity())
905         return true;
906     UNUSED_PARAM(visitor);
907     return false;
908 }
909
910 void JSTestInterfaceOwner::finalize(JSC::Handle<JSC::Unknown> handle, void* context)
911 {
912     JSTestInterface* jsTestInterface = jsCast<JSTestInterface*>(handle.slot()->asCell());
913     DOMWrapperWorld& world = *static_cast<DOMWrapperWorld*>(context);
914     uncacheWrapper(world, &jsTestInterface->impl(), jsTestInterface);
915     jsTestInterface->releaseImpl();
916 }
917
918 JSC::JSValue toJS(JSC::ExecState*, JSDOMGlobalObject* globalObject, TestInterface* impl)
919 {
920     if (!impl)
921         return jsNull();
922     if (JSValue result = getExistingWrapper<JSTestInterface>(globalObject, impl))
923         return result;
924 #if COMPILER(CLANG)
925     // If you hit this failure the interface definition has the ImplementationLacksVTable
926     // attribute. You should remove that attribute. If the class has subclasses
927     // that may be passed through this toJS() function you should use the SkipVTableValidation
928     // attribute to TestInterface.
929     COMPILE_ASSERT(!__is_polymorphic(TestInterface), TestInterface_is_polymorphic_but_idl_claims_not_to_be);
930 #endif
931     return createNewWrapper<JSTestInterface>(globalObject, impl);
932 }
933
934 TestInterface* toTestInterface(JSC::JSValue value)
935 {
936     if (auto* wrapper = jsDynamicCast<JSTestInterface*>(value))
937         return &wrapper->impl();
938     return nullptr;
939 }
940
941 }
942
943 #endif // ENABLE(Condition1) || ENABLE(Condition2)