Replace WTF::move with WTFMove
[WebKit-https.git] / Source / WebCore / bindings / scripts / test / JS / JSattribute.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 "JSattribute.h"
23
24 #include "JSDOMBinding.h"
25 #include "JSDOMConstructor.h"
26 #include "URL.h"
27 #include <runtime/JSString.h>
28 #include <wtf/GetPtr.h>
29
30 using namespace JSC;
31
32 namespace WebCore {
33
34 // Attributes
35
36 JSC::EncodedJSValue jsattributeReadonly(JSC::ExecState*, JSC::JSObject*, JSC::EncodedJSValue, JSC::PropertyName);
37 JSC::EncodedJSValue jsattributeConstructor(JSC::ExecState*, JSC::JSObject*, JSC::EncodedJSValue, JSC::PropertyName);
38
39 class JSattributePrototype : public JSC::JSNonFinalObject {
40 public:
41     typedef JSC::JSNonFinalObject Base;
42     static JSattributePrototype* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
43     {
44         JSattributePrototype* ptr = new (NotNull, JSC::allocateCell<JSattributePrototype>(vm.heap)) JSattributePrototype(vm, globalObject, structure);
45         ptr->finishCreation(vm);
46         return ptr;
47     }
48
49     DECLARE_INFO;
50     static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
51     {
52         return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
53     }
54
55 private:
56     JSattributePrototype(JSC::VM& vm, JSC::JSGlobalObject*, JSC::Structure* structure)
57         : JSC::JSNonFinalObject(vm, structure)
58     {
59     }
60
61     void finishCreation(JSC::VM&);
62 };
63
64 typedef JSDOMConstructorNotConstructable<JSattribute> JSattributeConstructor;
65
66 template<> void JSattributeConstructor::initializeProperties(VM& vm, JSDOMGlobalObject& globalObject)
67 {
68     putDirect(vm, vm.propertyNames->prototype, JSattribute::getPrototype(vm, &globalObject), DontDelete | ReadOnly | DontEnum);
69     putDirect(vm, vm.propertyNames->name, jsNontrivialString(&vm, String(ASCIILiteral("attribute"))), ReadOnly | DontEnum);
70     putDirect(vm, vm.propertyNames->length, jsNumber(0), ReadOnly | DontEnum);
71 }
72
73 template<> const ClassInfo JSattributeConstructor::s_info = { "attributeConstructor", &Base::s_info, 0, CREATE_METHOD_TABLE(JSattributeConstructor) };
74
75 /* Hash table for prototype */
76
77 static const HashTableValue JSattributePrototypeTableValues[] =
78 {
79     { "constructor", DontEnum | ReadOnly, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsattributeConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
80     { "readonly", ReadOnly | CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsattributeReadonly), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
81 };
82
83 const ClassInfo JSattributePrototype::s_info = { "attributePrototype", &Base::s_info, 0, CREATE_METHOD_TABLE(JSattributePrototype) };
84
85 void JSattributePrototype::finishCreation(VM& vm)
86 {
87     Base::finishCreation(vm);
88     reifyStaticProperties(vm, JSattributePrototypeTableValues, *this);
89 }
90
91 const ClassInfo JSattribute::s_info = { "attribute", &Base::s_info, 0, CREATE_METHOD_TABLE(JSattribute) };
92
93 JSattribute::JSattribute(Structure* structure, JSDOMGlobalObject& globalObject, Ref<attribute>&& impl)
94     : JSDOMWrapper<attribute>(structure, globalObject, WTFMove(impl))
95 {
96 }
97
98 JSObject* JSattribute::createPrototype(VM& vm, JSGlobalObject* globalObject)
99 {
100     return JSattributePrototype::create(vm, globalObject, JSattributePrototype::createStructure(vm, globalObject, globalObject->errorPrototype()));
101 }
102
103 JSObject* JSattribute::getPrototype(VM& vm, JSGlobalObject* globalObject)
104 {
105     return getDOMPrototype<JSattribute>(vm, globalObject);
106 }
107
108 void JSattribute::destroy(JSC::JSCell* cell)
109 {
110     JSattribute* thisObject = static_cast<JSattribute*>(cell);
111     thisObject->JSattribute::~JSattribute();
112 }
113
114 EncodedJSValue jsattributeReadonly(ExecState* state, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
115 {
116     UNUSED_PARAM(state);
117     UNUSED_PARAM(slotBase);
118     UNUSED_PARAM(thisValue);
119     JSattribute* castedThis = jsDynamicCast<JSattribute*>(JSValue::decode(thisValue));
120     if (UNLIKELY(!castedThis)) {
121         if (jsDynamicCast<JSattributePrototype*>(slotBase))
122             return reportDeprecatedGetterError(*state, "attribute", "readonly");
123         return throwGetterTypeError(*state, "attribute", "readonly");
124     }
125     auto& impl = castedThis->wrapped();
126     JSValue result = jsStringWithCache(state, impl.readonly());
127     return JSValue::encode(result);
128 }
129
130
131 EncodedJSValue jsattributeConstructor(ExecState* state, JSObject* baseValue, EncodedJSValue, PropertyName)
132 {
133     JSattributePrototype* domObject = jsDynamicCast<JSattributePrototype*>(baseValue);
134     if (!domObject)
135         return throwVMTypeError(state);
136     return JSValue::encode(JSattribute::getConstructor(state->vm(), domObject->globalObject()));
137 }
138
139 JSValue JSattribute::getConstructor(VM& vm, JSGlobalObject* globalObject)
140 {
141     return getDOMConstructor<JSattributeConstructor>(vm, *jsCast<JSDOMGlobalObject*>(globalObject));
142 }
143
144 bool JSattributeOwner::isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown> handle, void*, SlotVisitor& visitor)
145 {
146     UNUSED_PARAM(handle);
147     UNUSED_PARAM(visitor);
148     return false;
149 }
150
151 void JSattributeOwner::finalize(JSC::Handle<JSC::Unknown> handle, void* context)
152 {
153     auto* jsattribute = jsCast<JSattribute*>(handle.slot()->asCell());
154     auto& world = *static_cast<DOMWrapperWorld*>(context);
155     uncacheWrapper(world, &jsattribute->wrapped(), jsattribute);
156 }
157
158 #if ENABLE(BINDING_INTEGRITY)
159 #if PLATFORM(WIN)
160 #pragma warning(disable: 4483)
161 extern "C" { extern void (*const __identifier("??_7attribute@WebCore@@6B@")[])(); }
162 #else
163 extern "C" { extern void* _ZTVN7WebCore9attributeE[]; }
164 #endif
165 #endif
166
167 JSC::JSValue toJSNewlyCreated(JSC::ExecState*, JSDOMGlobalObject* globalObject, attribute* impl)
168 {
169     if (!impl)
170         return jsNull();
171     return createNewWrapper<JSattribute>(globalObject, impl);
172 }
173
174 JSC::JSValue toJS(JSC::ExecState*, JSDOMGlobalObject* globalObject, attribute* impl)
175 {
176     if (!impl)
177         return jsNull();
178     if (JSValue result = getExistingWrapper<JSattribute>(globalObject, impl))
179         return result;
180
181 #if ENABLE(BINDING_INTEGRITY)
182     void* actualVTablePointer = *(reinterpret_cast<void**>(impl));
183 #if PLATFORM(WIN)
184     void* expectedVTablePointer = reinterpret_cast<void*>(__identifier("??_7attribute@WebCore@@6B@"));
185 #else
186     void* expectedVTablePointer = &_ZTVN7WebCore9attributeE[2];
187 #if COMPILER(CLANG)
188     // If this fails attribute does not have a vtable, so you need to add the
189     // ImplementationLacksVTable attribute to the interface definition
190     COMPILE_ASSERT(__is_polymorphic(attribute), attribute_is_not_polymorphic);
191 #endif
192 #endif
193     // If you hit this assertion you either have a use after free bug, or
194     // attribute has subclasses. If attribute has subclasses that get passed
195     // to toJS() we currently require attribute you to opt out of binding hardening
196     // by adding the SkipVTableValidation attribute to the interface IDL definition
197     RELEASE_ASSERT(actualVTablePointer == expectedVTablePointer);
198 #endif
199     return createNewWrapper<JSattribute>(globalObject, impl);
200 }
201
202 attribute* JSattribute::toWrapped(JSC::JSValue value)
203 {
204     if (auto* wrapper = jsDynamicCast<JSattribute*>(value))
205         return &wrapper->wrapped();
206     return nullptr;
207 }
208
209 }