switch to using first context in webgl thread

Author: mukilan

components/shared/webxr/layer.rs

@@ -80,7 +80,7 @@ impl<GL: GLTypes> LayerGrandManager<GL> {
 
     pub fn create_layer_manager<F, M>(&self, factory: F) -> Result<LayerManager, Error>
     where
-        F: 'static + Send + FnOnce(&mut dyn GLContexts<GL>) -> Result<M, Error>,
+        F: 'static + Send + FnOnce(&GL::Device, &mut dyn GLContexts<GL>) -> Result<M, Error>,
         M: 'static + LayerManagerAPI<GL>,
     {
         self.0
@@ -172,7 +172,13 @@ impl Drop for LayerManager {
 
 #[allow(clippy::type_complexity)]
 pub struct LayerManagerFactory<GL: GLTypes>(
-    Box<dyn Send + FnOnce(&mut dyn GLContexts<GL>) -> Result<Box<dyn LayerManagerAPI<GL>>, Error>>,
+    Box<
+        dyn Send
+            + FnOnce(
+                &GL::Device,
+                &mut dyn GLContexts<GL>,
+            ) -> Result<Box<dyn LayerManagerAPI<GL>>, Error>,
+    >,
 );
 
 impl<GL: GLTypes> Debug for LayerManagerFactory<GL> {
@@ -184,17 +190,20 @@ impl<GL: GLTypes> Debug for LayerManagerFactory<GL> {
 impl<GL: GLTypes> LayerManagerFactory<GL> {
     pub fn new<F, M>(factory: F) -> LayerManagerFactory<GL>
     where
-        F: 'static + Send + FnOnce(&mut dyn GLContexts<GL>) -> Result<M, Error>,
+        F: 'static + Send + FnOnce(&GL::Device, &mut dyn GLContexts<GL>) -> Result<M, Error>,
         M: 'static + LayerManagerAPI<GL>,
     {
-        LayerManagerFactory(Box::new(move |contexts| Ok(Box::new(factory(contexts)?))))
+        LayerManagerFactory(Box::new(move |device, contexts| {
+            Ok(Box::new(factory(device, contexts)?))
+        }))
     }
 
     pub fn build(
         self,
+        device: &GL::Device,
         contexts: &mut dyn GLContexts<GL>,
     ) -> Result<Box<dyn LayerManagerAPI<GL>>, Error> {
-        (self.0)(contexts)
+        (self.0)(device, contexts)
     }
 }
 

components/webgl/webgl_thread.rs

@@ -415,7 +415,14 @@ impl WebGLThread {
         };
         match command {
             WebXRCommand::CreateLayerManager(sender) => {
-                let result = webxr_bridge.create_layer_manager(self);
+                let device = self
+                    .device_map
+                    .iter()
+                    .next()
+                    .expect("No devices registered with WebGL thread")
+                    .1
+                    .clone();
+                let result = webxr_bridge.create_layer_manager(&device, self);
                 let _ = sender.send(result);
             },
             WebXRCommand::DestroyLayerManager(manager_id) => {

components/webgl/webxr.rs

@@ -47,13 +47,14 @@ impl WebXRBridge {
 impl WebXRBridge {
     pub(crate) fn create_layer_manager(
         &mut self,
+        device: &Rc<Device>,
         contexts: &mut dyn WebXRContexts<WebXRSurfman>,
     ) -> Result<WebXRLayerManagerId, WebXRError> {
         let factory = self
             .factory_receiver
             .recv()
             .map_err(|_| WebXRError::CommunicationError)?;
-        let manager = factory.build(contexts)?;
+        let manager = factory.build(device, contexts)?;
         let manager_id = WebXRLayerManagerId::new(self.next_manager_id);
         self.next_manager_id = self
             .next_manager_id

components/webxr/glwindow/mod.rs

@@ -465,9 +465,9 @@ impl GlWindowDevice {
         }
         let swap_chains = self.swap_chains.clone();
         let viewports = self.viewports();
-        let layer_manager = self
-            .grand_manager
-            .create_layer_manager(move |_| Ok(SurfmanLayerManager::new(viewports, swap_chains)))?;
+        let layer_manager = self.grand_manager.create_layer_manager(move |_, _| {
+            Ok(SurfmanLayerManager::new(viewports, swap_chains))
+        })?;
         self.layer_manager = Some(layer_manager);
         Ok(self.layer_manager.as_mut().unwrap())
     }

components/webxr/headless/mod.rs

@@ -213,9 +213,9 @@ impl HeadlessDevice {
         }
         let swap_chains = SwapChains::new();
         let viewports = self.viewports();
-        let layer_manager = self
-            .grand_manager
-            .create_layer_manager(move |_| Ok(SurfmanLayerManager::new(viewports, swap_chains)))?;
+        let layer_manager = self.grand_manager.create_layer_manager(move |_, _| {
+            Ok(SurfmanLayerManager::new(viewports, swap_chains))
+        })?;
         self.layer_manager = Some(layer_manager);
         Ok(self.layer_manager.as_mut().unwrap())
     }

components/webxr/openxr/graphics.rs

@@ -15,6 +15,7 @@ pub trait GraphicsProviderMethods<G: Graphics> {
     fn enable_graphics_extensions(exts: &mut ExtensionSet);
     fn pick_format(formats: &[u32]) -> u32;
     fn create_session(
+        device: &SurfmanDevice,
         instance: &Instance,
         system: SystemId,
     ) -> Result<(Session<G>, FrameWaiter, FrameStream<G>), Error>;

components/webxr/openxr/graphics_d3d11.rs

@@ -11,8 +11,8 @@ use openxr::{
     ExtensionSet, FormFactor, FrameStream, FrameWaiter, Graphics, Instance, Session, SystemId,
 };
 use surfman::{
-    Adapter as SurfmanAdapter, Connection as SurfmanConnection, Context as SurfmanContext,
-    Device as SurfmanDevice, Error as SurfmanError, SurfaceTexture,
+    Adapter as SurfmanAdapter, Context as SurfmanContext, Device as SurfmanDevice,
+    Error as SurfmanError, SurfaceTexture,
 };
 use webxr_api::Error;
 use winapi::Interface;
@@ -50,20 +50,23 @@ impl GraphicsProviderMethods<D3D11> for GraphicsProvider {
     }
 
     fn create_session(
+        device: &SurfmanDevice,
         instance: &Instance,
         system: SystemId,
     ) -> Result<(Session<D3D11>, FrameWaiter, FrameStream<D3D11>), Error> {
-        // FIXME: We should ensure that the OpenXR runtime's texture will be shareable with
-        // surfman's surfaces by validating the requirements of the XR runtime and ensuring that
-        // the WebGL context can use the same device when `makeXRCompatible` is called.
-        let adapter = create_surfman_adapter(instance).ok_or(Error::NoMatchingDevice)?;
-        let connection = SurfmanConnection::new().map_err(|_| Error::NoMatchingDevice)?;
-        let device = connection
-            .create_device(&adapter)
-            .map_err(|_| Error::NoMatchingDevice)?;
+        // Get the current surfman device and extract its D3D device. This will ensure
+        // that the OpenXR runtime's texture will be shareable with surfman's surfaces.
         let native_device = device.native_device();
         let d3d_device = native_device.d3d11_device;
 
+        // FIXME: we should be using these graphics requirements to drive the actual
+        //        d3d device creation, rather than assuming the device that surfman
+        //        already created is appropriate. OpenXR returns a validation error
+        //        unless we call this method, so we call it and ignore the results
+        //        in the short term.
+        let _requirements = D3D11::requirements(instance, system)
+            .map_err(|e| Error::BackendSpecific(format!("D3D11::requirements {:?}", e)))?;
+
         unsafe {
             instance
                 .create_session::<D3D11>(

components/webxr/openxr/mod.rs

@@ -840,9 +840,9 @@ impl OpenXrDevice {
         let shared_data_clone = shared_data.clone();
         let mut data = shared_data.lock().unwrap();
 
-        let layer_manager = grand_manager.create_layer_manager(move |_| {
+        let layer_manager = grand_manager.create_layer_manager(move |device, _| {
             let (session, frame_waiter, frame_stream) =
-                GraphicsProvider::create_session(&instance_clone, system)?;
+                GraphicsProvider::create_session(&*device, &instance_clone, system)?;
             let (passthrough, passthrough_layer) = if supports_passthrough {
                 let flags = PassthroughFlagsFB::IS_RUNNING_AT_CREATION;
                 let purpose = PassthroughLayerPurposeFB::RECONSTRUCTION;