implement CachedFrozenArray (#34145)

* extract code into CachedFrozenArray

Signed-off-by: Gae24 <96017547+Gae24@users.noreply.github.com>

* fix borrow crash

Signed-off-by: Gae24 <96017547+Gae24@users.noreply.github.com>

* fix already borrowed error

using an else will cause the borrow to live more than it needs
Signed-off-by: Gae24 <96017547+Gae24@users.noreply.github.com>

* restore return statement

Signed-off-by: Gae24 <96017547+Gae24@users.noreply.github.com>

---------

Signed-off-by: Gae24 <96017547+Gae24@users.noreply.github.com>

components/script/dom/bindings/frozenarray.rs

@@ -0,0 +1,52 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+use js::conversions::ToJSValConvertible;
+use js::jsapi::Heap;
+use js::jsval::JSVal;
+use js::rust::MutableHandleValue;
+
+use crate::dom::bindings::cell::DomRefCell;
+use crate::dom::bindings::utils::to_frozen_array;
+use crate::script_runtime::JSContext;
+
+#[derive(JSTraceable)]
+pub struct CachedFrozenArray {
+    frozen_value: DomRefCell<Option<Heap<JSVal>>>,
+}
+
+impl CachedFrozenArray {
+    pub fn new() -> CachedFrozenArray {
+        CachedFrozenArray {
+            frozen_value: DomRefCell::new(None),
+        }
+    }
+
+    pub fn get_or_init<F: FnOnce() -> Vec<T>, T: ToJSValConvertible>(
+        &self,
+        f: F,
+        cx: JSContext,
+        mut retval: MutableHandleValue,
+    ) {
+        if let Some(inner) = &*self.frozen_value.borrow() {
+            retval.set(inner.get());
+            return;
+        }
+
+        let array = f();
+        to_frozen_array(array.as_slice(), cx, retval);
+
+        // Safety: need to create the Heap value in its final memory location before setting it.
+        *self.frozen_value.borrow_mut() = Some(Heap::default());
+        self.frozen_value
+            .borrow()
+            .as_ref()
+            .unwrap()
+            .set(retval.get());
+    }
+
+    pub fn clear(&self) {
+        *self.frozen_value.borrow_mut() = None;
+    }
+}

components/script/dom/bindings/mod.rs

@@ -142,6 +142,7 @@ pub mod constructor;
 pub mod conversions;
 pub mod error;
 pub mod finalize;
+pub mod frozenarray;
 pub mod guard;
 pub mod import;
 pub mod inheritance;

components/script/dom/extendablemessageevent.rs

@@ -8,17 +8,16 @@ use js::jsval::JSVal;
 use js::rust::{HandleObject, HandleValue, MutableHandleValue};
 use servo_atoms::Atom;
 
-use crate::dom::bindings::cell::DomRefCell;
 use crate::dom::bindings::codegen::Bindings::ExtendableEventBinding::ExtendableEvent_Binding::ExtendableEventMethods;
 use crate::dom::bindings::codegen::Bindings::ExtendableMessageEventBinding;
 use crate::dom::bindings::codegen::Bindings::ExtendableMessageEventBinding::ExtendableMessageEventMethods;
 use crate::dom::bindings::error::Fallible;
+use crate::dom::bindings::frozenarray::CachedFrozenArray;
 use crate::dom::bindings::inheritance::Castable;
 use crate::dom::bindings::reflector::reflect_dom_object_with_proto;
 use crate::dom::bindings::root::{Dom, DomRoot};
 use crate::dom::bindings::str::DOMString;
 use crate::dom::bindings::trace::RootedTraceableBox;
-use crate::dom::bindings::utils::to_frozen_array;
 use crate::dom::event::Event;
 use crate::dom::eventtarget::EventTarget;
 use crate::dom::extendableevent::ExtendableEvent;
@@ -42,7 +41,7 @@ pub struct ExtendableMessageEvent {
     /// <https://w3c.github.io/ServiceWorker/#dom-extendablemessageevent-ports>
     ports: Vec<Dom<MessagePort>>,
     #[ignore_malloc_size_of = "mozjs"]
-    frozen_ports: DomRefCell<Option<Heap<JSVal>>>,
+    frozen_ports: CachedFrozenArray,
 }
 
 #[allow(non_snake_case)]
@@ -61,7 +60,7 @@ impl ExtendableMessageEvent {
                 .into_iter()
                 .map(|port| Dom::from_ref(&*port))
                 .collect(),
-            frozen_ports: DomRefCell::new(None),
+            frozen_ports: CachedFrozenArray::new(),
         }
     }
 
