Source/WebCore/bindings/scripts/test/JS/JSreadonly.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 "JSreadonly.h"
  23
  24 #include "JSDOMBinding.h"
  25 #include "JSDOMConstructor.h"
  26 #include <runtime/FunctionPrototype.h>
  27 #include <wtf/GetPtr.h>
  28
  29 using namespace JSC;
  30
  31 namespace WebCore {
  32
  33 // Attributes
  34
  35 JSC::EncodedJSValue jsreadonlyConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
  36 bool setJSreadonlyConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
  37
  38 class JSreadonlyPrototype : public JSC::JSNonFinalObject {
  39 public:
  40     using Base = JSC::JSNonFinalObject;
  41     static JSreadonlyPrototype* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
  42     {
  43         JSreadonlyPrototype* ptr = new (NotNull, JSC::allocateCell<JSreadonlyPrototype>(vm.heap)) JSreadonlyPrototype(vm, globalObject, structure);
  44         ptr->finishCreation(vm);
  45         return ptr;
  46     }
  47
  48     DECLARE_INFO;
  49     static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
  50     {
  51         return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
  52     }
  53
  54 private:
  55     JSreadonlyPrototype(JSC::VM& vm, JSC::JSGlobalObject*, JSC::Structure* structure)
  56         : JSC::JSNonFinalObject(vm, structure)
  57     {
  58     }
  59
  60     void finishCreation(JSC::VM&);
  61 };
  62
  63 using JSreadonlyConstructor = JSDOMConstructorNotConstructable<JSreadonly>;
  64
  65 template<> JSValue JSreadonlyConstructor::prototypeForStructure(JSC::VM& vm, const JSDOMGlobalObject& globalObject)
  66 {
  67     UNUSED_PARAM(vm);
  68     return globalObject.functionPrototype();
  69 }
  70
  71 template<> void JSreadonlyConstructor::initializeProperties(VM& vm, JSDOMGlobalObject& globalObject)
  72 {
  73     putDirect(vm, vm.propertyNames->prototype, JSreadonly::prototype(vm, &globalObject), DontDelete | ReadOnly | DontEnum);
  74     putDirect(vm, vm.propertyNames->name, jsNontrivialString(&vm, String(ASCIILiteral("readonly"))), ReadOnly | DontEnum);
  75     putDirect(vm, vm.propertyNames->length, jsNumber(0), ReadOnly | DontEnum);
  76 }
  77
  78 template<> const ClassInfo JSreadonlyConstructor::s_info = { "readonly", &Base::s_info, 0, CREATE_METHOD_TABLE(JSreadonlyConstructor) };
  79
  80 /* Hash table for prototype */
  81
  82 static const HashTableValue JSreadonlyPrototypeTableValues[] =
  83 {
  84     { "constructor", DontEnum, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsreadonlyConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSreadonlyConstructor) } },
  85 };
  86
  87 const ClassInfo JSreadonlyPrototype::s_info = { "readonlyPrototype", &Base::s_info, 0, CREATE_METHOD_TABLE(JSreadonlyPrototype) };
  88
  89 void JSreadonlyPrototype::finishCreation(VM& vm)
  90 {
  91     Base::finishCreation(vm);
  92     reifyStaticProperties(vm, JSreadonlyPrototypeTableValues, *this);
  93 }
  94
  95 const ClassInfo JSreadonly::s_info = { "readonly", &Base::s_info, 0, CREATE_METHOD_TABLE(JSreadonly) };
  96
  97 JSreadonly::JSreadonly(Structure* structure, JSDOMGlobalObject& globalObject, Ref<readonly>&& impl)
  98     : JSDOMWrapper<readonly>(structure, globalObject, WTFMove(impl))
  99 {
 100 }
 101
 102 JSObject* JSreadonly::createPrototype(VM& vm, JSGlobalObject* globalObject)
 103 {
 104     return JSreadonlyPrototype::create(vm, globalObject, JSreadonlyPrototype::createStructure(vm, globalObject, globalObject->objectPrototype()));
 105 }
 106
 107 JSObject* JSreadonly::prototype(VM& vm, JSGlobalObject* globalObject)
 108 {
 109     return getDOMPrototype<JSreadonly>(vm, globalObject);
 110 }
 111
 112 void JSreadonly::destroy(JSC::JSCell* cell)
 113 {
 114     JSreadonly* thisObject = static_cast<JSreadonly*>(cell);
 115     thisObject->JSreadonly::~JSreadonly();
 116 }
 117
 118 EncodedJSValue jsreadonlyConstructor(ExecState* state, EncodedJSValue thisValue, PropertyName)
 119 {
 120     VM& vm = state->vm();
 121     auto throwScope = DECLARE_THROW_SCOPE(vm);
 122     JSreadonlyPrototype* domObject = jsDynamicCast<JSreadonlyPrototype*>(JSValue::decode(thisValue));
 123     if (UNLIKELY(!domObject))
 124         return throwVMTypeError(state, throwScope);
 125     return JSValue::encode(JSreadonly::getConstructor(state->vm(), domObject->globalObject()));
 126 }
 127
 128 bool setJSreadonlyConstructor(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
 129 {
 130     VM& vm = state->vm();
 131     auto throwScope = DECLARE_THROW_SCOPE(vm);
 132     JSValue value = JSValue::decode(encodedValue);
 133     JSreadonlyPrototype* domObject = jsDynamicCast<JSreadonlyPrototype*>(JSValue::decode(thisValue));
 134     if (UNLIKELY(!domObject)) {
 135         throwVMTypeError(state, throwScope);
 136         return false;
 137     }
 138     // Shadowing a built-in constructor
 139     return domObject->putDirect(state->vm(), state->propertyNames().constructor, value);
 140 }
 141
 142 JSValue JSreadonly::getConstructor(VM& vm, const JSGlobalObject* globalObject)
 143 {
 144     return getDOMConstructor<JSreadonlyConstructor>(vm, *jsCast<const JSDOMGlobalObject*>(globalObject));
 145 }
 146
 147 bool JSreadonlyOwner::isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown> handle, void*, SlotVisitor& visitor)
 148 {
 149     UNUSED_PARAM(handle);
 150     UNUSED_PARAM(visitor);
 151     return false;
 152 }
 153
 154 void JSreadonlyOwner::finalize(JSC::Handle<JSC::Unknown> handle, void* context)
 155 {
 156     auto* jsreadonly = jsCast<JSreadonly*>(handle.slot()->asCell());
 157     auto& world = *static_cast<DOMWrapperWorld*>(context);
 158     uncacheWrapper(world, &jsreadonly->wrapped(), jsreadonly);
 159 }
 160
 161 JSC::JSValue toJSNewlyCreated(JSC::ExecState*, JSDOMGlobalObject* globalObject, Ref<readonly>&& impl)
 162 {
 163 #if COMPILER(CLANG)
 164     // If you hit this failure the interface definition has the ImplementationLacksVTable
 165     // attribute. You should remove that attribute. If the class has subclasses
 166     // that may be passed through this toJS() function you should use the SkipVTableValidation
 167     // attribute to readonly.
 168     static_assert(!__is_polymorphic(readonly), "readonly is polymorphic but the IDL claims it is not");
 169 #endif
 170     return createWrapper<readonly>(globalObject, WTFMove(impl));
 171 }
 172
 173 JSC::JSValue toJS(JSC::ExecState* state, JSDOMGlobalObject* globalObject, readonly& impl)
 174 {
 175     return wrap(state, globalObject, impl);
 176 }
 177
 178 readonly* JSreadonly::toWrapped(JSC::JSValue value)
 179 {
 180     if (auto* wrapper = jsDynamicCast<JSreadonly*>(value))
 181         return &wrapper->wrapped();
 182     return nullptr;
 183 }
 184
 185 }