Diff
Modified: trunk/Source/WebCore/ChangeLog (267311 => 267312)
--- trunk/Source/WebCore/ChangeLog 2020-09-19 14:20:18 UTC (rev 267311)
+++ trunk/Source/WebCore/ChangeLog 2020-09-19 14:22:11 UTC (rev 267312)
@@ -1,5 +1,34 @@
2020-09-19 Sam Weinig <wei...@apple.com>
+ Add support for Settings equivilent of RuntimeConditionallyReadWrite
+ https://bugs.webkit.org/show_bug.cgi?id=216697
+
+ Reviewed by Darin Adler.
+
+ Adds a new extended attribute, [SettingsConditionallyReadWrite] to allow users of
+ [RuntimeConditionallyReadWrite] to convert from RuntimeEnabledFeatures to Settings.
+
+ * bindings/scripts/CodeGeneratorJS.pm:
+ (NeedsRuntimeReadWriteCheck):
+ (GeneratePropertiesHashTable):
+ (GenerateRuntimeEnableConditionalString):
+ (GenerateImplementation):
+ * bindings/scripts/IDLAttributes.json:
+ Adds new extended attribute.
+
+ * bindings/scripts/test/DOMWindowConstructors.idl:
+ * bindings/scripts/test/JS/JSDOMWindow.cpp:
+ * bindings/scripts/test/JS/JSTestConditionallyReadWrite.cpp: Added.
+ * bindings/scripts/test/JS/JSTestConditionallyReadWrite.h: Added.
+ * bindings/scripts/test/JS/JSTestObj.cpp:
+ * bindings/scripts/test/SupplementalDependencies.dep:
+ * bindings/scripts/test/TestConditionallyReadWrite.idl: Added.
+ * bindings/scripts/test/TestObj.idl:
+ Move conditionally read-write tests to a new test, TestConditionallyReadWrite.idl and
+ update results.
+
+2020-09-19 Sam Weinig <wei...@apple.com>
+
Remove runtime setting for enabling/disabling the CrossOriginResourcePolicy API
https://bugs.webkit.org/show_bug.cgi?id=216561
Modified: trunk/Source/WebCore/bindings/scripts/CodeGeneratorJS.pm (267311 => 267312)
--- trunk/Source/WebCore/bindings/scripts/CodeGeneratorJS.pm 2020-09-19 14:20:18 UTC (rev 267311)
+++ trunk/Source/WebCore/bindings/scripts/CodeGeneratorJS.pm 2020-09-19 14:22:11 UTC (rev 267312)
@@ -1989,6 +1989,14 @@
|| $context->extendedAttributes->{CustomEnabled};
}
+sub NeedsRuntimeReadWriteCheck
+{
+ my ($interface, $context) = @_;
+
+ return $context->extendedAttributes->{RuntimeConditionallyReadWrite}
+ || $context->extendedAttributes->{SettingsConditionallyReadWrite}
+}
+
# https://heycam.github.io/webidl/#es-operations
sub OperationShouldBeOnInstance
{
@@ -3404,7 +3412,7 @@
$readWriteConditionals->{$name} = $readWriteConditional if $readWriteConditional;
my $needsRuntimeCheck = NeedsRuntimeCheck($interface, $attribute);
- my $needsRuntimeReadWriteCheck = $attribute->extendedAttributes->{RuntimeConditionallyReadWrite};
+ my $needsRuntimeReadWriteCheck = NeedsRuntimeReadWriteCheck($interface, $attribute);
if ($needsRuntimeCheck && $needsRuntimeReadWriteCheck) {
die "Being both runtime enabled and runtime conditionally read-write is not yet supported (used on the '${name}' attribute of '${interfaceName}').\n";
@@ -4038,6 +4046,20 @@
}
}
+ if ($context->extendedAttributes->{SettingsConditionallyReadWrite}) {
+ assert("Must specify value for SettingsConditionallyReadWrite.") if $context->extendedAttributes->{SettingsConditionallyReadWrite} eq "VALUE_IS_MISSING";
+
+ AddToImplIncludes("Document.h");
+ AddToImplIncludes("Settings.h");
+
+ assert("SettingsConditionallyReadWrite can only be used by interfaces only exposed to the Window") if $interface->extendedAttributes->{Exposed} && $interface->extendedAttributes->{Exposed} ne "Window";
+
+ my @flags = split(/&/, $context->extendedAttributes->{SettingsConditionallyReadWrite});
+ foreach my $flag (@flags) {
+ push(@conjuncts, "downcast<Document>(jsCast<JSDOMGlobalObject*>(" . $globalObjectPtr . ")->scriptExecutionContext())->settings()." . ToMethodName($flag) . "Enabled()");
+ }
+ }
+
if ($context->extendedAttributes->{CustomEnabled}) {
assert("CustomEnabled can only be used by interfaces only exposed to the Window") if $interface->extendedAttributes->{Exposed} && $interface->extendedAttributes->{Exposed} ne "Window";
@@ -4551,7 +4573,7 @@
}
foreach my $attribute (@runtimeEnabledAttributes) {
- if ($attribute->extendedAttributes->{RuntimeConditionallyReadWrite}) {
+ if (NeedsRuntimeReadWriteCheck($interface, $attribute)) {
AddToImplIncludes("WebCoreJSClientData.h");
my $runtimeEnableConditionalString = GenerateRuntimeEnableConditionalString($interface, $attribute);
Modified: trunk/Source/WebCore/bindings/scripts/IDLAttributes.json (267311 => 267312)
--- trunk/Source/WebCore/bindings/scripts/IDLAttributes.json 2020-09-19 14:20:18 UTC (rev 267311)
+++ trunk/Source/WebCore/bindings/scripts/IDLAttributes.json 2020-09-19 14:22:11 UTC (rev 267312)
@@ -487,6 +487,11 @@
"values": ["ExecState", "ScriptExecutionContext", "GlobalObject", "ActiveWindow", "FirstWindow"],
"supportsConjunction": true
},
+ "SettingsConditionallyReadWrite": {
+ "contextsAllowed": ["attribute"],
+ "values": ["*"],
+ "supportsConjunction": true
+ },
"SkipCallbackInvokeCheck": {
"contextsAllowed": ["operation", "callback-function"]
},
Modified: trunk/Source/WebCore/bindings/scripts/test/DOMWindowConstructors.idl (267311 => 267312)
--- trunk/Source/WebCore/bindings/scripts/test/DOMWindowConstructors.idl 2020-09-19 14:20:18 UTC (rev 267311)
+++ trunk/Source/WebCore/bindings/scripts/test/DOMWindowConstructors.idl 2020-09-19 14:22:11 UTC (rev 267312)
@@ -1,5 +1,6 @@
partial interface DOMWindow {
attribute ExposedToWorkerAndWindowConstructor ExposedToWorkerAndWindow;
+ attribute TestConditionallyReadWriteConstructor TestConditionallyReadWrite;
attribute TestNodeConstructor TestNode;
attribute TestObjConstructor TestObject;
attribute TestPromiseRejectionEventConstructor TestPromiseRejectionEvent;
Modified: trunk/Source/WebCore/bindings/scripts/test/JS/JSDOMWindow.cpp (267311 => 267312)
--- trunk/Source/WebCore/bindings/scripts/test/JS/JSDOMWindow.cpp 2020-09-19 14:20:18 UTC (rev 267311)
+++ trunk/Source/WebCore/bindings/scripts/test/JS/JSDOMWindow.cpp 2020-09-19 14:22:11 UTC (rev 267312)
@@ -29,6 +29,7 @@
#include "JSDOMExceptionHandling.h"
#include "JSDOMWrapperCache.h"
#include "JSExposedToWorkerAndWindow.h"
+#include "JSTestConditionallyReadWrite.h"
#include "JSTestNode.h"
#include "JSTestObj.h"
#include "JSTestPromiseRejectionEvent.h"
@@ -53,6 +54,8 @@
bool setJSDOMWindowConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
JSC::EncodedJSValue jsDOMWindowExposedToWorkerAndWindowConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::PropertyName);
bool setJSDOMWindowExposedToWorkerAndWindowConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
+JSC::EncodedJSValue jsDOMWindowTestConditionallyReadWriteConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::PropertyName);
+bool setJSDOMWindowTestConditionallyReadWriteConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
JSC::EncodedJSValue jsDOMWindowTestNodeConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::PropertyName);
bool setJSDOMWindowTestNodeConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
JSC::EncodedJSValue jsDOMWindowTestObjectConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::PropertyName);
@@ -64,16 +67,24 @@
/* Hash table */
-static const struct CompactHashIndex JSDOMWindowTableIndex[10] = {
+static const struct CompactHashIndex JSDOMWindowTableIndex[18] = {
{ -1, -1 },
- { 0, 8 },
+ { 0, 16 },
{ -1, -1 },
{ -1, -1 },
{ -1, -1 },
{ -1, -1 },
+ { -1, -1 },
+ { -1, -1 },
+ { -1, -1 },
{ 3, -1 },
{ -1, -1 },
- { 1, 9 },
+ { -1, -1 },
+ { -1, -1 },
+ { -1, -1 },
+ { 4, -1 },
+ { -1, -1 },
+ { 1, 17 },
{ 2, -1 },
};
@@ -81,12 +92,13 @@
static const HashTableValue JSDOMWindowTableValues[] =
{
{ "ExposedToWorkerAndWindow", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowExposedToWorkerAndWindowConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowExposedToWorkerAndWindowConstructor) } },
+ { "TestConditionallyReadWrite", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowTestConditionallyReadWriteConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowTestConditionallyReadWriteConstructor) } },
{ "TestNode", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowTestNodeConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowTestNodeConstructor) } },
{ "TestObject", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowTestObjectConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowTestObjectConstructor) } },
{ "TestPromiseRejectionEvent", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowTestPromiseRejectionEventConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowTestPromiseRejectionEventConstructor) } },
};
-static const HashTable JSDOMWindowTable = { 4, 7, true, JSDOMWindow::info(), JSDOMWindowTableValues, JSDOMWindowTableIndex };
+static const HashTable JSDOMWindowTable = { 5, 15, true, JSDOMWindow::info(), JSDOMWindowTableValues, JSDOMWindowTableIndex };
template<> JSValue JSDOMWindowConstructor::prototypeForStructure(JSC::VM& vm, const JSDOMGlobalObject& globalObject)
{
return JSEventTarget::getConstructor(vm, &globalObject);
@@ -195,6 +207,29 @@
return IDLAttribute<JSDOMWindow>::set<setJSDOMWindowExposedToWorkerAndWindowConstructorSetter>(*lexicalGlobalObject, thisValue, encodedValue, "ExposedToWorkerAndWindow");
}
+static inline JSValue jsDOMWindowTestConditionallyReadWriteConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
+{
+ UNUSED_PARAM(lexicalGlobalObject);
+ return JSTestConditionallyReadWrite::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
+}
+
+EncodedJSValue jsDOMWindowTestConditionallyReadWriteConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName)
+{
+ return IDLAttribute<JSDOMWindow>::get<jsDOMWindowTestConditionallyReadWriteConstructorGetter>(*lexicalGlobalObject, thisValue, "TestConditionallyReadWrite");
+}
+
+static inline bool setJSDOMWindowTestConditionallyReadWriteConstructorSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
+{
+ auto& vm = JSC::getVM(&lexicalGlobalObject);
+ // Shadowing a built-in constructor.
+ return thisObject.putDirect(vm, Identifier::fromString(vm, reinterpret_cast<const LChar*>("TestConditionallyReadWrite"), strlen("TestConditionallyReadWrite")), value);
+}
+
+bool setJSDOMWindowTestConditionallyReadWriteConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
+{
+ return IDLAttribute<JSDOMWindow>::set<setJSDOMWindowTestConditionallyReadWriteConstructorSetter>(*lexicalGlobalObject, thisValue, encodedValue, "TestConditionallyReadWrite");
+}
+
static inline JSValue jsDOMWindowTestNodeConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
{
UNUSED_PARAM(lexicalGlobalObject);
Added: trunk/Source/WebCore/bindings/scripts/test/JS/JSTestConditionallyReadWrite.cpp (0 => 267312)
--- trunk/Source/WebCore/bindings/scripts/test/JS/JSTestConditionallyReadWrite.cpp (rev 0)
+++ trunk/Source/WebCore/bindings/scripts/test/JS/JSTestConditionallyReadWrite.cpp 2020-09-19 14:22:11 UTC (rev 267312)
@@ -0,0 +1,712 @@
+/*
+ This file is part of the WebKit open source project.
+ This file has been generated by generate-bindings.pl. DO NOT MODIFY!
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Library General Public
+ License as published by the Free Software Foundation; either
+ version 2 of the License, or (at your option) any later version.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public License
+ along with this library; see the file COPYING.LIB. If not, write to
+ the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ Boston, MA 02110-1301, USA.
+*/
+
+#include "config.h"
+#include "JSTestConditionallyReadWrite.h"
+
+#include "ActiveDOMObject.h"
+#include "DOMIsoSubspaces.h"
+#include "DOMPromiseProxy.h"
+#include "Document.h"
+#include "JSDOMAttribute.h"
+#include "JSDOMBinding.h"
+#include "JSDOMConstructorNotConstructable.h"
+#include "JSDOMConvertInterface.h"
+#include "JSDOMConvertNumbers.h"
+#include "JSDOMConvertPromise.h"
+#include "JSDOMExceptionHandling.h"
+#include "JSDOMGlobalObject.h"
+#include "JSDOMWrapperCache.h"
+#include "JSNode.h"
+#include "RuntimeEnabledFeatures.h"
+#include "ScriptExecutionContext.h"
+#include "Settings.h"
+#include "WebCoreJSClientData.h"
+#include <_javascript_Core/FunctionPrototype.h>
+#include <_javascript_Core/HeapAnalyzer.h>
+#include <_javascript_Core/JSCInlines.h>
+#include <_javascript_Core/JSDestructibleObjectHeapCellType.h>
+#include <_javascript_Core/SubspaceInlines.h>
+#include <wtf/GetPtr.h>
+#include <wtf/PointerPreparations.h>
+#include <wtf/URL.h>
+
+
+namespace WebCore {
+using namespace JSC;
+
+// Attributes
+
+JSC::EncodedJSValue jsTestConditionallyReadWriteConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::PropertyName);
+bool setJSTestConditionallyReadWriteConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
+JSC::EncodedJSValue jsTestConditionallyReadWriteConditionallyReadWriteAttribute(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::PropertyName);
+#if ENABLE(CONDITION)
+bool setJSTestConditionallyReadWriteConditionallyReadWriteAttribute(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
+#endif
+#if ENABLE(CONDITION2)
+JSC::EncodedJSValue jsTestConditionallyReadWriteConditionalAndConditionallyReadWriteAttribute(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::PropertyName);
+#if ENABLE(CONDITION)
+bool setJSTestConditionallyReadWriteConditionalAndConditionallyReadWriteAttribute(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
+#endif
+#endif
+JSC::EncodedJSValue jsTestConditionallyReadWriteRuntimeConditionallyReadWriteAttribute(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::PropertyName);
+bool setJSTestConditionallyReadWriteRuntimeConditionallyReadWriteAttribute(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
+JSC::EncodedJSValue jsTestConditionallyReadWriteRuntimeConditionallyReadWriteAttributeUnforgeable(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::PropertyName);
+bool setJSTestConditionallyReadWriteRuntimeConditionallyReadWriteAttributeUnforgeable(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
+JSC::EncodedJSValue jsTestConditionallyReadWriteRuntimeConditionallyReadWriteAttributeUnforgeablePrivate(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::PropertyName);
+bool setJSTestConditionallyReadWriteRuntimeConditionallyReadWriteAttributeUnforgeablePrivate(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
+JSC::EncodedJSValue jsTestConditionallyReadWriteRuntimeConditionallyReadWriteAttributePromise(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::PropertyName);
+bool setJSTestConditionallyReadWriteRuntimeConditionallyReadWriteAttributePromise(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
+JSC::EncodedJSValue jsTestConditionallyReadWriteSettingsConditionallyReadWriteAttribute(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::PropertyName);
+bool setJSTestConditionallyReadWriteSettingsConditionallyReadWriteAttribute(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
+JSC::EncodedJSValue jsTestConditionallyReadWriteSettingsConditionallyReadWriteAttributeUnforgeable(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::PropertyName);
+bool setJSTestConditionallyReadWriteSettingsConditionallyReadWriteAttributeUnforgeable(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
+JSC::EncodedJSValue jsTestConditionallyReadWriteSettingsConditionallyReadWriteAttributeUnforgeablePrivate(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::PropertyName);
+bool setJSTestConditionallyReadWriteSettingsConditionallyReadWriteAttributeUnforgeablePrivate(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
+JSC::EncodedJSValue jsTestConditionallyReadWriteSettingsConditionallyReadWriteAttributePromise(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::PropertyName);
+bool setJSTestConditionallyReadWriteSettingsConditionallyReadWriteAttributePromise(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
+
+class JSTestConditionallyReadWritePrototype final : public JSC::JSNonFinalObject {
+public:
+ using Base = JSC::JSNonFinalObject;
+ static JSTestConditionallyReadWritePrototype* create(JSC::VM& vm, JSDOMGlobalObject* globalObject, JSC::Structure* structure)
+ {
+ JSTestConditionallyReadWritePrototype* ptr = new (NotNull, JSC::allocateCell<JSTestConditionallyReadWritePrototype>(vm.heap)) JSTestConditionallyReadWritePrototype(vm, globalObject, structure);
+ ptr->finishCreation(vm);
+ return ptr;
+ }
+
+ DECLARE_INFO;
+ template<typename CellType, JSC::SubspaceAccess>
+ static JSC::IsoSubspace* subspaceFor(JSC::VM& vm)
+ {
+ STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSTestConditionallyReadWritePrototype, Base);
+ return &vm.plainObjectSpace;
+ }
+ static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+ {
+ return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
+ }
+
+private:
+ JSTestConditionallyReadWritePrototype(JSC::VM& vm, JSC::JSGlobalObject*, JSC::Structure* structure)
+ : JSC::JSNonFinalObject(vm, structure)
+ {
+ }
+
+ void finishCreation(JSC::VM&);
+};
+STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSTestConditionallyReadWritePrototype, JSTestConditionallyReadWritePrototype::Base);
+
+using JSTestConditionallyReadWriteConstructor = JSDOMConstructorNotConstructable<JSTestConditionallyReadWrite>;
+
+/* Hash table */
+
+static const struct CompactHashIndex JSTestConditionallyReadWriteTableIndex[8] = {
+ { -1, -1 },
+ { -1, -1 },
+ { 1, -1 },
+ { 0, -1 },
+ { -1, -1 },
+ { -1, -1 },
+ { -1, -1 },
+ { -1, -1 },
+};
+
+
+static const HashTableValue JSTestConditionallyReadWriteTableValues[] =
+{
+ { "runtimeConditionallyReadWriteAttributeUnforgeable", static_cast<unsigned>(JSC::PropertyAttribute::DontDelete | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestConditionallyReadWriteRuntimeConditionallyReadWriteAttributeUnforgeable), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestConditionallyReadWriteRuntimeConditionallyReadWriteAttributeUnforgeable) } },
+ { "settingsConditionallyReadWriteAttributeUnforgeable", static_cast<unsigned>(JSC::PropertyAttribute::DontDelete | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestConditionallyReadWriteSettingsConditionallyReadWriteAttributeUnforgeable), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestConditionallyReadWriteSettingsConditionallyReadWriteAttributeUnforgeable) } },
+};
+
+static const HashTable JSTestConditionallyReadWriteTable = { 2, 7, true, JSTestConditionallyReadWrite::info(), JSTestConditionallyReadWriteTableValues, JSTestConditionallyReadWriteTableIndex };
+template<> JSValue JSTestConditionallyReadWriteConstructor::prototypeForStructure(JSC::VM& vm, const JSDOMGlobalObject& globalObject)
+{
+ UNUSED_PARAM(vm);
+ return globalObject.functionPrototype();
+}
+
+template<> void JSTestConditionallyReadWriteConstructor::initializeProperties(VM& vm, JSDOMGlobalObject& globalObject)
+{
+ putDirect(vm, vm.propertyNames->prototype, JSTestConditionallyReadWrite::prototype(vm, globalObject), JSC::PropertyAttribute::DontDelete | JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::DontEnum);
+ putDirect(vm, vm.propertyNames->name, jsNontrivialString(vm, "TestConditionallyReadWrite"_s), JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::DontEnum);
+ putDirect(vm, vm.propertyNames->length, jsNumber(0), JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::DontEnum);
+}
+
+template<> const ClassInfo JSTestConditionallyReadWriteConstructor::s_info = { "TestConditionallyReadWrite", &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSTestConditionallyReadWriteConstructor) };
+
+/* Hash table for prototype */
+
+static const HashTableValue JSTestConditionallyReadWritePrototypeTableValues[] =
+{
+ { "constructor", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestConditionallyReadWriteConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestConditionallyReadWriteConstructor) } },
+#if ENABLE(CONDITION)
+ { "conditionallyReadWriteAttribute", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestConditionallyReadWriteConditionallyReadWriteAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestConditionallyReadWriteConditionallyReadWriteAttribute) } },
+#else
+ { "conditionallyReadWriteAttribute", JSC::PropertyAttribute::ReadOnly | static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestConditionallyReadWriteConditionallyReadWriteAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
+#endif
+#if ENABLE(CONDITION2)
+#if ENABLE(CONDITION)
+ { "conditionalAndConditionallyReadWriteAttribute", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestConditionallyReadWriteConditionalAndConditionallyReadWriteAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestConditionallyReadWriteConditionalAndConditionallyReadWriteAttribute) } },
+#else
+ { "conditionalAndConditionallyReadWriteAttribute", JSC::PropertyAttribute::ReadOnly | static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestConditionallyReadWriteConditionalAndConditionallyReadWriteAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
+#endif
+#else
+ { 0, 0, NoIntrinsic, { 0, 0 } },
+#endif
+ { "runtimeConditionallyReadWriteAttribute", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestConditionallyReadWriteRuntimeConditionallyReadWriteAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestConditionallyReadWriteRuntimeConditionallyReadWriteAttribute) } },
+ { "runtimeConditionallyReadWriteAttributePromise", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestConditionallyReadWriteRuntimeConditionallyReadWriteAttributePromise), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestConditionallyReadWriteRuntimeConditionallyReadWriteAttributePromise) } },
+ { "settingsConditionallyReadWriteAttribute", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestConditionallyReadWriteSettingsConditionallyReadWriteAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestConditionallyReadWriteSettingsConditionallyReadWriteAttribute) } },
+ { "settingsConditionallyReadWriteAttributePromise", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestConditionallyReadWriteSettingsConditionallyReadWriteAttributePromise), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestConditionallyReadWriteSettingsConditionallyReadWriteAttributePromise) } },
+};
+
+const ClassInfo JSTestConditionallyReadWritePrototype::s_info = { "TestConditionallyReadWrite", &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSTestConditionallyReadWritePrototype) };
+
+void JSTestConditionallyReadWritePrototype::finishCreation(VM& vm)
+{
+ Base::finishCreation(vm);
+ reifyStaticProperties(vm, JSTestConditionallyReadWrite::info(), JSTestConditionallyReadWritePrototypeTableValues, *this);
+ bool hasDisabledRuntimeProperties = false;
+ if (!RuntimeEnabledFeatures::sharedFeatures().testFeatureEnabled()) {
+ hasDisabledRuntimeProperties = true;
+ auto propertyName = Identifier::fromString(vm, reinterpret_cast<const LChar*>("runtimeConditionallyReadWriteAttribute"), strlen("runtimeConditionallyReadWriteAttribute"));
+ VM::DeletePropertyModeScope scope(vm, VM::DeletePropertyMode::IgnoreConfigurable);
+ DeletePropertySlot slot;
+ JSObject::deleteProperty(this, globalObject(), propertyName, slot);
+ }
+ if (!RuntimeEnabledFeatures::sharedFeatures().testFeatureEnabled()) {
+ hasDisabledRuntimeProperties = true;
+ auto propertyName = Identifier::fromString(vm, reinterpret_cast<const LChar*>("runtimeConditionallyReadWriteAttributePromise"), strlen("runtimeConditionallyReadWriteAttributePromise"));
+ VM::DeletePropertyModeScope scope(vm, VM::DeletePropertyMode::IgnoreConfigurable);
+ DeletePropertySlot slot;
+ JSObject::deleteProperty(this, globalObject(), propertyName, slot);
+ }
+ if (!downcast<Document>(jsCast<JSDOMGlobalObject*>(globalObject())->scriptExecutionContext())->settings().testFeatureEnabled()) {
+ hasDisabledRuntimeProperties = true;
+ auto propertyName = Identifier::fromString(vm, reinterpret_cast<const LChar*>("settingsConditionallyReadWriteAttribute"), strlen("settingsConditionallyReadWriteAttribute"));
+ VM::DeletePropertyModeScope scope(vm, VM::DeletePropertyMode::IgnoreConfigurable);
+ DeletePropertySlot slot;
+ JSObject::deleteProperty(this, globalObject(), propertyName, slot);
+ }
+ if (!downcast<Document>(jsCast<JSDOMGlobalObject*>(globalObject())->scriptExecutionContext())->settings().testFeatureEnabled()) {
+ hasDisabledRuntimeProperties = true;
+ auto propertyName = Identifier::fromString(vm, reinterpret_cast<const LChar*>("settingsConditionallyReadWriteAttributePromise"), strlen("settingsConditionallyReadWriteAttributePromise"));
+ VM::DeletePropertyModeScope scope(vm, VM::DeletePropertyMode::IgnoreConfigurable);
+ DeletePropertySlot slot;
+ JSObject::deleteProperty(this, globalObject(), propertyName, slot);
+ }
+ // Adding back attribute, but as readonly, after removing the read-write variant above.
+ if (!RuntimeEnabledFeatures::sharedFeatures().testFeatureEnabled())
+ putDirectCustomAccessor(vm, static_cast<JSVMClientData*>(vm.clientData)->builtinNames().runtimeConditionallyReadWriteAttributePublicName(), JSC::DOMAttributeGetterSetter::create(vm, jsTestConditionallyReadWriteRuntimeConditionallyReadWriteAttribute, nullptr, JSC::DOMAttributeAnnotation { JSTestConditionallyReadWrite::info(), nullptr }), attributesForStructure(static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute)));
+ // Adding back attribute, but as readonly, after removing the read-write variant above.
+ if (!RuntimeEnabledFeatures::sharedFeatures().testFeatureEnabled())
+ putDirectCustomAccessor(vm, static_cast<JSVMClientData*>(vm.clientData)->builtinNames().runtimeConditionallyReadWriteAttributePromisePublicName(), CustomGetterSetter::create(vm, jsTestConditionallyReadWriteRuntimeConditionallyReadWriteAttributePromise, nullptr), attributesForStructure(static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor)));
+ // Adding back attribute, but as readonly, after removing the read-write variant above.
+ if (!downcast<Document>(jsCast<JSDOMGlobalObject*>(globalObject())->scriptExecutionContext())->settings().testFeatureEnabled())
+ putDirectCustomAccessor(vm, static_cast<JSVMClientData*>(vm.clientData)->builtinNames().settingsConditionallyReadWriteAttributePublicName(), JSC::DOMAttributeGetterSetter::create(vm, jsTestConditionallyReadWriteSettingsConditionallyReadWriteAttribute, nullptr, JSC::DOMAttributeAnnotation { JSTestConditionallyReadWrite::info(), nullptr }), attributesForStructure(static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute)));
+ // Adding back attribute, but as readonly, after removing the read-write variant above.
+ if (!downcast<Document>(jsCast<JSDOMGlobalObject*>(globalObject())->scriptExecutionContext())->settings().testFeatureEnabled())
+ putDirectCustomAccessor(vm, static_cast<JSVMClientData*>(vm.clientData)->builtinNames().settingsConditionallyReadWriteAttributePromisePublicName(), CustomGetterSetter::create(vm, jsTestConditionallyReadWriteSettingsConditionallyReadWriteAttributePromise, nullptr), attributesForStructure(static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor)));
+ if (hasDisabledRuntimeProperties && structure()->isDictionary())
+ flattenDictionaryObject(vm);
+ JSC_TO_STRING_TAG_WITHOUT_TRANSITION();
+}
+
+const ClassInfo JSTestConditionallyReadWrite::s_info = { "TestConditionallyReadWrite", &Base::s_info, &JSTestConditionallyReadWriteTable, nullptr, CREATE_METHOD_TABLE(JSTestConditionallyReadWrite) };
+
+JSTestConditionallyReadWrite::JSTestConditionallyReadWrite(Structure* structure, JSDOMGlobalObject& globalObject, Ref<TestConditionallyReadWrite>&& impl)
+ : JSDOMWrapper<TestConditionallyReadWrite>(structure, globalObject, WTFMove(impl))
+{
+}
+
+void JSTestConditionallyReadWrite::finishCreation(VM& vm)
+{
+ Base::finishCreation(vm);
+ ASSERT(inherits(vm, info()));
+
+ static_assert(!std::is_base_of<ActiveDOMObject, TestConditionallyReadWrite>::value, "Interface is not marked as [ActiveDOMObject] even though implementation class subclasses ActiveDOMObject.");
+
+ putDirectCustomAccessor(vm, static_cast<JSVMClientData*>(vm.clientData)->builtinNames().runtimeConditionallyReadWriteAttributeUnforgeablePrivatePrivateName(), CustomGetterSetter::create(vm, jsTestConditionallyReadWriteRuntimeConditionallyReadWriteAttributeUnforgeablePrivate, nullptr), attributesForStructure(JSC::PropertyAttribute::DontDelete | JSC::PropertyAttribute::ReadOnly));
+ putDirectCustomAccessor(vm, static_cast<JSVMClientData*>(vm.clientData)->builtinNames().settingsConditionallyReadWriteAttributeUnforgeablePrivatePrivateName(), CustomGetterSetter::create(vm, jsTestConditionallyReadWriteSettingsConditionallyReadWriteAttributeUnforgeablePrivate, nullptr), attributesForStructure(JSC::PropertyAttribute::DontDelete | JSC::PropertyAttribute::ReadOnly));
+}
+
+JSObject* JSTestConditionallyReadWrite::createPrototype(VM& vm, JSDOMGlobalObject& globalObject)
+{
+ return JSTestConditionallyReadWritePrototype::create(vm, &globalObject, JSTestConditionallyReadWritePrototype::createStructure(vm, &globalObject, globalObject.objectPrototype()));
+}
+
+JSObject* JSTestConditionallyReadWrite::prototype(VM& vm, JSDOMGlobalObject& globalObject)
+{
+ return getDOMPrototype<JSTestConditionallyReadWrite>(vm, globalObject);
+}
+
+JSValue JSTestConditionallyReadWrite::getConstructor(VM& vm, const JSGlobalObject* globalObject)
+{
+ return getDOMConstructor<JSTestConditionallyReadWriteConstructor>(vm, *jsCast<const JSDOMGlobalObject*>(globalObject));
+}
+
+void JSTestConditionallyReadWrite::destroy(JSC::JSCell* cell)
+{
+ JSTestConditionallyReadWrite* thisObject = static_cast<JSTestConditionallyReadWrite*>(cell);
+ thisObject->JSTestConditionallyReadWrite::~JSTestConditionallyReadWrite();
+}
+
+template<> inline JSTestConditionallyReadWrite* IDLAttribute<JSTestConditionallyReadWrite>::cast(JSGlobalObject& lexicalGlobalObject, EncodedJSValue thisValue)
+{
+ return jsDynamicCast<JSTestConditionallyReadWrite*>(JSC::getVM(&lexicalGlobalObject), JSValue::decode(thisValue));
+}
+
+EncodedJSValue jsTestConditionallyReadWriteConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName)
+{
+ VM& vm = JSC::getVM(lexicalGlobalObject);
+ auto throwScope = DECLARE_THROW_SCOPE(vm);
+ auto* prototype = jsDynamicCast<JSTestConditionallyReadWritePrototype*>(vm, JSValue::decode(thisValue));
+ if (UNLIKELY(!prototype))
+ return throwVMTypeError(lexicalGlobalObject, throwScope);
+ return JSValue::encode(JSTestConditionallyReadWrite::getConstructor(JSC::getVM(lexicalGlobalObject), prototype->globalObject()));
+}
+
+bool setJSTestConditionallyReadWriteConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
+{
+ VM& vm = JSC::getVM(lexicalGlobalObject);
+ auto throwScope = DECLARE_THROW_SCOPE(vm);
+ auto* prototype = jsDynamicCast<JSTestConditionallyReadWritePrototype*>(vm, JSValue::decode(thisValue));
+ if (UNLIKELY(!prototype)) {
+ throwVMTypeError(lexicalGlobalObject, throwScope);
+ return false;
+ }
+ // Shadowing a built-in constructor
+ return prototype->putDirect(vm, vm.propertyNames->constructor, JSValue::decode(encodedValue));
+}
+
+static inline JSValue jsTestConditionallyReadWriteConditionallyReadWriteAttributeGetter(JSGlobalObject& lexicalGlobalObject, JSTestConditionallyReadWrite& thisObject)
+{
+ auto& vm = JSC::getVM(&lexicalGlobalObject);
+ auto throwScope = DECLARE_THROW_SCOPE(vm);
+ auto& impl = thisObject.wrapped();
+ RELEASE_AND_RETURN(throwScope, (toJS<IDLInterface<Node>>(lexicalGlobalObject, *thisObject.globalObject(), throwScope, impl.conditionallyReadWriteAttribute())));
+}
+
+EncodedJSValue jsTestConditionallyReadWriteConditionallyReadWriteAttribute(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName)
+{
+ return IDLAttribute<JSTestConditionallyReadWrite>::get<jsTestConditionallyReadWriteConditionallyReadWriteAttributeGetter, CastedThisErrorBehavior::Assert>(*lexicalGlobalObject, thisValue, "conditionallyReadWriteAttribute");
+}
+
+#if ENABLE(CONDITION)
+static inline bool setJSTestConditionallyReadWriteConditionallyReadWriteAttributeSetter(JSGlobalObject& lexicalGlobalObject, JSTestConditionallyReadWrite& thisObject, JSValue value)
+{
+ auto& vm = JSC::getVM(&lexicalGlobalObject);
+ auto throwScope = DECLARE_THROW_SCOPE(vm);
+ auto& impl = thisObject.wrapped();
+ auto nativeValue = convert<IDLInterface<Node>>(lexicalGlobalObject, value, [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwAttributeTypeError(lexicalGlobalObject, scope, "TestConditionallyReadWrite", "conditionallyReadWriteAttribute", "Node"); });
+ RETURN_IF_EXCEPTION(throwScope, false);
+ AttributeSetter::call(lexicalGlobalObject, throwScope, [&] {
+ return impl.setConditionallyReadWriteAttribute(*nativeValue);
+ });
+ return true;
+}
+
+bool setJSTestConditionallyReadWriteConditionallyReadWriteAttribute(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
+{
+ return IDLAttribute<JSTestConditionallyReadWrite>::set<setJSTestConditionallyReadWriteConditionallyReadWriteAttributeSetter>(*lexicalGlobalObject, thisValue, encodedValue, "conditionallyReadWriteAttribute");
+}
+
+#endif
+
+#if ENABLE(CONDITION2)
+static inline JSValue jsTestConditionallyReadWriteConditionalAndConditionallyReadWriteAttributeGetter(JSGlobalObject& lexicalGlobalObject, JSTestConditionallyReadWrite& thisObject)
+{
+ auto& vm = JSC::getVM(&lexicalGlobalObject);
+ auto throwScope = DECLARE_THROW_SCOPE(vm);
+ auto& impl = thisObject.wrapped();
+ RELEASE_AND_RETURN(throwScope, (toJS<IDLInterface<Node>>(lexicalGlobalObject, *thisObject.globalObject(), throwScope, impl.conditionalAndConditionallyReadWriteAttribute())));
+}
+
+EncodedJSValue jsTestConditionallyReadWriteConditionalAndConditionallyReadWriteAttribute(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName)
+{
+ return IDLAttribute<JSTestConditionallyReadWrite>::get<jsTestConditionallyReadWriteConditionalAndConditionallyReadWriteAttributeGetter, CastedThisErrorBehavior::Assert>(*lexicalGlobalObject, thisValue, "conditionalAndConditionallyReadWriteAttribute");
+}
+
+#endif
+
+#if ENABLE(CONDITION2)
+#if ENABLE(CONDITION)
+static inline bool setJSTestConditionallyReadWriteConditionalAndConditionallyReadWriteAttributeSetter(JSGlobalObject& lexicalGlobalObject, JSTestConditionallyReadWrite& thisObject, JSValue value)
+{
+ auto& vm = JSC::getVM(&lexicalGlobalObject);
+ auto throwScope = DECLARE_THROW_SCOPE(vm);
+ auto& impl = thisObject.wrapped();
+ auto nativeValue = convert<IDLInterface<Node>>(lexicalGlobalObject, value, [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwAttributeTypeError(lexicalGlobalObject, scope, "TestConditionallyReadWrite", "conditionalAndConditionallyReadWriteAttribute", "Node"); });
+ RETURN_IF_EXCEPTION(throwScope, false);
+ AttributeSetter::call(lexicalGlobalObject, throwScope, [&] {
+ return impl.setConditionalAndConditionallyReadWriteAttribute(*nativeValue);
+ });
+ return true;
+}
+
+bool setJSTestConditionallyReadWriteConditionalAndConditionallyReadWriteAttribute(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
+{
+ return IDLAttribute<JSTestConditionallyReadWrite>::set<setJSTestConditionallyReadWriteConditionalAndConditionallyReadWriteAttributeSetter>(*lexicalGlobalObject, thisValue, encodedValue, "conditionalAndConditionallyReadWriteAttribute");
+}
+
+#endif
+
+#endif
+
+static inline JSValue jsTestConditionallyReadWriteRuntimeConditionallyReadWriteAttributeGetter(JSGlobalObject& lexicalGlobalObject, JSTestConditionallyReadWrite& thisObject)
+{
+ auto& vm = JSC::getVM(&lexicalGlobalObject);
+ auto throwScope = DECLARE_THROW_SCOPE(vm);
+ auto& impl = thisObject.wrapped();
+ RELEASE_AND_RETURN(throwScope, (toJS<IDLInterface<Node>>(lexicalGlobalObject, *thisObject.globalObject(), throwScope, impl.runtimeConditionallyReadWriteAttribute())));
+}
+
+EncodedJSValue jsTestConditionallyReadWriteRuntimeConditionallyReadWriteAttribute(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName)
+{
+ return IDLAttribute<JSTestConditionallyReadWrite>::get<jsTestConditionallyReadWriteRuntimeConditionallyReadWriteAttributeGetter, CastedThisErrorBehavior::Assert>(*lexicalGlobalObject, thisValue, "runtimeConditionallyReadWriteAttribute");
+}
+
+static inline bool setJSTestConditionallyReadWriteRuntimeConditionallyReadWriteAttributeSetter(JSGlobalObject& lexicalGlobalObject, JSTestConditionallyReadWrite& thisObject, JSValue value)
+{
+ auto& vm = JSC::getVM(&lexicalGlobalObject);
+ auto throwScope = DECLARE_THROW_SCOPE(vm);
+ auto& impl = thisObject.wrapped();
+ auto nativeValue = convert<IDLInterface<Node>>(lexicalGlobalObject, value, [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwAttributeTypeError(lexicalGlobalObject, scope, "TestConditionallyReadWrite", "runtimeConditionallyReadWriteAttribute", "Node"); });
+ RETURN_IF_EXCEPTION(throwScope, false);
+ AttributeSetter::call(lexicalGlobalObject, throwScope, [&] {
+ return impl.setRuntimeConditionallyReadWriteAttribute(*nativeValue);
+ });
+ return true;
+}
+
+bool setJSTestConditionallyReadWriteRuntimeConditionallyReadWriteAttribute(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
+{
+ return IDLAttribute<JSTestConditionallyReadWrite>::set<setJSTestConditionallyReadWriteRuntimeConditionallyReadWriteAttributeSetter>(*lexicalGlobalObject, thisValue, encodedValue, "runtimeConditionallyReadWriteAttribute");
+}
+
+static inline JSValue jsTestConditionallyReadWriteRuntimeConditionallyReadWriteAttributeUnforgeableGetter(JSGlobalObject& lexicalGlobalObject, JSTestConditionallyReadWrite& thisObject)
+{
+ auto& vm = JSC::getVM(&lexicalGlobalObject);
+ auto throwScope = DECLARE_THROW_SCOPE(vm);
+ auto& impl = thisObject.wrapped();
+ RELEASE_AND_RETURN(throwScope, (toJS<IDLInterface<Node>>(lexicalGlobalObject, *thisObject.globalObject(), throwScope, impl.runtimeConditionallyReadWriteAttributeUnforgeable())));
+}
+
+EncodedJSValue jsTestConditionallyReadWriteRuntimeConditionallyReadWriteAttributeUnforgeable(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName)
+{
+ return IDLAttribute<JSTestConditionallyReadWrite>::get<jsTestConditionallyReadWriteRuntimeConditionallyReadWriteAttributeUnforgeableGetter, CastedThisErrorBehavior::Assert>(*lexicalGlobalObject, thisValue, "runtimeConditionallyReadWriteAttributeUnforgeable");
+}
+
+static inline bool setJSTestConditionallyReadWriteRuntimeConditionallyReadWriteAttributeUnforgeableSetter(JSGlobalObject& lexicalGlobalObject, JSTestConditionallyReadWrite& thisObject, JSValue value)
+{
+ auto& vm = JSC::getVM(&lexicalGlobalObject);
+ auto throwScope = DECLARE_THROW_SCOPE(vm);
+ auto& impl = thisObject.wrapped();
+ auto nativeValue = convert<IDLInterface<Node>>(lexicalGlobalObject, value, [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwAttributeTypeError(lexicalGlobalObject, scope, "TestConditionallyReadWrite", "runtimeConditionallyReadWriteAttributeUnforgeable", "Node"); });
+ RETURN_IF_EXCEPTION(throwScope, false);
+ AttributeSetter::call(lexicalGlobalObject, throwScope, [&] {
+ return impl.setRuntimeConditionallyReadWriteAttributeUnforgeable(*nativeValue);
+ });
+ return true;
+}
+
+bool setJSTestConditionallyReadWriteRuntimeConditionallyReadWriteAttributeUnforgeable(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
+{
+ return IDLAttribute<JSTestConditionallyReadWrite>::set<setJSTestConditionallyReadWriteRuntimeConditionallyReadWriteAttributeUnforgeableSetter>(*lexicalGlobalObject, thisValue, encodedValue, "runtimeConditionallyReadWriteAttributeUnforgeable");
+}
+
+static inline JSValue jsTestConditionallyReadWriteRuntimeConditionallyReadWriteAttributeUnforgeablePrivateGetter(JSGlobalObject& lexicalGlobalObject, JSTestConditionallyReadWrite& thisObject)
+{
+ auto& vm = JSC::getVM(&lexicalGlobalObject);
+ auto throwScope = DECLARE_THROW_SCOPE(vm);
+ auto& impl = thisObject.wrapped();
+ RELEASE_AND_RETURN(throwScope, (toJS<IDLInterface<Node>>(lexicalGlobalObject, *thisObject.globalObject(), throwScope, impl.runtimeConditionallyReadWriteAttributeUnforgeablePrivate())));
+}
+
+EncodedJSValue jsTestConditionallyReadWriteRuntimeConditionallyReadWriteAttributeUnforgeablePrivate(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName)
+{
+ return IDLAttribute<JSTestConditionallyReadWrite>::get<jsTestConditionallyReadWriteRuntimeConditionallyReadWriteAttributeUnforgeablePrivateGetter>(*lexicalGlobalObject, thisValue, "runtimeConditionallyReadWriteAttributeUnforgeablePrivate");
+}
+
+static inline bool setJSTestConditionallyReadWriteRuntimeConditionallyReadWriteAttributeUnforgeablePrivateSetter(JSGlobalObject& lexicalGlobalObject, JSTestConditionallyReadWrite& thisObject, JSValue value)
+{
+ auto& vm = JSC::getVM(&lexicalGlobalObject);
+ auto throwScope = DECLARE_THROW_SCOPE(vm);
+ auto& impl = thisObject.wrapped();
+ auto nativeValue = convert<IDLInterface<Node>>(lexicalGlobalObject, value, [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwAttributeTypeError(lexicalGlobalObject, scope, "TestConditionallyReadWrite", "runtimeConditionallyReadWriteAttributeUnforgeablePrivate", "Node"); });
+ RETURN_IF_EXCEPTION(throwScope, false);
+ AttributeSetter::call(lexicalGlobalObject, throwScope, [&] {
+ return impl.setRuntimeConditionallyReadWriteAttributeUnforgeablePrivate(*nativeValue);
+ });
+ return true;
+}
+
+bool setJSTestConditionallyReadWriteRuntimeConditionallyReadWriteAttributeUnforgeablePrivate(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
+{
+ return IDLAttribute<JSTestConditionallyReadWrite>::set<setJSTestConditionallyReadWriteRuntimeConditionallyReadWriteAttributeUnforgeablePrivateSetter>(*lexicalGlobalObject, thisValue, encodedValue, "runtimeConditionallyReadWriteAttributeUnforgeablePrivate");
+}
+
+static inline JSValue jsTestConditionallyReadWriteRuntimeConditionallyReadWriteAttributePromiseGetter(JSGlobalObject& lexicalGlobalObject, JSTestConditionallyReadWrite& thisObject)
+{
+ auto& vm = JSC::getVM(&lexicalGlobalObject);
+ auto throwScope = DECLARE_THROW_SCOPE(vm);
+ auto& impl = thisObject.wrapped();
+ RELEASE_AND_RETURN(throwScope, (toJS<IDLPromise<IDLDouble>>(lexicalGlobalObject, *thisObject.globalObject(), throwScope, impl.runtimeConditionallyReadWriteAttributePromise())));
+}
+
+EncodedJSValue jsTestConditionallyReadWriteRuntimeConditionallyReadWriteAttributePromise(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName)
+{
+ return IDLAttribute<JSTestConditionallyReadWrite>::get<jsTestConditionallyReadWriteRuntimeConditionallyReadWriteAttributePromiseGetter, CastedThisErrorBehavior::RejectPromise>(*lexicalGlobalObject, thisValue, "runtimeConditionallyReadWriteAttributePromise");
+}
+
+static inline bool setJSTestConditionallyReadWriteRuntimeConditionallyReadWriteAttributePromiseSetter(JSGlobalObject& lexicalGlobalObject, JSTestConditionallyReadWrite& thisObject, JSValue value)
+{
+ auto& vm = JSC::getVM(&lexicalGlobalObject);
+ auto throwScope = DECLARE_THROW_SCOPE(vm);
+ auto& impl = thisObject.wrapped();
+ auto nativeValue = convert<IDLPromise<IDLDouble>>(lexicalGlobalObject, value);
+ RETURN_IF_EXCEPTION(throwScope, false);
+ AttributeSetter::call(lexicalGlobalObject, throwScope, [&] {
+ return impl.setRuntimeConditionallyReadWriteAttributePromise(nativeValue.releaseNonNull());
+ });
+ return true;
+}
+
+bool setJSTestConditionallyReadWriteRuntimeConditionallyReadWriteAttributePromise(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
+{
+ return IDLAttribute<JSTestConditionallyReadWrite>::set<setJSTestConditionallyReadWriteRuntimeConditionallyReadWriteAttributePromiseSetter>(*lexicalGlobalObject, thisValue, encodedValue, "runtimeConditionallyReadWriteAttributePromise");
+}
+
+static inline JSValue jsTestConditionallyReadWriteSettingsConditionallyReadWriteAttributeGetter(JSGlobalObject& lexicalGlobalObject, JSTestConditionallyReadWrite& thisObject)
+{
+ auto& vm = JSC::getVM(&lexicalGlobalObject);
+ auto throwScope = DECLARE_THROW_SCOPE(vm);
+ auto& impl = thisObject.wrapped();
+ RELEASE_AND_RETURN(throwScope, (toJS<IDLInterface<Node>>(lexicalGlobalObject, *thisObject.globalObject(), throwScope, impl.settingsConditionallyReadWriteAttribute())));
+}
+
+EncodedJSValue jsTestConditionallyReadWriteSettingsConditionallyReadWriteAttribute(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName)
+{
+ return IDLAttribute<JSTestConditionallyReadWrite>::get<jsTestConditionallyReadWriteSettingsConditionallyReadWriteAttributeGetter, CastedThisErrorBehavior::Assert>(*lexicalGlobalObject, thisValue, "settingsConditionallyReadWriteAttribute");
+}
+
+static inline bool setJSTestConditionallyReadWriteSettingsConditionallyReadWriteAttributeSetter(JSGlobalObject& lexicalGlobalObject, JSTestConditionallyReadWrite& thisObject, JSValue value)
+{
+ auto& vm = JSC::getVM(&lexicalGlobalObject);
+ auto throwScope = DECLARE_THROW_SCOPE(vm);
+ auto& impl = thisObject.wrapped();
+ auto nativeValue = convert<IDLInterface<Node>>(lexicalGlobalObject, value, [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwAttributeTypeError(lexicalGlobalObject, scope, "TestConditionallyReadWrite", "settingsConditionallyReadWriteAttribute", "Node"); });
+ RETURN_IF_EXCEPTION(throwScope, false);
+ AttributeSetter::call(lexicalGlobalObject, throwScope, [&] {
+ return impl.setSettingsConditionallyReadWriteAttribute(*nativeValue);
+ });
+ return true;
+}
+
+bool setJSTestConditionallyReadWriteSettingsConditionallyReadWriteAttribute(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
+{
+ return IDLAttribute<JSTestConditionallyReadWrite>::set<setJSTestConditionallyReadWriteSettingsConditionallyReadWriteAttributeSetter>(*lexicalGlobalObject, thisValue, encodedValue, "settingsConditionallyReadWriteAttribute");
+}
+
+static inline JSValue jsTestConditionallyReadWriteSettingsConditionallyReadWriteAttributeUnforgeableGetter(JSGlobalObject& lexicalGlobalObject, JSTestConditionallyReadWrite& thisObject)
+{
+ auto& vm = JSC::getVM(&lexicalGlobalObject);
+ auto throwScope = DECLARE_THROW_SCOPE(vm);
+ auto& impl = thisObject.wrapped();
+ RELEASE_AND_RETURN(throwScope, (toJS<IDLInterface<Node>>(lexicalGlobalObject, *thisObject.globalObject(), throwScope, impl.settingsConditionallyReadWriteAttributeUnforgeable())));
+}
+
+EncodedJSValue jsTestConditionallyReadWriteSettingsConditionallyReadWriteAttributeUnforgeable(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName)
+{
+ return IDLAttribute<JSTestConditionallyReadWrite>::get<jsTestConditionallyReadWriteSettingsConditionallyReadWriteAttributeUnforgeableGetter, CastedThisErrorBehavior::Assert>(*lexicalGlobalObject, thisValue, "settingsConditionallyReadWriteAttributeUnforgeable");
+}
+
+static inline bool setJSTestConditionallyReadWriteSettingsConditionallyReadWriteAttributeUnforgeableSetter(JSGlobalObject& lexicalGlobalObject, JSTestConditionallyReadWrite& thisObject, JSValue value)
+{
+ auto& vm = JSC::getVM(&lexicalGlobalObject);
+ auto throwScope = DECLARE_THROW_SCOPE(vm);
+ auto& impl = thisObject.wrapped();
+ auto nativeValue = convert<IDLInterface<Node>>(lexicalGlobalObject, value, [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwAttributeTypeError(lexicalGlobalObject, scope, "TestConditionallyReadWrite", "settingsConditionallyReadWriteAttributeUnforgeable", "Node"); });
+ RETURN_IF_EXCEPTION(throwScope, false);
+ AttributeSetter::call(lexicalGlobalObject, throwScope, [&] {
+ return impl.setSettingsConditionallyReadWriteAttributeUnforgeable(*nativeValue);
+ });
+ return true;
+}
+
+bool setJSTestConditionallyReadWriteSettingsConditionallyReadWriteAttributeUnforgeable(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
+{
+ return IDLAttribute<JSTestConditionallyReadWrite>::set<setJSTestConditionallyReadWriteSettingsConditionallyReadWriteAttributeUnforgeableSetter>(*lexicalGlobalObject, thisValue, encodedValue, "settingsConditionallyReadWriteAttributeUnforgeable");
+}
+
+static inline JSValue jsTestConditionallyReadWriteSettingsConditionallyReadWriteAttributeUnforgeablePrivateGetter(JSGlobalObject& lexicalGlobalObject, JSTestConditionallyReadWrite& thisObject)
+{
+ auto& vm = JSC::getVM(&lexicalGlobalObject);
+ auto throwScope = DECLARE_THROW_SCOPE(vm);
+ auto& impl = thisObject.wrapped();
+ RELEASE_AND_RETURN(throwScope, (toJS<IDLInterface<Node>>(lexicalGlobalObject, *thisObject.globalObject(), throwScope, impl.settingsConditionallyReadWriteAttributeUnforgeablePrivate())));
+}
+
+EncodedJSValue jsTestConditionallyReadWriteSettingsConditionallyReadWriteAttributeUnforgeablePrivate(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName)
+{
+ return IDLAttribute<JSTestConditionallyReadWrite>::get<jsTestConditionallyReadWriteSettingsConditionallyReadWriteAttributeUnforgeablePrivateGetter>(*lexicalGlobalObject, thisValue, "settingsConditionallyReadWriteAttributeUnforgeablePrivate");
+}
+
+static inline bool setJSTestConditionallyReadWriteSettingsConditionallyReadWriteAttributeUnforgeablePrivateSetter(JSGlobalObject& lexicalGlobalObject, JSTestConditionallyReadWrite& thisObject, JSValue value)
+{
+ auto& vm = JSC::getVM(&lexicalGlobalObject);
+ auto throwScope = DECLARE_THROW_SCOPE(vm);
+ auto& impl = thisObject.wrapped();
+ auto nativeValue = convert<IDLInterface<Node>>(lexicalGlobalObject, value, [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwAttributeTypeError(lexicalGlobalObject, scope, "TestConditionallyReadWrite", "settingsConditionallyReadWriteAttributeUnforgeablePrivate", "Node"); });
+ RETURN_IF_EXCEPTION(throwScope, false);
+ AttributeSetter::call(lexicalGlobalObject, throwScope, [&] {
+ return impl.setSettingsConditionallyReadWriteAttributeUnforgeablePrivate(*nativeValue);
+ });
+ return true;
+}
+
+bool setJSTestConditionallyReadWriteSettingsConditionallyReadWriteAttributeUnforgeablePrivate(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
+{
+ return IDLAttribute<JSTestConditionallyReadWrite>::set<setJSTestConditionallyReadWriteSettingsConditionallyReadWriteAttributeUnforgeablePrivateSetter>(*lexicalGlobalObject, thisValue, encodedValue, "settingsConditionallyReadWriteAttributeUnforgeablePrivate");
+}
+
+static inline JSValue jsTestConditionallyReadWriteSettingsConditionallyReadWriteAttributePromiseGetter(JSGlobalObject& lexicalGlobalObject, JSTestConditionallyReadWrite& thisObject)
+{
+ auto& vm = JSC::getVM(&lexicalGlobalObject);
+ auto throwScope = DECLARE_THROW_SCOPE(vm);
+ auto& impl = thisObject.wrapped();
+ RELEASE_AND_RETURN(throwScope, (toJS<IDLPromise<IDLDouble>>(lexicalGlobalObject, *thisObject.globalObject(), throwScope, impl.settingsConditionallyReadWriteAttributePromise())));
+}
+
+EncodedJSValue jsTestConditionallyReadWriteSettingsConditionallyReadWriteAttributePromise(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName)
+{
+ return IDLAttribute<JSTestConditionallyReadWrite>::get<jsTestConditionallyReadWriteSettingsConditionallyReadWriteAttributePromiseGetter, CastedThisErrorBehavior::RejectPromise>(*lexicalGlobalObject, thisValue, "settingsConditionallyReadWriteAttributePromise");
+}
+
+static inline bool setJSTestConditionallyReadWriteSettingsConditionallyReadWriteAttributePromiseSetter(JSGlobalObject& lexicalGlobalObject, JSTestConditionallyReadWrite& thisObject, JSValue value)
+{
+ auto& vm = JSC::getVM(&lexicalGlobalObject);
+ auto throwScope = DECLARE_THROW_SCOPE(vm);
+ auto& impl = thisObject.wrapped();
+ auto nativeValue = convert<IDLPromise<IDLDouble>>(lexicalGlobalObject, value);
+ RETURN_IF_EXCEPTION(throwScope, false);
+ AttributeSetter::call(lexicalGlobalObject, throwScope, [&] {
+ return impl.setSettingsConditionallyReadWriteAttributePromise(nativeValue.releaseNonNull());
+ });
+ return true;
+}
+
+bool setJSTestConditionallyReadWriteSettingsConditionallyReadWriteAttributePromise(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
+{
+ return IDLAttribute<JSTestConditionallyReadWrite>::set<setJSTestConditionallyReadWriteSettingsConditionallyReadWriteAttributePromiseSetter>(*lexicalGlobalObject, thisValue, encodedValue, "settingsConditionallyReadWriteAttributePromise");
+}
+
+JSC::IsoSubspace* JSTestConditionallyReadWrite::subspaceForImpl(JSC::VM& vm)
+{
+ auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);
+ auto& spaces = clientData.subspaces();
+ if (auto* space = spaces.m_subspaceForTestConditionallyReadWrite.get())
+ return space;
+ static_assert(std::is_base_of_v<JSC::JSDestructibleObject, JSTestConditionallyReadWrite> || !JSTestConditionallyReadWrite::needsDestruction);
+ if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestConditionallyReadWrite>)
+ spaces.m_subspaceForTestConditionallyReadWrite = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.destructibleObjectHeapCellType.get(), JSTestConditionallyReadWrite);
+ else
+ spaces.m_subspaceForTestConditionallyReadWrite = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.cellHeapCellType.get(), JSTestConditionallyReadWrite);
+ auto* space = spaces.m_subspaceForTestConditionallyReadWrite.get();
+IGNORE_WARNINGS_BEGIN("unreachable-code")
+IGNORE_WARNINGS_BEGIN("tautological-compare")
+ if (&JSTestConditionallyReadWrite::visitOutputConstraints != &JSC::JSCell::visitOutputConstraints)
+ clientData.outputConstraintSpaces().append(space);
+IGNORE_WARNINGS_END
+IGNORE_WARNINGS_END
+ return space;
+}
+
+void JSTestConditionallyReadWrite::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
+{
+ auto* thisObject = jsCast<JSTestConditionallyReadWrite*>(cell);
+ analyzer.setWrappedObjectForCell(cell, &thisObject->wrapped());
+ if (thisObject->scriptExecutionContext())
+ analyzer.setLabelForCell(cell, "url " + thisObject->scriptExecutionContext()->url().string());
+ Base::analyzeHeap(cell, analyzer);
+}
+
+bool JSTestConditionallyReadWriteOwner::isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown> handle, void*, SlotVisitor& visitor, const char** reason)
+{
+ UNUSED_PARAM(handle);
+ UNUSED_PARAM(visitor);
+ UNUSED_PARAM(reason);
+ return false;
+}
+
+void JSTestConditionallyReadWriteOwner::finalize(JSC::Handle<JSC::Unknown> handle, void* context)
+{
+ auto* jsTestConditionallyReadWrite = static_cast<JSTestConditionallyReadWrite*>(handle.slot()->asCell());
+ auto& world = *static_cast<DOMWrapperWorld*>(context);
+ uncacheWrapper(world, &jsTestConditionallyReadWrite->wrapped(), jsTestConditionallyReadWrite);
+}
+
+#if ENABLE(BINDING_INTEGRITY)
+#if PLATFORM(WIN)
+#pragma warning(disable: 4483)
+extern "C" { extern void (*const __identifier("??_7TestConditionallyReadWrite@WebCore@@6B@")[])(); }
+#else
+extern "C" { extern void* _ZTVN7WebCore26TestConditionallyReadWriteE[]; }
+#endif
+#endif
+
+JSC::JSValue toJSNewlyCreated(JSC::JSGlobalObject*, JSDOMGlobalObject* globalObject, Ref<TestConditionallyReadWrite>&& impl)
+{
+
+#if ENABLE(BINDING_INTEGRITY)
+ const void* actualVTablePointer = getVTablePointer(impl.ptr());
+#if PLATFORM(WIN)
+ void* expectedVTablePointer = __identifier("??_7TestConditionallyReadWrite@WebCore@@6B@");
+#else
+ void* expectedVTablePointer = &_ZTVN7WebCore26TestConditionallyReadWriteE[2];
+#endif
+
+ // If this fails TestConditionallyReadWrite does not have a vtable, so you need to add the
+ // ImplementationLacksVTable attribute to the interface definition
+ static_assert(std::is_polymorphic<TestConditionallyReadWrite>::value, "TestConditionallyReadWrite is not polymorphic");
+
+ // If you hit this assertion you either have a use after free bug, or
+ // TestConditionallyReadWrite has subclasses. If TestConditionallyReadWrite has subclasses that get passed
+ // to toJS() we currently require TestConditionallyReadWrite you to opt out of binding hardening
+ // by adding the SkipVTableValidation attribute to the interface IDL definition
+ RELEASE_ASSERT(actualVTablePointer == expectedVTablePointer);
+#endif
+ return createWrapper<TestConditionallyReadWrite>(globalObject, WTFMove(impl));
+}
+
+JSC::JSValue toJS(JSC::JSGlobalObject* lexicalGlobalObject, JSDOMGlobalObject* globalObject, TestConditionallyReadWrite& impl)
+{
+ return wrap(lexicalGlobalObject, globalObject, impl);
+}
+
+TestConditionallyReadWrite* JSTestConditionallyReadWrite::toWrapped(JSC::VM& vm, JSC::JSValue value)
+{
+ if (auto* wrapper = jsDynamicCast<JSTestConditionallyReadWrite*>(vm, value))
+ return &wrapper->wrapped();
+ return nullptr;
+}
+
+}
Added: trunk/Source/WebCore/bindings/scripts/test/JS/JSTestConditionallyReadWrite.h (0 => 267312)
--- trunk/Source/WebCore/bindings/scripts/test/JS/JSTestConditionallyReadWrite.h (rev 0)
+++ trunk/Source/WebCore/bindings/scripts/test/JS/JSTestConditionallyReadWrite.h 2020-09-19 14:22:11 UTC (rev 267312)
@@ -0,0 +1,95 @@
+/*
+ This file is part of the WebKit open source project.
+ This file has been generated by generate-bindings.pl. DO NOT MODIFY!
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Library General Public
+ License as published by the Free Software Foundation; either
+ version 2 of the License, or (at your option) any later version.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public License
+ along with this library; see the file COPYING.LIB. If not, write to
+ the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ Boston, MA 02110-1301, USA.
+*/
+
+#pragma once
+
+#include "JSDOMWrapper.h"
+#include "TestConditionallyReadWrite.h"
+#include <wtf/NeverDestroyed.h>
+
+namespace WebCore {
+
+class JSTestConditionallyReadWrite : public JSDOMWrapper<TestConditionallyReadWrite> {
+public:
+ using Base = JSDOMWrapper<TestConditionallyReadWrite>;
+ static JSTestConditionallyReadWrite* create(JSC::Structure* structure, JSDOMGlobalObject* globalObject, Ref<TestConditionallyReadWrite>&& impl)
+ {
+ JSTestConditionallyReadWrite* ptr = new (NotNull, JSC::allocateCell<JSTestConditionallyReadWrite>(globalObject->vm().heap)) JSTestConditionallyReadWrite(structure, *globalObject, WTFMove(impl));
+ ptr->finishCreation(globalObject->vm());
+ return ptr;
+ }
+
+ static JSC::JSObject* createPrototype(JSC::VM&, JSDOMGlobalObject&);
+ static JSC::JSObject* prototype(JSC::VM&, JSDOMGlobalObject&);
+ static TestConditionallyReadWrite* toWrapped(JSC::VM&, JSC::JSValue);
+ static void destroy(JSC::JSCell*);
+
+ DECLARE_INFO;
+
+ static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+ {
+ return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info(), JSC::NonArray);
+ }
+
+ static JSC::JSValue getConstructor(JSC::VM&, const JSC::JSGlobalObject*);
+ template<typename, JSC::SubspaceAccess mode> static JSC::IsoSubspace* subspaceFor(JSC::VM& vm)
+ {
+ if constexpr (mode == JSC::SubspaceAccess::Concurrently)
+ return nullptr;
+ return subspaceForImpl(vm);
+ }
+ static JSC::IsoSubspace* subspaceForImpl(JSC::VM& vm);
+ static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
+public:
+ static constexpr unsigned StructureFlags = Base::StructureFlags | JSC::HasStaticPropertyTable;
+protected:
+ JSTestConditionallyReadWrite(JSC::Structure*, JSDOMGlobalObject&, Ref<TestConditionallyReadWrite>&&);
+
+ void finishCreation(JSC::VM&);
+};
+
+class JSTestConditionallyReadWriteOwner : public JSC::WeakHandleOwner {
+public:
+ virtual bool isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown>, void* context, JSC::SlotVisitor&, const char**);
+ virtual void finalize(JSC::Handle<JSC::Unknown>, void* context);
+};
+
+inline JSC::WeakHandleOwner* wrapperOwner(DOMWrapperWorld&, TestConditionallyReadWrite*)
+{
+ static NeverDestroyed<JSTestConditionallyReadWriteOwner> owner;
+ return &owner.get();
+}
+
+inline void* wrapperKey(TestConditionallyReadWrite* wrappableObject)
+{
+ return wrappableObject;
+}
+
+JSC::JSValue toJS(JSC::JSGlobalObject*, JSDOMGlobalObject*, TestConditionallyReadWrite&);
+inline JSC::JSValue toJS(JSC::JSGlobalObject* lexicalGlobalObject, JSDOMGlobalObject* globalObject, TestConditionallyReadWrite* impl) { return impl ? toJS(lexicalGlobalObject, globalObject, *impl) : JSC::jsNull(); }
+JSC::JSValue toJSNewlyCreated(JSC::JSGlobalObject*, JSDOMGlobalObject*, Ref<TestConditionallyReadWrite>&&);
+inline JSC::JSValue toJSNewlyCreated(JSC::JSGlobalObject* lexicalGlobalObject, JSDOMGlobalObject* globalObject, RefPtr<TestConditionallyReadWrite>&& impl) { return impl ? toJSNewlyCreated(lexicalGlobalObject, globalObject, impl.releaseNonNull()) : JSC::jsNull(); }
+
+template<> struct JSDOMWrapperConverterTraits<TestConditionallyReadWrite> {
+ using WrapperClass = JSTestConditionallyReadWrite;
+ using ToWrappedReturnType = TestConditionallyReadWrite*;
+};
+
+} // namespace WebCore
Modified: trunk/Source/WebCore/bindings/scripts/test/JS/JSTestObj.cpp (267311 => 267312)
--- trunk/Source/WebCore/bindings/scripts/test/JS/JSTestObj.cpp 2020-09-19 14:20:18 UTC (rev 267311)
+++ trunk/Source/WebCore/bindings/scripts/test/JS/JSTestObj.cpp 2020-09-19 14:22:11 UTC (rev 267312)
@@ -1786,24 +1786,6 @@
bool setJSTestObjPutForwardsNullableAttribute(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
JSC::EncodedJSValue jsTestObjStringifierAttribute(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::PropertyName);
bool setJSTestObjStringifierAttribute(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
-JSC::EncodedJSValue jsTestObjConditionallyReadWriteAttribute(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::PropertyName);
-#if ENABLE(CONDITION)
-bool setJSTestObjConditionallyReadWriteAttribute(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
-#endif
-#if ENABLE(CONDITION2)
-JSC::EncodedJSValue jsTestObjConditionalAndConditionallyReadWriteAttribute(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::PropertyName);
-#if ENABLE(CONDITION)
-bool setJSTestObjConditionalAndConditionallyReadWriteAttribute(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
-#endif
-#endif
-JSC::EncodedJSValue jsTestObjRuntimeConditionallyReadWriteAttribute(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::PropertyName);
-bool setJSTestObjRuntimeConditionallyReadWriteAttribute(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
-JSC::EncodedJSValue jsTestObjRuntimeConditionallyReadWriteAttributeUnforgeable(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::PropertyName);
-bool setJSTestObjRuntimeConditionallyReadWriteAttributeUnforgeable(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
-JSC::EncodedJSValue jsTestObjRuntimeConditionallyReadWriteAttributeUnforgeablePrivate(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::PropertyName);
-bool setJSTestObjRuntimeConditionallyReadWriteAttributeUnforgeablePrivate(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
-JSC::EncodedJSValue jsTestObjRuntimeConditionallyReadWriteAttributePromise(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::PropertyName);
-bool setJSTestObjRuntimeConditionallyReadWriteAttributePromise(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
JSC::EncodedJSValue jsTestObjConditionallyExposedToWindowAttribute(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::PropertyName);
bool setJSTestObjConditionallyExposedToWindowAttribute(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
JSC::EncodedJSValue jsTestObjConditionallyExposedToWorkerAttribute(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::PropertyName);
@@ -1850,7 +1832,7 @@
static const struct CompactHashIndex JSTestObjTableIndex[16] = {
{ -1, -1 },
{ -1, -1 },
- { 5, -1 },
+ { 4, -1 },
{ -1, -1 },
{ -1, -1 },
{ -1, -1 },
@@ -1859,11 +1841,11 @@
{ 0, -1 },
{ 1, -1 },
{ 2, -1 },
- { 4, -1 },
{ -1, -1 },
{ -1, -1 },
{ -1, -1 },
{ -1, -1 },
+ { -1, -1 },
};
@@ -1885,11 +1867,10 @@
#else
{ 0, 0, NoIntrinsic, { 0, 0 } },
#endif
- { "runtimeConditionallyReadWriteAttributeUnforgeable", static_cast<unsigned>(JSC::PropertyAttribute::DontDelete | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjRuntimeConditionallyReadWriteAttributeUnforgeable), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjRuntimeConditionallyReadWriteAttributeUnforgeable) } },
{ "unforgeableMethod", static_cast<unsigned>(JSC::PropertyAttribute::DontDelete | JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsTestObjInstanceFunctionUnforgeableMethod), (intptr_t) (0) } },
};
-static const HashTable JSTestObjTable = { 6, 15, true, JSTestObj::info(), JSTestObjTableValues, JSTestObjTableIndex };
+static const HashTable JSTestObjTable = { 5, 15, true, JSTestObj::info(), JSTestObjTableValues, JSTestObjTableIndex };
/* Hash table for constructor */
static const HashTableValue JSTestObjConstructorTableValues[] =
@@ -2139,22 +2120,6 @@
{ "putForwardsAttribute", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjPutForwardsAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjPutForwardsAttribute) } },
{ "putForwardsNullableAttribute", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjPutForwardsNullableAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjPutForwardsNullableAttribute) } },
{ "stringifierAttribute", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjStringifierAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjStringifierAttribute) } },
-#if ENABLE(CONDITION)
- { "conditionallyReadWriteAttribute", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjConditionallyReadWriteAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjConditionallyReadWriteAttribute) } },
-#else
- { "conditionallyReadWriteAttribute", JSC::PropertyAttribute::ReadOnly | static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjConditionallyReadWriteAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
-#endif
-#if ENABLE(CONDITION2)
-#if ENABLE(CONDITION)
- { "conditionalAndConditionallyReadWriteAttribute", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjConditionalAndConditionallyReadWriteAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjConditionalAndConditionallyReadWriteAttribute) } },
-#else
- { "conditionalAndConditionallyReadWriteAttribute", JSC::PropertyAttribute::ReadOnly | static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjConditionalAndConditionallyReadWriteAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
-#endif
-#else
- { 0, 0, NoIntrinsic, { 0, 0 } },
-#endif
- { "runtimeConditionallyReadWriteAttribute", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjRuntimeConditionallyReadWriteAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjRuntimeConditionallyReadWriteAttribute) } },
- { "runtimeConditionallyReadWriteAttributePromise", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjRuntimeConditionallyReadWriteAttributePromise), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjRuntimeConditionallyReadWriteAttributePromise) } },
{ "conditionallyExposedToWindowAttribute", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjConditionallyExposedToWindowAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjConditionallyExposedToWindowAttribute) } },
{ "conditionallyExposedToWorkerAttribute", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjConditionallyExposedToWorkerAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjConditionallyExposedToWorkerAttribute) } },
{ "conditionallyExposedToWindowAndWorkerAttribute", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjConditionallyExposedToWindowAndWorkerAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjConditionallyExposedToWindowAndWorkerAttribute) } },
@@ -2437,20 +2402,6 @@
JSObject::deleteProperty(this, globalObject(), propertyName, slot);
}
#endif
- if (!RuntimeEnabledFeatures::sharedFeatures().testFeatureEnabled()) {
- hasDisabledRuntimeProperties = true;
- auto propertyName = Identifier::fromString(vm, reinterpret_cast<const LChar*>("runtimeConditionallyReadWriteAttribute"), strlen("runtimeConditionallyReadWriteAttribute"));
- VM::DeletePropertyModeScope scope(vm, VM::DeletePropertyMode::IgnoreConfigurable);
- DeletePropertySlot slot;
- JSObject::deleteProperty(this, globalObject(), propertyName, slot);
- }
- if (!RuntimeEnabledFeatures::sharedFeatures().testFeatureEnabled()) {
- hasDisabledRuntimeProperties = true;
- auto propertyName = Identifier::fromString(vm, reinterpret_cast<const LChar*>("runtimeConditionallyReadWriteAttributePromise"), strlen("runtimeConditionallyReadWriteAttributePromise"));
- VM::DeletePropertyModeScope scope(vm, VM::DeletePropertyMode::IgnoreConfigurable);
- DeletePropertySlot slot;
- JSObject::deleteProperty(this, globalObject(), propertyName, slot);
- }
if (!jsCast<JSDOMGlobalObject*>(globalObject())->scriptExecutionContext()->isDocument()) {
hasDisabledRuntimeProperties = true;
auto propertyName = Identifier::fromString(vm, reinterpret_cast<const LChar*>("conditionallyExposedToWindowAttribute"), strlen("conditionallyExposedToWindowAttribute"));
@@ -2465,12 +2416,6 @@
DeletePropertySlot slot;
JSObject::deleteProperty(this, globalObject(), propertyName, slot);
}
- // Adding back attribute, but as readonly, after removing the read-write variant above.
- if (!RuntimeEnabledFeatures::sharedFeatures().testFeatureEnabled())
- putDirectCustomAccessor(vm, static_cast<JSVMClientData*>(vm.clientData)->builtinNames().runtimeConditionallyReadWriteAttributePublicName(), JSC::DOMAttributeGetterSetter::create(vm, jsTestObjRuntimeConditionallyReadWriteAttribute, nullptr, JSC::DOMAttributeAnnotation { JSTestObj::info(), nullptr }), attributesForStructure(static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute)));
- // Adding back attribute, but as readonly, after removing the read-write variant above.
- if (!RuntimeEnabledFeatures::sharedFeatures().testFeatureEnabled())
- putDirectCustomAccessor(vm, static_cast<JSVMClientData*>(vm.clientData)->builtinNames().runtimeConditionallyReadWriteAttributePromisePublicName(), CustomGetterSetter::create(vm, jsTestObjRuntimeConditionallyReadWriteAttributePromise, nullptr), attributesForStructure(static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor)));
if (hasDisabledRuntimeProperties && structure()->isDictionary())
flattenDictionaryObject(vm);
putDirect(vm, static_cast<JSVMClientData*>(vm.clientData)->builtinNames().privateMethodPrivateName(), JSFunction::create(vm, globalObject(), 0, String(), jsTestObjPrototypeFunctionPrivateMethod), JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::DontEnum);
@@ -2498,7 +2443,6 @@
static_assert(!std::is_base_of<ActiveDOMObject, TestObj>::value, "Interface is not marked as [ActiveDOMObject] even though implementation class subclasses ActiveDOMObject.");
- putDirectCustomAccessor(vm, static_cast<JSVMClientData*>(vm.clientData)->builtinNames().runtimeConditionallyReadWriteAttributeUnforgeablePrivatePrivateName(), CustomGetterSetter::create(vm, jsTestObjRuntimeConditionallyReadWriteAttributeUnforgeablePrivate, nullptr), attributesForStructure(JSC::PropertyAttribute::DontDelete | JSC::PropertyAttribute::ReadOnly));
}
JSObject* JSTestObj::createPrototype(VM& vm, JSDOMGlobalObject& globalObject)
@@ -5281,204 +5225,6 @@
return IDLAttribute<JSTestObj>::set<setJSTestObjStringifierAttributeSetter>(*lexicalGlobalObject, thisValue, encodedValue, "stringifierAttribute");
}
-static inline JSValue jsTestObjConditionallyReadWriteAttributeGetter(JSGlobalObject& lexicalGlobalObject, JSTestObj& thisObject)
-{
- auto& vm = JSC::getVM(&lexicalGlobalObject);
- auto throwScope = DECLARE_THROW_SCOPE(vm);
- auto& impl = thisObject.wrapped();
- RELEASE_AND_RETURN(throwScope, (toJS<IDLInterface<Node>>(lexicalGlobalObject, *thisObject.globalObject(), throwScope, impl.conditionallyReadWriteAttribute())));
-}
-
-EncodedJSValue jsTestObjConditionallyReadWriteAttribute(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName)
-{
- return IDLAttribute<JSTestObj>::get<jsTestObjConditionallyReadWriteAttributeGetter, CastedThisErrorBehavior::Assert>(*lexicalGlobalObject, thisValue, "conditionallyReadWriteAttribute");
-}
-
-#if ENABLE(CONDITION)
-static inline bool setJSTestObjConditionallyReadWriteAttributeSetter(JSGlobalObject& lexicalGlobalObject, JSTestObj& thisObject, JSValue value)
-{
- auto& vm = JSC::getVM(&lexicalGlobalObject);
- auto throwScope = DECLARE_THROW_SCOPE(vm);
- auto& impl = thisObject.wrapped();
- auto nativeValue = convert<IDLInterface<Node>>(lexicalGlobalObject, value, [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwAttributeTypeError(lexicalGlobalObject, scope, "TestObject", "conditionallyReadWriteAttribute", "Node"); });
- RETURN_IF_EXCEPTION(throwScope, false);
- AttributeSetter::call(lexicalGlobalObject, throwScope, [&] {
- return impl.setConditionallyReadWriteAttribute(*nativeValue);
- });
- return true;
-}
-
-bool setJSTestObjConditionallyReadWriteAttribute(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
-{
- return IDLAttribute<JSTestObj>::set<setJSTestObjConditionallyReadWriteAttributeSetter>(*lexicalGlobalObject, thisValue, encodedValue, "conditionallyReadWriteAttribute");
-}
-
-#endif
-
-#if ENABLE(CONDITION2)
-static inline JSValue jsTestObjConditionalAndConditionallyReadWriteAttributeGetter(JSGlobalObject& lexicalGlobalObject, JSTestObj& thisObject)
-{
- auto& vm = JSC::getVM(&lexicalGlobalObject);
- auto throwScope = DECLARE_THROW_SCOPE(vm);
- auto& impl = thisObject.wrapped();
- RELEASE_AND_RETURN(throwScope, (toJS<IDLInterface<Node>>(lexicalGlobalObject, *thisObject.globalObject(), throwScope, impl.conditionalAndConditionallyReadWriteAttribute())));
-}
-
-EncodedJSValue jsTestObjConditionalAndConditionallyReadWriteAttribute(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName)
-{
- return IDLAttribute<JSTestObj>::get<jsTestObjConditionalAndConditionallyReadWriteAttributeGetter, CastedThisErrorBehavior::Assert>(*lexicalGlobalObject, thisValue, "conditionalAndConditionallyReadWriteAttribute");
-}
-
-#endif
-
-#if ENABLE(CONDITION2)
-#if ENABLE(CONDITION)
-static inline bool setJSTestObjConditionalAndConditionallyReadWriteAttributeSetter(JSGlobalObject& lexicalGlobalObject, JSTestObj& thisObject, JSValue value)
-{
- auto& vm = JSC::getVM(&lexicalGlobalObject);
- auto throwScope = DECLARE_THROW_SCOPE(vm);
- auto& impl = thisObject.wrapped();
- auto nativeValue = convert<IDLInterface<Node>>(lexicalGlobalObject, value, [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwAttributeTypeError(lexicalGlobalObject, scope, "TestObject", "conditionalAndConditionallyReadWriteAttribute", "Node"); });
- RETURN_IF_EXCEPTION(throwScope, false);
- AttributeSetter::call(lexicalGlobalObject, throwScope, [&] {
- return impl.setConditionalAndConditionallyReadWriteAttribute(*nativeValue);
- });
- return true;
-}
-
-bool setJSTestObjConditionalAndConditionallyReadWriteAttribute(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
-{
- return IDLAttribute<JSTestObj>::set<setJSTestObjConditionalAndConditionallyReadWriteAttributeSetter>(*lexicalGlobalObject, thisValue, encodedValue, "conditionalAndConditionallyReadWriteAttribute");
-}
-
-#endif
-
-#endif
-
-static inline JSValue jsTestObjRuntimeConditionallyReadWriteAttributeGetter(JSGlobalObject& lexicalGlobalObject, JSTestObj& thisObject)
-{
- auto& vm = JSC::getVM(&lexicalGlobalObject);
- auto throwScope = DECLARE_THROW_SCOPE(vm);
- auto& impl = thisObject.wrapped();
- RELEASE_AND_RETURN(throwScope, (toJS<IDLInterface<Node>>(lexicalGlobalObject, *thisObject.globalObject(), throwScope, impl.runtimeConditionallyReadWriteAttribute())));
-}
-
-EncodedJSValue jsTestObjRuntimeConditionallyReadWriteAttribute(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName)
-{
- return IDLAttribute<JSTestObj>::get<jsTestObjRuntimeConditionallyReadWriteAttributeGetter, CastedThisErrorBehavior::Assert>(*lexicalGlobalObject, thisValue, "runtimeConditionallyReadWriteAttribute");
-}
-
-static inline bool setJSTestObjRuntimeConditionallyReadWriteAttributeSetter(JSGlobalObject& lexicalGlobalObject, JSTestObj& thisObject, JSValue value)
-{
- auto& vm = JSC::getVM(&lexicalGlobalObject);
- auto throwScope = DECLARE_THROW_SCOPE(vm);
- auto& impl = thisObject.wrapped();
- auto nativeValue = convert<IDLInterface<Node>>(lexicalGlobalObject, value, [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwAttributeTypeError(lexicalGlobalObject, scope, "TestObject", "runtimeConditionallyReadWriteAttribute", "Node"); });
- RETURN_IF_EXCEPTION(throwScope, false);
- AttributeSetter::call(lexicalGlobalObject, throwScope, [&] {
- return impl.setRuntimeConditionallyReadWriteAttribute(*nativeValue);
- });
- return true;
-}
-
-bool setJSTestObjRuntimeConditionallyReadWriteAttribute(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
-{
- return IDLAttribute<JSTestObj>::set<setJSTestObjRuntimeConditionallyReadWriteAttributeSetter>(*lexicalGlobalObject, thisValue, encodedValue, "runtimeConditionallyReadWriteAttribute");
-}
-
-static inline JSValue jsTestObjRuntimeConditionallyReadWriteAttributeUnforgeableGetter(JSGlobalObject& lexicalGlobalObject, JSTestObj& thisObject)
-{
- auto& vm = JSC::getVM(&lexicalGlobalObject);
- auto throwScope = DECLARE_THROW_SCOPE(vm);
- auto& impl = thisObject.wrapped();
- RELEASE_AND_RETURN(throwScope, (toJS<IDLInterface<Node>>(lexicalGlobalObject, *thisObject.globalObject(), throwScope, impl.runtimeConditionallyReadWriteAttributeUnforgeable())));
-}
-
-EncodedJSValue jsTestObjRuntimeConditionallyReadWriteAttributeUnforgeable(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName)
-{
- return IDLAttribute<JSTestObj>::get<jsTestObjRuntimeConditionallyReadWriteAttributeUnforgeableGetter, CastedThisErrorBehavior::Assert>(*lexicalGlobalObject, thisValue, "runtimeConditionallyReadWriteAttributeUnforgeable");
-}
-
-static inline bool setJSTestObjRuntimeConditionallyReadWriteAttributeUnforgeableSetter(JSGlobalObject& lexicalGlobalObject, JSTestObj& thisObject, JSValue value)
-{
- auto& vm = JSC::getVM(&lexicalGlobalObject);
- auto throwScope = DECLARE_THROW_SCOPE(vm);
- auto& impl = thisObject.wrapped();
- auto nativeValue = convert<IDLInterface<Node>>(lexicalGlobalObject, value, [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwAttributeTypeError(lexicalGlobalObject, scope, "TestObject", "runtimeConditionallyReadWriteAttributeUnforgeable", "Node"); });
- RETURN_IF_EXCEPTION(throwScope, false);
- AttributeSetter::call(lexicalGlobalObject, throwScope, [&] {
- return impl.setRuntimeConditionallyReadWriteAttributeUnforgeable(*nativeValue);
- });
- return true;
-}
-
-bool setJSTestObjRuntimeConditionallyReadWriteAttributeUnforgeable(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
-{
- return IDLAttribute<JSTestObj>::set<setJSTestObjRuntimeConditionallyReadWriteAttributeUnforgeableSetter>(*lexicalGlobalObject, thisValue, encodedValue, "runtimeConditionallyReadWriteAttributeUnforgeable");
-}
-
-static inline JSValue jsTestObjRuntimeConditionallyReadWriteAttributeUnforgeablePrivateGetter(JSGlobalObject& lexicalGlobalObject, JSTestObj& thisObject)
-{
- auto& vm = JSC::getVM(&lexicalGlobalObject);
- auto throwScope = DECLARE_THROW_SCOPE(vm);
- auto& impl = thisObject.wrapped();
- RELEASE_AND_RETURN(throwScope, (toJS<IDLInterface<Node>>(lexicalGlobalObject, *thisObject.globalObject(), throwScope, impl.runtimeConditionallyReadWriteAttributeUnforgeablePrivate())));
-}
-
-EncodedJSValue jsTestObjRuntimeConditionallyReadWriteAttributeUnforgeablePrivate(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName)
-{
- return IDLAttribute<JSTestObj>::get<jsTestObjRuntimeConditionallyReadWriteAttributeUnforgeablePrivateGetter>(*lexicalGlobalObject, thisValue, "runtimeConditionallyReadWriteAttributeUnforgeablePrivate");
-}
-
-static inline bool setJSTestObjRuntimeConditionallyReadWriteAttributeUnforgeablePrivateSetter(JSGlobalObject& lexicalGlobalObject, JSTestObj& thisObject, JSValue value)
-{
- auto& vm = JSC::getVM(&lexicalGlobalObject);
- auto throwScope = DECLARE_THROW_SCOPE(vm);
- auto& impl = thisObject.wrapped();
- auto nativeValue = convert<IDLInterface<Node>>(lexicalGlobalObject, value, [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwAttributeTypeError(lexicalGlobalObject, scope, "TestObject", "runtimeConditionallyReadWriteAttributeUnforgeablePrivate", "Node"); });
- RETURN_IF_EXCEPTION(throwScope, false);
- AttributeSetter::call(lexicalGlobalObject, throwScope, [&] {
- return impl.setRuntimeConditionallyReadWriteAttributeUnforgeablePrivate(*nativeValue);
- });
- return true;
-}
-
-bool setJSTestObjRuntimeConditionallyReadWriteAttributeUnforgeablePrivate(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
-{
- return IDLAttribute<JSTestObj>::set<setJSTestObjRuntimeConditionallyReadWriteAttributeUnforgeablePrivateSetter>(*lexicalGlobalObject, thisValue, encodedValue, "runtimeConditionallyReadWriteAttributeUnforgeablePrivate");
-}
-
-static inline JSValue jsTestObjRuntimeConditionallyReadWriteAttributePromiseGetter(JSGlobalObject& lexicalGlobalObject, JSTestObj& thisObject)
-{
- auto& vm = JSC::getVM(&lexicalGlobalObject);
- auto throwScope = DECLARE_THROW_SCOPE(vm);
- auto& impl = thisObject.wrapped();
- RELEASE_AND_RETURN(throwScope, (toJS<IDLPromise<IDLDouble>>(lexicalGlobalObject, *thisObject.globalObject(), throwScope, impl.runtimeConditionallyReadWriteAttributePromise())));
-}
-
-EncodedJSValue jsTestObjRuntimeConditionallyReadWriteAttributePromise(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName)
-{
- return IDLAttribute<JSTestObj>::get<jsTestObjRuntimeConditionallyReadWriteAttributePromiseGetter, CastedThisErrorBehavior::RejectPromise>(*lexicalGlobalObject, thisValue, "runtimeConditionallyReadWriteAttributePromise");
-}
-
-static inline bool setJSTestObjRuntimeConditionallyReadWriteAttributePromiseSetter(JSGlobalObject& lexicalGlobalObject, JSTestObj& thisObject, JSValue value)
-{
- auto& vm = JSC::getVM(&lexicalGlobalObject);
- auto throwScope = DECLARE_THROW_SCOPE(vm);
- auto& impl = thisObject.wrapped();
- auto nativeValue = convert<IDLPromise<IDLDouble>>(lexicalGlobalObject, value);
- RETURN_IF_EXCEPTION(throwScope, false);
- AttributeSetter::call(lexicalGlobalObject, throwScope, [&] {
- return impl.setRuntimeConditionallyReadWriteAttributePromise(nativeValue.releaseNonNull());
- });
- return true;
-}
-
-bool setJSTestObjRuntimeConditionallyReadWriteAttributePromise(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
-{
- return IDLAttribute<JSTestObj>::set<setJSTestObjRuntimeConditionallyReadWriteAttributePromiseSetter>(*lexicalGlobalObject, thisValue, encodedValue, "runtimeConditionallyReadWriteAttributePromise");
-}
-
static inline JSValue jsTestObjConditionallyExposedToWindowAttributeGetter(JSGlobalObject& lexicalGlobalObject, JSTestObj& thisObject)
{
auto& vm = JSC::getVM(&lexicalGlobalObject);
Modified: trunk/Source/WebCore/bindings/scripts/test/SupplementalDependencies.dep (267311 => 267312)
--- trunk/Source/WebCore/bindings/scripts/test/SupplementalDependencies.dep 2020-09-19 14:20:18 UTC (rev 267311)
+++ trunk/Source/WebCore/bindings/scripts/test/SupplementalDependencies.dep 2020-09-19 14:22:11 UTC (rev 267312)
@@ -49,6 +49,9 @@
DOMTestConditionalIncludes.h: TestMixinInterface.idl
WebDOMTestConditionalIncludes.h: TestMixinInterface.idl
TestMixinInterface.idl:
+JSTestConditionallyReadWrite.h:
+DOMTestConditionallyReadWrite.h:
+WebDOMTestConditionallyReadWrite.h:
JSTestDOMJIT.h:
DOMTestDOMJIT.h:
WebDOMTestDOMJIT.h:
Added: trunk/Source/WebCore/bindings/scripts/test/TestConditionallyReadWrite.idl (0 => 267312)
--- trunk/Source/WebCore/bindings/scripts/test/TestConditionallyReadWrite.idl (rev 0)
+++ trunk/Source/WebCore/bindings/scripts/test/TestConditionallyReadWrite.idl 2020-09-19 14:22:11 UTC (rev 267312)
@@ -0,0 +1,41 @@
+/*
+ * Copyright (C) 2020 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+[
+ Exposed=Window
+] interface TestConditionallyReadWrite {
+ [ConditionallyReadWrite=CONDITION] attribute Node conditionallyReadWriteAttribute;
+ [Conditional=CONDITION2, ConditionallyReadWrite=CONDITION] attribute Node conditionalAndConditionallyReadWriteAttribute;
+
+ [RuntimeConditionallyReadWrite=TestFeature] attribute Node runtimeConditionallyReadWriteAttribute;
+ [RuntimeConditionallyReadWrite=TestFeature, LegacyUnforgeable] attribute Node runtimeConditionallyReadWriteAttributeUnforgeable;
+ [RuntimeConditionallyReadWrite=TestFeature, PrivateIdentifier, LegacyUnforgeable] attribute Node runtimeConditionallyReadWriteAttributeUnforgeablePrivate;
+ [RuntimeConditionallyReadWrite=TestFeature] attribute Promise<double> runtimeConditionallyReadWriteAttributePromise;
+
+ [SettingsConditionallyReadWrite=TestFeature] attribute Node settingsConditionallyReadWriteAttribute;
+ [SettingsConditionallyReadWrite=TestFeature, LegacyUnforgeable] attribute Node settingsConditionallyReadWriteAttributeUnforgeable;
+ [SettingsConditionallyReadWrite=TestFeature, PrivateIdentifier, LegacyUnforgeable] attribute Node settingsConditionallyReadWriteAttributeUnforgeablePrivate;
+ [SettingsConditionallyReadWrite=TestFeature] attribute Promise<double> settingsConditionallyReadWriteAttributePromise;
+};
Modified: trunk/Source/WebCore/bindings/scripts/test/TestObj.idl (267311 => 267312)
--- trunk/Source/WebCore/bindings/scripts/test/TestObj.idl 2020-09-19 14:20:18 UTC (rev 267311)
+++ trunk/Source/WebCore/bindings/scripts/test/TestObj.idl 2020-09-19 14:22:11 UTC (rev 267312)
@@ -444,14 +444,6 @@
Node testReturnValueOptimization([ReturnValue] Node a, Node b);
[MayThrowException] Node testReturnValueOptimizationWithException([ReturnValue] Node a, Node b);
- [ConditionallyReadWrite=CONDITION] attribute Node conditionallyReadWriteAttribute;
- [Conditional=CONDITION2, ConditionallyReadWrite=CONDITION] attribute Node conditionalAndConditionallyReadWriteAttribute;
-
- [RuntimeConditionallyReadWrite=TestFeature] attribute Node runtimeConditionallyReadWriteAttribute;
- [RuntimeConditionallyReadWrite=TestFeature, LegacyUnforgeable] attribute Node runtimeConditionallyReadWriteAttributeUnforgeable;
- [RuntimeConditionallyReadWrite=TestFeature, PrivateIdentifier, LegacyUnforgeable] attribute Node runtimeConditionallyReadWriteAttributeUnforgeablePrivate;
- [RuntimeConditionallyReadWrite=TestFeature] attribute Promise<double> runtimeConditionallyReadWriteAttributePromise;
-
[Exposed=Window] attribute long conditionallyExposedToWindowAttribute;
[Exposed=Worker] attribute long conditionallyExposedToWorkerAttribute;
[Exposed=(Worker, Window)] attribute long conditionallyExposedToWindowAndWorkerAttribute;
