Make DOMPoint and DOMPointReadOnly serializable (#35989)

* script: Make DOMPointReadOnly serializable.

Signed-off-by: Josh Matthews <josh@joshmatthews.net>

* script: Make DOMPoint serializable.

Signed-off-by: Josh Matthews <josh@joshmatthews.net>

* script: Shrink worker script event.

Signed-off-by: Josh Matthews <josh@joshmatthews.net>

* Update components/script/dom/dompoint.rs

Co-authored-by: Martin Robinson <mrobinson@igalia.com>
Signed-off-by: Josh Matthews <josh@joshmatthews.net>

---------

Signed-off-by: Josh Matthews <josh@joshmatthews.net>
Co-authored-by: Martin Robinson <mrobinson@igalia.com>

components/script/dom/dompointreadonly.rs

@@ -3,15 +3,21 @@
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
 use std::cell::Cell;
+use std::collections::HashMap;
+use std::num::NonZeroU32;
 
+use base::id::{DomPointId, DomPointIndex, PipelineNamespaceId};
 use dom_struct::dom_struct;
 use js::rust::HandleObject;
+use script_traits::serializable::DomPoint;
 
 use crate::dom::bindings::codegen::Bindings::DOMPointBinding::DOMPointInit;
 use crate::dom::bindings::codegen::Bindings::DOMPointReadOnlyBinding::DOMPointReadOnlyMethods;
 use crate::dom::bindings::error::Fallible;
 use crate::dom::bindings::reflector::{Reflector, reflect_dom_object_with_proto};
 use crate::dom::bindings::root::DomRoot;
+use crate::dom::bindings::serializable::{IntoStorageKey, Serializable, StorageKey};
+use crate::dom::bindings::structuredclone::{StructuredData, StructuredDataReader};
 use crate::dom::globalscope::GlobalScope;
 use crate::script_runtime::CanGc;
 
@@ -134,3 +140,70 @@ impl DOMPointWriteMethods for DOMPointReadOnly {
         self.w.set(value);
     }
 }
+
+impl Serializable for DOMPointReadOnly {
+    type Id = DomPointId;
+    type Data = DomPoint;
+
+    fn serialize(&self) -> Result<(Self::Id, Self::Data), ()> {
+        let serialized = DomPoint {
+            x: self.x.get(),
+            y: self.y.get(),
+            z: self.z.get(),
+            w: self.w.get(),
+        };
+        Ok((DomPointId::new(), serialized))
+    }
+
+    fn deserialize(
+        owner: &GlobalScope,
+        serialized: Self::Data,
+        can_gc: CanGc,
+    ) -> Result<DomRoot<Self>, ()>
+    where
+        Self: Sized,
+    {
+        Ok(Self::new(
+            owner,
+            serialized.x,
+            serialized.y,
+            serialized.z,
+            serialized.w,
+            can_gc,
+        ))
+    }
+
+    fn serialized_storage(data: StructuredData<'_>) -> &mut Option<HashMap<Self::Id, Self::Data>> {
+        match data {
+            StructuredData::Reader(r) => &mut r.points,
+            StructuredData::Writer(w) => &mut w.points,
+        }
+    }
+
+    fn deserialized_storage(
+        reader: &mut StructuredDataReader,
+    ) -> &mut Option<HashMap<StorageKey, DomRoot<Self>>> {
+        &mut reader.points_read_only
+    }
+}
+
+impl From<StorageKey> for DomPointId {
+    fn from(storage_key: StorageKey) -> DomPointId {
+        let namespace_id = PipelineNamespaceId(storage_key.name_space);
+        let index = DomPointIndex(
+            NonZeroU32::new(storage_key.index).expect("Deserialized point index is zero"),
+        );
+
+        DomPointId {
+            namespace_id,
+            index,
+        }
+    }
+}
+
+impl IntoStorageKey for DomPointId {
+    fn into_storage_key(self) -> StorageKey {
+        let DomPointIndex(index) = self.index;
+        StorageKey::new(self.namespace_id, index)
+    }
+}