Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-08-03 04:30:10 +01:00
Code Issues Projects Releases Packages Wiki Activity

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

Browse source 
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>
This commit is contained in:
Martin Robinson 2025-02-05 22:10:17 +01:00 • committed by GitHub
parent eb0382449f
commit 1e5db41afd
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
9 changed files with 77 additions and 70 deletions
Download patch file Download diff file Expand all files Collapse all files

6
components/shared/webxr/device.rs
View file

@ -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);

7
components/shared/webxr/events.rs
View file

@ -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);

17
components/shared/webxr/lib.rs
View file

@ -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

8
components/shared/webxr/mock.rs
View file

@ -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,
}

41
components/shared/webxr/registry.rs
View file

@ -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>>),
}

42
components/shared/webxr/session.rs
View file

@ -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;

10
components/webxr/glwindow/mod.rs
View file

@ -18,10 +18,10 @@ use surfman::{
use webxr_api::util::ClipPlanes;
use webxr_api::{
ContextId, DeviceAPI, DiscoveryAPI, Display, Error, Event, EventBuffer, Floor, Frame,
InputSource, LayerGrandManager, LayerId, LayerInit, LayerManager, Native, Quitter, Sender,
Session, SessionBuilder, SessionInit, SessionMode, SomeEye, View, Viewer, ViewerPose, Viewport,
Viewports, Views, CUBE_BACK, CUBE_BOTTOM, CUBE_LEFT, CUBE_RIGHT, CUBE_TOP, LEFT_EYE, RIGHT_EYE,
VIEWER,
InputSource, LayerGrandManager, LayerId, LayerInit, LayerManager, Native, Quitter, Session,
SessionBuilder, SessionInit, SessionMode, SomeEye, View, Viewer, ViewerPose, Viewport,
Viewports, Views, WebXrSender, CUBE_BACK, CUBE_BOTTOM, CUBE_LEFT, CUBE_RIGHT, CUBE_TOP,
LEFT_EYE, RIGHT_EYE, VIEWER,
};
use crate::{SurfmanGL, SurfmanLayerManager};
@ -305,7 +305,7 @@ impl DeviceAPI for GlWindowDevice {
vec![]
}
fn set_event_dest(&mut self, dest: Sender<Event>) {
fn set_event_dest(&mut self, dest: WebXrSender<Event>) {
self.events.upgrade(dest)
}

10
components/webxr/headless/mod.rs
View file

@ -13,8 +13,8 @@ use webxr_api::{
Frame, FrameUpdateEvent, HitTestId, HitTestResult, HitTestSource, Input, InputFrame, InputId,
InputSource, LayerGrandManager, LayerId, LayerInit, LayerManager, MockButton, MockDeviceInit,
MockDeviceMsg, MockDiscoveryAPI, MockInputMsg, MockViewInit, MockViewsInit, MockWorld, Native,
Quitter, Ray, Receiver, SelectEvent, SelectKind, Sender, Session, SessionBuilder, SessionInit,
SessionMode, Space, SubImages, View, Viewer, ViewerPose, Viewports, Views,
Quitter, Ray, SelectEvent, SelectKind, Session, SessionBuilder, SessionInit, SessionMode,
Space, SubImages, View, Viewer, ViewerPose, Viewports, Views, WebXrReceiver, WebXrSender,
};
use crate::{SurfmanGL, SurfmanLayerManager};
@ -74,7 +74,7 @@ impl MockDiscoveryAPI<SurfmanGL> for HeadlessMockDiscovery {
fn simulate_device_connection(
&mut self,
init: MockDeviceInit,
receiver: Receiver<MockDeviceMsg>,
receiver: WebXrReceiver<MockDeviceMsg>,
) -> Result<Box<dyn DiscoveryAPI<SurfmanGL>>, Error> {
let viewer_origin = init.viewer_origin;
let floor_transform = init.floor_origin.map(|f| f.inverse());
@ -107,7 +107,7 @@ impl MockDiscoveryAPI<SurfmanGL> for HeadlessMockDiscovery {
}
}
fn run_loop(receiver: Receiver<MockDeviceMsg>, data: Arc<Mutex<HeadlessDeviceData>>) {
fn run_loop(receiver: WebXrReceiver<MockDeviceMsg>, data: Arc<Mutex<HeadlessDeviceData>>) {
while let Ok(msg) = receiver.recv() {
if !data.lock().expect("Mutex poisoned").handle_msg(msg) {
break;
@ -283,7 +283,7 @@ impl DeviceAPI for HeadlessDevice {
vec![]
}
fn set_event_dest(&mut self, dest: Sender<Event>) {
fn set_event_dest(&mut self, dest: WebXrSender<Event>) {
self.with_per_session(|s| s.events.upgrade(dest))
}

6
components/webxr/openxr/mod.rs
View file

@ -29,9 +29,9 @@ use webxr_api::util::{self, ClipPlanes};
use webxr_api::{
BaseSpace, Capture, ContextId, DeviceAPI, DiscoveryAPI, Display, Error, Event, EventBuffer,
Floor, Frame, GLContexts, InputId, InputSource, LayerGrandManager, LayerId, LayerInit,
LayerManager, LayerManagerAPI, LeftEye, Native, Quitter, RightEye, SelectKind, Sender,
LayerManager, LayerManagerAPI, LeftEye, Native, Quitter, RightEye, SelectKind,
Session as WebXrSession, SessionBuilder, SessionInit, SessionMode, SubImage, SubImages, View,
ViewerPose, Viewport, Viewports, Views, Visibility,
ViewerPose, Viewport, Viewports, Views, Visibility, WebXrSender,
};
use crate::gl_utils::GlClearer;
@ -1421,7 +1421,7 @@ impl DeviceAPI for OpenXrDevice {
]
}
fn set_event_dest(&mut self, dest: Sender<Event>) {
fn set_event_dest(&mut self, dest: WebXrSender<Event>) {
self.events.upgrade(dest)
}