LibWeb: Add {,de}serialization steps for DOMRectReadonly

Tests/LibWeb/Text/expected/HTML/StructuredClone-serializable-objects.txt

@@ -16,3 +16,5 @@ instanceOf DOMPointReadOnly: true
 DOMPointReadOnly: {"x":10,"y":20,"z":30,"w":40}
 instanceOf DOMPoint: true
 DOMPoint: {"x":10,"y":20,"z":30,"w":40}
+instanceOf DOMRectReadOnly: true
+DOMRectReadOnly: {"x":10,"y":20,"width":30,"height":40,"top":20,"right":40,"bottom":60,"left":10}

Tests/LibWeb/Text/input/HTML/StructuredClone-serializable-objects.html

@@ -35,6 +35,10 @@
         println(`instanceOf DOMPoint: ${domPoint instanceof DOMPoint}`);
         println(`DOMPoint: ${JSON.stringify(domPoint)}`);
 
+        let domRectReadOnly = structuredClone(new DOMRectReadOnly(10, 20, 30, 40));
+        println(`instanceOf DOMRectReadOnly: ${domRectReadOnly instanceof DOMRectReadOnly}`);
+        println(`DOMRectReadOnly: ${JSON.stringify(domRectReadOnly)}`);
+
         done();
     });
 </script>

Userland/Libraries/LibWeb/Geometry/DOMRectReadOnly.cpp

@@ -1,11 +1,13 @@
 /*
  * Copyright (c) 2022, Andreas Kling <kling@serenityos.org>
+ * Copyright (c) 2024, Kenneth Myhra <kennethmyhra@serenityos.org>
  *
  * SPDX-License-Identifier: BSD-2-Clause
  */
 
 #include <LibWeb/Bindings/Intrinsics.h>
 #include <LibWeb/Geometry/DOMRectReadOnly.h>
+#include <LibWeb/HTML/StructuredSerialize.h>
 #include <LibWeb/WebIDL/ExceptionOr.h>
 
 namespace Web::Geometry {
@@ -24,12 +26,22 @@ JS::NonnullGCPtr<DOMRectReadOnly> DOMRectReadOnly::from_rect(JS::VM& vm, Geometr
     return realm.heap().allocate<DOMRectReadOnly>(realm, realm, other.x, other.y, other.width, other.height);
 }
 
+JS::NonnullGCPtr<DOMRectReadOnly> DOMRectReadOnly::create(JS::Realm& realm)
+{
+    return realm.heap().allocate<DOMRectReadOnly>(realm, realm);
+}
+
 DOMRectReadOnly::DOMRectReadOnly(JS::Realm& realm, double x, double y, double width, double height)
     : PlatformObject(realm)
     , m_rect(x, y, width, height)
 {
 }
 
+DOMRectReadOnly::DOMRectReadOnly(JS::Realm& realm)
+    : PlatformObject(realm)
+{
+}
+
 DOMRectReadOnly::~DOMRectReadOnly() = default;
 
 void DOMRectReadOnly::initialize(JS::Realm& realm)
@@ -38,4 +50,35 @@ void DOMRectReadOnly::initialize(JS::Realm& realm)
     WEB_SET_PROTOTYPE_FOR_INTERFACE(DOMRectReadOnly);
 }
 
+// https://drafts.fxtf.org/geometry/#structured-serialization
+WebIDL::ExceptionOr<void> DOMRectReadOnly::serialization_steps(HTML::SerializationRecord& serialized, bool)
+{
+    // 1. Set serialized.[[X]] to value’s x coordinate.
+    HTML::serialize_primitive_type(serialized, this->x());
+    // 2. Set serialized.[[Y]] to value’s y coordinate.
+    HTML::serialize_primitive_type(serialized, this->y());
+    // 3. Set serialized.[[Width]] to value’s width.
+    HTML::serialize_primitive_type(serialized, this->width());
+    // 4. Set serialized.[[Height]] to value’s height.
+    HTML::serialize_primitive_type(serialized, this->height());
+    return {};
+}
+
+// https://drafts.fxtf.org/geometry/#structured-serialization
+WebIDL::ExceptionOr<void> DOMRectReadOnly::deserialization_steps(ReadonlySpan<u32> const& serialized, size_t& position)
+{
+    // 1. Set value’s x coordinate to serialized.[[X]].
+    auto x = HTML::deserialize_primitive_type<double>(serialized, position);
+    // 2. Set value’s y coordinate to serialized.[[Y]].
+    auto y = HTML::deserialize_primitive_type<double>(serialized, position);
+    // 3. Set value’s width to serialized.[[Width]].
+    auto width = HTML::deserialize_primitive_type<double>(serialized, position);
+    // 4. Set value’s height to serialized.[[Height]].
+    auto height = HTML::deserialize_primitive_type<double>(serialized, position);
+
+    m_rect = { x, y, width, height };
+
+    return {};
+}
+
 }

