script: Move Window-only gamepad functionality out of GlobalScope (#36805)

The only code that calls these methods is in the script thread, and the
code is simpler when we can assume a Window global. Pulling this thread
led to cleaning up a lot of constructors for Window-only WebXR code,
too.

Testing: Existing WPT coverage.

---------

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

components/script/dom/webxr/xrhittestsource.rs

@@ -8,7 +8,7 @@ use webxr_api::HitTestId;
 use crate::dom::bindings::codegen::Bindings::XRHitTestSourceBinding::XRHitTestSourceMethods;
 use crate::dom::bindings::reflector::{Reflector, reflect_dom_object};
 use crate::dom::bindings::root::{Dom, DomRoot};
-use crate::dom::globalscope::GlobalScope;
+use crate::dom::window::Window;
 use crate::dom::xrsession::XRSession;
 use crate::script_runtime::CanGc;
 
@@ -31,14 +31,14 @@ impl XRHitTestSource {
     }
 
     pub(crate) fn new(
-        global: &GlobalScope,
+        window: &Window,
         id: HitTestId,
         session: &XRSession,
         can_gc: CanGc,
     ) -> DomRoot<XRHitTestSource> {
         reflect_dom_object(
             Box::new(XRHitTestSource::new_inherited(id, session)),
-            global,
+            window,
             can_gc,
         )
     }

components/script/dom/webxr/xrinputsource.rs

@@ -17,6 +17,7 @@ use crate::dom::bindings::reflector::{DomGlobal, Reflector, reflect_dom_object};
 use crate::dom::bindings::root::{Dom, DomRoot, MutNullableDom};
 use crate::dom::gamepad::Gamepad;
 use crate::dom::globalscope::GlobalScope;
+use crate::dom::window::Window;
 use crate::dom::xrhand::XRHand;
 use crate::dom::xrsession::XRSession;
 use crate::dom::xrspace::XRSpace;
@@ -40,14 +41,14 @@ pub(crate) struct XRInputSource {
 
 impl XRInputSource {
     pub(crate) fn new_inherited(
-        global: &GlobalScope,
+        window: &Window,
         session: &XRSession,
         info: InputSource,
         can_gc: CanGc,
     ) -> XRInputSource {
         // <https://www.w3.org/TR/webxr-gamepads-module-1/#gamepad-differences>
         let gamepad = Gamepad::new(
-            global,
+            window,
             0,
             "".into(),
             "xr-standard".into(),
@@ -74,18 +75,18 @@ impl XRInputSource {
 
     #[allow(unsafe_code)]
     pub(crate) fn new(
-        global: &GlobalScope,
+        window: &Window,
         session: &XRSession,
         info: InputSource,
         can_gc: CanGc,
     ) -> DomRoot<XRInputSource> {
         let source = reflect_dom_object(
-            Box::new(XRInputSource::new_inherited(global, session, info, can_gc)),
-            global,
+            Box::new(XRInputSource::new_inherited(window, session, info, can_gc)),
+            window,
             can_gc,
         );
 
-        let _ac = enter_realm(global);
+        let _ac = enter_realm(window);
         let cx = GlobalScope::get_cx();
         unsafe {
             rooted!(in(*cx) let mut profiles = UndefinedValue());

components/script/dom/webxr/xrinputsourcearray.rs

@@ -11,7 +11,7 @@ use crate::dom::bindings::inheritance::Castable;
 use crate::dom::bindings::reflector::{DomGlobal, Reflector, reflect_dom_object};
 use crate::dom::bindings::root::{Dom, DomRoot};
 use crate::dom::event::Event;
-use crate::dom::globalscope::GlobalScope;
+use crate::dom::window::Window;
 use crate::dom::xrinputsource::XRInputSource;
 use crate::dom::xrinputsourceschangeevent::XRInputSourcesChangeEvent;
 use crate::dom::xrsession::XRSession;
@@ -31,10 +31,10 @@ impl XRInputSourceArray {
         }
     }
 
-    pub(crate) fn new(global: &GlobalScope, can_gc: CanGc) -> DomRoot<XRInputSourceArray> {
+    pub(crate) fn new(window: &Window, can_gc: CanGc) -> DomRoot<XRInputSourceArray> {
         reflect_dom_object(
             Box::new(XRInputSourceArray::new_inherited()),
-            global,
+            window,
             can_gc,
         )
     }
@@ -60,7 +60,7 @@ impl XRInputSourceArray {
                     .any(|i| i.id() == info.id),
                 "Should never add a duplicate input id!"
             );
-            let input = XRInputSource::new(&global, session, info.clone(), can_gc);
+            let input = XRInputSource::new(window, session, info.clone(), can_gc);
             self.input_sources.borrow_mut().push(Dom::from_ref(&input));
             added.push(input);
         }
@@ -121,7 +121,7 @@ impl XRInputSourceArray {
             &[]
         };
         self.input_sources.borrow_mut().retain(|i| i.id() != id);
-        let input = XRInputSource::new(&global, session, info, can_gc);
+        let input = XRInputSource::new(window, session, info, can_gc);
         self.input_sources.borrow_mut().push(Dom::from_ref(&input));
 
         let added = [input];

components/script/dom/webxr/xrrenderstate.rs

@@ -14,7 +14,7 @@ use crate::dom::bindings::num::Finite;
 use crate::dom::bindings::reflector::{DomGlobal, Reflector, reflect_dom_object};
 use crate::dom::bindings::root::{Dom, DomRoot, MutNullableDom};
 use crate::dom::bindings::utils::to_frozen_array;
-use crate::dom::globalscope::GlobalScope;
+use crate::dom::window::Window;
 use crate::dom::xrlayer::XRLayer;
 use crate::dom::xrwebgllayer::XRWebGLLayer;
 use crate::script_runtime::{CanGc, JSContext};
@@ -49,7 +49,7 @@ impl XRRenderState {
     }
 
     pub(crate) fn new(
-        global: &GlobalScope,
+        window: &Window,
         depth_near: f64,
         depth_far: f64,
         inline_vertical_fov: Option<f64>,
@@ -65,14 +65,14 @@ impl XRRenderState {
                 layer,
                 layers,
             )),
-            global,
+            window,
             can_gc,
         )
     }
 
     pub(crate) fn clone_object(&self) -> DomRoot<Self> {
         XRRenderState::new(
-            &self.global(),
+            self.global().as_window(),
             self.depth_near.get(),
             self.depth_far.get(),
             self.inline_vertical_fov.get(),

components/script/dom/webxr/xrsession.rs

@@ -54,8 +54,8 @@ use crate::dom::bindings::root::{Dom, DomRoot, MutDom, MutNullableDom};
 use crate::dom::bindings::utils::to_frozen_array;
 use crate::dom::event::Event;
 use crate::dom::eventtarget::EventTarget;
-use crate::dom::globalscope::GlobalScope;
 use crate::dom::promise::Promise;
+use crate::dom::window::Window;
 use crate::dom::xrboundedreferencespace::XRBoundedReferenceSpace;
 use crate::dom::xrframe::XRFrame;
 use crate::dom::xrhittestsource::XRHitTestSource;
@@ -152,7 +152,7 @@ impl XRSession {
     }
 
     pub(crate) fn new(
-        global: &GlobalScope,
+        window: &Window,
         session: Session,
         mode: XRSessionMode,
         frame_receiver: IpcReceiver<Frame>,
@@ -163,8 +163,8 @@ impl XRSession {
         } else {
             None
         };
-        let render_state = XRRenderState::new(global, 0.1, 1000.0, ivfov, None, Vec::new(), can_gc);
-        let input_sources = XRInputSourceArray::new(global, can_gc);
+        let render_state = XRRenderState::new(window, 0.1, 1000.0, ivfov, None, Vec::new(), can_gc);
+        let input_sources = XRInputSourceArray::new(window, can_gc);
         let ret = reflect_dom_object(
             Box::new(XRSession::new_inherited(
                 session,
@@ -172,7 +172,7 @@ impl XRSession {
                 &input_sources,
                 mode,
             )),
-            global,
+            window,
             can_gc,
         );
         ret.attach_event_handler();
@@ -587,7 +587,7 @@ impl XRSession {
             FrameUpdateEvent::HitTestSourceAdded(id) => {
                 if let Some(promise) = self.pending_hit_test_promises.borrow_mut().remove(&id) {
                     promise.resolve_native(
-                        &XRHitTestSource::new(&self.global(), id, self, can_gc),
+                        &XRHitTestSource::new(self.global().as_window(), id, self, can_gc),
                         can_gc,
                     );
                 } else {

components/script/dom/webxr/xrsystem.rs

@@ -297,7 +297,13 @@ impl XRSystem {
                 return;
             },
         };
-        let session = XRSession::new(&self.global(), session, mode, frame_receiver, CanGc::note());
+        let session = XRSession::new(
+            self.global().as_window(),
+            session,
+            mode,
+            frame_receiver,
+            CanGc::note(),
+        );
         if mode == XRSessionMode::Inline {
             self.active_inline_sessions
                 .borrow_mut()