Unreviewed. Rebaselined run-bindings-tests results.
[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 "JSTestSupplemental.h"
30 #include "TestInterface.h"
31 #include "TestSupplemental.h"
32 #include <runtime/Error.h>
33 #include <wtf/GetPtr.h>
34
35 #if ENABLE(Condition11) || ENABLE(Condition12)
36 #include "KURL.h"
37 #include <runtime/JSString.h>
38 #endif
39
40 using namespace JSC;
41
42 namespace WebCore {
43
44 ASSERT_CLASS_FITS_IN_CELL(JSTestInterface);
45
46 /* Hash table */
47
48 static const HashTableValue JSTestInterfaceTableValues[] =
49 {
50 #if ENABLE(Condition11) || ENABLE(Condition12)
51     { "str1", DontDelete | ReadOnly, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceStr1), (intptr_t)0, NoIntrinsic },
52 #endif
53 #if ENABLE(Condition11) || ENABLE(Condition12)
54     { "str2", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceStr2), (intptr_t)setJSTestInterfaceStr2, NoIntrinsic },
55 #endif
56 #if ENABLE(Condition11) || ENABLE(Condition12)
57     { "str3", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceStr3), (intptr_t)setJSTestInterfaceStr3, NoIntrinsic },
58 #endif
59     { "constructor", DontEnum | ReadOnly, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceConstructor), (intptr_t)0, NoIntrinsic },
60     { 0, 0, 0, 0, NoIntrinsic }
61 };
62
63 static const HashTable JSTestInterfaceTable = { 8, 7, JSTestInterfaceTableValues, 0 };
64 /* Hash table for constructor */
65
66 static const HashTableValue JSTestInterfaceConstructorTableValues[] =
67 {
68     { 0, 0, 0, 0, NoIntrinsic }
69 };
70
71 static const HashTable JSTestInterfaceConstructorTable = { 1, 0, JSTestInterfaceConstructorTableValues, 0 };
72 const ClassInfo JSTestInterfaceConstructor::s_info = { "TestInterfaceConstructor", &DOMConstructorObject::s_info, &JSTestInterfaceConstructorTable, 0, CREATE_METHOD_TABLE(JSTestInterfaceConstructor) };
73
74 JSTestInterfaceConstructor::JSTestInterfaceConstructor(Structure* structure, JSDOMGlobalObject* globalObject)
75     : DOMConstructorObject(structure, globalObject)
76 {
77 }
78
79 void JSTestInterfaceConstructor::finishCreation(ExecState* exec, JSDOMGlobalObject* globalObject)
80 {
81     Base::finishCreation(exec->globalData());
82     ASSERT(inherits(&s_info));
83     putDirect(exec->globalData(), exec->propertyNames().prototype, JSTestInterfacePrototype::self(exec, globalObject), DontDelete | ReadOnly);
84 }
85
86 bool JSTestInterfaceConstructor::getOwnPropertySlot(JSCell* cell, ExecState* exec, const Identifier& propertyName, PropertySlot& slot)
87 {
88     return getStaticValueSlot<JSTestInterfaceConstructor, JSDOMWrapper>(exec, &JSTestInterfaceConstructorTable, static_cast<JSTestInterfaceConstructor*>(cell), propertyName, slot);
89 }
90
91 bool JSTestInterfaceConstructor::getOwnPropertyDescriptor(JSObject* object, ExecState* exec, const Identifier& propertyName, PropertyDescriptor& descriptor)
92 {
93     return getStaticValueDescriptor<JSTestInterfaceConstructor, JSDOMWrapper>(exec, &JSTestInterfaceConstructorTable, static_cast<JSTestInterfaceConstructor*>(object), propertyName, descriptor);
94 }
95
96 EncodedJSValue JSC_HOST_CALL JSTestInterfaceConstructor::constructJSTestInterface(ExecState* exec)
97 {
98     JSTestInterfaceConstructor* jsConstructor = static_cast<JSTestInterfaceConstructor*>(exec->callee());
99     if (exec->argumentCount() < 1)
100         return throwVMError(exec, createTypeError(exec, "Not enough arguments"));
101     ExceptionCode ec = 0;
102     const String& str1(ustringToString(MAYBE_MISSING_PARAMETER(exec, 0, MissingIsUndefined).isEmpty() ? UString() : MAYBE_MISSING_PARAMETER(exec, 0, MissingIsUndefined).toString(exec)));
103     if (exec->hadException())
104         return JSValue::encode(jsUndefined());
105     const String& str2(ustringToString(MAYBE_MISSING_PARAMETER(exec, 1, MissingIsUndefined).isEmpty() ? UString() : MAYBE_MISSING_PARAMETER(exec, 1, MissingIsUndefined).toString(exec)));
106     if (exec->hadException())
107         return JSValue::encode(jsUndefined());
108     ScriptExecutionContext* context = jsConstructor->scriptExecutionContext();
109     if (!context)
110         return throwVMError(exec, createReferenceError(exec, "TestInterface constructor associated document is unavailable"));
111     RefPtr<TestInterface> object = TestInterface::create(context, str1, str2, ec);
112     if (ec) {
113         setDOMException(exec, ec);
114         return JSValue::encode(JSValue());
115     }
116     return JSValue::encode(asObject(toJS(exec, jsConstructor->globalObject(), object.get())));
117 }
118
119 ConstructType JSTestInterfaceConstructor::getConstructData(JSCell*, ConstructData& constructData)
120 {
121     constructData.native.function = constructJSTestInterface;
122     return ConstructTypeHost;
123 }
124
125 /* Hash table for prototype */
126
127 static const HashTableValue JSTestInterfacePrototypeTableValues[] =
128 {
129     { 0, 0, 0, 0, NoIntrinsic }
130 };
131
132 static const HashTable JSTestInterfacePrototypeTable = { 1, 0, JSTestInterfacePrototypeTableValues, 0 };
133 const ClassInfo JSTestInterfacePrototype::s_info = { "TestInterfacePrototype", &JSC::JSNonFinalObject::s_info, &JSTestInterfacePrototypeTable, 0, CREATE_METHOD_TABLE(JSTestInterfacePrototype) };
134
135 JSObject* JSTestInterfacePrototype::self(ExecState* exec, JSGlobalObject* globalObject)
136 {
137     return getDOMPrototype<JSTestInterface>(exec, globalObject);
138 }
139
140 const ClassInfo JSTestInterface::s_info = { "TestInterface", &JSDOMWrapper::s_info, &JSTestInterfaceTable, 0 , CREATE_METHOD_TABLE(JSTestInterface) };
141
142 JSTestInterface::JSTestInterface(Structure* structure, JSDOMGlobalObject* globalObject, PassRefPtr<TestInterface> impl)
143     : JSDOMWrapper(structure, globalObject)
144     , m_impl(impl.leakRef())
145 {
146 }
147
148 void JSTestInterface::finishCreation(JSGlobalData& globalData)
149 {
150     Base::finishCreation(globalData);
151     ASSERT(inherits(&s_info));
152 }
153
154 JSObject* JSTestInterface::createPrototype(ExecState* exec, JSGlobalObject* globalObject)
155 {
156     return JSTestInterfacePrototype::create(exec->globalData(), globalObject, JSTestInterfacePrototype::createStructure(globalObject->globalData(), globalObject, globalObject->objectPrototype()));
157 }
158
159 bool JSTestInterface::getOwnPropertySlot(JSCell* cell, ExecState* exec, const Identifier& propertyName, PropertySlot& slot)
160 {
161     JSTestInterface* thisObject = jsCast<JSTestInterface*>(cell);
162     ASSERT_GC_OBJECT_INHERITS(thisObject, &s_info);
163     return getStaticValueSlot<JSTestInterface, Base>(exec, &JSTestInterfaceTable, thisObject, propertyName, slot);
164 }
165
166 bool JSTestInterface::getOwnPropertyDescriptor(JSObject* object, ExecState* exec, const Identifier& propertyName, PropertyDescriptor& descriptor)
167 {
168     JSTestInterface* thisObject = jsCast<JSTestInterface*>(object);
169     ASSERT_GC_OBJECT_INHERITS(thisObject, &s_info);
170     return getStaticValueDescriptor<JSTestInterface, Base>(exec, &JSTestInterfaceTable, thisObject, propertyName, descriptor);
171 }
172
173 #if ENABLE(Condition11) || ENABLE(Condition12)
174 JSValue jsTestInterfaceStr1(ExecState* exec, JSValue slotBase, const Identifier&)
175 {
176     JSTestInterface* castedThis = static_cast<JSTestInterface*>(asObject(slotBase));
177     UNUSED_PARAM(exec);
178     TestInterface* imp = static_cast<TestInterface*>(castedThis->impl());
179     JSValue result = jsString(exec, TestSupplemental::str1(imp));
180     return result;
181 }
182
183 #endif
184
185 #if ENABLE(Condition11) || ENABLE(Condition12)
186 JSValue jsTestInterfaceStr2(ExecState* exec, JSValue slotBase, const Identifier&)
187 {
188     JSTestInterface* castedThis = static_cast<JSTestInterface*>(asObject(slotBase));
189     UNUSED_PARAM(exec);
190     TestInterface* imp = static_cast<TestInterface*>(castedThis->impl());
191     JSValue result = jsString(exec, TestSupplemental::str2(imp));
192     return result;
193 }
194
195 #endif
196
197 #if ENABLE(Condition11) || ENABLE(Condition12)
198 JSValue jsTestInterfaceStr3(ExecState* exec, JSValue slotBase, const Identifier&)
199 {
200     JSTestInterface* castedThis = static_cast<JSTestInterface*>(asObject(slotBase));
201     return JSTestSupplemental::str3(castedThis, exec);
202 }
203
204 #endif
205
206 JSValue jsTestInterfaceConstructor(ExecState* exec, JSValue slotBase, const Identifier&)
207 {
208     JSTestInterface* domObject = static_cast<JSTestInterface*>(asObject(slotBase));
209     return JSTestInterface::getConstructor(exec, domObject->globalObject());
210 }
211
212 void JSTestInterface::put(JSCell* cell, ExecState* exec, const Identifier& propertyName, JSValue value, PutPropertySlot& slot)
213 {
214     JSTestInterface* thisObject = jsCast<JSTestInterface*>(cell);
215     ASSERT_GC_OBJECT_INHERITS(thisObject, &s_info);
216     lookupPut<JSTestInterface, Base>(exec, propertyName, value, &JSTestInterfaceTable, thisObject, slot);
217 }
218
219 #if ENABLE(Condition11) || ENABLE(Condition12)
220 void setJSTestInterfaceStr2(ExecState* exec, JSObject* thisObject, JSValue value)
221 {
222     JSTestInterface* castedThis = static_cast<JSTestInterface*>(thisObject);
223     TestInterface* imp = static_cast<TestInterface*>(castedThis->impl());
224     TestSupplemental::setStr2(imp, ustringToString(value.isEmpty() ? UString() : value.toString(exec)));
225 }
226
227 #endif
228
229 #if ENABLE(Condition11) || ENABLE(Condition12)
230 void setJSTestInterfaceStr3(ExecState* exec, JSObject* thisObject, JSValue value)
231 {
232     JSTestSupplemental::setStr3(static_cast<JSTestInterface*>(thisObject), exec, value);
233 }
234
235 #endif
236
237 JSValue JSTestInterface::getConstructor(ExecState* exec, JSGlobalObject* globalObject)
238 {
239     return getDOMConstructor<JSTestInterfaceConstructor>(exec, static_cast<JSDOMGlobalObject*>(globalObject));
240 }
241
242 static inline bool isObservable(JSTestInterface* jsTestInterface)
243 {
244     if (jsTestInterface->hasCustomProperties())
245         return true;
246     return false;
247 }
248
249 bool JSTestInterfaceOwner::isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown> handle, void*, SlotVisitor& visitor)
250 {
251     JSTestInterface* jsTestInterface = static_cast<JSTestInterface*>(handle.get().asCell());
252     if (jsTestInterface->impl()->hasPendingActivity())
253         return true;
254     if (!isObservable(jsTestInterface))
255         return false;
256     UNUSED_PARAM(visitor);
257     return false;
258 }
259
260 void JSTestInterfaceOwner::finalize(JSC::Handle<JSC::Unknown> handle, void* context)
261 {
262     JSTestInterface* jsTestInterface = static_cast<JSTestInterface*>(handle.get().asCell());
263     DOMWrapperWorld* world = static_cast<DOMWrapperWorld*>(context);
264     uncacheWrapper(world, jsTestInterface->impl(), jsTestInterface);
265     jsTestInterface->releaseImpl();
266 }
267
268 JSC::JSValue toJS(JSC::ExecState* exec, JSDOMGlobalObject* globalObject, TestInterface* impl)
269 {
270     return wrap<JSTestInterface>(exec, globalObject, impl);
271 }
272
273 TestInterface* toTestInterface(JSC::JSValue value)
274 {
275     return value.inherits(&JSTestInterface::s_info) ? static_cast<JSTestInterface*>(asObject(value))->impl() : 0;
276 }
277
278 }
279
280 #endif // ENABLE(Condition1) || ENABLE(Condition2)