@@ -208,25 +207,16 @@ impl ExtendableMessageEventMethods for ExtendableMessageEvent {
     }
 
     /// <https://w3c.github.io/ServiceWorker/#extendablemessage-event-ports>
-    fn Ports(&self, cx: JSContext, mut retval: MutableHandleValue) {
+    fn Ports(&self, cx: JSContext, retval: MutableHandleValue) {
-        if let Some(ports) = &*self.frozen_ports.borrow() {
+        self.frozen_ports.get_or_init(
-            retval.set(ports.get());
+            || {
-            return;
+                self.ports
-        }
+                    .iter()
-
+                    .map(|port| DomRoot::from_ref(&**port))
-        let ports: Vec<DomRoot<MessagePort>> = self
+                    .collect()
-            .ports
+            },
-            .iter()
+            cx,
-            .map(|port| DomRoot::from_ref(&**port))
+            retval,
-            .collect();
+        );
-        to_frozen_array(ports.as_slice(), cx, retval);
-
-        // Safety: need to create the Heap value in its final memory location before setting it.
-        *self.frozen_ports.borrow_mut() = Some(Heap::default());
-        self.frozen_ports
-            .borrow()
-            .as_ref()
-            .unwrap()
-            .set(retval.get());
     }
 }

components/script/dom/globalscope.rs

@@ -31,7 +31,7 @@ use js::jsapi::{
     InstantiateGlobalStencil, InstantiateOptions, JSContext, JSObject, JSScript, RuntimeCode,
     SetScriptPrivate,
 };
