Move various reflector types and traits to script_bindings (#35279)

* script: Move Reflector to script_bindings.

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

* script: Extract global() helper from DomObject into new trait. Move DomObject and related traits to script_bindings.

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

---------

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

components/script_bindings/Cargo.toml

@@ -38,3 +38,6 @@ style = { workspace = true }
 [features]
 webgpu = []
 webxr = []
+
+[lints.rust]
+unexpected_cfgs = { level = "warn", check-cfg = ['cfg(crown)'] }

components/script_bindings/callback.rs

@@ -0,0 +1,24 @@
+/* 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::jsapi::JSObject;
+use js::rust::HandleObject;
+
+use crate::reflector::DomObject;
+
+pub trait ThisReflector {
+    fn jsobject(&self) -> *mut JSObject;
+}
+
+impl<T: DomObject> ThisReflector for T {
+    fn jsobject(&self) -> *mut JSObject {
+        self.reflector().get_jsobject().get()
+    }
+}
+
+impl ThisReflector for HandleObject<'_> {
+    fn jsobject(&self) -> *mut JSObject {
+        self.get()
+    }
+}

components/script_bindings/codegen/CodegenRust.py

@@ -2699,6 +2699,7 @@ def DomTypes(descriptors, descriptorProvider, dictionaries, callbacks, typedefs,
                 "js::conversions::ToJSValConvertible",
                 "crate::dom::bindings::reflector::MutDomObject",
                 "crate::dom::bindings::reflector::DomObject",
+                "crate::dom::bindings::reflector::DomGlobal",
             ]
 
         if descriptor.register:

components/script_bindings/conversions.rs

@@ -12,10 +12,11 @@ use js::jsapi::{
     JSContext, JSString, JS_DeprecatedStringHasLatin1Chars, JS_GetLatin1StringCharsAndLength,
     JS_GetTwoByteStringCharsAndLength, JS_NewStringCopyN,
 };
-use js::jsval::StringValue;
-use js::rust::{HandleValue, MutableHandleValue, ToString};
+use js::jsval::{ObjectValue, StringValue};
+use js::rust::{maybe_wrap_value, HandleValue, MutableHandleValue, ToString};
 use servo_config::opts;
 
+use crate::reflector::Reflector;
 use crate::str::{ByteString, DOMString, USVString};
 
 // http://heycam.github.io/webidl/#es-USVString
@@ -191,3 +192,12 @@ impl FromJSValConvertible for ByteString {
         }
     }
 }
+
+impl ToJSValConvertible for Reflector {
+    unsafe fn to_jsval(&self, cx: *mut JSContext, mut rval: MutableHandleValue) {
+        let obj = self.get_jsobject().get();
+        assert!(!obj.is_null());
+        rval.set(ObjectValue(obj));
+        maybe_wrap_value(cx, rval);
+    }
+}

components/script_bindings/lib.rs

@@ -2,6 +2,14 @@
  * 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/. */
 
+#![cfg_attr(crown, feature(register_tool))]
+// Register the linter `crown`, which is the Servo-specific linter for the script
+// crate. Issue a warning if `crown` is not being used to compile, but not when
+// building rustdoc or running clippy.
+#![cfg_attr(crown, register_tool(crown))]
+#![cfg_attr(any(doc, clippy), allow(unknown_lints))]
+#![deny(crown_is_not_used)]
+
 #[macro_use]
 extern crate jstraceable_derive;
 #[macro_use]
@@ -9,7 +17,9 @@ extern crate log;
 #[macro_use]
 extern crate malloc_size_of_derive;
 
+pub mod callback;
 pub mod conversions;
+pub mod reflector;
 pub mod str;
 mod trace;
 

components/script_bindings/reflector.rs

@@ -0,0 +1,92 @@
+/* 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::jsapi::{Heap, JSObject};
+use js::rust::HandleObject;
+use malloc_size_of_derive::MallocSizeOf;
+
+/// A struct to store a reference to the reflector of a DOM object.
+#[cfg_attr(crown, allow(crown::unrooted_must_root))]
+#[derive(MallocSizeOf)]
+#[cfg_attr(crown, crown::unrooted_must_root_lint::must_root)]
+// If you're renaming or moving this field, update the path in plugins::reflector as well
+pub struct Reflector {
+    #[ignore_malloc_size_of = "defined and measured in rust-mozjs"]
+    object: Heap<*mut JSObject>,
+}
+
+unsafe impl js::gc::Traceable for Reflector {
+    unsafe fn trace(&self, _: *mut js::jsapi::JSTracer) {}
+}
+
+#[cfg_attr(crown, allow(crown::unrooted_must_root))]
+impl PartialEq for Reflector {
+    fn eq(&self, other: &Reflector) -> bool {
+        self.object.get() == other.object.get()
+    }
+}
+
+impl Reflector {
+    /// Get the reflector.
+    #[inline]
+    pub fn get_jsobject(&self) -> HandleObject {
+        // We're rooted, so it's safe to hand out a handle to object in Heap
+        unsafe { HandleObject::from_raw(self.object.handle()) }
+    }
+
+    /// Initialize the reflector. (May be called only once.)
+    ///
+    /// # Safety
+    ///
+    /// The provided [`JSObject`] pointer must point to a valid [`JSObject`].
+    pub unsafe fn set_jsobject(&self, object: *mut JSObject) {
+        assert!(self.object.get().is_null());
+        assert!(!object.is_null());
+        self.object.set(object);
+    }
+
+    /// Return a pointer to the memory location at which the JS reflector
+    /// object is stored. Used to root the reflector, as
+    /// required by the JSAPI rooting APIs.
+    pub fn rootable(&self) -> &Heap<*mut JSObject> {
+        &self.object
+    }
+
+    /// Create an uninitialized `Reflector`.
+    // These are used by the bindings and do not need `default()` functions.
+    #[allow(clippy::new_without_default)]
+    pub fn new() -> Reflector {
+        Reflector {
+            object: Heap::default(),
+        }
+    }
+}
+
+/// A trait to provide access to the `Reflector` for a DOM object.
+pub trait DomObject: js::gc::Traceable + 'static {
+    /// Returns the receiver's reflector.
+    fn reflector(&self) -> &Reflector;
+}
+
+impl DomObject for Reflector {
+    fn reflector(&self) -> &Self {
+        self
+    }
+}
+
+/// A trait to initialize the `Reflector` for a DOM object.
+pub trait MutDomObject: DomObject {
+    /// Initializes the Reflector
+    ///
+    /// # Safety
+    ///
+    /// The provided [`JSObject`] pointer must point to a valid [`JSObject`].
+    unsafe fn init_reflector(&self, obj: *mut JSObject);
+}
+
+impl MutDomObject for Reflector {
+    unsafe fn init_reflector(&self, obj: *mut JSObject) {
+        self.set_jsobject(obj)
+    }
+}