Add inlineVerticalFieldOfView support

components/script/dom/webidls/XRRenderState.webidl

@@ -7,11 +7,13 @@
 dictionary XRRenderStateInit {
   double depthNear;
   double depthFar;
+  double inlineVerticalFieldOfView;
   XRWebGLLayer baseLayer;
 };
 
 [SecureContext, Exposed=Window, Pref="dom.webxr.enabled"] interface XRRenderState {
   readonly attribute double depthNear;
   readonly attribute double depthFar;
+  readonly attribute double inlineVerticalFieldOfView;
   readonly attribute XRWebGLLayer? baseLayer;
 };

components/script/dom/xrrenderstate.rs

@@ -17,6 +17,7 @@ pub struct XRRenderState {
     reflector_: Reflector,
     depth_near: Cell<f64>,
     depth_far: Cell<f64>,
+    inline_vertical_fov: Cell<f64>,
     layer: MutNullableDom<XRWebGLLayer>,
 }
 
@@ -24,12 +25,14 @@ impl XRRenderState {
     pub fn new_inherited(
         depth_near: f64,
         depth_far: f64,
+        inline_vertical_fov: f64,
         layer: Option<&XRWebGLLayer>,
     ) -> XRRenderState {
         XRRenderState {
             reflector_: Reflector::new(),
             depth_near: Cell::new(depth_near),
             depth_far: Cell::new(depth_far),
+            inline_vertical_fov: Cell::new(inline_vertical_fov),
             layer: MutNullableDom::new(layer),
         }
     }
@@ -38,10 +41,16 @@ impl XRRenderState {
         global: &GlobalScope,
         depth_near: f64,
         depth_far: f64,
+        inline_vertical_fov: f64,
         layer: Option<&XRWebGLLayer>,
     ) -> DomRoot<XRRenderState> {
         reflect_dom_object(
-            Box::new(XRRenderState::new_inherited(depth_near, depth_far, layer)),
+            Box::new(XRRenderState::new_inherited(
+                depth_near,
+                depth_far,
+                inline_vertical_fov,
+                layer,
+            )),
             global,
             XRRenderStateBinding::Wrap,
         )
@@ -52,6 +61,7 @@ impl XRRenderState {
             &self.global(),
             self.depth_near.get(),
             self.depth_far.get(),
+            self.inline_vertical_fov.get(),
             self.layer.get().as_ref().map(|x| &**x),
         )
     }
@@ -62,6 +72,9 @@ impl XRRenderState {
     pub fn set_depth_far(&self, depth: f64) {
         self.depth_far.set(depth)
     }
+    pub fn set_inline_vertical_fov(&self, fov: f64) {
+        self.inline_vertical_fov.set(fov)
+    }
     pub fn set_layer(&self, layer: Option<&XRWebGLLayer>) {
         self.layer.set(layer)
     }
@@ -78,6 +91,11 @@ impl XRRenderStateMethods for XRRenderState {
         Finite::wrap(self.depth_far.get())
     }
 
+    /// https://immersive-web.github.io/webxr/#dom-xrrenderstate-inlineverticalfieldofview
+    fn InlineVerticalFieldOfView(&self) -> Finite<f64> {
+        Finite::wrap(self.inline_vertical_fov.get())
+    }
+
     /// https://immersive-web.github.io/webxr/#dom-xrrenderstate-baselayer
     fn GetBaseLayer(&self) -> Option<DomRoot<XRWebGLLayer>> {
         self.layer.get()

components/script/dom/xrsession.rs

@@ -112,7 +112,8 @@ impl XRSession {
     }
 
     pub fn new(global: &GlobalScope, session: Session, mode: XRSessionMode) -> DomRoot<XRSession> {
-        let render_state = XRRenderState::new(global, 0.1, 1000.0, None);
+        use std::f64::consts::FRAC_PI_2;
+        let render_state = XRRenderState::new(global, 0.1, 1000.0, FRAC_PI_2, None);
         let input_sources = XRInputSourceArray::new(global);
         let ret = reflect_dom_object(
             Box::new(XRSession::new_inherited(
@@ -399,9 +400,10 @@ impl XRSessionMethods for XRSession {
             }
         }
 
-        // XXXManishearth step 4:
+        // Step 4:
-        // If newState’s inlineVerticalFieldOfView is set and session is an
+        if init.inlineVerticalFieldOfView.is_some() {
-        // immersive session, throw an InvalidStateError and abort these steps.
+            return Err(Error::InvalidState);
+        }
 
         let pending = self
             .pending_render_state
@@ -412,6 +414,9 @@ impl XRSessionMethods for XRSession {
         if let Some(far) = init.depthFar {
             pending.set_depth_far(*far);
         }
+        if let Some(fov) = init.inlineVerticalFieldOfView {
+            pending.set_inline_vertical_fov(*fov);
+        }
         if let Some(ref layer) = init.baseLayer {
             pending.set_layer(Some(&layer))
         }
@@ -421,7 +426,6 @@ impl XRSessionMethods for XRSession {
                 .borrow_mut()
                 .update_clip_planes(*pending.DepthNear() as f32, *pending.DepthFar() as f32);
         }
-        // XXXManishearth handle inlineVerticalFieldOfView
         Ok(())
     }