769fc669e90c75c5e4e73fec86661f06d2c937f3
[WebKit-https.git] / Source / WebCore / bindings / scripts / test / JS / JSTestSerializedScriptValueInterface.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 "JSTestSerializedScriptValueInterface.h"
26
27 #include "JSMessagePort.h"
28 #include "MessagePort.h"
29 #include "ScriptExecutionContext.h"
30 #include "SerializedScriptValue.h"
31 #include "TestSerializedScriptValueInterface.h"
32 #include <runtime/JSArray.h>
33 #include <wtf/GetPtr.h>
34
35 using namespace JSC;
36
37 namespace WebCore {
38
39 /* Hash table for constructor */
40
41 static const struct CompactHashIndex JSTestSerializedScriptValueInterfaceConstructorTableIndex[1] = {
42     { -1, -1 },
43 };
44
45
46 static const HashTableValue JSTestSerializedScriptValueInterfaceConstructorTableValues[] =
47 {
48     { 0, 0, NoIntrinsic, 0, 0 }
49 };
50
51 static const HashTable JSTestSerializedScriptValueInterfaceConstructorTable = { 0, 0, false, JSTestSerializedScriptValueInterfaceConstructorTableValues, 0, JSTestSerializedScriptValueInterfaceConstructorTableIndex };
52 const ClassInfo JSTestSerializedScriptValueInterfaceConstructor::s_info = { "TestSerializedScriptValueInterfaceConstructor", &Base::s_info, &JSTestSerializedScriptValueInterfaceConstructorTable, 0, CREATE_METHOD_TABLE(JSTestSerializedScriptValueInterfaceConstructor) };
53
54 JSTestSerializedScriptValueInterfaceConstructor::JSTestSerializedScriptValueInterfaceConstructor(Structure* structure, JSDOMGlobalObject* globalObject)
55     : DOMConstructorObject(structure, globalObject)
56 {
57 }
58
59 void JSTestSerializedScriptValueInterfaceConstructor::finishCreation(VM& vm, JSDOMGlobalObject* globalObject)
60 {
61     Base::finishCreation(vm);
62     ASSERT(inherits(info()));
63     putDirect(vm, vm.propertyNames->prototype, JSTestSerializedScriptValueInterfacePrototype::self(vm, globalObject), DontDelete | ReadOnly);
64     putDirect(vm, vm.propertyNames->length, jsNumber(0), ReadOnly | DontDelete | DontEnum);
65 }
66
67 bool JSTestSerializedScriptValueInterfaceConstructor::getOwnPropertySlot(JSObject* object, ExecState* exec, PropertyName propertyName, PropertySlot& slot)
68 {
69     return getStaticValueSlot<JSTestSerializedScriptValueInterfaceConstructor, JSDOMWrapper>(exec, JSTestSerializedScriptValueInterfaceConstructorTable, jsCast<JSTestSerializedScriptValueInterfaceConstructor*>(object), propertyName, slot);
70 }
71
72 /* Hash table for prototype */
73
74 static const struct CompactHashIndex JSTestSerializedScriptValueInterfacePrototypeTableIndex[17] = {
75     { -1, -1 },
76     { -1, -1 },
77     { 3, -1 },
78     { -1, -1 },
79     { -1, -1 },
80     { 2, 16 },
81     { -1, -1 },
82     { 4, -1 },
83     { -1, -1 },
84     { 0, -1 },
85     { -1, -1 },
86     { 1, -1 },
87     { -1, -1 },
88     { -1, -1 },
89     { -1, -1 },
90     { -1, -1 },
91     { 5, -1 },
92 };
93
94
95 static const HashTableValue JSTestSerializedScriptValueInterfacePrototypeTableValues[] =
96 {
97     { "constructor", DontEnum | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestSerializedScriptValueInterfaceConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
98     { "value", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestSerializedScriptValueInterfaceValue), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestSerializedScriptValueInterfaceValue) },
99     { "readonlyValue", DontDelete | ReadOnly | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestSerializedScriptValueInterfaceReadonlyValue), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
100     { "cachedValue", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestSerializedScriptValueInterfaceCachedValue), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestSerializedScriptValueInterfaceCachedValue) },
101     { "ports", DontDelete | ReadOnly | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestSerializedScriptValueInterfacePorts), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
102     { "cachedReadonlyValue", DontDelete | ReadOnly | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestSerializedScriptValueInterfaceCachedReadonlyValue), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
103 };
104
105 static const HashTable JSTestSerializedScriptValueInterfacePrototypeTable = { 6, 15, true, JSTestSerializedScriptValueInterfacePrototypeTableValues, 0, JSTestSerializedScriptValueInterfacePrototypeTableIndex };
106 const ClassInfo JSTestSerializedScriptValueInterfacePrototype::s_info = { "TestSerializedScriptValueInterfacePrototype", &Base::s_info, &JSTestSerializedScriptValueInterfacePrototypeTable, 0, CREATE_METHOD_TABLE(JSTestSerializedScriptValueInterfacePrototype) };
107
108 JSObject* JSTestSerializedScriptValueInterfacePrototype::self(VM& vm, JSGlobalObject* globalObject)
109 {
110     return getDOMPrototype<JSTestSerializedScriptValueInterface>(vm, globalObject);
111 }
112
113 bool JSTestSerializedScriptValueInterfacePrototype::getOwnPropertySlot(JSObject* object, ExecState* exec, PropertyName propertyName, PropertySlot& slot)
114 {
115     JSTestSerializedScriptValueInterfacePrototype* thisObject = jsCast<JSTestSerializedScriptValueInterfacePrototype*>(object);
116     return getStaticPropertySlot<JSTestSerializedScriptValueInterfacePrototype, JSObject>(exec, JSTestSerializedScriptValueInterfacePrototypeTable, thisObject, propertyName, slot);
117 }
118
119 const ClassInfo JSTestSerializedScriptValueInterface::s_info = { "TestSerializedScriptValueInterface", &Base::s_info, 0, 0 , CREATE_METHOD_TABLE(JSTestSerializedScriptValueInterface) };
120
121 JSTestSerializedScriptValueInterface::JSTestSerializedScriptValueInterface(Structure* structure, JSDOMGlobalObject* globalObject, PassRefPtr<TestSerializedScriptValueInterface> impl)
122     : JSDOMWrapper(structure, globalObject)
123     , m_impl(impl.leakRef())
124 {
125 }
126
127 void JSTestSerializedScriptValueInterface::finishCreation(VM& vm)
128 {
129     Base::finishCreation(vm);
130     ASSERT(inherits(info()));
131 }
132
133 JSObject* JSTestSerializedScriptValueInterface::createPrototype(VM& vm, JSGlobalObject* globalObject)
134 {
135     return JSTestSerializedScriptValueInterfacePrototype::create(vm, globalObject, JSTestSerializedScriptValueInterfacePrototype::createStructure(vm, globalObject, globalObject->objectPrototype()));
136 }
137
138 void JSTestSerializedScriptValueInterface::destroy(JSC::JSCell* cell)
139 {
140     JSTestSerializedScriptValueInterface* thisObject = static_cast<JSTestSerializedScriptValueInterface*>(cell);
141     thisObject->JSTestSerializedScriptValueInterface::~JSTestSerializedScriptValueInterface();
142 }
143
144 JSTestSerializedScriptValueInterface::~JSTestSerializedScriptValueInterface()
145 {
146     releaseImplIfNotNull();
147 }
148
149 bool JSTestSerializedScriptValueInterface::getOwnPropertySlot(JSObject* object, ExecState* exec, PropertyName propertyName, PropertySlot& slot)
150 {
151     JSTestSerializedScriptValueInterface* thisObject = jsCast<JSTestSerializedScriptValueInterface*>(object);
152     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
153     return Base::getOwnPropertySlot(thisObject, exec, propertyName, slot);
154 }
155
156 EncodedJSValue jsTestSerializedScriptValueInterfaceValue(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
157 {
158     JSTestSerializedScriptValueInterface* castedThis = jsDynamicCast<JSTestSerializedScriptValueInterface*>(JSValue::decode(thisValue));
159     UNUSED_PARAM(slotBase);
160     if (UNLIKELY(!castedThis)) {
161         if (jsDynamicCast<JSTestSerializedScriptValueInterfacePrototype*>(slotBase)) {
162             ScriptExecutionContext* scriptExecutionContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
163             scriptExecutionContext->addConsoleMessage(MessageSource::JS, MessageLevel::Error, String("Deprecated attempt to access property 'value' on a non-TestSerializedScriptValueInterface object."));
164             return JSValue::encode(jsUndefined());
165         }
166         return throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestSerializedScriptValueInterface", ".", "value", " getter can only be used on instances of ", "TestSerializedScriptValueInterface"));
167     }
168     UNUSED_PARAM(exec);
169     TestSerializedScriptValueInterface& impl = castedThis->impl();
170     JSValue result = impl.value() ? impl.value()->deserialize(exec, castedThis->globalObject(), 0) : jsNull();
171     return JSValue::encode(result);
172 }
173
174
175 EncodedJSValue jsTestSerializedScriptValueInterfaceReadonlyValue(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
176 {
177     JSTestSerializedScriptValueInterface* castedThis = jsDynamicCast<JSTestSerializedScriptValueInterface*>(JSValue::decode(thisValue));
178     UNUSED_PARAM(slotBase);
179     if (UNLIKELY(!castedThis)) {
180         if (jsDynamicCast<JSTestSerializedScriptValueInterfacePrototype*>(slotBase)) {
181             ScriptExecutionContext* scriptExecutionContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
182             scriptExecutionContext->addConsoleMessage(MessageSource::JS, MessageLevel::Error, String("Deprecated attempt to access property 'readonlyValue' on a non-TestSerializedScriptValueInterface object."));
183             return JSValue::encode(jsUndefined());
184         }
185         return throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestSerializedScriptValueInterface", ".", "readonlyValue", " getter can only be used on instances of ", "TestSerializedScriptValueInterface"));
186     }
187     UNUSED_PARAM(exec);
188     TestSerializedScriptValueInterface& impl = castedThis->impl();
189     JSValue result = impl.readonlyValue() ? impl.readonlyValue()->deserialize(exec, castedThis->globalObject(), 0) : jsNull();
190     return JSValue::encode(result);
191 }
192
193
194 EncodedJSValue jsTestSerializedScriptValueInterfaceCachedValue(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
195 {
196     JSTestSerializedScriptValueInterface* castedThis = jsDynamicCast<JSTestSerializedScriptValueInterface*>(JSValue::decode(thisValue));
197     UNUSED_PARAM(slotBase);
198     if (UNLIKELY(!castedThis)) {
199         if (jsDynamicCast<JSTestSerializedScriptValueInterfacePrototype*>(slotBase)) {
200             ScriptExecutionContext* scriptExecutionContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
201             scriptExecutionContext->addConsoleMessage(MessageSource::JS, MessageLevel::Error, String("Deprecated attempt to access property 'cachedValue' on a non-TestSerializedScriptValueInterface object."));
202             return JSValue::encode(jsUndefined());
203         }
204         return throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestSerializedScriptValueInterface", ".", "cachedValue", " getter can only be used on instances of ", "TestSerializedScriptValueInterface"));
205     }
206     UNUSED_PARAM(exec);
207     if (JSValue cachedValue = castedThis->m_cachedValue.get())
208         return JSValue::encode(cachedValue);
209     TestSerializedScriptValueInterface& impl = castedThis->impl();
210     JSValue result = impl.cachedValue() ? impl.cachedValue()->deserialize(exec, castedThis->globalObject(), 0) : jsNull();
211     castedThis->m_cachedValue.set(exec->vm(), castedThis, result);
212     return JSValue::encode(result);
213 }
214
215
216 EncodedJSValue jsTestSerializedScriptValueInterfacePorts(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
217 {
218     JSTestSerializedScriptValueInterface* castedThis = jsDynamicCast<JSTestSerializedScriptValueInterface*>(JSValue::decode(thisValue));
219     UNUSED_PARAM(slotBase);
220     if (UNLIKELY(!castedThis)) {
221         if (jsDynamicCast<JSTestSerializedScriptValueInterfacePrototype*>(slotBase)) {
222             ScriptExecutionContext* scriptExecutionContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
223             scriptExecutionContext->addConsoleMessage(MessageSource::JS, MessageLevel::Error, String("Deprecated attempt to access property 'ports' on a non-TestSerializedScriptValueInterface object."));
224             return JSValue::encode(jsUndefined());
225         }
226         return throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestSerializedScriptValueInterface", ".", "ports", " getter can only be used on instances of ", "TestSerializedScriptValueInterface"));
227     }
228     UNUSED_PARAM(exec);
229     TestSerializedScriptValueInterface& impl = castedThis->impl();
230     JSValue result = jsArray(exec, castedThis->globalObject(), impl.ports());
231     return JSValue::encode(result);
232 }
233
234
235 EncodedJSValue jsTestSerializedScriptValueInterfaceCachedReadonlyValue(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
236 {
237     JSTestSerializedScriptValueInterface* castedThis = jsDynamicCast<JSTestSerializedScriptValueInterface*>(JSValue::decode(thisValue));
238     UNUSED_PARAM(slotBase);
239     if (UNLIKELY(!castedThis)) {
240         if (jsDynamicCast<JSTestSerializedScriptValueInterfacePrototype*>(slotBase)) {
241             ScriptExecutionContext* scriptExecutionContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
242             scriptExecutionContext->addConsoleMessage(MessageSource::JS, MessageLevel::Error, String("Deprecated attempt to access property 'cachedReadonlyValue' on a non-TestSerializedScriptValueInterface object."));
243             return JSValue::encode(jsUndefined());
244         }
245         return throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestSerializedScriptValueInterface", ".", "cachedReadonlyValue", " getter can only be used on instances of ", "TestSerializedScriptValueInterface"));
246     }
247     UNUSED_PARAM(exec);
248     if (JSValue cachedValue = castedThis->m_cachedReadonlyValue.get())
249         return JSValue::encode(cachedValue);
250     TestSerializedScriptValueInterface& impl = castedThis->impl();
251     JSValue result = impl.cachedReadonlyValue() ? impl.cachedReadonlyValue()->deserialize(exec, castedThis->globalObject(), 0) : jsNull();
252     castedThis->m_cachedReadonlyValue.set(exec->vm(), castedThis, result);
253     return JSValue::encode(result);
254 }
255
256
257 EncodedJSValue jsTestSerializedScriptValueInterfaceConstructor(ExecState* exec, JSObject* baseValue, EncodedJSValue thisValue, PropertyName)
258 {
259     UNUSED_PARAM(baseValue);
260     UNUSED_PARAM(thisValue);
261     JSTestSerializedScriptValueInterfacePrototype* domObject = jsDynamicCast<JSTestSerializedScriptValueInterfacePrototype*>(baseValue);
262     if (!domObject)
263         return throwVMTypeError(exec);
264     return JSValue::encode(JSTestSerializedScriptValueInterface::getConstructor(exec->vm(), domObject->globalObject()));
265 }
266
267 void setJSTestSerializedScriptValueInterfaceValue(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
268 {
269     JSValue value = JSValue::decode(encodedValue);
270     UNUSED_PARAM(exec);
271     JSTestSerializedScriptValueInterface* castedThis = jsDynamicCast<JSTestSerializedScriptValueInterface*>(JSValue::decode(thisValue));
272     if (UNLIKELY(!castedThis)) {
273         throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestSerializedScriptValueInterface", ".", "value", " setter can only be used on instances of ", "TestSerializedScriptValueInterface"));
274         return;
275     }
276     TestSerializedScriptValueInterface& impl = castedThis->impl();
277     RefPtr<SerializedScriptValue> nativeValue(SerializedScriptValue::create(exec, value, 0, 0));
278     if (UNLIKELY(exec->hadException()))
279         return;
280     impl.setValue(nativeValue);
281 }
282
283
284 void setJSTestSerializedScriptValueInterfaceCachedValue(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
285 {
286     JSValue value = JSValue::decode(encodedValue);
287     UNUSED_PARAM(exec);
288     JSTestSerializedScriptValueInterface* castedThis = jsDynamicCast<JSTestSerializedScriptValueInterface*>(JSValue::decode(thisValue));
289     if (UNLIKELY(!castedThis)) {
290         throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestSerializedScriptValueInterface", ".", "cachedValue", " setter can only be used on instances of ", "TestSerializedScriptValueInterface"));
291         return;
292     }
293     TestSerializedScriptValueInterface& impl = castedThis->impl();
294     RefPtr<SerializedScriptValue> nativeValue(SerializedScriptValue::create(exec, value, 0, 0));
295     if (UNLIKELY(exec->hadException()))
296         return;
297     impl.setCachedValue(nativeValue);
298 }
299
300
301 JSValue JSTestSerializedScriptValueInterface::getConstructor(VM& vm, JSGlobalObject* globalObject)
302 {
303     return getDOMConstructor<JSTestSerializedScriptValueInterfaceConstructor>(vm, jsCast<JSDOMGlobalObject*>(globalObject));
304 }
305
306 void JSTestSerializedScriptValueInterface::visitChildren(JSCell* cell, SlotVisitor& visitor)
307 {
308     JSTestSerializedScriptValueInterface* thisObject = jsCast<JSTestSerializedScriptValueInterface*>(cell);
309     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
310     COMPILE_ASSERT(StructureFlags & OverridesVisitChildren, OverridesVisitChildrenWithoutSettingFlag);
311     ASSERT(thisObject->structure()->typeInfo().overridesVisitChildren());
312     Base::visitChildren(thisObject, visitor);
313     visitor.append(&thisObject->m_cachedValue);
314     visitor.append(&thisObject->m_cachedReadonlyValue);
315 }
316
317 bool JSTestSerializedScriptValueInterfaceOwner::isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown> handle, void*, SlotVisitor& visitor)
318 {
319     UNUSED_PARAM(handle);
320     UNUSED_PARAM(visitor);
321     return false;
322 }
323
324 void JSTestSerializedScriptValueInterfaceOwner::finalize(JSC::Handle<JSC::Unknown> handle, void* context)
325 {
326     JSTestSerializedScriptValueInterface* jsTestSerializedScriptValueInterface = jsCast<JSTestSerializedScriptValueInterface*>(handle.slot()->asCell());
327     DOMWrapperWorld& world = *static_cast<DOMWrapperWorld*>(context);
328     uncacheWrapper(world, &jsTestSerializedScriptValueInterface->impl(), jsTestSerializedScriptValueInterface);
329     jsTestSerializedScriptValueInterface->releaseImpl();
330 }
331
332 #if ENABLE(BINDING_INTEGRITY)
333 #if PLATFORM(WIN)
334 #pragma warning(disable: 4483)
335 extern "C" { extern void (*const __identifier("??_7TestSerializedScriptValueInterface@WebCore@@6B@")[])(); }
336 #else
337 extern "C" { extern void* _ZTVN7WebCore34TestSerializedScriptValueInterfaceE[]; }
338 #endif
339 #endif
340 JSC::JSValue toJS(JSC::ExecState* exec, JSDOMGlobalObject* globalObject, TestSerializedScriptValueInterface* impl)
341 {
342     if (!impl)
343         return jsNull();
344     if (JSValue result = getExistingWrapper<JSTestSerializedScriptValueInterface>(exec, impl))
345         return result;
346
347 #if ENABLE(BINDING_INTEGRITY)
348     void* actualVTablePointer = *(reinterpret_cast<void**>(impl));
349 #if PLATFORM(WIN)
350     void* expectedVTablePointer = reinterpret_cast<void*>(__identifier("??_7TestSerializedScriptValueInterface@WebCore@@6B@"));
351 #else
352     void* expectedVTablePointer = &_ZTVN7WebCore34TestSerializedScriptValueInterfaceE[2];
353 #if COMPILER(CLANG)
354     // If this fails TestSerializedScriptValueInterface does not have a vtable, so you need to add the
355     // ImplementationLacksVTable attribute to the interface definition
356     COMPILE_ASSERT(__is_polymorphic(TestSerializedScriptValueInterface), TestSerializedScriptValueInterface_is_not_polymorphic);
357 #endif
358 #endif
359     // If you hit this assertion you either have a use after free bug, or
360     // TestSerializedScriptValueInterface has subclasses. If TestSerializedScriptValueInterface has subclasses that get passed
361     // to toJS() we currently require TestSerializedScriptValueInterface you to opt out of binding hardening
362     // by adding the SkipVTableValidation attribute to the interface IDL definition
363     RELEASE_ASSERT(actualVTablePointer == expectedVTablePointer);
364 #endif
365     return createNewWrapper<JSTestSerializedScriptValueInterface>(exec, globalObject, impl);
366 }
367
368 TestSerializedScriptValueInterface* toTestSerializedScriptValueInterface(JSC::JSValue value)
369 {
370     return value.inherits(JSTestSerializedScriptValueInterface::info()) ? &jsCast<JSTestSerializedScriptValueInterface*>(value)->impl() : 0;
371 }
372
373 }
374
375 #endif // ENABLE(Condition1) || ENABLE(Condition2)