LibWeb: Implement size attribute of CountQueuingStrategy

Co-authored-by: Matthew Olsson <mattco@serenityos.org>

Userland/Libraries/LibWeb/HTML/Window.cpp

@@ -110,6 +110,7 @@ void Window::visit_edges(JS::Cell::Visitor& visitor)
         visitor.visit(plugin_object);
     for (auto& mime_type_object : m_pdf_viewer_mime_type_objects)
         visitor.visit(mime_type_object);
+    visitor.visit(m_count_queuing_strategy_size_function);
 }
 
 Window::~Window() = default;
@@ -757,6 +758,28 @@ Vector<JS::NonnullGCPtr<MimeType>> Window::pdf_viewer_mime_type_objects()
     return m_pdf_viewer_mime_type_objects;
 }
 
+// https://streams.spec.whatwg.org/#count-queuing-strategy-size-function
+WebIDL::ExceptionOr<JS::NonnullGCPtr<WebIDL::CallbackType>> Window::count_queuing_strategy_size_function()
+{
+    auto& realm = this->realm();
+
+    if (!m_count_queuing_strategy_size_function) {
+        // 1. Let steps be the following steps:
+        auto steps = [](auto const&) {
+            // 1. Return 1.
+            return 1.0;
+        };
+
+        // 2. Let F be ! CreateBuiltinFunction(steps, 0, "size", « », globalObject’s relevant Realm).
+        auto function = JS::NativeFunction::create(realm, move(steps), 0, "size", &realm);
+
+        // 3. Set globalObject’s count queuing strategy size function to a Function that represents a reference to F, with callback context equal to globalObject’s relevant settings object.
+        m_count_queuing_strategy_size_function = MUST_OR_THROW_OOM(heap().allocate<WebIDL::CallbackType>(realm, *function, relevant_settings_object(*this)));
+    }
+
+    return JS::NonnullGCPtr { *m_count_queuing_strategy_size_function };
+}
+
 WebIDL::ExceptionOr<void> Window::initialize_web_interfaces(Badge<WindowEnvironmentSettingsObject>)
 {
     auto& realm = this->realm();

Userland/Libraries/LibWeb/HTML/Window.h

@@ -122,6 +122,8 @@ public:
     CrossOriginPropertyDescriptorMap const& cross_origin_property_descriptor_map() const { return m_cross_origin_property_descriptor_map; }
     CrossOriginPropertyDescriptorMap& cross_origin_property_descriptor_map() { return m_cross_origin_property_descriptor_map; }
 
+    WebIDL::ExceptionOr<JS::NonnullGCPtr<WebIDL::CallbackType>> count_queuing_strategy_size_function();
+
     // JS API functions
     JS::NonnullGCPtr<WindowProxy> window() const;
     JS::NonnullGCPtr<WindowProxy> self() const;
@@ -241,6 +243,9 @@ private:
 
     // https://html.spec.whatwg.org/multipage/interaction.html#user-activation-data-model
     HighResolutionTime::DOMHighResTimeStamp m_last_activation_timestamp { NumericLimits<double>::max() };
+
+    // https://streams.spec.whatwg.org/#count-queuing-strategy-size-function
+    JS::GCPtr<WebIDL::CallbackType> m_count_queuing_strategy_size_function;
 };
 
 void run_animation_frame_callbacks(DOM::Document&, double now);

Userland/Libraries/LibWeb/Streams/CountQueuingStrategy.cpp

@@ -1,11 +1,13 @@
 /*
  * Copyright (c) 2023, Shannon Booth <shannon.ml.booth@gmail.com>
+ * Copyright (c) 2023, Matthew Olsson <mattco@serenityos.org>
  *
  * SPDX-License-Identifier: BSD-2-Clause
  */
 
 #include <LibWeb/Bindings/CountQueuingStrategyPrototype.h>
 #include <LibWeb/Bindings/Intrinsics.h>
+#include <LibWeb/HTML/Window.h>
 #include <LibWeb/Streams/CountQueuingStrategy.h>
 #include <LibWeb/WebIDL/ExceptionOr.h>
 
@@ -27,6 +29,13 @@ CountQueuingStrategy::CountQueuingStrategy(JS::Realm& realm, double high_water_m
 
 CountQueuingStrategy::~CountQueuingStrategy() = default;
 
+// https://streams.spec.whatwg.org/#cqs-size
+WebIDL::ExceptionOr<JS::NonnullGCPtr<WebIDL::CallbackType>> CountQueuingStrategy::size()
+{
+    // 1. Return this's relevant global object's count queuing strategy size function.
+    return global_object().count_queuing_strategy_size_function();
+}
+
 JS::ThrowCompletionOr<void> CountQueuingStrategy::initialize(JS::Realm& realm)
 {
     MUST_OR_THROW_OOM(Base::initialize(realm));

Userland/Libraries/LibWeb/Streams/CountQueuingStrategy.h

@@ -31,6 +31,8 @@ public:
         return m_high_water_mark;
     }
 
+    WebIDL::ExceptionOr<JS::NonnullGCPtr<WebIDL::CallbackType>> size();
+
 private:
     explicit CountQueuingStrategy(JS::Realm&, double high_water_mark);
 

Userland/Libraries/LibWeb/Streams/CountQueuingStrategy.idl

@@ -1,3 +1,4 @@
+#import <WebIDL/Function.idl>
 #import <Streams/QueuingStrategyInit.idl>
 
 // https://streams.spec.whatwg.org/#cqs-class-definition
@@ -7,5 +8,5 @@ interface CountQueuingStrategy {
 
     readonly attribute unrestricted double highWaterMark;
 
-    // FIXME: readonly attribute Function size;
+    readonly attribute Function size;
 };