-use js::jsval::{JSVal, PrivateValue, UndefinedValue};
+use js::jsval::{PrivateValue, UndefinedValue};
 use js::panic::maybe_resume_unwind;
 use js::rust::wrappers::{JS_ExecuteScript, JS_GetScriptPrivate};
 use js::rust::{
@@ -81,6 +81,7 @@ use crate::dom::bindings::codegen::Bindings::WindowBinding::WindowMethods;
 use crate::dom::bindings::codegen::Bindings::WorkerGlobalScopeBinding::WorkerGlobalScopeMethods;
 use crate::dom::bindings::conversions::{root_from_object, root_from_object_static};
 use crate::dom::bindings::error::{report_pending_exception, Error, ErrorInfo};
+use crate::dom::bindings::frozenarray::CachedFrozenArray;
 use crate::dom::bindings::inheritance::Castable;
 use crate::dom::bindings::refcounted::{Trusted, TrustedPromise};
 use crate::dom::bindings::reflector::DomObject;
@@ -88,7 +89,6 @@ use crate::dom::bindings::root::{Dom, DomRoot, MutNullableDom};
 use crate::dom::bindings::settings_stack::{entry_global, incumbent_global, AutoEntryScript};
 use crate::dom::bindings::str::DOMString;
 use crate::dom::bindings::structuredclone;
-use crate::dom::bindings::utils::to_frozen_array;
 use crate::dom::bindings::weakref::{DOMTracker, WeakRef};
 use crate::dom::blob::Blob;
 use crate::dom::broadcastchannel::BroadcastChannel;
@@ -336,7 +336,7 @@ pub struct GlobalScope {
 
     // https://w3c.github.io/performance-timeline/#supportedentrytypes-attribute
     #[ignore_malloc_size_of = "mozjs"]
-    frozen_supported_performance_entry_types: DomRefCell<Option<Heap<JSVal>>>,
+    frozen_supported_performance_entry_types: CachedFrozenArray,
 
     /// currect https state (from previous request)
     #[no_trace]
@@ -798,7 +798,7 @@ impl GlobalScope {
             user_agent,
             gpu_id_hub,
             gpu_devices: DomRefCell::new(HashMapTracedValues::new()),
-            frozen_supported_performance_entry_types: DomRefCell::new(Default::default()),
+            frozen_supported_performance_entry_types: CachedFrozenArray::new(),
             https_state: Cell::new(HttpsState::None),
             console_group_stack: DomRefCell::new(Vec::new()),
             console_count_map: Default::default(),
@@ -3072,29 +3072,17 @@ impl GlobalScope {
     }
 
     /// <https://w3c.github.io/performance-timeline/#supportedentrytypes-attribute>
-    pub fn supported_performance_entry_types(
+    pub fn supported_performance_entry_types(&self, cx: SafeJSContext, retval: MutableHandleValue) {
-        &self,
+        self.frozen_supported_performance_entry_types.get_or_init(
-        cx: SafeJSContext,
+            || {
-        mut retval: MutableHandleValue,
+                VALID_ENTRY_TYPES
-    ) {
+                    .iter()
-        if let Some(types) = &*self.frozen_supported_performance_entry_types.borrow() {
+                    .map(|t| DOMString::from(t.to_string()))
-            retval.set(types.get());
+                    .collect()
-            return;
+            },
-        }
+            cx,
-
+            retval,
-        let types: Vec<DOMString> = VALID_ENTRY_TYPES
+        );
-            .iter()
-            .map(|t| DOMString::from(t.to_string()))
-            .collect();
-        to_frozen_array(types.as_slice(), cx, retval);
-
-        // Safety: need to create the Heap value in its final memory location before setting it.
-        *self.frozen_supported_performance_entry_types.borrow_mut() = Some(Heap::default());
-        self.frozen_supported_performance_entry_types
-            .borrow()
-            .as_ref()
-            .unwrap()
-            .set(retval.get());
     }
 
     pub fn is_headless(&self) -> bool {

components/script/dom/messageevent.rs

@@ -14,12 +14,12 @@ use crate::dom::bindings::codegen::Bindings::MessageEventBinding;
 use crate::dom::bindings::codegen::Bindings::MessageEventBinding::MessageEventMethods;
 use crate::dom::bindings::codegen::UnionTypes::WindowProxyOrMessagePortOrServiceWorker;
 use crate::dom::bindings::error::Fallible;
+use crate::dom::bindings::frozenarray::CachedFrozenArray;
 use crate::dom::bindings::inheritance::Castable;
 use crate::dom::bindings::reflector::reflect_dom_object_with_proto;
 use crate::dom::bindings::root::{Dom, DomRoot};
 use crate::dom::bindings::str::DOMString;
 use crate::dom::bindings::trace::RootedTraceableBox;
-use crate::dom::bindings::utils::to_frozen_array;
 use crate::dom::event::Event;
 use crate::dom::eventtarget::EventTarget;
 use crate::dom::globalscope::GlobalScope;
@@ -64,7 +64,7 @@ pub struct MessageEvent {
     lastEventId: DomRefCell<DOMString>,
     ports: DomRefCell<Vec<Dom<MessagePort>>>,
     #[ignore_malloc_size_of = "mozjs"]
-    frozen_ports: DomRefCell<Option<Heap<JSVal>>>,
+    frozen_ports: CachedFrozenArray,
 }
 
 #[allow(non_snake_case)]
@@ -87,7 +87,7 @@ impl MessageEvent {
                     .map(|port| Dom::from_ref(&*port))
                     .collect(),
             ),
-            frozen_ports: DomRefCell::new(None),
+            frozen_ports: CachedFrozenArray::new(),
         }
     }
 
@@ -302,27 +302,18 @@ impl MessageEventMethods for MessageEvent {
     }
 
     /// <https://html.spec.whatwg.org/multipage/#dom-messageevent-ports>
-    fn Ports(&self, cx: JSContext, mut retval: MutableHandleValue) {
+    fn Ports(&self, cx: JSContext, retval: MutableHandleValue) {
-        if let Some(ports) = &*self.frozen_ports.borrow() {
+        self.frozen_ports.get_or_init(
-            retval.set(ports.get());
+            || {
-            return;
+                self.ports
-        }
+                    .borrow()
-
+                    .iter()
-        let ports: Vec<DomRoot<MessagePort>> = self
+                    .map(|port| DomRoot::from_ref(&**port))
-            .ports
+                    .collect()
-            .borrow()
+            },
-            .iter()
+            cx,
-            .map(|port| DomRoot::from_ref(&**port))
+            retval,
-            .collect();
+        );
-        to_frozen_array(ports.as_slice(), cx, retval);
-
-        // Safety: need to create the Heap value in its final memory location before setting it.
-        *self.frozen_ports.borrow_mut() = Some(Heap::default());
-        self.frozen_ports
-            .borrow()
-            .as_ref()
-            .unwrap()
-            .set(retval.get());
     }
 
     /// <https://html.spec.whatwg.org/multipage/#dom-messageevent-initmessageevent>
@@ -347,7 +338,7 @@ impl MessageEventMethods for MessageEvent {
             .into_iter()
             .map(|port| Dom::from_ref(&*port))
             .collect();
-        *self.frozen_ports.borrow_mut() = None;
+        self.frozen_ports.clear();
         self.event
             .init_event(Atom::from(type_), bubbles, cancelable);
     }