Update test API, hook it up to webxr mocking

components/script/dom/xrtest.rs

@@ -9,15 +9,21 @@
 use crate::dom::bindings::codegen::Bindings::XRTestBinding::{
     self, FakeXRDeviceInit, XRTestMethods,
 };
+use crate::dom::bindings::refcounted::{Trusted, TrustedPromise};
 use crate::dom::bindings::reflector::{reflect_dom_object, DomObject, Reflector};
 use crate::dom::bindings::root::DomRoot;
 use crate::dom::fakexrdevice::{get_origin, get_views, FakeXRDevice};
 use crate::dom::globalscope::GlobalScope;
 use crate::dom::promise::Promise;
+use crate::task_source::TaskSource;
 use dom_struct::dom_struct;
+use euclid::TypedRigidTransform3D;
+use ipc_channel::ipc::IpcSender;
+use ipc_channel::router::ROUTER;
+use profile_traits::ipc;
 use std::cell::Cell;
 use std::rc::Rc;
-use webvr_traits::{MockVRInit, WebVRMsg};
+use webxr_api::{self, Error as XRError, MockDeviceInit, MockDeviceMsg};
 
 #[dom_struct]
 pub struct XRTest {
@@ -40,11 +46,39 @@ impl XRTest {
             XRTestBinding::Wrap,
         )
     }
+
+    fn device_obtained(
+        &self,
+        response: Result<IpcSender<MockDeviceMsg>, XRError>,
+        trusted: TrustedPromise,
+    ) {
+        let promise = trusted.root();
+        if let Ok(sender) = response {
+            let device = FakeXRDevice::new(&self.global(), sender);
+            promise.resolve_native(&device);
+        } else {
+            promise.reject_native(&());
+        }
+    }
 }
 
 impl XRTestMethods for XRTest {
     /// https://github.com/immersive-web/webxr-test-api/blob/master/explainer.md
     fn SimulateDeviceConnection(&self, init: &FakeXRDeviceInit) -> Rc<Promise> {
+        #[derive(serde::Serialize, serde::Deserialize)]
+        pub struct MockDevice {
+            sender: IpcSender<Result<IpcSender<MockDeviceMsg>, XRError>>,
+        }
+
+        #[typetag::serde]
+        impl webxr_api::MockDeviceCallback for MockDevice {
+            fn callback(&mut self, result: Result<IpcSender<MockDeviceMsg>, XRError>) {
+                self.sender
+                    .send(result)
+                    .expect("mock device callback failed");
+            }
+        }
+
         let p = Promise::new(&self.global());
 
         if !init.supportsImmersive || self.session_started.get() {
@@ -61,7 +95,19 @@ impl XRTestMethods for XRTest {
                 },
             }
         } else {
-            Default::default()
+            TypedRigidTransform3D::identity()
+        };
+
+        let floor_origin = if let Some(ref o) = init.floorOrigin {
+            match get_origin(&o) {
+                Ok(origin) => origin,
+                Err(e) => {
+                    p.reject_error(e);
+                    return p;
+                },
+            }
+        } else {
+            TypedRigidTransform3D::identity()
         };
 
         let views = match get_views(&init.views) {
@@ -72,20 +118,47 @@ impl XRTestMethods for XRTest {
             },
         };
 
-        let init = MockVRInit {
-            viewer_origin: Some(origin),
-            views: Some(views),
-            eye_level: None,
+        let init = MockDeviceInit {
+            viewer_origin: origin,
+            views,
+            supports_immersive: init.supportsImmersive,
+            supports_unbounded: init.supportsUnbounded,
+            floor_origin,
         };
 
         self.session_started.set(true);
-        self.global()
-            .as_window()
-            .webvr_thread()
-            .unwrap()
-            .send(WebVRMsg::CreateMockDisplay(init))
-            .unwrap();
-        p.resolve_native(&FakeXRDevice::new(&self.global()));
+
+        let global = self.global();
+        let window = global.as_window();
+        let this = Trusted::new(self);
+        let mut trusted = Some(TrustedPromise::new(p.clone()));
+
+        let (task_source, canceller) = window
+            .task_manager()
+            .dom_manipulation_task_source_with_canceller();
+        let (sender, receiver) = ipc::channel(global.time_profiler_chan().clone()).unwrap();
+        ROUTER.add_route(
+            receiver.to_opaque(),
+            Box::new(move |message| {
+                let trusted = trusted
+                    .take()
+                    .expect("SimulateDeviceConnection callback called twice");
+                let this = this.clone();
+                let message = message
+                    .to()
+                    .expect("SimulateDeviceConnection callback given incorrect payload");
+
+                let _ = task_source.queue_with_canceller(
+                    task!(request_session: move || {
+                        this.root().device_obtained(message, trusted);
+                    }),
+                    &canceller,
+                );
+            }),
+        );
+        window
+            .webxr_registry()
+            .simulate_device_connection(init, MockDevice { sender });
 
         p
     }