script/dom/webxr/
xrtest.rs

1/* This Source Code Form is subject to the terms of the Mozilla Public
2 * License, v. 2.0. If a copy of the MPL was not distributed with this
3 * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
4
5/* This Source Code Form is subject to the terms of the Mozilla Public
6 * License, v. 2.0. If a copy of the MPL was not distributed with this
7 * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
8
9use std::rc::Rc;
10
11use dom_struct::dom_struct;
12use ipc_channel::ipc::IpcSender;
13use ipc_channel::router::ROUTER;
14use js::jsval::JSVal;
15use profile_traits::ipc;
16use webxr_api::{self, Error as XRError, MockDeviceInit, MockDeviceMsg};
17
18use crate::ScriptThread;
19use crate::dom::bindings::callback::ExceptionHandling;
20use crate::dom::bindings::cell::DomRefCell;
21use crate::dom::bindings::codegen::Bindings::FunctionBinding::Function;
22use crate::dom::bindings::codegen::Bindings::XRSystemBinding::XRSessionMode;
23use crate::dom::bindings::codegen::Bindings::XRTestBinding::{FakeXRDeviceInit, XRTestMethods};
24use crate::dom::bindings::refcounted::{Trusted, TrustedPromise};
25use crate::dom::bindings::reflector::{DomGlobal, Reflector, reflect_dom_object};
26use crate::dom::bindings::root::{Dom, DomRoot};
27use crate::dom::fakexrdevice::{FakeXRDevice, get_origin, get_views, get_world};
28use crate::dom::globalscope::GlobalScope;
29use crate::dom::promise::Promise;
30use crate::script_runtime::CanGc;
31
32#[dom_struct]
33pub(crate) struct XRTest {
34    reflector: Reflector,
35    devices_connected: DomRefCell<Vec<Dom<FakeXRDevice>>>,
36}
37
38impl XRTest {
39    pub(crate) fn new_inherited() -> XRTest {
40        XRTest {
41            reflector: Reflector::new(),
42            devices_connected: DomRefCell::new(vec![]),
43        }
44    }
45
46    pub(crate) fn new(global: &GlobalScope, can_gc: CanGc) -> DomRoot<XRTest> {
47        reflect_dom_object(Box::new(XRTest::new_inherited()), global, can_gc)
48    }
49
50    fn device_obtained(
51        &self,
52        response: Result<IpcSender<MockDeviceMsg>, XRError>,
53        trusted: TrustedPromise,
54        can_gc: CanGc,
55    ) {
56        let promise = trusted.root();
57        if let Ok(sender) = response {
58            let device = FakeXRDevice::new(&self.global(), sender, CanGc::note());
59            self.devices_connected
60                .borrow_mut()
61                .push(Dom::from_ref(&device));
62            promise.resolve_native(&device, can_gc);
63        } else {
64            promise.reject_native(&(), can_gc);
65        }
66    }
67}
68
69impl XRTestMethods<crate::DomTypeHolder> for XRTest {
70    /// <https://github.com/immersive-web/webxr-test-api/blob/master/explainer.md>
71    fn SimulateDeviceConnection(&self, init: &FakeXRDeviceInit, can_gc: CanGc) -> Rc<Promise> {
72        let global = self.global();
73        let p = Promise::new(&global, can_gc);
74
75        let origin = if let Some(ref o) = init.viewerOrigin {
76            match get_origin(o) {
77                Ok(origin) => Some(origin),
78                Err(e) => {
79                    p.reject_error(e, can_gc);
80                    return p;
81                },
82            }
83        } else {
84            None
85        };
86
87        let floor_origin = if let Some(ref o) = init.floorOrigin {
88            match get_origin(o) {
89                Ok(origin) => Some(origin),
90                Err(e) => {
91                    p.reject_error(e, can_gc);
92                    return p;
93                },
94            }
95        } else {
96            None
97        };
98
99        let views = match get_views(&init.views) {
100            Ok(views) => views,
101            Err(e) => {
102                p.reject_error(e, can_gc);
103                return p;
104            },
105        };
106
107        let supported_features = if let Some(ref s) = init.supportedFeatures {
108            s.iter().cloned().map(String::from).collect()
109        } else {
110            vec![]
111        };
112
113        let world = if let Some(ref w) = init.world {
114            let w = match get_world(w) {
115                Ok(w) => w,
116                Err(e) => {
117                    p.reject_error(e, can_gc);
118                    return p;
119                },
120            };
121            Some(w)
122        } else {
123            None
124        };
125
126        let (mut supports_inline, mut supports_vr, mut supports_ar) = (false, false, false);
127
128        if let Some(ref modes) = init.supportedModes {
129            for mode in modes {
130                match mode {
131                    XRSessionMode::Immersive_vr => supports_vr = true,
132                    XRSessionMode::Immersive_ar => supports_ar = true,
133                    XRSessionMode::Inline => supports_inline = true,
134                }
135            }
136        }
137
138        let init = MockDeviceInit {
139            viewer_origin: origin,
140            views,
141            supports_inline,
142            supports_vr,
143            supports_ar,
144            floor_origin,
145            supported_features,
146            world,
147        };
148
149        let global = self.global();
150        let this = Trusted::new(self);
151        let mut trusted = Some(TrustedPromise::new(p.clone()));
152
153        let task_source = global
154            .task_manager()
155            .dom_manipulation_task_source()
156            .to_sendable();
157        let (sender, receiver) = ipc::channel(global.time_profiler_chan().clone()).unwrap();
158
159        ROUTER.add_typed_route(
160            receiver.to_ipc_receiver(),
161            Box::new(move |message| {
162                let trusted = trusted
163                    .take()
164                    .expect("SimulateDeviceConnection callback called twice");
165                let this = this.clone();
166                let message =
167                    message.expect("SimulateDeviceConnection callback given incorrect payload");
168
169                task_source.queue(task!(request_session: move || {
170                    this.root().device_obtained(message, trusted, CanGc::note());
171                }));
172            }),
173        );
174        if let Some(mut r) = global.as_window().webxr_registry() {
175            r.simulate_device_connection(init, sender);
176        }
177
178        p
179    }
180
181    /// <https://github.com/immersive-web/webxr-test-api/blob/master/explainer.md>
182    fn SimulateUserActivation(&self, f: Rc<Function>, can_gc: CanGc) {
183        let _guard = ScriptThread::user_interacting_guard();
184        rooted!(in(*GlobalScope::get_cx()) let mut value: JSVal);
185        let _ = f.Call__(
186            vec![],
187            value.handle_mut(),
188            ExceptionHandling::Rethrow,
189            can_gc,
190        );
191    }
192
193    /// <https://github.com/immersive-web/webxr-test-api/blob/master/explainer.md>
194    fn DisconnectAllDevices(&self, can_gc: CanGc) -> Rc<Promise> {
195        // XXXManishearth implement device disconnection and session ending
196        let global = self.global();
197        let p = Promise::new(&global, can_gc);
198        let mut devices = self.devices_connected.borrow_mut();
199        if devices.is_empty() {
200            p.resolve_native(&(), can_gc);
201        } else {
202            let mut len = devices.len();
203
204            let (sender, receiver) = ipc::channel(global.time_profiler_chan().clone()).unwrap();
205            let mut rooted_devices: Vec<_> =
206                devices.iter().map(|x| DomRoot::from_ref(&**x)).collect();
207            devices.clear();
208
209            let mut trusted = Some(TrustedPromise::new(p.clone()));
210            let task_source = global
211                .task_manager()
212                .dom_manipulation_task_source()
213                .to_sendable();
214
215            ROUTER.add_typed_route(
216                receiver.to_ipc_receiver(),
217                Box::new(move |_| {
218                    len -= 1;
219                    if len == 0 {
220                        let trusted = trusted
221                            .take()
222                            .expect("DisconnectAllDevices disconnected more devices than expected");
223                        task_source.queue(trusted.resolve_task(()));
224                    }
225                }),
226            );
227
228            for device in rooted_devices.drain(..) {
229                device.disconnect(sender.clone());
230            }
231        };
232        p
233    }
234}
script/dom/webxr/xrtest.rs

script/dom/webxr/
xrtest.rs
