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

Auto merge of #23814 - Manishearth:events, r=asajeffrey

Browse source 
Partial support for events in WebXR

Needs https://github.com/servo/webxr/pull/20

r? @asajeffrey

<!-- Reviewable:start -->
---
This change is [<img src="https://reviewable.io/review_button.svg" height="34" align="absmiddle" alt="Reviewable"/>](https://reviewable.io/reviews/servo/servo/23814)
<!-- Reviewable:end -->
This commit is contained in:
bors-servo 2019-07-23 09:44:59 -04:00 • committed by GitHub
commit 7afe2153e8
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
19 changed files with 299 additions and 108 deletions
Download patch file Download diff file Expand all files Collapse all files

4
components/script/dom/fakexrdevice.rs
View file

@ -38,6 +38,10 @@ impl FakeXRDevice {
FakeXRDeviceBinding::Wrap,
)
}
pub fn disconnect(&self, sender: IpcSender<()>) {
let _ = self.sender.send(MockDeviceMsg::Disconnect(sender));
}
}
pub fn get_views(views: &[FakeXRViewInit]) -> Fallible<Views> {

2
components/script/dom/mod.rs
View file

@ -547,12 +547,12 @@ pub mod xmlserializer;
pub mod xr;
pub mod xrframe;
pub mod xrinputsource;
pub mod xrlayer;
pub mod xrpose;
pub mod xrreferencespace;
pub mod xrrenderstate;
pub mod xrrigidtransform;
pub mod xrsession;
pub mod xrsessionevent;
pub mod xrspace;
pub mod xrtest;
pub mod xrview;

8
components/script/dom/webidls/XRLayer.webidl
View file

@ -1,8 +0,0 @@
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at https://mozilla.org/MPL/2.0/. */
// https://immersive-web.github.io/webxr/#xrlayer-interface
[SecureContext, Exposed=Window, Pref="dom.webxr.enabled"]
interface XRLayer {};

4
components/script/dom/webidls/XRRenderState.webidl
View file

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

4
components/script/dom/webidls/XRSession.webidl
View file

@ -29,7 +29,7 @@ interface XRSession : EventTarget {
// FrozenArray<XRInputSource> getInputSources();
sequence<XRInputSource> getInputSources();
void updateRenderState(optional XRRenderStateInit state = {});
[Throws] void updateRenderState(optional XRRenderStateInit state = {});
long requestAnimationFrame(XRFrameRequestCallback callback);
void cancelAnimationFrame(long handle);
@ -38,7 +38,7 @@ interface XRSession : EventTarget {
// // Events
// attribute EventHandler onblur;
// attribute EventHandler onfocus;
// attribute EventHandler onend;
attribute EventHandler onend;
// attribute EventHandler onselect;
// attribute EventHandler oninputsourceschange;
// attribute EventHandler onselectstart;

15
components/script/dom/webidls/XRSessionEvent.webidl Normal file
View file

@ -0,0 +1,15 @@
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at https://mozilla.org/MPL/2.0/. */
// https://immersive-web.github.io/webxr/#xrsessionevent-interface
[SecureContext, Exposed=Window, Pref="dom.webxr.enabled", Constructor
(DOMString type, XRSessionEventInit eventInitDict)]
interface XRSessionEvent : Event {
[SameObject] readonly attribute XRSession session;
};
dictionary XRSessionEventInit : EventInit {
required XRSession session;
};

2
components/script/dom/webidls/XRWebGLLayer.webidl
View file

@ -21,7 +21,7 @@ dictionary XRWebGLLayerInit {
XRWebGLRenderingContext context,
optional XRWebGLLayerInit layerInit = {}),
Pref="dom.webxr.enabled"]
interface XRWebGLLayer : XRLayer {
interface XRWebGLLayer {
// // Attributes
readonly attribute XRWebGLRenderingContext context;

11
components/script/dom/xr.rs
View file

@ -76,6 +76,17 @@ impl XR {
self.pending_immersive_session.set(false);
self.active_immersive_session.set(Some(session))
}
/// https://immersive-web.github.io/webxr/#ref-for-eventdef-xrsession-end
pub fn end_session(&self, session: &XRSession) {
// Step 3
if let Some(active) = self.active_immersive_session.get() {
if Dom::from_ref(&*active) == Dom::from_ref(session) {
self.active_immersive_session.set(None);
}
}
// XXXManishearth when we support inline sessions we should remove them too
}
}
impl Drop for XR {

19
components/script/dom/xrlayer.rs
View file

@ -1,19 +0,0 @@
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at https://mozilla.org/MPL/2.0/. */
use crate::dom::bindings::reflector::Reflector;
use dom_struct::dom_struct;
#[dom_struct]
pub struct XRLayer {
reflector_: Reflector,
}
impl XRLayer {
pub fn new_inherited() -> XRLayer {
XRLayer {
reflector_: Reflector::new(),
}
}
}

12
components/script/dom/xrrenderstate.rs
View file

@ -7,7 +7,7 @@ use crate::dom::bindings::num::Finite;
use crate::dom::bindings::reflector::{reflect_dom_object, DomObject, Reflector};
use crate::dom::bindings::root::{DomRoot, MutNullableDom};
use crate::dom::globalscope::GlobalScope;
use crate::dom::xrlayer::XRLayer;
use crate::dom::xrwebgllayer::XRWebGLLayer;
use dom_struct::dom_struct;
use std::cell::Cell;
@ -17,14 +17,14 @@ pub struct XRRenderState {
reflector_: Reflector,
depth_near: Cell<f64>,
depth_far: Cell<f64>,
layer: MutNullableDom<XRLayer>,
layer: MutNullableDom<XRWebGLLayer>,
}
impl XRRenderState {
pub fn new_inherited(
depth_near: f64,
depth_far: f64,
layer: Option<&XRLayer>,
layer: Option<&XRWebGLLayer>,
) -> XRRenderState {
XRRenderState {
reflector_: Reflector::new(),
@ -38,7 +38,7 @@ impl XRRenderState {
global: &GlobalScope,
depth_near: f64,
depth_far: f64,
layer: Option<&XRLayer>,
layer: Option<&XRWebGLLayer>,
) -> DomRoot<XRRenderState> {
reflect_dom_object(
Box::new(XRRenderState::new_inherited(depth_near, depth_far, layer)),
@ -62,7 +62,7 @@ impl XRRenderState {
pub fn set_depth_far(&self, depth: f64) {
self.depth_far.set(depth)
}
pub fn set_layer(&self, layer: Option<&XRLayer>) {
pub fn set_layer(&self, layer: Option<&XRWebGLLayer>) {
self.layer.set(layer)
}
}
@ -79,7 +79,7 @@ impl XRRenderStateMethods for XRRenderState {
}
/// https://immersive-web.github.io/webxr/#dom-xrrenderstate-baselayer
fn GetBaseLayer(&self) -> Option<DomRoot<XRLayer>> {
fn GetBaseLayer(&self) -> Option<DomRoot<XRWebGLLayer>> {
self.layer.get()
}
}

140
components/script/dom/xrsession.rs
View file

@ -5,7 +5,9 @@
use crate::compartments::InCompartment;
use crate::dom::bindings::callback::ExceptionHandling;
use crate::dom::bindings::cell::DomRefCell;
use crate::dom::bindings::codegen::Bindings::NavigatorBinding::NavigatorBinding::NavigatorMethods;
use crate::dom::bindings::codegen::Bindings::WebGLRenderingContextBinding::WebGLRenderingContextMethods;
use crate::dom::bindings::codegen::Bindings::WindowBinding::WindowBinding::WindowMethods;
use crate::dom::bindings::codegen::Bindings::XRBinding::XRSessionMode;
use crate::dom::bindings::codegen::Bindings::XRReferenceSpaceBinding::XRReferenceSpaceType;
use crate::dom::bindings::codegen::Bindings::XRRenderStateBinding::XRRenderStateInit;
@ -15,12 +17,13 @@ use crate::dom::bindings::codegen::Bindings::XRSessionBinding::XREnvironmentBlen
use crate::dom::bindings::codegen::Bindings::XRSessionBinding::XRFrameRequestCallback;
use crate::dom::bindings::codegen::Bindings::XRSessionBinding::XRSessionMethods;
use crate::dom::bindings::codegen::Bindings::XRWebGLLayerBinding::XRWebGLLayerMethods;
use crate::dom::bindings::error::Error;
use crate::dom::bindings::error::{Error, ErrorResult};
use crate::dom::bindings::inheritance::Castable;
use crate::dom::bindings::num::Finite;
use crate::dom::bindings::refcounted::Trusted;
use crate::dom::bindings::reflector::{reflect_dom_object, DomObject};
use crate::dom::bindings::root::{Dom, DomRoot, MutDom, MutNullableDom};
use crate::dom::event::Event;
use crate::dom::eventtarget::EventTarget;
use crate::dom::globalscope::GlobalScope;
use crate::dom::node::Node;
@ -28,9 +31,9 @@ use crate::dom::node::NodeDamage;
use crate::dom::promise::Promise;
use crate::dom::xrframe::XRFrame;
use crate::dom::xrinputsource::XRInputSource;
use crate::dom::xrlayer::XRLayer;
use crate::dom::xrreferencespace::XRReferenceSpace;
use crate::dom::xrrenderstate::XRRenderState;
use crate::dom::xrsessionevent::XRSessionEvent;
use crate::dom::xrspace::XRSpace;
use crate::dom::xrwebgllayer::XRWebGLLayer;
use crate::task_source::TaskSource;
@ -42,12 +45,12 @@ use profile_traits::ipc;
use std::cell::Cell;
use std::mem;
use std::rc::Rc;
use webxr_api::{self, Frame, Session};
use webxr_api::{self, Event as XREvent, Frame, Session};
#[dom_struct]
pub struct XRSession {
eventtarget: EventTarget,
base_layer: MutNullableDom<XRLayer>,
base_layer: MutNullableDom<XRWebGLLayer>,
blend_mode: XREnvironmentBlendMode,
viewer_space: MutNullableDom<XRSpace>,
#[ignore_malloc_size_of = "defined in webxr"]
@ -62,6 +65,11 @@ pub struct XRSession {
#[ignore_malloc_size_of = "defined in ipc-channel"]
raf_sender: DomRefCell<Option<IpcSender<(f64, Frame)>>>,
input_sources: DomRefCell<Vec<Dom<XRInputSource>>>,
// Any promises from calling end()
#[ignore_malloc_size_of = "promises are hard"]
end_promises: DomRefCell<Vec<Rc<Promise>>>,
/// https://immersive-web.github.io/webxr/#ended
ended: Cell<bool>,
}
impl XRSession {
@ -81,6 +89,8 @@ impl XRSession {
raf_callback_list: DomRefCell::new(vec![]),
raf_sender: DomRefCell::new(None),
input_sources: DomRefCell::new(vec![]),
end_promises: DomRefCell::new(vec![]),
ended: Cell::new(false),
}
}
@ -100,6 +110,7 @@ impl XRSession {
input_sources.push(Dom::from_ref(&input));
}
}
ret.attach_event_handler();
ret
}
@ -108,6 +119,71 @@ impl XRSession {
with(&session)
}
pub fn is_ended(&self) -> bool {
self.ended.get()
}
fn attach_event_handler(&self) {
#[derive(serde::Serialize, serde::Deserialize)]
pub struct EventCallback {
sender: IpcSender<XREvent>,
}
#[typetag::serde]
impl webxr_api::EventCallback for EventCallback {
fn callback(&mut self, event: XREvent) {
let _ = self.sender.send(event);
}
}
let this = Trusted::new(self);
let global = self.global();
let window = global.as_window();
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 this = this.clone();
let _ = task_source.queue_with_canceller(
task!(xr_event_callback: move || {
this.root().event_callback(message.to().unwrap());
}),
&canceller,
);
}),
);
// request animation frame
self.session
.borrow_mut()
.set_event_callback(EventCallback { sender });
}
fn event_callback(&self, event: XREvent) {
match event {
XREvent::SessionEnd => {
// https://immersive-web.github.io/webxr/#shut-down-the-session
// Step 2
self.ended.set(true);
// Step 3-4
self.global().as_window().Navigator().Xr().end_session(self);
// Step 5: We currently do not have any such promises
// Step 6 is happening n the XR session
// https://immersive-web.github.io/webxr/#dom-xrsession-end step 3
for promise in self.end_promises.borrow_mut().drain(..) {
promise.resolve_native(&());
}
// Step 7
let event = XRSessionEvent::new(&self.global(), atom!("end"), false, false, self);
event.upcast::<Event>().fire(self.upcast());
},
_ => (), // XXXManishearth TBD
}
}
/// https://immersive-web.github.io/webxr/#xr-animation-frame
fn raf_callback(&self, (time, frame): (f64, Frame)) {
// Step 1
@ -122,13 +198,9 @@ impl XRSession {
let layer = pending.GetBaseLayer();
if let Some(layer) = layer {
let mut session = self.session.borrow_mut();
if let Some(layer) = layer.downcast::<XRWebGLLayer>() {
session.update_webgl_external_image_api(
layer.Context().webgl_sender().webxr_external_image_api(),
);
} else {
error!("updateRenderState() called with unknown layer type")
}
session.update_webgl_external_image_api(
layer.Context().webgl_sender().webxr_external_image_api(),
);
}
}
@ -160,17 +232,18 @@ impl XRSession {
// If the canvas element is attached to the DOM, it is now dirty,
// and we need to trigger a reflow.
if let Some(webgl_layer) = base_layer.downcast::<XRWebGLLayer>() {
webgl_layer
.Context()
.Canvas()
.upcast::<Node>()
.dirty(NodeDamage::OtherNodeDamage);
}
base_layer
.Context()
.Canvas()
.upcast::<Node>()
.dirty(NodeDamage::OtherNodeDamage);
}
}
impl XRSessionMethods for XRSession {
/// https://immersive-web.github.io/webxr/#eventdef-xrsession-end
event_handler!(end, GetOnend, SetOnend);
/// https://immersive-web.github.io/webxr/#dom-xrsession-mode
fn Mode(&self) -> XRSessionMode {
XRSessionMode::Immersive_vr
@ -182,11 +255,19 @@ impl XRSessionMethods for XRSession {
}
/// https://immersive-web.github.io/webxr/#dom-xrsession-updaterenderstate
fn UpdateRenderState(&self, init: &XRRenderStateInit, _: InCompartment) {
// XXXManishearth various checks:
// If session’s ended value is true, throw an InvalidStateError and abort these steps
// If newState’s baseLayer's was created with an XRSession other than session,
// throw an InvalidStateError and abort these steps
fn UpdateRenderState(&self, init: &XRRenderStateInit, _: InCompartment) -> ErrorResult {
// Step 2
if self.ended.get() {
return Err(Error::InvalidState);
}
// Step 3:
if let Some(ref layer) = init.baseLayer {
if Dom::from_ref(layer.session()) != Dom::from_ref(self) {
return Err(Error::InvalidState);
}
}
// XXXManishearth step 4:
// If newState’s inlineVerticalFieldOfView is set and session is an
// immersive session, throw an InvalidStateError and abort these steps.
@ -203,6 +284,7 @@ impl XRSessionMethods for XRSession {
pending.set_layer(Some(&layer))
}
// XXXManishearth handle inlineVerticalFieldOfView
Ok(())
}
/// https://immersive-web.github.io/webxr/#dom-xrsession-requestanimationframe
@ -305,9 +387,15 @@ impl XRSessionMethods for XRSession {
/// https://immersive-web.github.io/webxr/#dom-xrsession-end
fn End(&self) -> Rc<Promise> {
// XXXManishearth implement device disconnection and session ending
let p = Promise::new(&self.global());
p.resolve_native(&());
let global = self.global();
let p = Promise::new(&global);
self.end_promises.borrow_mut().push(p.clone());
// This is duplicated in event_callback since this should
// happen ASAP for end() but can happen later if the device
// shuts itself down
self.ended.set(true);
global.as_window().Navigator().Xr().end_session(self);
self.session.borrow_mut().end_session();
p
}
}

78
components/script/dom/xrsessionevent.rs Normal file
View file

@ -0,0 +1,78 @@
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at https://mozilla.org/MPL/2.0/. */
use crate::dom::bindings::codegen::Bindings::EventBinding::EventBinding::EventMethods;
use crate::dom::bindings::codegen::Bindings::XRSessionEventBinding::{self, XRSessionEventMethods};
use crate::dom::bindings::error::Fallible;
use crate::dom::bindings::inheritance::Castable;
use crate::dom::bindings::reflector::{reflect_dom_object, DomObject};
use crate::dom::bindings::root::{Dom, DomRoot};
use crate::dom::bindings::str::DOMString;
use crate::dom::event::Event;
use crate::dom::globalscope::GlobalScope;
use crate::dom::window::Window;
use crate::dom::xrsession::XRSession;
use dom_struct::dom_struct;
use servo_atoms::Atom;
#[dom_struct]
pub struct XRSessionEvent {
event: Event,
session: Dom<XRSession>,
}
impl XRSessionEvent {
#[allow(unrooted_must_root)]
fn new_inherited(session: &XRSession) -> XRSessionEvent {
XRSessionEvent {
event: Event::new_inherited(),
session: Dom::from_ref(session),
}
}
pub fn new(
global: &GlobalScope,
type_: Atom,
bubbles: bool,
cancelable: bool,
session: &XRSession,
) -> DomRoot<XRSessionEvent> {
let trackevent = reflect_dom_object(
Box::new(XRSessionEvent::new_inherited(&session)),
global,
XRSessionEventBinding::Wrap,
);
{
let event = trackevent.upcast::<Event>();
event.init_event(type_, bubbles, cancelable);
}
trackevent
}
pub fn Constructor(
window: &Window,
type_: DOMString,
init: &XRSessionEventBinding::XRSessionEventInit,
) -> Fallible<DomRoot<XRSessionEvent>> {
Ok(XRSessionEvent::new(
&window.global(),
Atom::from(type_),
init.parent.bubbles,
init.parent.cancelable,
&init.session,
))
}
}
impl XRSessionEventMethods for XRSessionEvent {
// https://immersive-web.github.io/webxr/#dom-xrsessioneventinit-session
fn Session(&self) -> DomRoot<XRSession> {
DomRoot::from_ref(&*self.session)
}
// https://dom.spec.whatwg.org/#dom-event-istrusted
fn IsTrusted(&self) -> bool {
self.event.IsTrusted()
}
}

49
components/script/dom/xrtest.rs
View file

@ -7,13 +7,14 @@
* file, You can obtain one at https://mozilla.org/MPL/2.0/. */
use crate::dom::bindings::callback::ExceptionHandling;
use crate::dom::bindings::cell::DomRefCell;
use crate::dom::bindings::codegen::Bindings::FunctionBinding::Function;
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::bindings::root::{Dom, DomRoot};
use crate::dom::fakexrdevice::{get_origin, get_views, FakeXRDevice};
use crate::dom::globalscope::GlobalScope;
use crate::dom::promise::Promise;
@ -31,6 +32,7 @@ use webxr_api::{self, Error as XRError, MockDeviceInit, MockDeviceMsg};
pub struct XRTest {
reflector: Reflector,
session_started: Cell<bool>,
devices_connected: DomRefCell<Vec<Dom<FakeXRDevice>>>,
}
impl XRTest {
@ -38,6 +40,7 @@ impl XRTest {
XRTest {
reflector: Reflector::new(),
session_started: Cell::new(false),
devices_connected: DomRefCell::new(vec![]),
}
}
@ -57,6 +60,9 @@ impl XRTest {
let promise = trusted.root();
if let Ok(sender) = response {
let device = FakeXRDevice::new(&self.global(), sender);
self.devices_connected
.borrow_mut()
.push(Dom::from_ref(&device));
promise.resolve_native(&device);
} else {
promise.reject_native(&());
@ -174,8 +180,45 @@ impl XRTestMethods for XRTest {
/// https://github.com/immersive-web/webxr-test-api/blob/master/explainer.md
fn DisconnectAllDevices(&self) -> Rc<Promise> {
// XXXManishearth implement device disconnection and session ending
let p = Promise::new(&self.global());
p.resolve_native(&());
let global = self.global();
let p = Promise::new(&global);
let mut devices = self.devices_connected.borrow_mut();
if devices.is_empty() {
p.resolve_native(&());
} else {
let mut len = devices.len();
let (sender, receiver) = ipc::channel(global.time_profiler_chan().clone()).unwrap();
let mut rooted_devices: Vec<_> =
devices.iter().map(|x| DomRoot::from_ref(&**x)).collect();
devices.clear();
for device in rooted_devices.drain(..) {
device.disconnect(sender.clone());
}
let mut trusted = Some(TrustedPromise::new(p.clone()));
let (task_source, canceller) = global
.as_window()
.task_manager()
.dom_manipulation_task_source_with_canceller();
ROUTER.add_route(
receiver.to_opaque(),
Box::new(move |_| {
len -= 1;
if len == 0 {
let trusted = trusted
.take()
.expect("DisconnectAllDevices disconnected more devices than expected");
let _ =
task_source.queue_with_canceller(trusted.resolve_task(()), &canceller);
}
}),
);
// XXXManishearth this is a hack, it will need to be replaced when
// we improve how mock messaging works
p.resolve_native(&())
};
p
}
}

18
components/script/dom/xrwebgllayer.rs
View file

@ -10,14 +10,13 @@ use crate::dom::bindings::codegen::Bindings::WebGLRenderingContextBinding::WebGL
use crate::dom::bindings::codegen::Bindings::WebGLRenderingContextBinding::WebGLRenderingContextConstants as constants;
use crate::dom::bindings::error::Error;
use crate::dom::bindings::error::Fallible;
use crate::dom::bindings::reflector::{reflect_dom_object, DomObject};
use crate::dom::bindings::reflector::{reflect_dom_object, Reflector, DomObject};
use crate::dom::bindings::root::{Dom, DomRoot};
use crate::dom::globalscope::GlobalScope;
use crate::dom::webgl_validations::types::TexImageTarget;
use crate::dom::webglframebuffer::WebGLFramebuffer;
use crate::dom::webglrenderingcontext::WebGLRenderingContext;
use crate::dom::window::Window;
use crate::dom::xrlayer::XRLayer;
use crate::dom::xrsession::XRSession;
use crate::dom::xrview::XRView;
use crate::dom::xrviewport::XRViewport;
@ -28,7 +27,7 @@ use webxr_api::Views;
#[dom_struct]
pub struct XRWebGLLayer {
xrlayer: XRLayer,
reflector_: Reflector,
antialias: bool,
depth: bool,
stencil: bool,
@ -46,7 +45,7 @@ impl XRWebGLLayer {
framebuffer: &WebGLFramebuffer,
) -> XRWebGLLayer {
XRWebGLLayer {
xrlayer: XRLayer::new_inherited(),
reflector_: Reflector::new(),
antialias: init.antialias,
depth: init.depth,
stencil: init.stencil,
@ -83,6 +82,13 @@ impl XRWebGLLayer {
context: &WebGLRenderingContext,
init: &XRWebGLLayerInit,
) -> Fallible<DomRoot<Self>> {
// Step 2
if session.is_ended() {
return Err(Error::InvalidState);
}
// XXXManishearth step 3: throw error if context is lost
// XXXManishearth step 4: check XR compat flag for immersive sessions
let cx = global.get_cx();
let old_fbo = context.bound_framebuffer();
let old_texture = context
@ -139,6 +145,10 @@ impl XRWebGLLayer {
&framebuffer,
))
}
pub fn session(&self) -> &XRSession {
&self.session
}
}
impl XRWebGLLayerMethods for XRWebGLLayer {