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 "JSDOMAttribute.h"
  28 #include "JSDOMBinding.h"
  29 #include "JSDOMConstructorNotConstructable.h"
  30 #include "JSDOMConvertInterface.h"
  31 #include "JSDOMConvertSequences.h"
  32 #include "JSDOMConvertSerializedScriptValue.h"
  33 #include "JSDOMExceptionHandling.h"
  34 #include "JSDOMGlobalObject.h"
  35 #include "JSDOMOperation.h"
  36 #include "JSDOMWrapperCache.h"
  37 #include "JSMessagePort.h"
  38 #include "SerializedScriptValue.h"
  39 #include <JavaScriptCore/FunctionPrototype.h>
  40 #include <JavaScriptCore/JSArray.h>
  41 #include <JavaScriptCore/JSCInlines.h>
  42 #include <wtf/GetPtr.h>
  43 #include <wtf/PointerPreparations.h>
  44
  45
  46 namespace WebCore {
  47 using namespace JSC;
  48
  49 // Functions
  50
  51 JSC::EncodedJSValue JSC_HOST_CALL jsTestSerializedScriptValueInterfacePrototypeFunctionFunction(JSC::ExecState*);
  52 JSC::EncodedJSValue JSC_HOST_CALL jsTestSerializedScriptValueInterfacePrototypeFunctionFunctionReturning(JSC::ExecState*);
  53
  54 // Attributes
  55
  56 JSC::EncodedJSValue jsTestSerializedScriptValueInterfaceConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
  57 bool setJSTestSerializedScriptValueInterfaceConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
  58 JSC::EncodedJSValue jsTestSerializedScriptValueInterfaceValue(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
  59 bool setJSTestSerializedScriptValueInterfaceValue(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
  60 JSC::EncodedJSValue jsTestSerializedScriptValueInterfaceReadonlyValue(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
  61 JSC::EncodedJSValue jsTestSerializedScriptValueInterfaceCachedValue(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
  62 bool setJSTestSerializedScriptValueInterfaceCachedValue(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
  63 JSC::EncodedJSValue jsTestSerializedScriptValueInterfacePorts(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
  64 JSC::EncodedJSValue jsTestSerializedScriptValueInterfaceCachedReadonlyValue(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
  65
  66 class JSTestSerializedScriptValueInterfacePrototype : public JSC::JSNonFinalObject {
  67 public:
  68     using Base = JSC::JSNonFinalObject;
  69     static JSTestSerializedScriptValueInterfacePrototype* create(JSC::VM& vm, JSDOMGlobalObject* globalObject, JSC::Structure* structure)
  70     {
  71         JSTestSerializedScriptValueInterfacePrototype* ptr = new (NotNull, JSC::allocateCell<JSTestSerializedScriptValueInterfacePrototype>(vm.heap)) JSTestSerializedScriptValueInterfacePrototype(vm, globalObject, structure);
  72         ptr->finishCreation(vm);
  73         return ptr;
  74     }
  75
  76     DECLARE_INFO;
  77     static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
  78     {
  79         return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
  80     }
  81
  82 private:
  83     JSTestSerializedScriptValueInterfacePrototype(JSC::VM& vm, JSC::JSGlobalObject*, JSC::Structure* structure)
  84         : JSC::JSNonFinalObject(vm, structure)
  85     {
  86     }
  87
  88     void finishCreation(JSC::VM&);
  89 };
  90
  91 using JSTestSerializedScriptValueInterfaceConstructor = JSDOMConstructorNotConstructable<JSTestSerializedScriptValueInterface>;
  92
  93 template<> JSValue JSTestSerializedScriptValueInterfaceConstructor::prototypeForStructure(JSC::VM& vm, const JSDOMGlobalObject& globalObject)
  94 {
  95     UNUSED_PARAM(vm);
  96     return globalObject.functionPrototype();
  97 }
  98
  99 template<> void JSTestSerializedScriptValueInterfaceConstructor::initializeProperties(VM& vm, JSDOMGlobalObject& globalObject)
 100 {
 101     putDirect(vm, vm.propertyNames->prototype, JSTestSerializedScriptValueInterface::prototype(vm, globalObject), JSC::PropertyAttribute::DontDelete | JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::DontEnum);
 102     putDirect(vm, vm.propertyNames->name, jsNontrivialString(&vm, String(ASCIILiteral("TestSerializedScriptValueInterface"))), JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::DontEnum);
 103     putDirect(vm, vm.propertyNames->length, jsNumber(0), JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::DontEnum);
 104 }
 105
 106 template<> const ClassInfo JSTestSerializedScriptValueInterfaceConstructor::s_info = { "TestSerializedScriptValueInterface", &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSTestSerializedScriptValueInterfaceConstructor) };
 107
 108 /* Hash table for prototype */
 109
 110 static const HashTableValue JSTestSerializedScriptValueInterfacePrototypeTableValues[] =
 111 {
 112     { "constructor", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestSerializedScriptValueInterfaceConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestSerializedScriptValueInterfaceConstructor) } },
 113     { "value", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestSerializedScriptValueInterfaceValue), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestSerializedScriptValueInterfaceValue) } },
 114     { "readonlyValue", static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestSerializedScriptValueInterfaceReadonlyValue), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
 115     { "cachedValue", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestSerializedScriptValueInterfaceCachedValue), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestSerializedScriptValueInterfaceCachedValue) } },
 116     { "ports", static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestSerializedScriptValueInterfacePorts), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
 117     { "cachedReadonlyValue", static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestSerializedScriptValueInterfaceCachedReadonlyValue), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
 118     { "function", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestSerializedScriptValueInterfacePrototypeFunctionFunction), (intptr_t) (1) } },
 119     { "functionReturning", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestSerializedScriptValueInterfacePrototypeFunctionFunctionReturning), (intptr_t) (0) } },
 120 };
 121
 122 const ClassInfo JSTestSerializedScriptValueInterfacePrototype::s_info = { "TestSerializedScriptValueInterfacePrototype", &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSTestSerializedScriptValueInterfacePrototype) };
 123
 124 void JSTestSerializedScriptValueInterfacePrototype::finishCreation(VM& vm)
 125 {
 126     Base::finishCreation(vm);
 127     reifyStaticProperties(vm, JSTestSerializedScriptValueInterface::info(), JSTestSerializedScriptValueInterfacePrototypeTableValues, *this);
 128 }
 129
 130 const ClassInfo JSTestSerializedScriptValueInterface::s_info = { "TestSerializedScriptValueInterface", &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSTestSerializedScriptValueInterface) };
 131
 132 JSTestSerializedScriptValueInterface::JSTestSerializedScriptValueInterface(Structure* structure, JSDOMGlobalObject& globalObject, Ref<TestSerializedScriptValueInterface>&& impl)
 133     : JSDOMWrapper<TestSerializedScriptValueInterface>(structure, globalObject, WTFMove(impl))
 134 {
 135 }
 136
 137 void JSTestSerializedScriptValueInterface::finishCreation(VM& vm)
 138 {
 139     Base::finishCreation(vm);
 140     ASSERT(inherits(vm, info()));
 141
 142 }
 143
 144 JSObject* JSTestSerializedScriptValueInterface::createPrototype(VM& vm, JSDOMGlobalObject& globalObject)
 145 {
 146     return JSTestSerializedScriptValueInterfacePrototype::create(vm, &globalObject, JSTestSerializedScriptValueInterfacePrototype::createStructure(vm, &globalObject, globalObject.objectPrototype()));
 147 }
 148
 149 JSObject* JSTestSerializedScriptValueInterface::prototype(VM& vm, JSDOMGlobalObject& globalObject)
 150 {
 151     return getDOMPrototype<JSTestSerializedScriptValueInterface>(vm, globalObject);
 152 }
 153
 154 JSValue JSTestSerializedScriptValueInterface::getConstructor(VM& vm, const JSGlobalObject* globalObject)
 155 {
 156     return getDOMConstructor<JSTestSerializedScriptValueInterfaceConstructor>(vm, *jsCast<const JSDOMGlobalObject*>(globalObject));
 157 }
 158
 159 void JSTestSerializedScriptValueInterface::destroy(JSC::JSCell* cell)
 160 {
 161     JSTestSerializedScriptValueInterface* thisObject = static_cast<JSTestSerializedScriptValueInterface*>(cell);
 162     thisObject->JSTestSerializedScriptValueInterface::~JSTestSerializedScriptValueInterface();
 163 }
 164
 165 template<> inline JSTestSerializedScriptValueInterface* IDLAttribute<JSTestSerializedScriptValueInterface>::cast(ExecState& state, EncodedJSValue thisValue)
 166 {
 167     return jsDynamicDowncast<JSTestSerializedScriptValueInterface*>(state.vm(), JSValue::decode(thisValue));
 168 }
 169
 170 template<> inline JSTestSerializedScriptValueInterface* IDLOperation<JSTestSerializedScriptValueInterface>::cast(ExecState& state)
 171 {
 172     return jsDynamicDowncast<JSTestSerializedScriptValueInterface*>(state.vm(), state.thisValue());
 173 }
 174
 175 EncodedJSValue jsTestSerializedScriptValueInterfaceConstructor(ExecState* state, EncodedJSValue thisValue, PropertyName)
 176 {
 177     VM& vm = state->vm();
 178     auto throwScope = DECLARE_THROW_SCOPE(vm);
 179     auto* prototype = jsDynamicDowncast<JSTestSerializedScriptValueInterfacePrototype*>(vm, JSValue::decode(thisValue));
 180     if (UNLIKELY(!prototype))
 181         return throwVMTypeError(state, throwScope);
 182     return JSValue::encode(JSTestSerializedScriptValueInterface::getConstructor(state->vm(), prototype->globalObject()));
 183 }
 184
 185 bool setJSTestSerializedScriptValueInterfaceConstructor(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
 186 {
 187     VM& vm = state->vm();
 188     auto throwScope = DECLARE_THROW_SCOPE(vm);
 189     auto* prototype = jsDynamicDowncast<JSTestSerializedScriptValueInterfacePrototype*>(vm, JSValue::decode(thisValue));
 190     if (UNLIKELY(!prototype)) {
 191         throwVMTypeError(state, throwScope);
 192         return false;
 193     }
 194     // Shadowing a built-in constructor
 195     return prototype->putDirect(vm, vm.propertyNames->constructor, JSValue::decode(encodedValue));
 196 }
 197
 198 static inline JSValue jsTestSerializedScriptValueInterfaceValueGetter(ExecState& state, JSTestSerializedScriptValueInterface& thisObject, ThrowScope& throwScope)
 199 {
 200     UNUSED_PARAM(throwScope);
 201     UNUSED_PARAM(state);
 202     auto& impl = thisObject.wrapped();
 203     JSValue result = toJS<IDLSerializedScriptValue<SerializedScriptValue>>(state, *thisObject.globalObject(), throwScope, impl.value());
 204     return result;
 205 }
 206
 207 EncodedJSValue jsTestSerializedScriptValueInterfaceValue(ExecState* state, EncodedJSValue thisValue, PropertyName)
 208 {
 209     return IDLAttribute<JSTestSerializedScriptValueInterface>::get<jsTestSerializedScriptValueInterfaceValueGetter, CastedThisErrorBehavior::Assert>(*state, thisValue, "value");
 210 }
 211
 212 static inline bool setJSTestSerializedScriptValueInterfaceValueSetter(ExecState& state, JSTestSerializedScriptValueInterface& thisObject, JSValue value, ThrowScope& throwScope)
 213 {
 214     UNUSED_PARAM(throwScope);
 215     auto& impl = thisObject.wrapped();
 216     auto nativeValue = convert<IDLSerializedScriptValue<SerializedScriptValue>>(state, value);
 217     RETURN_IF_EXCEPTION(throwScope, false);
 218     AttributeSetter::call(state, throwScope, [&] {
 219         return impl.setValue(WTFMove(nativeValue));
 220     });
 221     return true;
 222 }
 223
 224 bool setJSTestSerializedScriptValueInterfaceValue(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
 225 {
 226     return IDLAttribute<JSTestSerializedScriptValueInterface>::set<setJSTestSerializedScriptValueInterfaceValueSetter>(*state, thisValue, encodedValue, "value");
 227 }
 228
 229 static inline JSValue jsTestSerializedScriptValueInterfaceReadonlyValueGetter(ExecState& state, JSTestSerializedScriptValueInterface& thisObject, ThrowScope& throwScope)
 230 {
 231     UNUSED_PARAM(throwScope);
 232     UNUSED_PARAM(state);
 233     auto& impl = thisObject.wrapped();
 234     JSValue result = toJS<IDLSerializedScriptValue<SerializedScriptValue>>(state, *thisObject.globalObject(), throwScope, impl.readonlyValue());
 235     return result;
 236 }
 237
 238 EncodedJSValue jsTestSerializedScriptValueInterfaceReadonlyValue(ExecState* state, EncodedJSValue thisValue, PropertyName)
 239 {
 240     return IDLAttribute<JSTestSerializedScriptValueInterface>::get<jsTestSerializedScriptValueInterfaceReadonlyValueGetter, CastedThisErrorBehavior::Assert>(*state, thisValue, "readonlyValue");
 241 }
 242
 243 static inline JSValue jsTestSerializedScriptValueInterfaceCachedValueGetter(ExecState& state, JSTestSerializedScriptValueInterface& thisObject, ThrowScope& throwScope)
 244 {
 245     UNUSED_PARAM(throwScope);
 246     UNUSED_PARAM(state);
 247     if (JSValue cachedValue = thisObject.m_cachedValue.get())
 248         return cachedValue;
 249     auto& impl = thisObject.wrapped();
 250     JSValue result = toJS<IDLSerializedScriptValue<SerializedScriptValue>>(state, *thisObject.globalObject(), throwScope, impl.cachedValue());
 251     thisObject.m_cachedValue.set(state.vm(), &thisObject, result);
 252     return result;
 253 }
 254
 255 EncodedJSValue jsTestSerializedScriptValueInterfaceCachedValue(ExecState* state, EncodedJSValue thisValue, PropertyName)
 256 {
 257     return IDLAttribute<JSTestSerializedScriptValueInterface>::get<jsTestSerializedScriptValueInterfaceCachedValueGetter, CastedThisErrorBehavior::Assert>(*state, thisValue, "cachedValue");
 258 }
 259
 260 static inline bool setJSTestSerializedScriptValueInterfaceCachedValueSetter(ExecState& state, JSTestSerializedScriptValueInterface& thisObject, JSValue value, ThrowScope& throwScope)
 261 {
 262     UNUSED_PARAM(throwScope);
 263     auto& impl = thisObject.wrapped();
 264     auto nativeValue = convert<IDLSerializedScriptValue<SerializedScriptValue>>(state, value);
 265     RETURN_IF_EXCEPTION(throwScope, false);
 266     AttributeSetter::call(state, throwScope, [&] {
 267         return impl.setCachedValue(WTFMove(nativeValue));
 268     });
 269     return true;
 270 }
 271
 272 bool setJSTestSerializedScriptValueInterfaceCachedValue(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
 273 {
 274     return IDLAttribute<JSTestSerializedScriptValueInterface>::set<setJSTestSerializedScriptValueInterfaceCachedValueSetter>(*state, thisValue, encodedValue, "cachedValue");
 275 }
 276
 277 static inline JSValue jsTestSerializedScriptValueInterfacePortsGetter(ExecState& state, JSTestSerializedScriptValueInterface& thisObject, ThrowScope& throwScope)
 278 {
 279     UNUSED_PARAM(throwScope);
 280     UNUSED_PARAM(state);
 281     auto& impl = thisObject.wrapped();
 282     JSValue result = toJS<IDLSequence<IDLInterface<MessagePort>>>(state, *thisObject.globalObject(), throwScope, impl.ports());
 283     return result;
 284 }
 285
 286 EncodedJSValue jsTestSerializedScriptValueInterfacePorts(ExecState* state, EncodedJSValue thisValue, PropertyName)
 287 {
 288     return IDLAttribute<JSTestSerializedScriptValueInterface>::get<jsTestSerializedScriptValueInterfacePortsGetter, CastedThisErrorBehavior::Assert>(*state, thisValue, "ports");
 289 }
 290
 291 static inline JSValue jsTestSerializedScriptValueInterfaceCachedReadonlyValueGetter(ExecState& state, JSTestSerializedScriptValueInterface& thisObject, ThrowScope& throwScope)
 292 {
 293     UNUSED_PARAM(throwScope);
 294     UNUSED_PARAM(state);
 295     if (JSValue cachedValue = thisObject.m_cachedReadonlyValue.get())
 296         return cachedValue;
 297     auto& impl = thisObject.wrapped();
 298     JSValue result = toJS<IDLSerializedScriptValue<SerializedScriptValue>>(state, *thisObject.globalObject(), throwScope, impl.cachedReadonlyValue());
 299     thisObject.m_cachedReadonlyValue.set(state.vm(), &thisObject, result);
 300     return result;
 301 }
 302
 303 EncodedJSValue jsTestSerializedScriptValueInterfaceCachedReadonlyValue(ExecState* state, EncodedJSValue thisValue, PropertyName)
 304 {
 305     return IDLAttribute<JSTestSerializedScriptValueInterface>::get<jsTestSerializedScriptValueInterfaceCachedReadonlyValueGetter, CastedThisErrorBehavior::Assert>(*state, thisValue, "cachedReadonlyValue");
 306 }
 307
 308 static inline JSC::EncodedJSValue jsTestSerializedScriptValueInterfacePrototypeFunctionFunctionBody(JSC::ExecState* state, typename IDLOperation<JSTestSerializedScriptValueInterface>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
 309 {
 310     UNUSED_PARAM(state);
 311     UNUSED_PARAM(throwScope);
 312     auto& impl = castedThis->wrapped();
 313     if (UNLIKELY(state->argumentCount() < 1))
 314         return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
 315     auto value = convert<IDLSerializedScriptValue<SerializedScriptValue>>(*state, state->uncheckedArgument(0));
 316     RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
 317     impl.function(WTFMove(value));
 318     return JSValue::encode(jsUndefined());
 319 }
 320
 321 EncodedJSValue JSC_HOST_CALL jsTestSerializedScriptValueInterfacePrototypeFunctionFunction(ExecState* state)
 322 {
 323     return IDLOperation<JSTestSerializedScriptValueInterface>::call<jsTestSerializedScriptValueInterfacePrototypeFunctionFunctionBody>(*state, "function");
 324 }
 325
 326 static inline JSC::EncodedJSValue jsTestSerializedScriptValueInterfacePrototypeFunctionFunctionReturningBody(JSC::ExecState* state, typename IDLOperation<JSTestSerializedScriptValueInterface>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
 327 {
 328     UNUSED_PARAM(state);
 329     UNUSED_PARAM(throwScope);
 330     auto& impl = castedThis->wrapped();
 331     return JSValue::encode(toJS<IDLSerializedScriptValue<SerializedScriptValue>>(*state, *castedThis->globalObject(), impl.functionReturning()));
 332 }
 333
 334 EncodedJSValue JSC_HOST_CALL jsTestSerializedScriptValueInterfacePrototypeFunctionFunctionReturning(ExecState* state)
 335 {
 336     return IDLOperation<JSTestSerializedScriptValueInterface>::call<jsTestSerializedScriptValueInterfacePrototypeFunctionFunctionReturningBody>(*state, "functionReturning");
 337 }
 338
 339 void JSTestSerializedScriptValueInterface::visitChildren(JSCell* cell, SlotVisitor& visitor)
 340 {
 341     auto* thisObject = jsCast<JSTestSerializedScriptValueInterface*>(cell);
 342     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
 343     Base::visitChildren(thisObject, visitor);
 344     visitor.append(thisObject->m_cachedValue);
 345     visitor.append(thisObject->m_cachedReadonlyValue);
 346 }
 347
 348 bool JSTestSerializedScriptValueInterfaceOwner::isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown> handle, void*, SlotVisitor& visitor)
 349 {
 350     UNUSED_PARAM(handle);
 351     UNUSED_PARAM(visitor);
 352     return false;
 353 }
 354
 355 void JSTestSerializedScriptValueInterfaceOwner::finalize(JSC::Handle<JSC::Unknown> handle, void* context)
 356 {
 357     auto* jsTestSerializedScriptValueInterface = static_cast<JSTestSerializedScriptValueInterface*>(handle.slot()->asCell());
 358     auto& world = *static_cast<DOMWrapperWorld*>(context);
 359     uncacheWrapper(world, &jsTestSerializedScriptValueInterface->wrapped(), jsTestSerializedScriptValueInterface);
 360 }
 361
 362 #if ENABLE(BINDING_INTEGRITY)
 363 #if PLATFORM(WIN)
 364 #pragma warning(disable: 4483)
 365 extern "C" { extern void (*const __identifier("??_7TestSerializedScriptValueInterface@WebCore@@6B@")[])(); }
 366 #else
 367 extern "C" { extern void* _ZTVN7WebCore34TestSerializedScriptValueInterfaceE[]; }
 368 #endif
 369 #endif
 370
 371 JSC::JSValue toJSNewlyCreated(JSC::ExecState*, JSDOMGlobalObject* globalObject, Ref<TestSerializedScriptValueInterface>&& impl)
 372 {
 373
 374 #if ENABLE(BINDING_INTEGRITY)
 375     void* actualVTablePointer = *(reinterpret_cast<void**>(impl.ptr()));
 376 #if PLATFORM(WIN)
 377     void* expectedVTablePointer = WTF_PREPARE_VTBL_POINTER_FOR_INSPECTION(__identifier("??_7TestSerializedScriptValueInterface@WebCore@@6B@"));
 378 #else
 379     void* expectedVTablePointer = WTF_PREPARE_VTBL_POINTER_FOR_INSPECTION(&_ZTVN7WebCore34TestSerializedScriptValueInterfaceE[2]);
 380 #endif
 381
 382     // If this fails TestSerializedScriptValueInterface does not have a vtable, so you need to add the
 383     // ImplementationLacksVTable attribute to the interface definition
 384     static_assert(std::is_polymorphic<TestSerializedScriptValueInterface>::value, "TestSerializedScriptValueInterface is not polymorphic");
 385
 386     // If you hit this assertion you either have a use after free bug, or
 387     // TestSerializedScriptValueInterface has subclasses. If TestSerializedScriptValueInterface has subclasses that get passed
 388     // to toJS() we currently require TestSerializedScriptValueInterface you to opt out of binding hardening
 389     // by adding the SkipVTableValidation attribute to the interface IDL definition
 390     RELEASE_ASSERT(actualVTablePointer == expectedVTablePointer);
 391 #endif
 392     return createWrapper<TestSerializedScriptValueInterface>(globalObject, WTFMove(impl));
 393 }
 394
 395 JSC::JSValue toJS(JSC::ExecState* state, JSDOMGlobalObject* globalObject, TestSerializedScriptValueInterface& impl)
 396 {
 397     return wrap(state, globalObject, impl);
 398 }
 399
 400 TestSerializedScriptValueInterface* JSTestSerializedScriptValueInterface::toWrapped(JSC::VM& vm, JSC::JSValue value)
 401 {
 402     if (auto* wrapper = jsDynamicDowncast<JSTestSerializedScriptValueInterface*>(vm, value))
 403         return &wrapper->wrapped();
 404     return nullptr;
 405 }
 406
 407 }
 408
 409 #endif // ENABLE(Condition1) || ENABLE(Condition2)