webxr: Rename sender & receiver type aliases to WebXrSender and WebXrReceiver (#35307)

This will prevent rust-analyzer from suggesting the import of these
types when dealing with `crossbeam` channels.

Signed-off-by: Martin Robinson <mrobinson@igalia.com>

components/shared/webxr/device.rs

@@ -8,8 +8,8 @@ use euclid::{Point2D, RigidTransform3D};
 
 use crate::{
     ContextId, EnvironmentBlendMode, Error, Event, Floor, Frame, HitTestId, HitTestSource,
-    InputSource, LayerId, LayerInit, Native, Quitter, Sender, Session, SessionBuilder, SessionInit,
-    SessionMode, Viewports,
+    InputSource, LayerId, LayerInit, Native, Quitter, Session, SessionBuilder, SessionInit,
+    SessionMode, Viewports, WebXrSender,
 };
 
 /// A trait for discovering XR devices
@@ -47,7 +47,7 @@ pub trait DeviceAPI: 'static {
     fn initial_inputs(&self) -> Vec<InputSource>;
 
     /// Sets the event handling channel
-    fn set_event_dest(&mut self, dest: Sender<Event>);
+    fn set_event_dest(&mut self, dest: WebXrSender<Event>);
 
     /// Quit the session
     fn quit(&mut self);

components/shared/webxr/events.rs

@@ -5,7 +5,8 @@
 use euclid::RigidTransform3D;
 
 use crate::{
-    ApiSpace, BaseSpace, Frame, InputFrame, InputId, InputSource, SelectEvent, SelectKind, Sender,
+    ApiSpace, BaseSpace, Frame, InputFrame, InputId, InputSource, SelectEvent, SelectKind,
+    WebXrSender,
 };
 
 #[derive(Clone, Debug)]
@@ -45,7 +46,7 @@ pub enum Visibility {
 /// when no event callback has been set
 pub enum EventBuffer {
     Buffered(Vec<Event>),
-    Sink(Sender<Event>),
+    Sink(WebXrSender<Event>),
 }
 
 impl Default for EventBuffer {
@@ -64,7 +65,7 @@ impl EventBuffer {
         }
     }
 
-    pub fn upgrade(&mut self, dest: Sender<Event>) {
+    pub fn upgrade(&mut self, dest: WebXrSender<Event>) {
         if let EventBuffer::Buffered(ref mut events) = *self {
             for event in events.drain(..) {
                 let _ = dest.send(event);

components/shared/webxr/lib.rs

@@ -20,7 +20,7 @@ pub mod util;
 mod view;
 
 #[cfg(not(feature = "ipc"))]
-pub use std::sync::mpsc::{Receiver, RecvTimeoutError, Sender};
+pub use std::sync::mpsc::{RecvTimeoutError, WebXrReceiver, WebXrSender};
 #[cfg(feature = "ipc")]
 use std::thread;
 use std::time::Duration;
@@ -37,11 +37,11 @@ pub use input::{
     Handedness, InputFrame, InputId, InputSource, SelectEvent, SelectKind, TargetRayMode,
 };
 #[cfg(feature = "ipc")]
-pub use ipc_channel::ipc::channel;
+pub use ipc_channel::ipc::channel as webxr_channel;
 #[cfg(feature = "ipc")]
-pub use ipc_channel::ipc::IpcReceiver as Receiver;
+pub use ipc_channel::ipc::IpcReceiver as WebXrReceiver;
 #[cfg(feature = "ipc")]
-pub use ipc_channel::ipc::IpcSender as Sender;
+pub use ipc_channel::ipc::IpcSender as WebXrSender;
 pub use layer::{
     ContextId, GLContexts, GLTypes, LayerGrandManager, LayerGrandManagerAPI, LayerId, LayerInit,
     LayerLayout, LayerManager, LayerManagerAPI, LayerManagerFactory, SubImage, SubImages,
@@ -63,18 +63,21 @@ pub use view::{
 };
 
 #[cfg(not(feature = "ipc"))]
-pub fn channel<T>() -> Result<(Sender<T>, Receiver<T>), ()> {
+pub fn webxr_channel<T>() -> Result<(WebXrWebXrSender<T>, WebXrWebXrReceiver<T>), ()> {
     Ok(std::sync::mpsc::channel())
 }
 
 #[cfg(not(feature = "ipc"))]
-pub fn recv_timeout<T>(receiver: &Receiver<T>, timeout: Duration) -> Result<T, RecvTimeoutError> {
+pub fn recv_timeout<T>(
+    receiver: &WebXrReceiver<T>,
+    timeout: Duration,
+) -> Result<T, RecvTimeoutError> {
     receiver.recv_timeout(timeout)
 }
 
 #[cfg(feature = "ipc")]
 pub fn recv_timeout<T>(
-    receiver: &Receiver<T>,
+    receiver: &WebXrReceiver<T>,
     timeout: Duration,
 ) -> Result<T, ipc_channel::ipc::TryRecvError>
 where

components/shared/webxr/mock.rs

@@ -8,8 +8,8 @@ use serde::{Deserialize, Serialize};
 
 use crate::{
     DiscoveryAPI, Display, EntityType, Error, Floor, Handedness, Input, InputId, InputSource,
-    LeftEye, Native, Receiver, RightEye, SelectEvent, SelectKind, Sender, TargetRayMode, Triangle,
-    Viewer, Viewport, Visibility,
+    LeftEye, Native, RightEye, SelectEvent, SelectKind, TargetRayMode, Triangle, Viewer, Viewport,
+    Visibility, WebXrReceiver, WebXrSender,
 };
 
 /// A trait for discovering mock XR devices
@@ -17,7 +17,7 @@ pub trait MockDiscoveryAPI<GL>: 'static {
     fn simulate_device_connection(
         &mut self,
         init: MockDeviceInit,
-        receiver: Receiver<MockDeviceMsg>,
+        receiver: WebXrReceiver<MockDeviceMsg>,
     ) -> Result<Box<dyn DiscoveryAPI<GL>>, Error>;
 }
 
@@ -62,7 +62,7 @@ pub enum MockDeviceMsg {
     VisibilityChange(Visibility),
     SetWorld(MockWorld),
     ClearWorld,
-    Disconnect(Sender<()>),
+    Disconnect(WebXrSender<()>),
     SetBoundsGeometry(Vec<Point2D<f32, Floor>>),
     SimulateResetPose,
 }

components/shared/webxr/registry.rs

@@ -8,14 +8,14 @@ use serde::{Deserialize, Serialize};
 
 use crate::{
     DiscoveryAPI, Error, Frame, GLTypes, LayerGrandManager, MainThreadSession, MockDeviceInit,
-    MockDeviceMsg, MockDiscoveryAPI, Receiver, Sender, Session, SessionBuilder, SessionId,
-    SessionInit, SessionMode,
+    MockDeviceMsg, MockDiscoveryAPI, Session, SessionBuilder, SessionId, SessionInit, SessionMode,
+    WebXrReceiver, WebXrSender,
 };
 
 #[derive(Clone)]
 #[cfg_attr(feature = "ipc", derive(Serialize, Deserialize))]
 pub struct Registry {
-    sender: Sender<RegistryMsg>,
+    sender: WebXrSender<RegistryMsg>,
     waker: MainThreadWakerImpl,
 }
 
@@ -23,8 +23,8 @@ pub struct MainThreadRegistry<GL> {
     discoveries: Vec<Box<dyn DiscoveryAPI<GL>>>,
     sessions: Vec<Box<dyn MainThreadSession>>,
     mocks: Vec<Box<dyn MockDiscoveryAPI<GL>>>,
-    sender: Sender<RegistryMsg>,
-    receiver: Receiver<RegistryMsg>,
+    sender: WebXrSender<RegistryMsg>,
+    receiver: WebXrReceiver<RegistryMsg>,
     waker: MainThreadWakerImpl,
     grand_manager: LayerGrandManager<GL>,
     next_session_id: u32,
@@ -45,7 +45,7 @@ impl Clone for Box<dyn MainThreadWaker> {
 #[cfg_attr(feature = "ipc", derive(Serialize, Deserialize))]
 struct MainThreadWakerImpl {
     #[cfg(feature = "ipc")]
-    sender: Sender<()>,
+    sender: WebXrSender<()>,
     #[cfg(not(feature = "ipc"))]
     waker: Box<dyn MainThreadWaker>,
 }
@@ -53,7 +53,7 @@ struct MainThreadWakerImpl {
 #[cfg(feature = "ipc")]
 impl MainThreadWakerImpl {
     fn new(waker: Box<dyn MainThreadWaker>) -> Result<MainThreadWakerImpl, Error> {
-        let (sender, receiver) = crate::channel().or(Err(Error::CommunicationError))?;
+        let (sender, receiver) = crate::webxr_channel().or(Err(Error::CommunicationError))?;
         ipc_channel::router::ROUTER.add_typed_route(receiver, Box::new(move |_| waker.wake()));
         Ok(MainThreadWakerImpl { sender })
     }
@@ -75,7 +75,7 @@ impl MainThreadWakerImpl {
 }
 
 impl Registry {
-    pub fn supports_session(&mut self, mode: SessionMode, dest: Sender<Result<(), Error>>) {
+    pub fn supports_session(&mut self, mode: SessionMode, dest: WebXrSender<Result<(), Error>>) {
         let _ = self.sender.send(RegistryMsg::SupportsSession(mode, dest));
         self.waker.wake();
     }
@@ -84,8 +84,8 @@ impl Registry {
         &mut self,
         mode: SessionMode,
         init: SessionInit,
-        dest: Sender<Result<Session, Error>>,
-        animation_frame_handler: Sender<Frame>,
+        dest: WebXrSender<Result<Session, Error>>,
+        animation_frame_handler: WebXrSender<Frame>,
     ) {
         let _ = self.sender.send(RegistryMsg::RequestSession(
             mode,
@@ -99,7 +99,7 @@ impl Registry {
     pub fn simulate_device_connection(
         &mut self,
         init: MockDeviceInit,
-        dest: Sender<Result<Sender<MockDeviceMsg>, Error>>,
+        dest: WebXrSender<Result<WebXrSender<MockDeviceMsg>, Error>>,
     ) {
         let _ = self
             .sender
@@ -113,7 +113,7 @@ impl<GL: 'static + GLTypes> MainThreadRegistry<GL> {
         waker: Box<dyn MainThreadWaker>,
         grand_manager: LayerGrandManager<GL>,
     ) -> Result<Self, Error> {
-        let (sender, receiver) = crate::channel().or(Err(Error::CommunicationError))?;
+        let (sender, receiver) = crate::webxr_channel().or(Err(Error::CommunicationError))?;
         let discoveries = Vec::new();
         let sessions = Vec::new();
         let mocks = Vec::new();
@@ -199,7 +199,7 @@ impl<GL: 'static + GLTypes> MainThreadRegistry<GL> {
         &mut self,
         mode: SessionMode,
         init: SessionInit,
-        raf_sender: Sender<Frame>,
+        raf_sender: WebXrSender<Frame>,
     ) -> Result<Session, Error> {
         for discovery in &mut self.discoveries {
             if discovery.supports_session(mode) {
@@ -225,9 +225,9 @@ impl<GL: 'static + GLTypes> MainThreadRegistry<GL> {
     fn simulate_device_connection(
         &mut self,
         init: MockDeviceInit,
-    ) -> Result<Sender<MockDeviceMsg>, Error> {
+    ) -> Result<WebXrSender<MockDeviceMsg>, Error> {
         for mock in &mut self.mocks {
-            let (sender, receiver) = crate::channel().or(Err(Error::CommunicationError))?;
+            let (sender, receiver) = crate::webxr_channel().or(Err(Error::CommunicationError))?;
             if let Ok(discovery) = mock.simulate_device_connection(init.clone(), receiver) {
                 self.discoveries.insert(0, discovery);
                 return Ok(sender);
@@ -243,9 +243,12 @@ enum RegistryMsg {
     RequestSession(
         SessionMode,
         SessionInit,
-        Sender<Result<Session, Error>>,
-        Sender<Frame>,
+        WebXrSender<Result<Session, Error>>,
+        WebXrSender<Frame>,
+    ),
+    SupportsSession(SessionMode, WebXrSender<Result<(), Error>>),
+    SimulateDeviceConnection(
+        MockDeviceInit,
+        WebXrSender<Result<WebXrSender<MockDeviceMsg>, Error>>,
     ),
-    SupportsSession(SessionMode, Sender<Result<(), Error>>),
-    SimulateDeviceConnection(MockDeviceInit, Sender<Result<Sender<MockDeviceMsg>, Error>>),
 }

components/shared/webxr/session.rs

@@ -11,9 +11,9 @@ use log::warn;
 use serde::{Deserialize, Serialize};
 
 use crate::{
-    channel, ContextId, DeviceAPI, Error, Event, Floor, Frame, FrameUpdateEvent, HitTestId,
-    HitTestSource, InputSource, LayerGrandManager, LayerId, LayerInit, Native, Receiver, Sender,
-    Viewport, Viewports,
+    webxr_channel, ContextId, DeviceAPI, Error, Event, Floor, Frame, FrameUpdateEvent, HitTestId,
+    HitTestSource, InputSource, LayerGrandManager, LayerId, LayerInit, Native, Viewport, Viewports,
+    WebXrReceiver, WebXrSender,
 };
 
 // How long to wait for an rAF.
@@ -89,24 +89,24 @@ pub enum EnvironmentBlendMode {
 #[derive(Debug)]
 #[cfg_attr(feature = "ipc", derive(Serialize, Deserialize))]
 enum SessionMsg {
-    CreateLayer(ContextId, LayerInit, Sender<Result<LayerId, Error>>),
+    CreateLayer(ContextId, LayerInit, WebXrSender<Result<LayerId, Error>>),
     DestroyLayer(ContextId, LayerId),
     SetLayers(Vec<(ContextId, LayerId)>),
-    SetEventDest(Sender<Event>),
+    SetEventDest(WebXrSender<Event>),
     UpdateClipPlanes(/* near */ f32, /* far */ f32),
     StartRenderLoop,
     RenderAnimationFrame,
     RequestHitTest(HitTestSource),
     CancelHitTest(HitTestId),
-    UpdateFrameRate(f32, Sender<f32>),
+    UpdateFrameRate(f32, WebXrSender<f32>),
     Quit,
-    GetBoundsGeometry(Sender<Option<Vec<Point2D<f32, Floor>>>>),
+    GetBoundsGeometry(WebXrSender<Option<Vec<Point2D<f32, Floor>>>>),
 }
 
 #[cfg_attr(feature = "ipc", derive(Serialize, Deserialize))]
 #[derive(Clone)]
 pub struct Quitter {
-    sender: Sender<SessionMsg>,
+    sender: WebXrSender<SessionMsg>,
 }
 
 impl Quitter {
@@ -122,7 +122,7 @@ impl Quitter {
 pub struct Session {
     floor_transform: Option<RigidTransform3D<f32, Native, Floor>>,
     viewports: Viewports,
-    sender: Sender<SessionMsg>,
+    sender: WebXrSender<SessionMsg>,
     environment_blend_mode: EnvironmentBlendMode,
     initial_inputs: Vec<InputSource>,
     granted_features: Vec<String>,
@@ -144,7 +144,7 @@ impl Session {
     }
 
     pub fn reference_space_bounds(&self) -> Option<Vec<Point2D<f32, Floor>>> {
-        let (sender, receiver) = channel().ok()?;
+        let (sender, receiver) = webxr_channel().ok()?;
         let _ = self.sender.send(SessionMsg::GetBoundsGeometry(sender));
         receiver.recv().ok()?
     }
@@ -175,7 +175,7 @@ impl Session {
     }
 
     pub fn create_layer(&self, context_id: ContextId, init: LayerInit) -> Result<LayerId, Error> {
-        let (sender, receiver) = channel().map_err(|_| Error::CommunicationError)?;
+        let (sender, receiver) = webxr_channel().map_err(|_| Error::CommunicationError)?;
         let _ = self
             .sender
             .send(SessionMsg::CreateLayer(context_id, init, sender));
@@ -201,7 +201,7 @@ impl Session {
         let _ = self.sender.send(SessionMsg::UpdateClipPlanes(near, far));
     }
 
-    pub fn set_event_dest(&mut self, dest: Sender<Event>) {
+    pub fn set_event_dest(&mut self, dest: WebXrSender<Event>) {
         let _ = self.sender.send(SessionMsg::SetEventDest(dest));
     }
 
@@ -233,7 +233,7 @@ impl Session {
         let _ = self.sender.send(SessionMsg::CancelHitTest(id));
     }
 
-    pub fn update_frame_rate(&mut self, rate: f32, sender: Sender<f32>) {
+    pub fn update_frame_rate(&mut self, rate: f32, sender: WebXrSender<f32>) {
         let _ = self.sender.send(SessionMsg::UpdateFrameRate(rate, sender));
     }
 
@@ -251,12 +251,12 @@ enum RenderState {
 
 /// For devices that want to do their own thread management, the `SessionThread` type is exposed.
 pub struct SessionThread<Device> {
-    receiver: Receiver<SessionMsg>,
-    sender: Sender<SessionMsg>,
+    receiver: WebXrReceiver<SessionMsg>,
+    sender: WebXrSender<SessionMsg>,
     layers: Vec<(ContextId, LayerId)>,
     pending_layers: Option<Vec<(ContextId, LayerId)>>,
     frame_count: u64,
-    frame_sender: Sender<Frame>,
+    frame_sender: WebXrSender<Frame>,
     running: bool,
     device: Device,
     id: SessionId,
@@ -269,10 +269,10 @@ where
 {
     pub fn new(
         mut device: Device,
-        frame_sender: Sender<Frame>,
+        frame_sender: WebXrSender<Frame>,
         id: SessionId,
     ) -> Result<Self, Error> {
-        let (sender, receiver) = crate::channel().or(Err(Error::CommunicationError))?;
+        let (sender, receiver) = crate::webxr_channel().or(Err(Error::CommunicationError))?;
         device.set_quitter(Quitter {
             sender: sender.clone(),
         });
@@ -440,7 +440,7 @@ where
 /// A type for building XR sessions
 pub struct SessionBuilder<'a, GL> {
     sessions: &'a mut Vec<Box<dyn MainThreadSession>>,
-    frame_sender: Sender<Frame>,
+    frame_sender: WebXrSender<Frame>,
     layer_grand_manager: LayerGrandManager<GL>,
     id: SessionId,
 }
@@ -452,7 +452,7 @@ impl<'a, GL: 'static> SessionBuilder<'a, GL> {
 
     pub(crate) fn new(
         sessions: &'a mut Vec<Box<dyn MainThreadSession>>,
-        frame_sender: Sender<Frame>,
+        frame_sender: WebXrSender<Frame>,
         layer_grand_manager: LayerGrandManager<GL>,
         id: SessionId,
     ) -> Self {
@@ -470,7 +470,7 @@ impl<'a, GL: 'static> SessionBuilder<'a, GL> {
         Factory: 'static + FnOnce(LayerGrandManager<GL>) -> Result<Device, Error> + Send,
         Device: DeviceAPI,
     {
-        let (acks, ackr) = crate::channel().or(Err(Error::CommunicationError))?;
+        let (acks, ackr) = crate::webxr_channel().or(Err(Error::CommunicationError))?;
         let frame_sender = self.frame_sender;
         let layer_grand_manager = self.layer_grand_manager;
         let id = self.id;