Unreviewed, rolling out r202302, r202303, r202305, and
[WebKit-https.git] / Source / WebCore / bindings / scripts / test / JS / JSTestNode.cpp
1 /*
2     This file is part of the WebKit open source project.
3     This file has been generated by generate-bindings.pl. DO NOT MODIFY!
4
5     This library is free software; you can redistribute it and/or
6     modify it under the terms of the GNU Library General Public
7     License as published by the Free Software Foundation; either
8     version 2 of the License, or (at your option) any later version.
9
10     This library is distributed in the hope that it will be useful,
11     but WITHOUT ANY WARRANTY; without even the implied warranty of
12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13     Library General Public License for more details.
14
15     You should have received a copy of the GNU Library General Public License
16     along with this library; see the file COPYING.LIB.  If not, write to
17     the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
18     Boston, MA 02110-1301, USA.
19 */
20
21 #include "config.h"
22 #include "JSTestNode.h"
23
24 #include "ExceptionCode.h"
25 #include "JSDOMBinding.h"
26 #include "JSDOMConstructor.h"
27 #include "JSDOMIterator.h"
28 #include "URL.h"
29 #include <runtime/Error.h>
30 #include <runtime/JSString.h>
31 #include <wtf/GetPtr.h>
32
33 using namespace JSC;
34
35 namespace WebCore {
36
37 // Functions
38
39 JSC::EncodedJSValue JSC_HOST_CALL jsTestNodePrototypeFunctionSymbolIterator(JSC::ExecState*);
40 JSC::EncodedJSValue JSC_HOST_CALL jsTestNodePrototypeFunctionEntries(JSC::ExecState*);
41 JSC::EncodedJSValue JSC_HOST_CALL jsTestNodePrototypeFunctionKeys(JSC::ExecState*);
42 JSC::EncodedJSValue JSC_HOST_CALL jsTestNodePrototypeFunctionValues(JSC::ExecState*);
43 JSC::EncodedJSValue JSC_HOST_CALL jsTestNodePrototypeFunctionForEach(JSC::ExecState*);
44
45 // Attributes
46
47 JSC::EncodedJSValue jsTestNodeName(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
48 bool setJSTestNodeName(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
49 JSC::EncodedJSValue jsTestNodeConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
50 bool setJSTestNodeConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
51
52 class JSTestNodePrototype : public JSC::JSNonFinalObject {
53 public:
54     typedef JSC::JSNonFinalObject Base;
55     static JSTestNodePrototype* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
56     {
57         JSTestNodePrototype* ptr = new (NotNull, JSC::allocateCell<JSTestNodePrototype>(vm.heap)) JSTestNodePrototype(vm, globalObject, structure);
58         ptr->finishCreation(vm);
59         return ptr;
60     }
61
62     DECLARE_INFO;
63     static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
64     {
65         return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
66     }
67
68 private:
69     JSTestNodePrototype(JSC::VM& vm, JSC::JSGlobalObject*, JSC::Structure* structure)
70         : JSC::JSNonFinalObject(vm, structure)
71     {
72     }
73
74     void finishCreation(JSC::VM&);
75 };
76
77 typedef JSDOMConstructor<JSTestNode> JSTestNodeConstructor;
78
79 template<> EncodedJSValue JSC_HOST_CALL JSTestNodeConstructor::construct(ExecState* state)
80 {
81     auto* castedThis = jsCast<JSTestNodeConstructor*>(state->callee());
82     auto object = TestNode::create();
83     return JSValue::encode(asObject(toJSNewlyCreated(state, castedThis->globalObject(), WTFMove(object))));
84 }
85
86 template<> JSValue JSTestNodeConstructor::prototypeForStructure(JSC::VM& vm, const JSDOMGlobalObject& globalObject)
87 {
88     return JSNode::getConstructor(vm, &globalObject);
89 }
90
91 template<> void JSTestNodeConstructor::initializeProperties(VM& vm, JSDOMGlobalObject& globalObject)
92 {
93     putDirect(vm, vm.propertyNames->prototype, JSTestNode::prototype(vm, &globalObject), DontDelete | ReadOnly | DontEnum);
94     putDirect(vm, vm.propertyNames->name, jsNontrivialString(&vm, String(ASCIILiteral("TestNode"))), ReadOnly | DontEnum);
95     putDirect(vm, vm.propertyNames->length, jsNumber(0), ReadOnly | DontEnum);
96 }
97
98 template<> const ClassInfo JSTestNodeConstructor::s_info = { "TestNode", &Base::s_info, 0, CREATE_METHOD_TABLE(JSTestNodeConstructor) };
99
100 /* Hash table for prototype */
101
102 static const HashTableValue JSTestNodePrototypeTableValues[] =
103 {
104     { "constructor", DontEnum, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestNodeConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestNodeConstructor) } },
105     { "name", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestNodeName), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestNodeName) } },
106     { "entries", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestNodePrototypeFunctionEntries), (intptr_t) (0) } },
107     { "keys", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestNodePrototypeFunctionKeys), (intptr_t) (0) } },
108     { "values", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestNodePrototypeFunctionValues), (intptr_t) (0) } },
109     { "forEach", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestNodePrototypeFunctionForEach), (intptr_t) (1) } },
110 };
111
112 const ClassInfo JSTestNodePrototype::s_info = { "TestNodePrototype", &Base::s_info, 0, CREATE_METHOD_TABLE(JSTestNodePrototype) };
113
114 void JSTestNodePrototype::finishCreation(VM& vm)
115 {
116     Base::finishCreation(vm);
117     reifyStaticProperties(vm, JSTestNodePrototypeTableValues, *this);
118     putDirect(vm, vm.propertyNames->iteratorSymbol, JSFunction::create(vm, globalObject(), 0, ASCIILiteral("[Symbol.Iterator]"), jsTestNodePrototypeFunctionSymbolIterator), ReadOnly | DontEnum);
119 }
120
121 const ClassInfo JSTestNode::s_info = { "TestNode", &Base::s_info, 0, CREATE_METHOD_TABLE(JSTestNode) };
122
123 JSTestNode::JSTestNode(Structure* structure, JSDOMGlobalObject& globalObject, Ref<TestNode>&& impl)
124     : JSNode(structure, globalObject, WTFMove(impl))
125 {
126 }
127
128 JSObject* JSTestNode::createPrototype(VM& vm, JSGlobalObject* globalObject)
129 {
130     return JSTestNodePrototype::create(vm, globalObject, JSTestNodePrototype::createStructure(vm, globalObject, JSNode::prototype(vm, globalObject)));
131 }
132
133 JSObject* JSTestNode::prototype(VM& vm, JSGlobalObject* globalObject)
134 {
135     return getDOMPrototype<JSTestNode>(vm, globalObject);
136 }
137
138 EncodedJSValue jsTestNodeName(ExecState* state, EncodedJSValue thisValue, PropertyName)
139 {
140     UNUSED_PARAM(state);
141     UNUSED_PARAM(thisValue);
142     JSValue decodedThisValue = JSValue::decode(thisValue);
143     auto* castedThis = jsDynamicCast<JSTestNode*>(decodedThisValue);
144     if (UNLIKELY(!castedThis)) {
145         return throwGetterTypeError(*state, "TestNode", "name");
146     }
147     auto& impl = castedThis->wrapped();
148     JSValue result = jsStringWithCache(state, impl.name());
149     return JSValue::encode(result);
150 }
151
152
153 EncodedJSValue jsTestNodeConstructor(ExecState* state, EncodedJSValue thisValue, PropertyName)
154 {
155     JSTestNodePrototype* domObject = jsDynamicCast<JSTestNodePrototype*>(JSValue::decode(thisValue));
156     if (UNLIKELY(!domObject))
157         return throwVMTypeError(state);
158     return JSValue::encode(JSTestNode::getConstructor(state->vm(), domObject->globalObject()));
159 }
160
161 bool setJSTestNodeConstructor(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
162 {
163     JSValue value = JSValue::decode(encodedValue);
164     JSTestNodePrototype* domObject = jsDynamicCast<JSTestNodePrototype*>(JSValue::decode(thisValue));
165     if (UNLIKELY(!domObject)) {
166         throwVMTypeError(state);
167         return false;
168     }
169     // Shadowing a built-in constructor
170     return domObject->putDirect(state->vm(), state->propertyNames().constructor, value);
171 }
172
173 bool setJSTestNodeName(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
174 {
175     JSValue value = JSValue::decode(encodedValue);
176     UNUSED_PARAM(thisValue);
177     JSTestNode* castedThis = jsDynamicCast<JSTestNode*>(JSValue::decode(thisValue));
178     if (UNLIKELY(!castedThis)) {
179         return throwSetterTypeError(*state, "TestNode", "name");
180     }
181     auto& impl = castedThis->wrapped();
182     auto nativeValue = value.toWTFString(state);
183     if (UNLIKELY(state->hadException()))
184         return false;
185     impl.setName(WTFMove(nativeValue));
186     return true;
187 }
188
189
190 JSValue JSTestNode::getConstructor(VM& vm, const JSGlobalObject* globalObject)
191 {
192     return getDOMConstructor<JSTestNodeConstructor>(vm, *jsCast<const JSDOMGlobalObject*>(globalObject));
193 }
194
195 using TestNodeIterator = JSDOMIterator<JSTestNode>;
196 using TestNodeIteratorPrototype = JSDOMIteratorPrototype<JSTestNode>;
197
198 template<>
199 const JSC::ClassInfo TestNodeIterator::s_info = { "TestNode Iterator", &Base::s_info, 0, CREATE_METHOD_TABLE(TestNodeIterator) };
200
201 template<>
202 const JSC::ClassInfo TestNodeIteratorPrototype::s_info = { "TestNode Iterator", &Base::s_info, 0, CREATE_METHOD_TABLE(TestNodeIteratorPrototype) };
203
204 JSC::EncodedJSValue JSC_HOST_CALL jsTestNodePrototypeFunctionSymbolIterator(JSC::ExecState* state)
205 {
206     return iteratorCreate<JSTestNode>(*state, IterationKind::Value, "[Symbol.Iterator]");
207 }
208
209 JSC::EncodedJSValue JSC_HOST_CALL jsTestNodePrototypeFunctionEntries(JSC::ExecState* state)
210 {
211     return iteratorCreate<JSTestNode>(*state, IterationKind::KeyValue, "entries");
212 }
213
214 JSC::EncodedJSValue JSC_HOST_CALL jsTestNodePrototypeFunctionKeys(JSC::ExecState* state)
215 {
216     return iteratorCreate<JSTestNode>(*state, IterationKind::Key, "keys");
217 }
218
219 JSC::EncodedJSValue JSC_HOST_CALL jsTestNodePrototypeFunctionValues(JSC::ExecState* state)
220 {
221     return iteratorCreate<JSTestNode>(*state, IterationKind::Value, "values");
222 }
223
224 JSC::EncodedJSValue JSC_HOST_CALL jsTestNodePrototypeFunctionForEach(JSC::ExecState* state)
225 {
226     return iteratorForEach<JSTestNode>(*state, "forEach");
227 }
228
229 void JSTestNode::visitChildren(JSCell* cell, SlotVisitor& visitor)
230 {
231     auto* thisObject = jsCast<JSTestNode*>(cell);
232     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
233     Base::visitChildren(thisObject, visitor);
234     thisObject->wrapped().visitJSEventListeners(visitor);
235 }
236
237 #if ENABLE(BINDING_INTEGRITY)
238 #if PLATFORM(WIN)
239 #pragma warning(disable: 4483)
240 extern "C" { extern void (*const __identifier("??_7TestNode@WebCore@@6B@")[])(); }
241 #else
242 extern "C" { extern void* _ZTVN7WebCore8TestNodeE[]; }
243 #endif
244 #endif
245
246 JSC::JSValue toJSNewlyCreated(JSC::ExecState*, JSDOMGlobalObject* globalObject, Ref<TestNode>&& impl)
247 {
248
249 #if ENABLE(BINDING_INTEGRITY)
250     void* actualVTablePointer = *(reinterpret_cast<void**>(impl.ptr()));
251 #if PLATFORM(WIN)
252     void* expectedVTablePointer = reinterpret_cast<void*>(__identifier("??_7TestNode@WebCore@@6B@"));
253 #else
254     void* expectedVTablePointer = &_ZTVN7WebCore8TestNodeE[2];
255 #if COMPILER(CLANG)
256     // If this fails TestNode does not have a vtable, so you need to add the
257     // ImplementationLacksVTable attribute to the interface definition
258     static_assert(__is_polymorphic(TestNode), "TestNode is not polymorphic");
259 #endif
260 #endif
261     // If you hit this assertion you either have a use after free bug, or
262     // TestNode has subclasses. If TestNode has subclasses that get passed
263     // to toJS() we currently require TestNode you to opt out of binding hardening
264     // by adding the SkipVTableValidation attribute to the interface IDL definition
265     RELEASE_ASSERT(actualVTablePointer == expectedVTablePointer);
266 #endif
267     return createWrapper<JSTestNode, TestNode>(globalObject, WTFMove(impl));
268 }
269
270 JSC::JSValue toJS(JSC::ExecState* state, JSDOMGlobalObject* globalObject, TestNode& impl)
271 {
272     return wrap(state, globalObject, impl);
273 }
274
275
276 }