Userland/Libraries/LibWeb/Geometry/DOMRectReadOnly.h

@@ -1,5 +1,6 @@
 /*
  * Copyright (c) 2021, Andreas Kling <kling@serenityos.org>
+ * Copyright (c) 2024, Kenneth Myhra <kennethmyhra@serenityos.org>
  *
  * SPDX-License-Identifier: BSD-2-Clause
  */
@@ -8,6 +9,7 @@
 
 #include <LibGfx/Rect.h>
 #include <LibWeb/Bindings/PlatformObject.h>
+#include <LibWeb/Bindings/Serializable.h>
 #include <LibWeb/Forward.h>
 
 namespace Web::Geometry {
@@ -21,13 +23,16 @@ struct DOMRectInit {
 };
 
 // https://drafts.fxtf.org/geometry/#domrectreadonly
-class DOMRectReadOnly : public Bindings::PlatformObject {
+class DOMRectReadOnly
+    : public Bindings::PlatformObject
+    , public Bindings::Serializable {
     WEB_PLATFORM_OBJECT(DOMRectReadOnly, Bindings::PlatformObject);
     JS_DECLARE_ALLOCATOR(DOMRectReadOnly);
 
 public:
     static WebIDL::ExceptionOr<JS::NonnullGCPtr<DOMRectReadOnly>> construct_impl(JS::Realm&, double x = 0, double y = 0, double width = 0, double height = 0);
     [[nodiscard]] static JS::NonnullGCPtr<DOMRectReadOnly> from_rect(JS::VM&, DOMRectInit const&);
+    static JS::NonnullGCPtr<DOMRectReadOnly> create(JS::Realm&);
 
     virtual ~DOMRectReadOnly() override;
 
@@ -64,8 +69,13 @@ public:
         return min(x(), x() + width());
     }
 
+    virtual StringView interface_name() const override { return "DOMRectReadOnly"sv; }
+    virtual WebIDL::ExceptionOr<void> serialization_steps(HTML::SerializationRecord&, bool for_storage) override;
+    virtual WebIDL::ExceptionOr<void> deserialization_steps(ReadonlySpan<u32> const&, size_t& position) override;
+
 protected:
     DOMRectReadOnly(JS::Realm&, double x, double y, double width, double height);
+    explicit DOMRectReadOnly(JS::Realm&);
 
     virtual void initialize(JS::Realm&) override;
 

Userland/Libraries/LibWeb/HTML/StructuredSerialize.cpp

@@ -39,6 +39,7 @@
 #include <LibWeb/Geometry/DOMMatrixReadOnly.h>
 #include <LibWeb/Geometry/DOMPoint.h>
 #include <LibWeb/Geometry/DOMPointReadOnly.h>
+#include <LibWeb/Geometry/DOMRectReadOnly.h>
 #include <LibWeb/HTML/MessagePort.h>
 #include <LibWeb/HTML/StructuredSerialize.h>
 #include <LibWeb/WebIDL/ExceptionOr.h>
@@ -975,6 +976,8 @@ private:
             return Geometry::DOMPointReadOnly::create(realm);
         if (interface_name == "DOMPoint"sv)
             return Geometry::DOMPoint::create(realm);
+        if (interface_name == "DOMRectReadOnly"sv)
+            return Geometry::DOMRectReadOnly::create(realm);
 
         VERIFY_NOT_REACHED();
     }