diff options
Diffstat (limited to 'components/script')
22 files changed, 477 insertions, 394 deletions
diff --git a/components/script/dom/bindings/trace.rs b/components/script/dom/bindings/trace.rs index 4168fb4effa..81017cd344e 100644 --- a/components/script/dom/bindings/trace.rs +++ b/components/script/dom/bindings/trace.rs @@ -30,11 +30,8 @@ //! `JSTraceable` to a datatype. use app_units::Au; -use canvas_traits::canvas::{CanvasGradientStop, LinearGradientStyle, RadialGradientStyle}; -use canvas_traits::canvas::{CompositionOrBlending, LineCapStyle, LineJoinStyle, RepetitionStyle}; -use canvas_traits::webgl::{WebGLBufferId, WebGLFramebufferId, WebGLProgramId, WebGLRenderbufferId}; -use canvas_traits::webgl::{WebGLChan, WebGLContextShareMode, WebGLError, WebGLPipeline, WebGLMsgSender}; -use canvas_traits::webgl::{WebGLReceiver, WebGLSender, WebGLShaderId, WebGLTextureId, WebGLVertexArrayId}; +use canvas_traits::{CanvasGradientStop, LinearGradientStyle, RadialGradientStyle}; +use canvas_traits::{CompositionOrBlending, LineCapStyle, LineJoinStyle, RepetitionStyle}; use cssparser::RGBA; use devtools_traits::{CSSError, TimelineMarkerType, WorkerId}; use dom::abstractworker::SharedRt; @@ -108,7 +105,8 @@ use style::stylesheets::keyframes_rule::Keyframe; use style::values::specified::Length; use time::Duration; use uuid::Uuid; -use webrender_api::ImageKey; +use webrender_api::{WebGLBufferId, WebGLError, WebGLFramebufferId, WebGLProgramId}; +use webrender_api::{WebGLRenderbufferId, WebGLShaderId, WebGLTextureId, WebGLVertexArrayId}; use webvr_traits::WebVRGamepadHand; /// A trait to allow tracing (only) DOM objects. @@ -393,13 +391,8 @@ unsafe_no_jsmanaged_fields!(OpaqueStyleAndLayoutData); unsafe_no_jsmanaged_fields!(PathBuf); unsafe_no_jsmanaged_fields!(CSSErrorReporter); unsafe_no_jsmanaged_fields!(DrawAPaintImageResult); -unsafe_no_jsmanaged_fields!(ImageKey); unsafe_no_jsmanaged_fields!(WebGLBufferId); -unsafe_no_jsmanaged_fields!(WebGLChan); -unsafe_no_jsmanaged_fields!(WebGLContextShareMode); unsafe_no_jsmanaged_fields!(WebGLFramebufferId); -unsafe_no_jsmanaged_fields!(WebGLMsgSender); -unsafe_no_jsmanaged_fields!(WebGLPipeline); unsafe_no_jsmanaged_fields!(WebGLProgramId); unsafe_no_jsmanaged_fields!(WebGLRenderbufferId); unsafe_no_jsmanaged_fields!(WebGLShaderId); @@ -473,20 +466,6 @@ unsafe impl<T: Send> JSTraceable for Sender<T> { } } -unsafe impl<T: Send> JSTraceable for WebGLReceiver<T> where T: for<'de> Deserialize<'de> + Serialize { - #[inline] - unsafe fn trace(&self, _: *mut JSTracer) { - // Do nothing - } -} - -unsafe impl<T: Send> JSTraceable for WebGLSender<T> where T: for<'de> Deserialize<'de> + Serialize { - #[inline] - unsafe fn trace(&self, _: *mut JSTracer) { - // Do nothing - } -} - unsafe impl JSTraceable for Transform2D<f32> { #[inline] unsafe fn trace(&self, _trc: *mut JSTracer) { diff --git a/components/script/dom/canvasgradient.rs b/components/script/dom/canvasgradient.rs index 3a0707ab5eb..64df591f760 100644 --- a/components/script/dom/canvasgradient.rs +++ b/components/script/dom/canvasgradient.rs @@ -2,7 +2,7 @@ * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ -use canvas_traits::canvas::{CanvasGradientStop, FillOrStrokeStyle, LinearGradientStyle, RadialGradientStyle}; +use canvas_traits::{CanvasGradientStop, FillOrStrokeStyle, LinearGradientStyle, RadialGradientStyle}; use cssparser::{Parser, ParserInput, RGBA}; use cssparser::Color as CSSColor; use dom::bindings::cell::DOMRefCell; diff --git a/components/script/dom/canvaspattern.rs b/components/script/dom/canvaspattern.rs index 46bcbedcef0..5d9dd5cb767 100644 --- a/components/script/dom/canvaspattern.rs +++ b/components/script/dom/canvaspattern.rs @@ -2,7 +2,7 @@ * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ -use canvas_traits::canvas::{FillOrStrokeStyle, RepetitionStyle, SurfaceStyle}; +use canvas_traits::{FillOrStrokeStyle, RepetitionStyle, SurfaceStyle}; use dom::bindings::codegen::Bindings::CanvasPatternBinding; use dom::bindings::js::Root; use dom::bindings::reflector::{Reflector, reflect_dom_object}; diff --git a/components/script/dom/canvasrenderingcontext2d.rs b/components/script/dom/canvasrenderingcontext2d.rs index d4fcfae4ab8..55d2ef3ceb4 100644 --- a/components/script/dom/canvasrenderingcontext2d.rs +++ b/components/script/dom/canvasrenderingcontext2d.rs @@ -2,10 +2,10 @@ * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ -use canvas_traits::canvas::{Canvas2dMsg, CanvasMsg}; -use canvas_traits::canvas::{CompositionOrBlending, FillOrStrokeStyle, FillRule}; -use canvas_traits::canvas::{LineCapStyle, LineJoinStyle, LinearGradientStyle}; -use canvas_traits::canvas::{RadialGradientStyle, RepetitionStyle, byte_swap_and_premultiply}; +use canvas_traits::{Canvas2dMsg, CanvasCommonMsg, CanvasMsg}; +use canvas_traits::{CompositionOrBlending, FillOrStrokeStyle, FillRule}; +use canvas_traits::{LineCapStyle, LineJoinStyle, LinearGradientStyle}; +use canvas_traits::{RadialGradientStyle, RepetitionStyle, byte_swap_and_premultiply}; use cssparser::{Parser, ParserInput, RGBA}; use cssparser::Color as CSSColor; use dom::bindings::cell::DOMRefCell; @@ -163,7 +163,7 @@ impl CanvasRenderingContext2D { pub fn set_bitmap_dimensions(&self, size: Size2D<i32>) { self.reset_to_initial_state(); self.ipc_renderer - .send(CanvasMsg::Recreate(size)) + .send(CanvasMsg::Common(CanvasCommonMsg::Recreate(size))) .unwrap(); } @@ -173,6 +173,10 @@ impl CanvasRenderingContext2D { *self.state.borrow_mut() = CanvasContextState::new(); } + pub fn ipc_renderer(&self) -> IpcSender<CanvasMsg> { + self.ipc_renderer.clone() + } + fn mark_as_dirty(&self) { if let Some(ref canvas) = self.canvas { canvas.upcast::<Node>().dirty(NodeDamage::OtherNodeDamage); @@ -1388,7 +1392,7 @@ impl CanvasRenderingContext2DMethods for CanvasRenderingContext2D { impl Drop for CanvasRenderingContext2D { fn drop(&mut self) { - if let Err(err) = self.ipc_renderer.send(CanvasMsg::Close) { + if let Err(err) = self.ipc_renderer.send(CanvasMsg::Common(CanvasCommonMsg::Close)) { warn!("Could not close canvas: {}", err) } } diff --git a/components/script/dom/htmlcanvaselement.rs b/components/script/dom/htmlcanvaselement.rs index 3d89c08b230..a95ff766171 100644 --- a/components/script/dom/htmlcanvaselement.rs +++ b/components/script/dom/htmlcanvaselement.rs @@ -3,7 +3,7 @@ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ use base64; -use canvas_traits::canvas::{CanvasMsg, FromScriptMsg}; +use canvas_traits::{CanvasMsg, FromScriptMsg}; use dom::attr::Attr; use dom::bindings::cell::DOMRefCell; use dom::bindings::codegen::Bindings::CanvasRenderingContext2DBinding::CanvasRenderingContext2DMethods; @@ -30,11 +30,11 @@ use euclid::Size2D; use html5ever::{LocalName, Prefix}; use image::ColorType; use image::png::PNGEncoder; -use ipc_channel::ipc; +use ipc_channel::ipc::{self, IpcSender}; use js::error::throw_type_error; use js::jsapi::{HandleValue, JSContext}; use offscreen_gl_context::GLContextAttributes; -use script_layout_interface::{HTMLCanvasData, HTMLCanvasDataSource}; +use script_layout_interface::HTMLCanvasData; use std::iter::repeat; use style::attr::{AttrValue, LengthOrPercentageOrAuto}; @@ -106,22 +106,21 @@ impl LayoutHTMLCanvasElementHelpers for LayoutJS<HTMLCanvasElement> { fn data(&self) -> HTMLCanvasData { unsafe { let canvas = &*self.unsafe_get(); - let source = match canvas.context.borrow_for_layout().as_ref() { - Some(&CanvasContext::Context2d(ref context)) => { - HTMLCanvasDataSource::Image(Some(context.to_layout().get_ipc_renderer())) - }, - Some(&CanvasContext::WebGL(ref context)) => { - context.to_layout().canvas_data_source() - }, - None => { - HTMLCanvasDataSource::Image(None) + let ipc_renderer = canvas.context.borrow_for_layout().as_ref().map(|context| { + match *context { + CanvasContext::Context2d(ref context) => { + context.to_layout().get_ipc_renderer() + }, + CanvasContext::WebGL(ref context) => { + context.to_layout().get_ipc_renderer() + }, } - }; + }); let width_attr = canvas.upcast::<Element>().get_attr_for_layout(&ns!(), &local_name!("width")); let height_attr = canvas.upcast::<Element>().get_attr_for_layout(&ns!(), &local_name!("height")); HTMLCanvasData { - source: source, + ipc_renderer: ipc_renderer, width: width_attr.map_or(DEFAULT_WIDTH, |val| val.as_uint()), height: height_attr.map_or(DEFAULT_HEIGHT, |val| val.as_uint()), } @@ -151,6 +150,15 @@ impl LayoutHTMLCanvasElementHelpers for LayoutJS<HTMLCanvasElement> { impl HTMLCanvasElement { + pub fn ipc_renderer(&self) -> Option<IpcSender<CanvasMsg>> { + self.context.borrow().as_ref().map(|context| { + match *context { + CanvasContext::Context2d(ref context) => context.ipc_renderer(), + CanvasContext::WebGL(ref context) => context.ipc_renderer(), + } + }) + } + pub fn get_or_init_2d_context(&self) -> Option<Root<CanvasRenderingContext2D>> { if self.context.borrow().is_none() { let window = window_from_node(self); @@ -213,26 +221,22 @@ impl HTMLCanvasElement { return None } - let data = match self.context.borrow().as_ref() { - Some(&CanvasContext::Context2d(ref context)) => { - let (sender, receiver) = ipc::channel().unwrap(); - let msg = CanvasMsg::FromScript(FromScriptMsg::SendPixels(sender)); - context.get_ipc_renderer().send(msg).unwrap(); + let data = if let Some(renderer) = self.ipc_renderer() { + let (sender, receiver) = ipc::channel().unwrap(); + let msg = CanvasMsg::FromScript(FromScriptMsg::SendPixels(sender)); + renderer.send(msg).unwrap(); - match receiver.recv().unwrap() { - Some(pixels) => pixels, - None => { - return None; - } + match receiver.recv().unwrap() { + Some(pixels) => pixels, + None => { + // TODO(emilio, #14109): Not sure if WebGL canvas is + // required for 2d spec, but I think it's not, if so, make + // this return a readback from the GL context. + return None; } - }, - Some(&CanvasContext::WebGL(_)) => { - // TODO: add a method in WebGLRenderingContext to get the pixels. - return None; - }, - None => { - repeat(0xffu8).take((size.height as usize) * (size.width as usize) * 4).collect() } + } else { + repeat(0xffu8).take((size.height as usize) * (size.width as usize) * 4).collect() }; Some((data, size)) diff --git a/components/script/dom/paintrenderingcontext2d.rs b/components/script/dom/paintrenderingcontext2d.rs index c6b62b50e15..c3aa9e4c98b 100644 --- a/components/script/dom/paintrenderingcontext2d.rs +++ b/components/script/dom/paintrenderingcontext2d.rs @@ -2,9 +2,9 @@ * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ -use canvas_traits::canvas::CanvasImageData; -use canvas_traits::canvas::CanvasMsg; -use canvas_traits::canvas::FromLayoutMsg; +use canvas_traits::CanvasData; +use canvas_traits::CanvasMsg; +use canvas_traits::FromLayoutMsg; use dom::bindings::codegen::Bindings::CanvasRenderingContext2DBinding::CanvasFillRule; use dom::bindings::codegen::Bindings::CanvasRenderingContext2DBinding::CanvasLineCap; use dom::bindings::codegen::Bindings::CanvasRenderingContext2DBinding::CanvasLineJoin; @@ -58,9 +58,9 @@ impl PaintRenderingContext2D { PaintRenderingContext2DBinding::Wrap) } - pub fn send_data(&self, sender: IpcSender<CanvasImageData>) { + pub fn send_data(&self, sender: IpcSender<CanvasData>) { let msg = CanvasMsg::FromLayout(FromLayoutMsg::SendData(sender)); - let _ = self.context.get_ipc_renderer().send(msg); + let _ = self.context.ipc_renderer().send(msg); } pub fn take_missing_image_urls(&self) -> Vec<ServoUrl> { diff --git a/components/script/dom/paintworkletglobalscope.rs b/components/script/dom/paintworkletglobalscope.rs index 607c432c78a..b0a43cbf25d 100644 --- a/components/script/dom/paintworkletglobalscope.rs +++ b/components/script/dom/paintworkletglobalscope.rs @@ -2,6 +2,7 @@ * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ +use canvas_traits::CanvasData; use dom::bindings::callback::CallbackContainer; use dom::bindings::cell::DOMRefCell; use dom::bindings::codegen::Bindings::PaintWorkletGlobalScopeBinding; @@ -297,7 +298,7 @@ impl PaintWorkletGlobalScope { let (sender, receiver) = ipc::channel().expect("IPC channel creation."); rendering_context.send_data(sender); let image_key = match receiver.recv() { - Ok(data) => Some(data.image_key), + Ok(CanvasData::Image(data)) => Some(data.image_key), _ => None, }; diff --git a/components/script/dom/vrdisplay.rs b/components/script/dom/vrdisplay.rs index a36bd27ad29..54f06fb928f 100644 --- a/components/script/dom/vrdisplay.rs +++ b/components/script/dom/vrdisplay.rs @@ -2,7 +2,7 @@ * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ -use canvas_traits::webgl::{webgl_channel, WebGLReceiver, WebVRCommand}; +use canvas_traits::CanvasMsg; use core::ops::Deref; use dom::bindings::callback::ExceptionHandling; use dom::bindings::cell::DOMRefCell; @@ -32,7 +32,8 @@ use dom::vrpose::VRPose; use dom::vrstageparameters::VRStageParameters; use dom::webglrenderingcontext::WebGLRenderingContext; use dom_struct::dom_struct; -use ipc_channel::ipc::{self, IpcSender}; +use ipc_channel::ipc; +use ipc_channel::ipc::{IpcSender, IpcReceiver}; use js::jsapi::JSContext; use script_runtime::CommonScriptMsg; use script_runtime::ScriptThreadEventCategory::WebVREvent; @@ -42,6 +43,7 @@ use std::mem; use std::rc::Rc; use std::sync::mpsc; use std::thread; +use webrender_api::VRCompositorCommand; use webvr_traits::{WebVRDisplayData, WebVRDisplayEvent, WebVRFrameData, WebVRLayer, WebVRMsg}; #[dom_struct] @@ -69,7 +71,7 @@ pub struct VRDisplay { // Compositor VRFrameData synchonization frame_data_status: Cell<VRFrameDataStatus>, #[ignore_heap_size_of = "channels are hard"] - frame_data_receiver: DOMRefCell<Option<WebGLReceiver<Result<Vec<u8>, ()>>>>, + frame_data_receiver: DOMRefCell<Option<IpcReceiver<Result<Vec<u8>, ()>>>>, running_display_raf: Cell<bool>, paused: Cell<bool>, stopped_on_pause: Cell<bool>, @@ -384,10 +386,11 @@ impl VRDisplayMethods for VRDisplay { return; } - let display_id = self.display.borrow().display_id; + let api_sender = self.layer_ctx.get().unwrap().ipc_renderer(); + let display_id = self.display.borrow().display_id as u64; let layer = self.layer.borrow(); - let msg = WebVRCommand::SubmitFrame(display_id, layer.left_bounds, layer.right_bounds); - self.layer_ctx.get().unwrap().send_vr_command(msg); + let msg = VRCompositorCommand::SubmitFrame(display_id, layer.left_bounds, layer.right_bounds); + api_sender.send(CanvasMsg::WebVR(msg)).unwrap(); } // https://w3c.github.io/webvr/spec/1.1/#dom-vrdisplay-getlayers @@ -486,11 +489,11 @@ impl VRDisplay { fn init_present(&self) { self.presenting.set(true); - let (sync_sender, sync_receiver) = webgl_channel().unwrap(); + let (sync_sender, sync_receiver) = ipc::channel().unwrap(); *self.frame_data_receiver.borrow_mut() = Some(sync_receiver); - let display_id = self.display.borrow().display_id; - let api_sender = self.layer_ctx.get().unwrap().webgl_sender(); + let display_id = self.display.borrow().display_id as u64; + let api_sender = self.layer_ctx.get().unwrap().ipc_renderer(); let js_sender = self.global().script_chan(); let address = Trusted::new(&*self); let near_init = self.depth_near.get(); @@ -508,7 +511,7 @@ impl VRDisplay { let mut far = far_init; // Initialize compositor - api_sender.send_vr(WebVRCommand::Create(display_id)).unwrap(); + api_sender.send(CanvasMsg::WebVR(VRCompositorCommand::Create(display_id))).unwrap(); loop { // Run RAF callbacks on JavaScript thread let msg = box NotifyDisplayRAF { @@ -518,8 +521,8 @@ impl VRDisplay { js_sender.send(CommonScriptMsg::RunnableMsg(WebVREvent, msg)).unwrap(); // Run Sync Poses in parallell on Render thread - let msg = WebVRCommand::SyncPoses(display_id, near, far, sync_sender.clone()); - api_sender.send_vr(msg).unwrap(); + let msg = VRCompositorCommand::SyncPoses(display_id, near, far, sync_sender.clone()); + api_sender.send(CanvasMsg::WebVR(msg)).unwrap(); // Wait until both SyncPoses & RAF ends if let Ok(depth) = raf_receiver.recv().unwrap() { @@ -538,9 +541,10 @@ impl VRDisplay { self.presenting.set(false); *self.frame_data_receiver.borrow_mut() = None; - let api_sender = self.layer_ctx.get().unwrap().webgl_sender(); - let display_id = self.display.borrow().display_id; - api_sender.send_vr(WebVRCommand::Release(display_id)).unwrap(); + let api_sender = self.layer_ctx.get().unwrap().ipc_renderer(); + let display_id = self.display.borrow().display_id as u64; + let msg = VRCompositorCommand::Release(display_id); + api_sender.send(CanvasMsg::WebVR(msg)).unwrap(); } // Only called when the JSContext is destroyed while presenting. @@ -623,7 +627,7 @@ impl Runnable for NotifyDisplayRAF { } -// WebVR Spec: If the number of values in the leftBounds/rightBounds arrays +// WebVR Spect: If the number of values in the leftBounds/rightBounds arrays // is not 0 or 4 for any of the passed layers the promise is rejected fn parse_bounds(src: &Option<Vec<Finite<f32>>>, dst: &mut [f32; 4]) -> Result<(), &'static str> { match *src { diff --git a/components/script/dom/webgl_extensions/ext/oesvertexarrayobject.rs b/components/script/dom/webgl_extensions/ext/oesvertexarrayobject.rs index 48385a3d50f..097742f5441 100644 --- a/components/script/dom/webgl_extensions/ext/oesvertexarrayobject.rs +++ b/components/script/dom/webgl_extensions/ext/oesvertexarrayobject.rs @@ -2,7 +2,7 @@ * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ -use canvas_traits::webgl::{webgl_channel, WebGLCommand, WebGLError}; +use canvas_traits::CanvasMsg; use dom::bindings::codegen::Bindings::OESVertexArrayObjectBinding::{self, OESVertexArrayObjectMethods}; use dom::bindings::codegen::Bindings::OESVertexArrayObjectBinding::OESVertexArrayObjectConstants; use dom::bindings::js::{JS, MutNullableJS, Root}; @@ -15,6 +15,7 @@ use js::jsapi::JSContext; use js::jsval::{JSVal, NullValue}; use std::iter; use super::{WebGLExtension, WebGLExtensions}; +use webrender_api::{self, WebGLCommand, WebGLError}; #[dom_struct] pub struct OESVertexArrayObject { @@ -47,8 +48,8 @@ impl OESVertexArrayObject { impl OESVertexArrayObjectMethods for OESVertexArrayObject { // https://www.khronos.org/registry/webgl/extensions/OES_vertex_array_object/ fn CreateVertexArrayOES(&self) -> Option<Root<WebGLVertexArrayObjectOES>> { - let (sender, receiver) = webgl_channel().unwrap(); - self.ctx.send_command(WebGLCommand::CreateVertexArray(sender)); + let (sender, receiver) = webrender_api::channel::msg_channel().unwrap(); + self.ctx.send_renderer_message(CanvasMsg::WebGL(WebGLCommand::CreateVertexArray(sender))); let result = receiver.recv().unwrap(); result.map(|vao_id| WebGLVertexArrayObjectOES::new(&self.global(), vao_id)) @@ -65,7 +66,7 @@ impl OESVertexArrayObjectMethods for OESVertexArrayObject { if let Some(bound_vao) = self.bound_vao.get() { if bound_vao.id() == vao.id() { self.bound_vao.set(None); - self.ctx.send_command(WebGLCommand::BindVertexArray(None)); + self.ctx.send_renderer_message(CanvasMsg::WebGL(WebGLCommand::BindVertexArray(None))); } } @@ -79,7 +80,7 @@ impl OESVertexArrayObjectMethods for OESVertexArrayObject { } // Delete the vao - self.ctx.send_command(WebGLCommand::DeleteVertexArray(vao.id())); + self.ctx.send_renderer_message(CanvasMsg::WebGL(WebGLCommand::DeleteVertexArray(vao.id()))); vao.set_deleted(); } } @@ -113,7 +114,7 @@ impl OESVertexArrayObjectMethods for OESVertexArrayObject { return; } - self.ctx.send_command(WebGLCommand::BindVertexArray(Some(vao.id()))); + self.ctx.send_renderer_message(CanvasMsg::WebGL(WebGLCommand::BindVertexArray(Some(vao.id())))); vao.set_ever_bound(); self.bound_vao.set(Some(&vao)); @@ -123,7 +124,7 @@ impl OESVertexArrayObjectMethods for OESVertexArrayObject { let element_array = vao.bound_buffer_element_array(); self.ctx.set_bound_buffer_element_array(element_array.as_ref().map(|buffer| &**buffer)); } else { - self.ctx.send_command(WebGLCommand::BindVertexArray(None)); + self.ctx.send_renderer_message(CanvasMsg::WebGL(WebGLCommand::BindVertexArray(None))); self.bound_vao.set(None); self.ctx.set_bound_attrib_buffers(iter::empty()); } diff --git a/components/script/dom/webgl_extensions/ext/webglvertexarrayobjectoes.rs b/components/script/dom/webgl_extensions/ext/webglvertexarrayobjectoes.rs index 2fe109cafa6..e44b7c9bc42 100644 --- a/components/script/dom/webgl_extensions/ext/webglvertexarrayobjectoes.rs +++ b/components/script/dom/webgl_extensions/ext/webglvertexarrayobjectoes.rs @@ -2,7 +2,6 @@ * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ -use canvas_traits::webgl::WebGLVertexArrayId; use core::cell::Ref; use core::iter::FromIterator; use dom::bindings::cell::DOMRefCell; @@ -16,6 +15,7 @@ use dom::webglobject::WebGLObject; use dom_struct::dom_struct; use std::cell::Cell; use std::collections::HashMap; +use webrender_api::WebGLVertexArrayId; #[dom_struct] pub struct WebGLVertexArrayObjectOES { diff --git a/components/script/dom/webgl_extensions/extensions.rs b/components/script/dom/webgl_extensions/extensions.rs index 2a780b129ff..28c32dede64 100644 --- a/components/script/dom/webgl_extensions/extensions.rs +++ b/components/script/dom/webgl_extensions/extensions.rs @@ -2,7 +2,6 @@ * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ -use canvas_traits::webgl::WebGLError; use core::iter::FromIterator; use core::nonzero::NonZero; use dom::bindings::cell::DOMRefCell; @@ -20,6 +19,7 @@ use std::cell::Ref; use std::collections::{HashMap, HashSet}; use super::{ext, WebGLExtension}; use super::wrapper::{WebGLExtensionWrapper, TypedWebGLExtensionWrapper}; +use webrender_api::WebGLError; // Data types that are implemented for texImage2D and texSubImage2D in WebGLRenderingContext // but must trigger a InvalidValue error until the related WebGL Extensions are enabled. diff --git a/components/script/dom/webgl_validations/tex_image_2d.rs b/components/script/dom/webgl_validations/tex_image_2d.rs index cd5320453c7..41b2795bc14 100644 --- a/components/script/dom/webgl_validations/tex_image_2d.rs +++ b/components/script/dom/webgl_validations/tex_image_2d.rs @@ -2,13 +2,13 @@ * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ -use canvas_traits::webgl::WebGLError::*; use dom::bindings::js::Root; use dom::webglrenderingcontext::WebGLRenderingContext; use dom::webgltexture::WebGLTexture; use std::{self, fmt}; use super::WebGLValidator; use super::types::{TexImageTarget, TexDataType, TexFormat}; +use webrender_api::WebGLError::*; /// The errors that the texImage* family of functions can generate. #[derive(Debug)] diff --git a/components/script/dom/webglbuffer.rs b/components/script/dom/webglbuffer.rs index 96db4466d56..448956a9b90 100644 --- a/components/script/dom/webglbuffer.rs +++ b/components/script/dom/webglbuffer.rs @@ -3,8 +3,7 @@ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ // https://www.khronos.org/registry/webgl/specs/latest/1.0/webgl.idl -use canvas_traits::webgl::{WebGLBufferId, WebGLCommand, WebGLError, WebGLMsgSender, WebGLResult, WebGLVertexArrayId}; -use canvas_traits::webgl::webgl_channel; +use canvas_traits::CanvasMsg; use dom::bindings::cell::DOMRefCell; use dom::bindings::codegen::Bindings::WebGLBufferBinding; use dom::bindings::js::Root; @@ -12,9 +11,11 @@ use dom::bindings::reflector::reflect_dom_object; use dom::webglobject::WebGLObject; use dom::window::Window; use dom_struct::dom_struct; +use ipc_channel::ipc::IpcSender; use std::cell::Cell; use std::collections::HashSet; - +use webrender_api; +use webrender_api::{WebGLBufferId, WebGLCommand, WebGLError, WebGLResult, WebGLVertexArrayId}; #[dom_struct] pub struct WebGLBuffer { @@ -28,11 +29,11 @@ pub struct WebGLBuffer { vao_references: DOMRefCell<Option<HashSet<WebGLVertexArrayId>>>, pending_delete: Cell<bool>, #[ignore_heap_size_of = "Defined in ipc-channel"] - renderer: WebGLMsgSender, + renderer: IpcSender<CanvasMsg>, } impl WebGLBuffer { - fn new_inherited(renderer: WebGLMsgSender, + fn new_inherited(renderer: IpcSender<CanvasMsg>, id: WebGLBufferId) -> WebGLBuffer { WebGLBuffer { @@ -47,17 +48,17 @@ impl WebGLBuffer { } } - pub fn maybe_new(window: &Window, renderer: WebGLMsgSender) + pub fn maybe_new(window: &Window, renderer: IpcSender<CanvasMsg>) -> Option<Root<WebGLBuffer>> { - let (sender, receiver) = webgl_channel().unwrap(); - renderer.send(WebGLCommand::CreateBuffer(sender)).unwrap(); + let (sender, receiver) = webrender_api::channel::msg_channel().unwrap(); + renderer.send(CanvasMsg::WebGL(WebGLCommand::CreateBuffer(sender))).unwrap(); let result = receiver.recv().unwrap(); result.map(|buffer_id| WebGLBuffer::new(window, renderer, buffer_id)) } pub fn new(window: &Window, - renderer: WebGLMsgSender, + renderer: IpcSender<CanvasMsg>, id: WebGLBufferId) -> Root<WebGLBuffer> { reflect_dom_object(box WebGLBuffer::new_inherited(renderer, id), @@ -80,7 +81,7 @@ impl WebGLBuffer { } else { self.target.set(Some(target)); } - let msg = WebGLCommand::BindBuffer(target, Some(self.id)); + let msg = CanvasMsg::WebGL(WebGLCommand::BindBuffer(target, Some(self.id))); self.renderer.send(msg).unwrap(); Ok(()) @@ -93,7 +94,9 @@ impl WebGLBuffer { } } self.capacity.set(data.len()); - self.renderer.send(WebGLCommand::BufferData(target, data.to_vec(), usage)).unwrap(); + self.renderer + .send(CanvasMsg::WebGL(WebGLCommand::BufferData(target, data.to_vec(), usage))) + .unwrap(); Ok(()) } @@ -105,7 +108,7 @@ impl WebGLBuffer { pub fn delete(&self) { if !self.is_deleted.get() { self.is_deleted.set(true); - let _ = self.renderer.send(WebGLCommand::DeleteBuffer(self.id)); + let _ = self.renderer.send(CanvasMsg::WebGL(WebGLCommand::DeleteBuffer(self.id))); } } @@ -141,7 +144,7 @@ impl WebGLBuffer { if let Some(ref mut vao_refs) = *self.vao_references.borrow_mut() { if vao_refs.take(&id).is_some() && self.pending_delete.get() { // WebGL spec: The deleted buffers should no longer be valid when the VAOs are deleted - let _ = self.renderer.send(WebGLCommand::DeleteBuffer(self.id)); + let _ = self.renderer.send(CanvasMsg::WebGL(WebGLCommand::DeleteBuffer(self.id))); self.is_deleted.set(true); } } diff --git a/components/script/dom/webglframebuffer.rs b/components/script/dom/webglframebuffer.rs index 7a6b1090064..bb486c80c38 100644 --- a/components/script/dom/webglframebuffer.rs +++ b/components/script/dom/webglframebuffer.rs @@ -3,9 +3,7 @@ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ // https://www.khronos.org/registry/webgl/specs/latest/1.0/webgl.idl -use canvas_traits::webgl::{WebGLCommand, WebGLFramebufferBindingRequest, WebGLFramebufferId}; -use canvas_traits::webgl::{WebGLMsgSender, WebGLResult, WebGLError}; -use canvas_traits::webgl::webgl_channel; +use canvas_traits::CanvasMsg; use dom::bindings::cell::DOMRefCell; use dom::bindings::codegen::Bindings::WebGLFramebufferBinding; use dom::bindings::codegen::Bindings::WebGLRenderingContextBinding::WebGLRenderingContextConstants as constants; @@ -16,7 +14,10 @@ use dom::webglrenderbuffer::WebGLRenderbuffer; use dom::webgltexture::WebGLTexture; use dom::window::Window; use dom_struct::dom_struct; +use ipc_channel::ipc::IpcSender; use std::cell::Cell; +use webrender_api; +use webrender_api::{WebGLCommand, WebGLFramebufferBindingRequest, WebGLFramebufferId, WebGLResult, WebGLError}; #[must_root] #[derive(JSTraceable, Clone, HeapSizeOf)] @@ -35,7 +36,7 @@ pub struct WebGLFramebuffer { size: Cell<Option<(i32, i32)>>, status: Cell<u32>, #[ignore_heap_size_of = "Defined in ipc-channel"] - renderer: WebGLMsgSender, + renderer: IpcSender<CanvasMsg>, // The attachment points for textures and renderbuffers on this // FBO. @@ -46,7 +47,7 @@ pub struct WebGLFramebuffer { } impl WebGLFramebuffer { - fn new_inherited(renderer: WebGLMsgSender, + fn new_inherited(renderer: IpcSender<CanvasMsg>, id: WebGLFramebufferId) -> WebGLFramebuffer { WebGLFramebuffer { @@ -64,17 +65,17 @@ impl WebGLFramebuffer { } } - pub fn maybe_new(window: &Window, renderer: WebGLMsgSender) + pub fn maybe_new(window: &Window, renderer: IpcSender<CanvasMsg>) -> Option<Root<WebGLFramebuffer>> { - let (sender, receiver) = webgl_channel().unwrap(); - renderer.send(WebGLCommand::CreateFramebuffer(sender)).unwrap(); + let (sender, receiver) = webrender_api::channel::msg_channel().unwrap(); + renderer.send(CanvasMsg::WebGL(WebGLCommand::CreateFramebuffer(sender))).unwrap(); let result = receiver.recv().unwrap(); result.map(|fb_id| WebGLFramebuffer::new(window, renderer, fb_id)) } pub fn new(window: &Window, - renderer: WebGLMsgSender, + renderer: IpcSender<CanvasMsg>, id: WebGLFramebufferId) -> Root<WebGLFramebuffer> { reflect_dom_object(box WebGLFramebuffer::new_inherited(renderer, id), @@ -97,13 +98,13 @@ impl WebGLFramebuffer { self.target.set(Some(target)); let cmd = WebGLCommand::BindFramebuffer(target, WebGLFramebufferBindingRequest::Explicit(self.id)); - self.renderer.send(cmd).unwrap(); + self.renderer.send(CanvasMsg::WebGL(cmd)).unwrap(); } pub fn delete(&self) { if !self.is_deleted.get() { self.is_deleted.set(true); - let _ = self.renderer.send(WebGLCommand::DeleteFramebuffer(self.id)); + let _ = self.renderer.send(CanvasMsg::WebGL(WebGLCommand::DeleteFramebuffer(self.id))); } } @@ -204,10 +205,10 @@ impl WebGLFramebuffer { } }; - self.renderer.send(WebGLCommand::FramebufferRenderbuffer(constants::FRAMEBUFFER, - attachment, - constants::RENDERBUFFER, - rb_id)).unwrap(); + self.renderer.send(CanvasMsg::WebGL(WebGLCommand::FramebufferRenderbuffer(constants::FRAMEBUFFER, + attachment, + constants::RENDERBUFFER, + rb_id))).unwrap(); self.update_status(); Ok(()) @@ -280,11 +281,11 @@ impl WebGLFramebuffer { } }; - self.renderer.send(WebGLCommand::FramebufferTexture2D(constants::FRAMEBUFFER, - attachment, - textarget, - tex_id, - level)).unwrap(); + self.renderer.send(CanvasMsg::WebGL(WebGLCommand::FramebufferTexture2D(constants::FRAMEBUFFER, + attachment, + textarget, + tex_id, + level))).unwrap(); self.update_status(); Ok(()) diff --git a/components/script/dom/webglprogram.rs b/components/script/dom/webglprogram.rs index 6c298bb83fb..c76a2f3da18 100644 --- a/components/script/dom/webglprogram.rs +++ b/components/script/dom/webglprogram.rs @@ -3,8 +3,7 @@ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ // https://www.khronos.org/registry/webgl/specs/latest/1.0/webgl.idl -use canvas_traits::webgl::{WebGLCommand, WebGLError, WebGLMsgSender, WebGLParameter, WebGLProgramId, WebGLResult}; -use canvas_traits::webgl::webgl_channel; +use canvas_traits::CanvasMsg; use dom::bindings::codegen::Bindings::WebGLProgramBinding; use dom::bindings::codegen::Bindings::WebGLRenderingContextBinding::WebGLRenderingContextConstants as constants; use dom::bindings::js::{MutNullableJS, Root}; @@ -16,7 +15,10 @@ use dom::webglrenderingcontext::MAX_UNIFORM_AND_ATTRIBUTE_LEN; use dom::webglshader::WebGLShader; use dom::window::Window; use dom_struct::dom_struct; +use ipc_channel::ipc::IpcSender; use std::cell::Cell; +use webrender_api; +use webrender_api::{WebGLCommand, WebGLError, WebGLParameter, WebGLProgramId, WebGLResult}; #[dom_struct] pub struct WebGLProgram { @@ -28,11 +30,11 @@ pub struct WebGLProgram { fragment_shader: MutNullableJS<WebGLShader>, vertex_shader: MutNullableJS<WebGLShader>, #[ignore_heap_size_of = "Defined in ipc-channel"] - renderer: WebGLMsgSender, + renderer: IpcSender<CanvasMsg>, } impl WebGLProgram { - fn new_inherited(renderer: WebGLMsgSender, + fn new_inherited(renderer: IpcSender<CanvasMsg>, id: WebGLProgramId) -> WebGLProgram { WebGLProgram { @@ -47,17 +49,17 @@ impl WebGLProgram { } } - pub fn maybe_new(window: &Window, renderer: WebGLMsgSender) + pub fn maybe_new(window: &Window, renderer: IpcSender<CanvasMsg>) -> Option<Root<WebGLProgram>> { - let (sender, receiver) = webgl_channel().unwrap(); - renderer.send(WebGLCommand::CreateProgram(sender)).unwrap(); + let (sender, receiver) = webrender_api::channel::msg_channel().unwrap(); + renderer.send(CanvasMsg::WebGL(WebGLCommand::CreateProgram(sender))).unwrap(); let result = receiver.recv().unwrap(); result.map(|program_id| WebGLProgram::new(window, renderer, program_id)) } pub fn new(window: &Window, - renderer: WebGLMsgSender, + renderer: IpcSender<CanvasMsg>, id: WebGLProgramId) -> Root<WebGLProgram> { reflect_dom_object(box WebGLProgram::new_inherited(renderer, id), @@ -76,7 +78,7 @@ impl WebGLProgram { pub fn delete(&self) { if !self.is_deleted.get() { self.is_deleted.set(true); - let _ = self.renderer.send(WebGLCommand::DeleteProgram(self.id)); + let _ = self.renderer.send(CanvasMsg::WebGL(WebGLCommand::DeleteProgram(self.id))); if let Some(shader) = self.fragment_shader.get() { shader.decrement_attached_counter(); @@ -115,7 +117,7 @@ impl WebGLProgram { } self.linked.set(true); - self.renderer.send(WebGLCommand::LinkProgram(self.id)).unwrap(); + self.renderer.send(CanvasMsg::WebGL(WebGLCommand::LinkProgram(self.id))).unwrap(); Ok(()) } @@ -128,7 +130,7 @@ impl WebGLProgram { return Err(WebGLError::InvalidOperation); } - self.renderer.send(WebGLCommand::UseProgram(self.id)).unwrap(); + self.renderer.send(CanvasMsg::WebGL(WebGLCommand::UseProgram(self.id))).unwrap(); Ok(()) } @@ -137,7 +139,7 @@ impl WebGLProgram { if self.is_deleted() { return Err(WebGLError::InvalidOperation); } - self.renderer.send(WebGLCommand::ValidateProgram(self.id)).unwrap(); + self.renderer.send(CanvasMsg::WebGL(WebGLCommand::ValidateProgram(self.id))).unwrap(); Ok(()) } @@ -164,7 +166,7 @@ impl WebGLProgram { shader_slot.set(Some(shader)); shader.increment_attached_counter(); - self.renderer.send(WebGLCommand::AttachShader(self.id, shader.id())).unwrap(); + self.renderer.send(CanvasMsg::WebGL(WebGLCommand::AttachShader(self.id, shader.id()))).unwrap(); Ok(()) } @@ -194,7 +196,7 @@ impl WebGLProgram { shader_slot.set(None); shader.decrement_attached_counter(); - self.renderer.send(WebGLCommand::DetachShader(self.id, shader.id())).unwrap(); + self.renderer.send(CanvasMsg::WebGL(WebGLCommand::DetachShader(self.id, shader.id()))).unwrap(); Ok(()) } @@ -214,7 +216,7 @@ impl WebGLProgram { } self.renderer - .send(WebGLCommand::BindAttribLocation(self.id, index, String::from(name))) + .send(CanvasMsg::WebGL(WebGLCommand::BindAttribLocation(self.id, index, String::from(name)))) .unwrap(); Ok(()) } @@ -223,9 +225,9 @@ impl WebGLProgram { if self.is_deleted() { return Err(WebGLError::InvalidValue); } - let (sender, receiver) = webgl_channel().unwrap(); + let (sender, receiver) = webrender_api::channel::msg_channel().unwrap(); self.renderer - .send(WebGLCommand::GetActiveUniform(self.id, index, sender)) + .send(CanvasMsg::WebGL(WebGLCommand::GetActiveUniform(self.id, index, sender))) .unwrap(); receiver.recv().unwrap().map(|(size, ty, name)| @@ -237,9 +239,9 @@ impl WebGLProgram { if self.is_deleted() { return Err(WebGLError::InvalidValue); } - let (sender, receiver) = webgl_channel().unwrap(); + let (sender, receiver) = webrender_api::channel::msg_channel().unwrap(); self.renderer - .send(WebGLCommand::GetActiveAttrib(self.id, index, sender)) + .send(CanvasMsg::WebGL(WebGLCommand::GetActiveAttrib(self.id, index, sender))) .unwrap(); receiver.recv().unwrap().map(|(size, ty, name)| @@ -264,9 +266,9 @@ impl WebGLProgram { return Ok(None); } - let (sender, receiver) = webgl_channel().unwrap(); + let (sender, receiver) = webrender_api::channel::msg_channel().unwrap(); self.renderer - .send(WebGLCommand::GetAttribLocation(self.id, String::from(name), sender)) + .send(CanvasMsg::WebGL(WebGLCommand::GetAttribLocation(self.id, String::from(name), sender))) .unwrap(); Ok(receiver.recv().unwrap()) } @@ -285,9 +287,9 @@ impl WebGLProgram { return Ok(None); } - let (sender, receiver) = webgl_channel().unwrap(); + let (sender, receiver) = webrender_api::channel::msg_channel().unwrap(); self.renderer - .send(WebGLCommand::GetUniformLocation(self.id, String::from(name), sender)) + .send(CanvasMsg::WebGL(WebGLCommand::GetUniformLocation(self.id, String::from(name), sender))) .unwrap(); Ok(receiver.recv().unwrap()) } @@ -306,15 +308,15 @@ impl WebGLProgram { return Ok("One or more shaders failed to compile".to_string()); } } - let (sender, receiver) = webgl_channel().unwrap(); - self.renderer.send(WebGLCommand::GetProgramInfoLog(self.id, sender)).unwrap(); + let (sender, receiver) = webrender_api::channel::msg_channel().unwrap(); + self.renderer.send(CanvasMsg::WebGL(WebGLCommand::GetProgramInfoLog(self.id, sender))).unwrap(); Ok(receiver.recv().unwrap()) } /// glGetProgramParameter pub fn parameter(&self, param_id: u32) -> WebGLResult<WebGLParameter> { - let (sender, receiver) = webgl_channel().unwrap(); - self.renderer.send(WebGLCommand::GetProgramParameter(self.id, param_id, sender)).unwrap(); + let (sender, receiver) = webrender_api::channel::msg_channel().unwrap(); + self.renderer.send(CanvasMsg::WebGL(WebGLCommand::GetProgramParameter(self.id, param_id, sender))).unwrap(); receiver.recv().unwrap() } } diff --git a/components/script/dom/webglrenderbuffer.rs b/components/script/dom/webglrenderbuffer.rs index 9a855651cc9..03589365c43 100644 --- a/components/script/dom/webglrenderbuffer.rs +++ b/components/script/dom/webglrenderbuffer.rs @@ -3,7 +3,7 @@ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ // https://www.khronos.org/registry/webgl/specs/latest/1.0/webgl.idl -use canvas_traits::webgl::{webgl_channel, WebGLCommand, WebGLError, WebGLMsgSender, WebGLRenderbufferId, WebGLResult}; +use canvas_traits::CanvasMsg; use dom::bindings::codegen::Bindings::WebGLRenderbufferBinding; use dom::bindings::codegen::Bindings::WebGLRenderingContextBinding::WebGLRenderingContextConstants as constants; use dom::bindings::js::Root; @@ -11,7 +11,10 @@ use dom::bindings::reflector::reflect_dom_object; use dom::webglobject::WebGLObject; use dom::window::Window; use dom_struct::dom_struct; +use ipc_channel::ipc::IpcSender; use std::cell::Cell; +use webrender_api; +use webrender_api::{WebGLCommand, WebGLRenderbufferId, WebGLResult, WebGLError}; #[dom_struct] pub struct WebGLRenderbuffer { @@ -22,11 +25,11 @@ pub struct WebGLRenderbuffer { size: Cell<Option<(i32, i32)>>, internal_format: Cell<Option<u32>>, #[ignore_heap_size_of = "Defined in ipc-channel"] - renderer: WebGLMsgSender, + renderer: IpcSender<CanvasMsg>, } impl WebGLRenderbuffer { - fn new_inherited(renderer: WebGLMsgSender, + fn new_inherited(renderer: IpcSender<CanvasMsg>, id: WebGLRenderbufferId) -> WebGLRenderbuffer { WebGLRenderbuffer { @@ -40,17 +43,17 @@ impl WebGLRenderbuffer { } } - pub fn maybe_new(window: &Window, renderer: WebGLMsgSender) + pub fn maybe_new(window: &Window, renderer: IpcSender<CanvasMsg>) -> Option<Root<WebGLRenderbuffer>> { - let (sender, receiver) = webgl_channel().unwrap(); - renderer.send(WebGLCommand::CreateRenderbuffer(sender)).unwrap(); + let (sender, receiver) = webrender_api::channel::msg_channel().unwrap(); + renderer.send(CanvasMsg::WebGL(WebGLCommand::CreateRenderbuffer(sender))).unwrap(); let result = receiver.recv().unwrap(); result.map(|renderbuffer_id| WebGLRenderbuffer::new(window, renderer, renderbuffer_id)) } pub fn new(window: &Window, - renderer: WebGLMsgSender, + renderer: IpcSender<CanvasMsg>, id: WebGLRenderbufferId) -> Root<WebGLRenderbuffer> { reflect_dom_object(box WebGLRenderbuffer::new_inherited(renderer, id), @@ -71,14 +74,14 @@ impl WebGLRenderbuffer { pub fn bind(&self, target: u32) { self.ever_bound.set(true); - let msg = WebGLCommand::BindRenderbuffer(target, Some(self.id)); + let msg = CanvasMsg::WebGL(WebGLCommand::BindRenderbuffer(target, Some(self.id))); self.renderer.send(msg).unwrap(); } pub fn delete(&self) { if !self.is_deleted.get() { self.is_deleted.set(true); - let _ = self.renderer.send(WebGLCommand::DeleteRenderbuffer(self.id)); + let _ = self.renderer.send(CanvasMsg::WebGL(WebGLCommand::DeleteRenderbuffer(self.id))); } } @@ -107,7 +110,8 @@ impl WebGLRenderbuffer { // FIXME: Invalidate completeness after the call - let msg = WebGLCommand::RenderbufferStorage(constants::RENDERBUFFER, internal_format, width, height); + let msg = CanvasMsg::WebGL(WebGLCommand::RenderbufferStorage(constants::RENDERBUFFER, + internal_format, width, height)); self.renderer.send(msg).unwrap(); self.size.set(Some((width, height))); diff --git a/components/script/dom/webglrenderingcontext.rs b/components/script/dom/webglrenderingcontext.rs index c45362b4fe2..20fe133e02c 100644 --- a/components/script/dom/webglrenderingcontext.rs +++ b/components/script/dom/webglrenderingcontext.rs @@ -3,11 +3,7 @@ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ use byteorder::{NativeEndian, ReadBytesExt, WriteBytesExt}; -use canvas_traits::canvas::{byte_swap, multiply_u8_pixel}; -use canvas_traits::webgl::{WebGLContextShareMode, WebGLCommand, WebGLError}; -use canvas_traits::webgl::{WebGLFramebufferBindingRequest, WebGLMsg, WebGLMsgSender, WebGLParameter, WebVRCommand}; -use canvas_traits::webgl::WebGLError::*; -use canvas_traits::webgl::webgl_channel; +use canvas_traits::{CanvasCommonMsg, CanvasMsg, byte_swap, multiply_u8_pixel}; use core::cell::Ref; use core::iter::FromIterator; use core::nonzero::NonZero; @@ -23,6 +19,7 @@ use dom::bindings::js::{JS, LayoutJS, MutNullableJS, Root}; use dom::bindings::reflector::{DomObject, Reflector, reflect_dom_object}; use dom::bindings::str::DOMString; use dom::event::{Event, EventBubbles, EventCancelable}; +use dom::globalscope::GlobalScope; use dom::htmlcanvaselement::HTMLCanvasElement; use dom::htmlcanvaselement::utils as canvas_utils; use dom::node::{Node, NodeDamage, window_from_node}; @@ -45,6 +42,7 @@ use dom::window::Window; use dom_struct::dom_struct; use euclid::Size2D; use half::f16; +use ipc_channel::ipc::{self, IpcSender}; use js::conversions::ConversionBehavior; use js::jsapi::{JSContext, JSObject, Type, Rooted}; use js::jsval::{BooleanValue, DoubleValue, Int32Value, JSVal, NullValue, UndefinedValue}; @@ -52,11 +50,13 @@ use js::typedarray::{TypedArray, TypedArrayElement, Float32, Int32}; use net_traits::image::base::PixelFormat; use net_traits::image_cache::ImageResponse; use offscreen_gl_context::{GLContextAttributes, GLLimits}; -use script_layout_interface::HTMLCanvasDataSource; +use script_traits::ScriptMsg; use servo_config::prefs::PREFS; use std::cell::Cell; use std::collections::HashMap; use webrender_api; +use webrender_api::{WebGLCommand, WebGLError, WebGLFramebufferBindingRequest, WebGLParameter}; +use webrender_api::WebGLError::*; type ImagePixelResult = Result<(Vec<u8>, Size2D<i32>, bool), ()>; pub const MAX_UNIFORM_AND_ATTRIBUTE_LEN: usize = 256; @@ -92,7 +92,9 @@ macro_rules! handle_object_deletion { } if let Some(command) = $unbind_command { - $self_.send_command(command); + $self_.ipc_renderer + .send(CanvasMsg::WebGL(command)) + .unwrap(); } } }; @@ -133,15 +135,12 @@ bitflags! { #[dom_struct] pub struct WebGLRenderingContext { reflector_: Reflector, - #[ignore_heap_size_of = "Channels are hard"] - webgl_sender: WebGLMsgSender, - #[ignore_heap_size_of = "Defined in webrender"] - webrender_image: Cell<Option<webrender_api::ImageKey>>, - share_mode: WebGLContextShareMode, + #[ignore_heap_size_of = "Defined in ipc-channel"] + ipc_renderer: IpcSender<CanvasMsg>, #[ignore_heap_size_of = "Defined in offscreen_gl_context"] limits: GLLimits, canvas: JS<HTMLCanvasElement>, - #[ignore_heap_size_of = "Defined in canvas_traits"] + #[ignore_heap_size_of = "Defined in webrender_api"] last_error: Cell<Option<WebGLError>>, texture_unpacking_settings: Cell<TextureUnpacking>, texture_unpacking_alignment: Cell<u32>, @@ -159,7 +158,7 @@ pub struct WebGLRenderingContext { current_scissor: Cell<(i32, i32, i32, i32)>, #[ignore_heap_size_of = "Because it's small"] current_clear_color: Cell<(f32, f32, f32, f32)>, - extension_manager: WebGLExtensions, + extension_manager: WebGLExtensions } impl WebGLRenderingContext { @@ -172,19 +171,17 @@ impl WebGLRenderingContext { return Err("WebGL context creation error forced by pref `webgl.testing.context_creation_error`".into()); } - let (sender, receiver) = webgl_channel().unwrap(); - let webgl_chan = window.webgl_chan(); - webgl_chan.send(WebGLMsg::CreateContext(size, attrs, sender)) - .unwrap(); + let (sender, receiver) = ipc::channel().unwrap(); + let script_to_constellation_chan = window.upcast::<GlobalScope>().script_to_constellation_chan(); + script_to_constellation_chan.send(ScriptMsg::CreateWebGLPaintThread(size, attrs, sender)) + .unwrap(); let result = receiver.recv().unwrap(); - result.map(|ctx_data| { + result.map(|(ipc_renderer, context_limits)| { WebGLRenderingContext { reflector_: Reflector::new(), - webgl_sender: ctx_data.sender, - webrender_image: Cell::new(None), - share_mode: ctx_data.share_mode, - limits: ctx_data.limits, + ipc_renderer: ipc_renderer, + limits: context_limits, canvas: JS::from_ref(canvas), last_error: Cell::new(None), texture_unpacking_settings: Cell::new(CONVERT_COLORSPACE), @@ -256,43 +253,31 @@ impl WebGLRenderingContext { } pub fn recreate(&self, size: Size2D<i32>) { - let (sender, receiver) = webgl_channel().unwrap(); - self.webgl_sender.send_resize(size, sender).unwrap(); - - if let Err(msg) = receiver.recv().unwrap() { - error!("Error resizing WebGLContext: {}", msg); - return; - }; - - // Reset webrender_image because resize creates a new image_key. - // The new image key is set in the next handle_layout() method. - self.webrender_image.set(None); + self.ipc_renderer.send(CanvasMsg::Common(CanvasCommonMsg::Recreate(size))).unwrap(); // ClearColor needs to be restored because after a resize the GLContext is recreated // and the framebuffer is cleared using the default black transparent color. let color = self.current_clear_color.get(); - self.send_command(WebGLCommand::ClearColor(color.0, color.1, color.2, color.3)); + self.ipc_renderer + .send(CanvasMsg::WebGL(WebGLCommand::ClearColor(color.0, color.1, color.2, color.3))) + .unwrap(); // WebGL Spec: Scissor rect must not change if the canvas is resized. // See: webgl/conformance-1.0.3/conformance/rendering/gl-scissor-canvas-dimensions.html // NativeContext handling library changes the scissor after a resize, so we need to reset the // default scissor when the canvas was created or the last scissor that the user set. let rect = self.current_scissor.get(); - self.send_command(WebGLCommand::Scissor(rect.0, rect.1, rect.2, rect.3)); - } - - pub fn webgl_sender(&self) -> WebGLMsgSender { - self.webgl_sender.clone() + self.ipc_renderer + .send(CanvasMsg::WebGL(WebGLCommand::Scissor(rect.0, rect.1, rect.2, rect.3))) + .unwrap() } - #[inline] - pub fn send_command(&self, command: WebGLCommand) { - self.webgl_sender.send(command).unwrap(); + pub fn ipc_renderer(&self) -> IpcSender<CanvasMsg> { + self.ipc_renderer.clone() } - #[inline] - pub fn send_vr_command(&self, command: WebVRCommand) { - self.webgl_sender.send_vr(command).unwrap(); + pub fn send_renderer_message(&self, msg: CanvasMsg) { + self.ipc_renderer.send(msg).unwrap(); } pub fn get_extension_manager<'a>(&'a self) -> &'a WebGLExtensions { @@ -385,7 +370,9 @@ impl WebGLRenderingContext { self.current_vertex_attrib_0.set((x, y, z, w)) } - self.send_command(WebGLCommand::VertexAttrib(indx, x, y, z, w)); + self.ipc_renderer + .send(CanvasMsg::WebGL(WebGLCommand::VertexAttrib(indx, x, y, z, w))) + .unwrap(); } fn get_current_framebuffer_size(&self) -> Option<(i32, i32)> { @@ -718,8 +705,8 @@ impl WebGLRenderingContext { // WebGLContext (probably via GetPixels()). ImageDataOrHTMLImageElementOrHTMLCanvasElementOrHTMLVideoElement::HTMLCanvasElement(canvas) => { if let Some((mut data, size)) = canvas.fetch_all_data() { - // Pixels got from Canvas have already alpha premultiplied byte_swap(&mut data); + // Pixels got from Canvas have already alpha premultiplied (data, size, true) } else { return Err(()); @@ -958,7 +945,9 @@ impl WebGLRenderingContext { // GL_UNPACK_ALIGNMENT, while for textures from images or // canvas (produced by rgba8_image_to_tex_image_data()), it // will be 1. - self.send_command(WebGLCommand::PixelStorei(constants::UNPACK_ALIGNMENT, unpacking_alignment as i32)); + self.ipc_renderer + .send(CanvasMsg::WebGL(WebGLCommand::PixelStorei(constants::UNPACK_ALIGNMENT, unpacking_alignment as i32))) + .unwrap(); let format = internal_format.as_gl_constant(); let data_type = data_type.as_gl_constant(); @@ -972,7 +961,9 @@ impl WebGLRenderingContext { data_type, pixels); - self.send_command(msg); + self.ipc_renderer + .send(CanvasMsg::WebGL(msg)) + .unwrap(); if let Some(fb) = self.bound_framebuffer.get() { fb.invalidate_texture(&*texture); @@ -1014,7 +1005,9 @@ impl WebGLRenderingContext { // GL_UNPACK_ALIGNMENT, while for textures from images or // canvas (produced by rgba8_image_to_tex_image_data()), it // will be 1. - self.send_command(WebGLCommand::PixelStorei(constants::UNPACK_ALIGNMENT, unpacking_alignment as i32)); + self.ipc_renderer + .send(CanvasMsg::WebGL(WebGLCommand::PixelStorei(constants::UNPACK_ALIGNMENT, unpacking_alignment as i32))) + .unwrap(); // TODO(emilio): convert colorspace if requested let msg = WebGLCommand::TexSubImage2D(target.as_gl_constant(), @@ -1023,7 +1016,9 @@ impl WebGLRenderingContext { format.as_gl_constant(), data_type.as_gl_constant(), pixels); - self.send_command(msg); + self.ipc_renderer + .send(CanvasMsg::WebGL(msg)) + .unwrap() } // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14 @@ -1040,38 +1035,17 @@ impl WebGLRenderingContext { } fn get_gl_extensions(&self) -> String { - let (sender, receiver) = webgl_channel().unwrap(); - self.send_command(WebGLCommand::GetExtensions(sender)); + let (sender, receiver) = webrender_api::channel::msg_channel().unwrap(); + self.ipc_renderer + .send(CanvasMsg::WebGL(WebGLCommand::GetExtensions(sender))) + .unwrap(); receiver.recv().unwrap() } - - fn layout_handle(&self) -> webrender_api::ImageKey { - match self.share_mode { - WebGLContextShareMode::SharedTexture => { - // WR using ExternalTexture requires a single update message. - self.webrender_image.get().unwrap_or_else(|| { - let (sender, receiver) = webgl_channel().unwrap(); - self.webgl_sender.send_update_wr_image(sender).unwrap(); - let image_key = receiver.recv().unwrap(); - self.webrender_image.set(Some(image_key)); - - image_key - }) - }, - WebGLContextShareMode::Readback => { - // WR using Readback requires to update WR image every frame - // in order to send the new raw pixels. - let (sender, receiver) = webgl_channel().unwrap(); - self.webgl_sender.send_update_wr_image(sender).unwrap(); - receiver.recv().unwrap() - } - } - } } impl Drop for WebGLRenderingContext { fn drop(&mut self) { - self.webgl_sender.send_remove().unwrap(); + self.ipc_renderer.send(CanvasMsg::Common(CanvasCommonMsg::Close)).unwrap(); } } @@ -1127,36 +1101,45 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext { // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.11 fn Flush(&self) { - self.send_command(WebGLCommand::Flush); + self.ipc_renderer + .send(CanvasMsg::WebGL(WebGLCommand::Flush)) + .unwrap(); } // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.11 fn Finish(&self) { - let (sender, receiver) = webgl_channel().unwrap(); - self.send_command(WebGLCommand::Finish(sender)); + let (sender, receiver) = webrender_api::channel::msg_channel().unwrap(); + self.ipc_renderer + .send(CanvasMsg::WebGL(WebGLCommand::Finish(sender))) + .unwrap(); receiver.recv().unwrap() } // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.1 fn DrawingBufferWidth(&self) -> i32 { - let (sender, receiver) = webgl_channel().unwrap(); - self.send_command(WebGLCommand::DrawingBufferWidth(sender)); + let (sender, receiver) = webrender_api::channel::msg_channel().unwrap(); + self.ipc_renderer + .send(CanvasMsg::WebGL(WebGLCommand::DrawingBufferWidth(sender))) + .unwrap(); receiver.recv().unwrap() } // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.1 fn DrawingBufferHeight(&self) -> i32 { - let (sender, receiver) = webgl_channel().unwrap(); - self.send_command(WebGLCommand::DrawingBufferHeight(sender)); + let (sender, receiver) = webrender_api::channel::msg_channel().unwrap(); + self.ipc_renderer + .send(CanvasMsg::WebGL(WebGLCommand::DrawingBufferHeight(sender))) + .unwrap(); receiver.recv().unwrap() } #[allow(unsafe_code)] // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.5 unsafe fn GetBufferParameter(&self, _cx: *mut JSContext, target: u32, parameter: u32) -> JSVal { - let (sender, receiver) = webgl_channel().unwrap(); - self.send_command(WebGLCommand::GetBufferParameter(target, parameter, sender)); - + let (sender, receiver) = webrender_api::channel::msg_channel().unwrap(); + self.ipc_renderer + .send(CanvasMsg::WebGL(WebGLCommand::GetBufferParameter(target, parameter, sender))) + .unwrap(); match handle_potential_webgl_error!(self, receiver.recv().unwrap(), WebGLParameter::Invalid) { WebGLParameter::Int(val) => Int32Value(val), WebGLParameter::Bool(_) => panic!("Buffer parameter should not be bool"), @@ -1222,9 +1205,10 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext { } } - let (sender, receiver) = webgl_channel().unwrap(); - self.send_command(WebGLCommand::GetParameter(parameter, sender)); - + let (sender, receiver) = webrender_api::channel::msg_channel().unwrap(); + self.ipc_renderer + .send(CanvasMsg::WebGL(WebGLCommand::GetParameter(parameter, sender))) + .unwrap(); match handle_potential_webgl_error!(self, receiver.recv().unwrap(), WebGLParameter::Invalid) { WebGLParameter::Int(val) => Int32Value(val), WebGLParameter::Bool(val) => BooleanValue(val), @@ -1259,13 +1243,13 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext { // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.2 fn GetContextAttributes(&self) -> Option<WebGLContextAttributes> { - let (sender, receiver) = webgl_channel().unwrap(); + let (sender, receiver) = webrender_api::channel::msg_channel().unwrap(); // If the send does not succeed, assume context lost - if self.webgl_sender.send(WebGLCommand::GetContextAttributes(sender)).is_err() { + if let Err(_) = self.ipc_renderer + .send(CanvasMsg::WebGL(WebGLCommand::GetContextAttributes(sender))) { return None; } - let attrs = receiver.recv().unwrap(); Some(WebGLContextAttributes { @@ -1301,12 +1285,12 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext { // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.3 fn ActiveTexture(&self, texture: u32) { - self.send_command(WebGLCommand::ActiveTexture(texture)); + self.ipc_renderer.send(CanvasMsg::WebGL(WebGLCommand::ActiveTexture(texture))).unwrap(); } // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.3 fn BlendColor(&self, r: f32, g: f32, b: f32, a: f32) { - self.send_command(WebGLCommand::BlendColor(r, g, b, a)); + self.ipc_renderer.send(CanvasMsg::WebGL(WebGLCommand::BlendColor(r, g, b, a))).unwrap(); } // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.3 @@ -1315,7 +1299,7 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext { return self.webgl_error(InvalidEnum); } - self.send_command(WebGLCommand::BlendEquation(mode)); + self.ipc_renderer.send(CanvasMsg::WebGL(WebGLCommand::BlendEquation(mode))).unwrap(); } // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.3 @@ -1324,7 +1308,9 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext { return self.webgl_error(InvalidEnum); } - self.send_command(WebGLCommand::BlendEquationSeparate(mode_rgb, mode_alpha)); + self.ipc_renderer + .send(CanvasMsg::WebGL(WebGLCommand::BlendEquationSeparate(mode_rgb, mode_alpha))) + .unwrap(); } // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.3 @@ -1341,7 +1327,9 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext { return self.webgl_error(InvalidOperation); } - self.send_command(WebGLCommand::BlendFunc(src_factor, dest_factor)); + self.ipc_renderer + .send(CanvasMsg::WebGL(WebGLCommand::BlendFunc(src_factor, dest_factor))) + .unwrap(); } // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.3 @@ -1358,7 +1346,8 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext { return self.webgl_error(InvalidOperation); } - self.send_command(WebGLCommand::BlendFuncSeparate(src_rgb, dest_rgb, src_alpha, dest_alpha)); + self.ipc_renderer.send( + CanvasMsg::WebGL(WebGLCommand::BlendFuncSeparate(src_rgb, dest_rgb, src_alpha, dest_alpha))).unwrap(); } // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.9 @@ -1404,7 +1393,9 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext { } else { slot.set(None); // Unbind the current buffer - self.send_command(WebGLCommand::BindBuffer(target, None)); + self.ipc_renderer + .send(CanvasMsg::WebGL(WebGLCommand::BindBuffer(target, None))) + .unwrap() } } @@ -1429,7 +1420,7 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext { } else { // Bind the default framebuffer let cmd = WebGLCommand::BindFramebuffer(target, WebGLFramebufferBindingRequest::Default); - self.send_command(cmd); + self.ipc_renderer.send(CanvasMsg::WebGL(cmd)).unwrap(); self.bound_framebuffer.set(framebuffer); } } @@ -1451,7 +1442,9 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext { _ => { self.bound_renderbuffer.set(None); // Unbind the currently bound renderbuffer - self.send_command(WebGLCommand::BindRenderbuffer(target, None)); + self.ipc_renderer + .send(CanvasMsg::WebGL(WebGLCommand::BindRenderbuffer(target, None))) + .unwrap() } } } @@ -1472,7 +1465,9 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext { } else { slot.set(None); // Unbind the currently bound texture - self.send_command(WebGLCommand::BindTexture(target, None)); + self.ipc_renderer + .send(CanvasMsg::WebGL(WebGLCommand::BindTexture(target, None))) + .unwrap() } } @@ -1590,7 +1585,9 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext { if (offset as usize) + data_vec.len() > bound_buffer.capacity() { return Ok(self.webgl_error(InvalidValue)); } - self.send_command(WebGLCommand::BufferSubData(target, offset as isize, data_vec)); + self.ipc_renderer + .send(CanvasMsg::WebGL(WebGLCommand::BufferSubData(target, offset as isize, data_vec))) + .unwrap(); Ok(()) } @@ -1673,7 +1670,7 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext { width as i32, height as i32, border as i32); - self.send_command(msg); + self.ipc_renderer.send(CanvasMsg::WebGL(msg)).unwrap() } // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.8 @@ -1717,7 +1714,7 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext { x, y, width as i32, height as i32); - self.send_command(msg); + self.ipc_renderer.send(CanvasMsg::WebGL(msg)).unwrap(); } // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.11 @@ -1726,36 +1723,46 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext { return; } - self.send_command(WebGLCommand::Clear(mask)); + self.ipc_renderer.send(CanvasMsg::WebGL(WebGLCommand::Clear(mask))).unwrap(); self.mark_as_dirty(); } // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.3 fn ClearColor(&self, red: f32, green: f32, blue: f32, alpha: f32) { self.current_clear_color.set((red, green, blue, alpha)); - self.send_command(WebGLCommand::ClearColor(red, green, blue, alpha)); + self.ipc_renderer + .send(CanvasMsg::WebGL(WebGLCommand::ClearColor(red, green, blue, alpha))) + .unwrap() } // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.3 fn ClearDepth(&self, depth: f32) { - self.send_command(WebGLCommand::ClearDepth(depth as f64)) + self.ipc_renderer + .send(CanvasMsg::WebGL(WebGLCommand::ClearDepth(depth as f64))) + .unwrap() } // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.3 fn ClearStencil(&self, stencil: i32) { - self.send_command(WebGLCommand::ClearStencil(stencil)) + self.ipc_renderer + .send(CanvasMsg::WebGL(WebGLCommand::ClearStencil(stencil))) + .unwrap() } // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.3 fn ColorMask(&self, r: bool, g: bool, b: bool, a: bool) { - self.send_command(WebGLCommand::ColorMask(r, g, b, a)) + self.ipc_renderer + .send(CanvasMsg::WebGL(WebGLCommand::ColorMask(r, g, b, a))) + .unwrap() } // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.3 fn CullFace(&self, mode: u32) { match mode { constants::FRONT | constants::BACK | constants::FRONT_AND_BACK => - self.send_command(WebGLCommand::CullFace(mode)), + self.ipc_renderer + .send(CanvasMsg::WebGL(WebGLCommand::CullFace(mode))) + .unwrap(), _ => self.webgl_error(InvalidEnum), } } @@ -1764,7 +1771,9 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext { fn FrontFace(&self, mode: u32) { match mode { constants::CW | constants::CCW => - self.send_command(WebGLCommand::FrontFace(mode)), + self.ipc_renderer + .send(CanvasMsg::WebGL(WebGLCommand::FrontFace(mode))) + .unwrap(), _ => self.webgl_error(InvalidEnum), } } @@ -1775,14 +1784,18 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext { constants::EQUAL | constants::LEQUAL | constants::GREATER | constants::NOTEQUAL | constants::GEQUAL | constants::ALWAYS => - self.send_command(WebGLCommand::DepthFunc(func)), + self.ipc_renderer + .send(CanvasMsg::WebGL(WebGLCommand::DepthFunc(func))) + .unwrap(), _ => self.webgl_error(InvalidEnum), } } // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.3 fn DepthMask(&self, flag: bool) { - self.send_command(WebGLCommand::DepthMask(flag)) + self.ipc_renderer + .send(CanvasMsg::WebGL(WebGLCommand::DepthMask(flag))) + .unwrap() } // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.3 @@ -1796,20 +1809,26 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext { return self.webgl_error(InvalidOperation); } - self.send_command(WebGLCommand::DepthRange(near as f64, far as f64)) + self.ipc_renderer + .send(CanvasMsg::WebGL(WebGLCommand::DepthRange(near as f64, far as f64))) + .unwrap() } // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.3 fn Enable(&self, cap: u32) { if self.validate_feature_enum(cap) { - self.send_command(WebGLCommand::Enable(cap)); + self.ipc_renderer + .send(CanvasMsg::WebGL(WebGLCommand::Enable(cap))) + .unwrap(); } } // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.3 fn Disable(&self, cap: u32) { if self.validate_feature_enum(cap) { - self.send_command(WebGLCommand::Disable(cap)); + self.ipc_renderer + .send(CanvasMsg::WebGL(WebGLCommand::Disable(cap))) + .unwrap() } } @@ -1824,27 +1843,27 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext { // generated objects, either here or in the webgl thread // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.5 fn CreateBuffer(&self) -> Option<Root<WebGLBuffer>> { - WebGLBuffer::maybe_new(self.global().as_window(), self.webgl_sender.clone()) + WebGLBuffer::maybe_new(self.global().as_window(), self.ipc_renderer.clone()) } // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.6 fn CreateFramebuffer(&self) -> Option<Root<WebGLFramebuffer>> { - WebGLFramebuffer::maybe_new(self.global().as_window(), self.webgl_sender.clone()) + WebGLFramebuffer::maybe_new(self.global().as_window(), self.ipc_renderer.clone()) } // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.7 fn CreateRenderbuffer(&self) -> Option<Root<WebGLRenderbuffer>> { - WebGLRenderbuffer::maybe_new(self.global().as_window(), self.webgl_sender.clone()) + WebGLRenderbuffer::maybe_new(self.global().as_window(), self.ipc_renderer.clone()) } // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.8 fn CreateTexture(&self) -> Option<Root<WebGLTexture>> { - WebGLTexture::maybe_new(self.global().as_window(), self.webgl_sender.clone()) + WebGLTexture::maybe_new(self.global().as_window(), self.ipc_renderer.clone()) } // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.9 fn CreateProgram(&self) -> Option<Root<WebGLProgram>> { - WebGLProgram::maybe_new(self.global().as_window(), self.webgl_sender.clone()) + WebGLProgram::maybe_new(self.global().as_window(), self.ipc_renderer.clone()) } // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.9 @@ -1856,7 +1875,7 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext { return None; } } - WebGLShader::maybe_new(self.global().as_window(), self.webgl_sender.clone(), shader_type) + WebGLShader::maybe_new(self.global().as_window(), self.ipc_renderer.clone(), shader_type) } // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.5 @@ -1980,7 +1999,9 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext { return; } - self.send_command(WebGLCommand::DrawArrays(mode, first, count)); + self.ipc_renderer + .send(CanvasMsg::WebGL(WebGLCommand::DrawArrays(mode, first, count))) + .unwrap(); self.mark_as_dirty(); }, _ => self.webgl_error(InvalidEnum), @@ -2044,7 +2065,9 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext { constants::LINE_LOOP | constants::LINES | constants::TRIANGLE_STRIP | constants::TRIANGLE_FAN | constants::TRIANGLES => { - self.send_command(WebGLCommand::DrawElements(mode, count, type_, offset)); + self.ipc_renderer + .send(CanvasMsg::WebGL(WebGLCommand::DrawElements(mode, count, type_, offset))) + .unwrap(); self.mark_as_dirty(); }, _ => self.webgl_error(InvalidEnum), @@ -2057,7 +2080,9 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext { return self.webgl_error(InvalidValue); } - self.send_command(WebGLCommand::EnableVertexAttribArray(attrib_id)); + self.ipc_renderer + .send(CanvasMsg::WebGL(WebGLCommand::EnableVertexAttribArray(attrib_id))) + .unwrap() } // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.10 @@ -2066,7 +2091,9 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext { return self.webgl_error(InvalidValue); } - self.send_command(WebGLCommand::DisableVertexAttribArray(attrib_id)); + self.ipc_renderer + .send(CanvasMsg::WebGL(WebGLCommand::DisableVertexAttribArray(attrib_id))) + .unwrap() } // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.10 @@ -2196,11 +2223,11 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext { shader_type: u32, precision_type: u32) -> Option<Root<WebGLShaderPrecisionFormat>> { - let (sender, receiver) = webgl_channel().unwrap(); - self.send_command(WebGLCommand::GetShaderPrecisionFormat(shader_type, - precision_type, - sender)); - + let (sender, receiver) = webrender_api::channel::msg_channel().unwrap(); + self.ipc_renderer.send(CanvasMsg::WebGL(WebGLCommand::GetShaderPrecisionFormat(shader_type, + precision_type, + sender))) + .unwrap(); match receiver.recv().unwrap() { Ok((range_min, range_max, precision)) => { Some(WebGLShaderPrecisionFormat::new(self.global().as_window(), range_min, range_max, precision)) @@ -2241,8 +2268,8 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext { return jsval.get(); } - let (sender, receiver) = webgl_channel().unwrap(); - self.send_command(WebGLCommand::GetVertexAttrib(index, pname, sender)); + let (sender, receiver) = webrender_api::channel::msg_channel().unwrap(); + self.ipc_renderer.send(CanvasMsg::WebGL(WebGLCommand::GetVertexAttrib(index, pname, sender))).unwrap(); match handle_potential_webgl_error!(self, receiver.recv().unwrap(), WebGLParameter::Invalid) { WebGLParameter::Int(val) => Int32Value(val), @@ -2260,8 +2287,8 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext { // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.10 fn GetVertexAttribOffset(&self, index: u32, pname: u32) -> i64 { - let (sender, receiver) = webgl_channel().unwrap(); - self.send_command(WebGLCommand::GetVertexAttribOffset(index, pname, sender)); + let (sender, receiver) = webrender_api::channel::msg_channel().unwrap(); + self.ipc_renderer.send(CanvasMsg::WebGL(WebGLCommand::GetVertexAttribOffset(index, pname, sender))).unwrap(); handle_potential_webgl_error!(self, receiver.recv().unwrap(), 0) as i64 } @@ -2280,7 +2307,9 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext { _ => return self.webgl_error(InvalidEnum), } - self.send_command(WebGLCommand::Hint(target, mode)); + self.ipc_renderer + .send(CanvasMsg::WebGL(WebGLCommand::Hint(target, mode))) + .unwrap() } // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.5 @@ -2292,8 +2321,10 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext { // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.3 fn IsEnabled(&self, cap: u32) -> bool { if self.validate_feature_enum(cap) { - let (sender, receiver) = webgl_channel().unwrap(); - self.send_command(WebGLCommand::IsEnabled(cap, sender)); + let (sender, receiver) = webrender_api::channel::msg_channel().unwrap(); + self.ipc_renderer + .send(CanvasMsg::WebGL(WebGLCommand::IsEnabled(cap, sender))) + .unwrap(); return receiver.recv().unwrap(); } @@ -2331,7 +2362,9 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext { return self.webgl_error(InvalidValue); } - self.send_command(WebGLCommand::LineWidth(width)) + self.ipc_renderer + .send(CanvasMsg::WebGL(WebGLCommand::LineWidth(width))) + .unwrap() } // NOTE: Usage of this function could affect rendering while we keep using @@ -2387,7 +2420,9 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext { // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.3 fn PolygonOffset(&self, factor: f32, units: f32) { - self.send_command(WebGLCommand::PolygonOffset(factor, units)) + self.ipc_renderer + .send(CanvasMsg::WebGL(WebGLCommand::PolygonOffset(factor, units))) + .unwrap() } #[allow(unsafe_code)] @@ -2487,8 +2522,10 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext { _ => return Ok(self.webgl_error(InvalidOperation)), }; - let (sender, receiver) = webgl_channel().unwrap(); - self.send_command(WebGLCommand::ReadPixels(x, y, width, height, format, pixel_type, sender)); + let (sender, receiver) = webrender_api::channel::msg_channel().unwrap(); + self.ipc_renderer + .send(CanvasMsg::WebGL(WebGLCommand::ReadPixels(x, y, width, height, format, pixel_type, sender))) + .unwrap(); let result = receiver.recv().unwrap(); @@ -2504,7 +2541,7 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext { // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.3 fn SampleCoverage(&self, value: f32, invert: bool) { - self.send_command(WebGLCommand::SampleCoverage(value, invert)); + self.ipc_renderer.send(CanvasMsg::WebGL(WebGLCommand::SampleCoverage(value, invert))).unwrap(); } // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.4 @@ -2514,7 +2551,9 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext { } self.current_scissor.set((x, y, width, height)); - self.send_command(WebGLCommand::Scissor(x, y, width, height)); + self.ipc_renderer + .send(CanvasMsg::WebGL(WebGLCommand::Scissor(x, y, width, height))) + .unwrap() } // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.3 @@ -2522,7 +2561,9 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext { match func { constants::NEVER | constants::LESS | constants::EQUAL | constants::LEQUAL | constants::GREATER | constants::NOTEQUAL | constants::GEQUAL | constants::ALWAYS => - self.send_command(WebGLCommand::StencilFunc(func, ref_, mask)), + self.ipc_renderer + .send(CanvasMsg::WebGL(WebGLCommand::StencilFunc(func, ref_, mask))) + .unwrap(), _ => self.webgl_error(InvalidEnum), } } @@ -2537,21 +2578,27 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext { match func { constants::NEVER | constants::LESS | constants::EQUAL | constants::LEQUAL | constants::GREATER | constants::NOTEQUAL | constants::GEQUAL | constants::ALWAYS => - self.send_command(WebGLCommand::StencilFuncSeparate(face, func, ref_, mask)), + self.ipc_renderer + .send(CanvasMsg::WebGL(WebGLCommand::StencilFuncSeparate(face, func, ref_, mask))) + .unwrap(), _ => self.webgl_error(InvalidEnum), } } // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.3 fn StencilMask(&self, mask: u32) { - self.send_command(WebGLCommand::StencilMask(mask)) + self.ipc_renderer + .send(CanvasMsg::WebGL(WebGLCommand::StencilMask(mask))) + .unwrap() } // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.3 fn StencilMaskSeparate(&self, face: u32, mask: u32) { match face { constants::FRONT | constants::BACK | constants::FRONT_AND_BACK => - self.send_command(WebGLCommand::StencilMaskSeparate(face, mask)), + self.ipc_renderer + .send(CanvasMsg::WebGL(WebGLCommand::StencilMaskSeparate(face, mask))) + .unwrap(), _ => return self.webgl_error(InvalidEnum), } } @@ -2560,7 +2607,9 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext { fn StencilOp(&self, fail: u32, zfail: u32, zpass: u32) { if self.validate_stencil_actions(fail) && self.validate_stencil_actions(zfail) && self.validate_stencil_actions(zpass) { - self.send_command(WebGLCommand::StencilOp(fail, zfail, zpass)); + self.ipc_renderer + .send(CanvasMsg::WebGL(WebGLCommand::StencilOp(fail, zfail, zpass))) + .unwrap() } else { self.webgl_error(InvalidEnum) } @@ -2575,7 +2624,9 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext { if self.validate_stencil_actions(fail) && self.validate_stencil_actions(zfail) && self.validate_stencil_actions(zpass) { - self.send_command(WebGLCommand::StencilOpSeparate(face, fail, zfail, zpass)) + self.ipc_renderer + .send(CanvasMsg::WebGL(WebGLCommand::StencilOpSeparate(face, fail, zfail, zpass))) + .unwrap() } else { self.webgl_error(InvalidEnum) } @@ -2607,7 +2658,9 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext { uniform: Option<&WebGLUniformLocation>, val: f32) { if self.validate_uniform_parameters(uniform, UniformSetterType::Float, &[val]) { - self.send_command(WebGLCommand::Uniform1f(uniform.unwrap().id(), val)) + self.ipc_renderer + .send(CanvasMsg::WebGL(WebGLCommand::Uniform1f(uniform.unwrap().id(), val))) + .unwrap() } } @@ -2616,7 +2669,9 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext { uniform: Option<&WebGLUniformLocation>, val: i32) { if self.validate_uniform_parameters(uniform, UniformSetterType::Int, &[val]) { - self.send_command(WebGLCommand::Uniform1i(uniform.unwrap().id(), val)) + self.ipc_renderer + .send(CanvasMsg::WebGL(WebGLCommand::Uniform1i(uniform.unwrap().id(), val))) + .unwrap() } } @@ -2630,7 +2685,9 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext { let data_vec = typed_array_or_sequence_to_vec::<Int32>(cx, data, ConversionBehavior::Default)?; if self.validate_uniform_parameters(uniform, UniformSetterType::Int, &data_vec) { - self.send_command(WebGLCommand::Uniform1iv(uniform.unwrap().id(), data_vec)) + self.ipc_renderer + .send(CanvasMsg::WebGL(WebGLCommand::Uniform1iv(uniform.unwrap().id(), data_vec))) + .unwrap() } Ok(()) @@ -2646,7 +2703,9 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext { let data_vec = typed_array_or_sequence_to_vec::<Float32>(cx, data, ())?; if self.validate_uniform_parameters(uniform, UniformSetterType::Float, &data_vec) { - self.send_command(WebGLCommand::Uniform1fv(uniform.unwrap().id(), data_vec)); + self.ipc_renderer + .send(CanvasMsg::WebGL(WebGLCommand::Uniform1fv(uniform.unwrap().id(), data_vec))) + .unwrap() } Ok(()) @@ -2657,7 +2716,9 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext { uniform: Option<&WebGLUniformLocation>, x: f32, y: f32) { if self.validate_uniform_parameters(uniform, UniformSetterType::FloatVec2, &[x, y]) { - self.send_command(WebGLCommand::Uniform2f(uniform.unwrap().id(), x, y)); + self.ipc_renderer + .send(CanvasMsg::WebGL(WebGLCommand::Uniform2f(uniform.unwrap().id(), x, y))) + .unwrap() } } @@ -2673,7 +2734,9 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext { if self.validate_uniform_parameters(uniform, UniformSetterType::FloatVec2, &data_vec) { - self.send_command(WebGLCommand::Uniform2fv(uniform.unwrap().id(), data_vec)); + self.ipc_renderer + .send(CanvasMsg::WebGL(WebGLCommand::Uniform2fv(uniform.unwrap().id(), data_vec))) + .unwrap() } Ok(()) @@ -2686,7 +2749,9 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext { if self.validate_uniform_parameters(uniform, UniformSetterType::IntVec2, &[x, y]) { - self.send_command(WebGLCommand::Uniform2i(uniform.unwrap().id(), x, y)); + self.ipc_renderer + .send(CanvasMsg::WebGL(WebGLCommand::Uniform2i(uniform.unwrap().id(), x, y))) + .unwrap() } } @@ -2702,7 +2767,9 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext { if self.validate_uniform_parameters(uniform, UniformSetterType::IntVec2, &data_vec) { - self.send_command(WebGLCommand::Uniform2iv(uniform.unwrap().id(), data_vec)); + self.ipc_renderer + .send(CanvasMsg::WebGL(WebGLCommand::Uniform2iv(uniform.unwrap().id(), data_vec))) + .unwrap() } Ok(()) @@ -2715,7 +2782,9 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext { if self.validate_uniform_parameters(uniform, UniformSetterType::FloatVec3, &[x, y, z]) { - self.send_command(WebGLCommand::Uniform3f(uniform.unwrap().id(), x, y, z)); + self.ipc_renderer + .send(CanvasMsg::WebGL(WebGLCommand::Uniform3f(uniform.unwrap().id(), x, y, z))) + .unwrap() } } @@ -2731,7 +2800,9 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext { if self.validate_uniform_parameters(uniform, UniformSetterType::FloatVec3, &data_vec) { - self.send_command(WebGLCommand::Uniform3fv(uniform.unwrap().id(), data_vec)) + self.ipc_renderer + .send(CanvasMsg::WebGL(WebGLCommand::Uniform3fv(uniform.unwrap().id(), data_vec))) + .unwrap() } Ok(()) @@ -2744,7 +2815,9 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext { if self.validate_uniform_parameters(uniform, UniformSetterType::IntVec3, &[x, y, z]) { - self.send_command(WebGLCommand::Uniform3i(uniform.unwrap().id(), x, y, z)) + self.ipc_renderer + .send(CanvasMsg::WebGL(WebGLCommand::Uniform3i(uniform.unwrap().id(), x, y, z))) + .unwrap() } } @@ -2760,7 +2833,9 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext { if self.validate_uniform_parameters(uniform, UniformSetterType::IntVec3, &data_vec) { - self.send_command(WebGLCommand::Uniform3iv(uniform.unwrap().id(), data_vec)) + self.ipc_renderer + .send(CanvasMsg::WebGL(WebGLCommand::Uniform3iv(uniform.unwrap().id(), data_vec))) + .unwrap() } Ok(()) @@ -2773,7 +2848,9 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext { if self.validate_uniform_parameters(uniform, UniformSetterType::IntVec4, &[x, y, z, w]) { - self.send_command(WebGLCommand::Uniform4i(uniform.unwrap().id(), x, y, z, w)) + self.ipc_renderer + .send(CanvasMsg::WebGL(WebGLCommand::Uniform4i(uniform.unwrap().id(), x, y, z, w))) + .unwrap() } } @@ -2790,7 +2867,9 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext { if self.validate_uniform_parameters(uniform, UniformSetterType::IntVec4, &data_vec) { - self.send_command(WebGLCommand::Uniform4iv(uniform.unwrap().id(), data_vec)) + self.ipc_renderer + .send(CanvasMsg::WebGL(WebGLCommand::Uniform4iv(uniform.unwrap().id(), data_vec))) + .unwrap() } Ok(()) @@ -2803,7 +2882,9 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext { if self.validate_uniform_parameters(uniform, UniformSetterType::FloatVec4, &[x, y, z, w]) { - self.send_command(WebGLCommand::Uniform4f(uniform.unwrap().id(), x, y, z, w)) + self.ipc_renderer + .send(CanvasMsg::WebGL(WebGLCommand::Uniform4f(uniform.unwrap().id(), x, y, z, w))) + .unwrap() } } @@ -2819,7 +2900,9 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext { if self.validate_uniform_parameters(uniform, UniformSetterType::FloatVec4, &data_vec) { - self.send_command(WebGLCommand::Uniform4fv(uniform.unwrap().id(), data_vec)) + self.ipc_renderer + .send(CanvasMsg::WebGL(WebGLCommand::Uniform4fv(uniform.unwrap().id(), data_vec))) + .unwrap() } Ok(()) @@ -2837,7 +2920,9 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext { if self.validate_uniform_parameters(uniform, UniformSetterType::FloatMat2, &data_vec) { - self.send_command(WebGLCommand::UniformMatrix2fv(uniform.unwrap().id(), transpose, data_vec)); + self.ipc_renderer + .send(CanvasMsg::WebGL(WebGLCommand::UniformMatrix2fv(uniform.unwrap().id(), transpose, data_vec))) + .unwrap() } Ok(()) @@ -2855,7 +2940,9 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext { if self.validate_uniform_parameters(uniform, UniformSetterType::FloatMat3, &data_vec) { - self.send_command(WebGLCommand::UniformMatrix3fv(uniform.unwrap().id(), transpose, data_vec)); + self.ipc_renderer + .send(CanvasMsg::WebGL(WebGLCommand::UniformMatrix3fv(uniform.unwrap().id(), transpose, data_vec))) + .unwrap() } Ok(()) @@ -2873,7 +2960,9 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext { if self.validate_uniform_parameters(uniform, UniformSetterType::FloatMat4, &data_vec) { - self.send_command(WebGLCommand::UniformMatrix4fv(uniform.unwrap().id(), transpose, data_vec)); + self.ipc_renderer + .send(CanvasMsg::WebGL(WebGLCommand::UniformMatrix4fv(uniform.unwrap().id(), transpose, data_vec))) + .unwrap() } Ok(()) @@ -3009,8 +3098,9 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext { self.bound_attrib_buffers.borrow_mut().insert(attrib_id, JS::from_ref(&*buffer_array)); - let msg = WebGLCommand::VertexAttribPointer(attrib_id, size, data_type, normalized, stride, offset as u32); - self.send_command(msg); + let msg = CanvasMsg::WebGL( + WebGLCommand::VertexAttribPointer(attrib_id, size, data_type, normalized, stride, offset as u32)); + self.ipc_renderer.send(msg).unwrap() } // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.4 @@ -3019,7 +3109,9 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext { return self.webgl_error(InvalidValue) } - self.send_command(WebGLCommand::Viewport(x, y, width, height)) + self.ipc_renderer + .send(CanvasMsg::WebGL(WebGLCommand::Viewport(x, y, width, height))) + .unwrap() } // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.8 @@ -3364,13 +3456,13 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext { pub trait LayoutCanvasWebGLRenderingContextHelpers { #[allow(unsafe_code)] - unsafe fn canvas_data_source(&self) -> HTMLCanvasDataSource; + unsafe fn get_ipc_renderer(&self) -> IpcSender<CanvasMsg>; } impl LayoutCanvasWebGLRenderingContextHelpers for LayoutJS<WebGLRenderingContext> { #[allow(unsafe_code)] - unsafe fn canvas_data_source(&self) -> HTMLCanvasDataSource { - HTMLCanvasDataSource::WebGL((*self.unsafe_get()).layout_handle()) + unsafe fn get_ipc_renderer(&self) -> IpcSender<CanvasMsg> { + (*self.unsafe_get()).ipc_renderer.clone() } } diff --git a/components/script/dom/webglshader.rs b/components/script/dom/webglshader.rs index cf6fc55072d..edd9cf7bdb3 100644 --- a/components/script/dom/webglshader.rs +++ b/components/script/dom/webglshader.rs @@ -4,7 +4,7 @@ // https://www.khronos.org/registry/webgl/specs/latest/1.0/webgl.idl use angle::hl::{BuiltInResources, Output, ShaderValidator}; -use canvas_traits::webgl::{webgl_channel, WebGLCommand, WebGLMsgSender, WebGLParameter, WebGLResult, WebGLShaderId}; +use canvas_traits::CanvasMsg; use dom::bindings::cell::DOMRefCell; use dom::bindings::codegen::Bindings::WebGLShaderBinding; use dom::bindings::js::Root; @@ -13,8 +13,11 @@ use dom::bindings::str::DOMString; use dom::webglobject::WebGLObject; use dom::window::Window; use dom_struct::dom_struct; +use ipc_channel::ipc::IpcSender; use std::cell::Cell; use std::sync::{ONCE_INIT, Once}; +use webrender_api; +use webrender_api::{WebGLCommand, WebGLParameter, WebGLResult, WebGLShaderId}; #[derive(Clone, Copy, PartialEq, Debug, JSTraceable, HeapSizeOf)] pub enum ShaderCompilationStatus { @@ -34,7 +37,7 @@ pub struct WebGLShader { attached_counter: Cell<u32>, compilation_status: Cell<ShaderCompilationStatus>, #[ignore_heap_size_of = "Defined in ipc-channel"] - renderer: WebGLMsgSender, + renderer: IpcSender<CanvasMsg>, } #[cfg(not(target_os = "android"))] @@ -46,7 +49,7 @@ const SHADER_OUTPUT_FORMAT: Output = Output::Essl; static GLSLANG_INITIALIZATION: Once = ONCE_INIT; impl WebGLShader { - fn new_inherited(renderer: WebGLMsgSender, + fn new_inherited(renderer: IpcSender<CanvasMsg>, id: WebGLShaderId, shader_type: u32) -> WebGLShader { @@ -65,18 +68,18 @@ impl WebGLShader { } pub fn maybe_new(window: &Window, - renderer: WebGLMsgSender, + renderer: IpcSender<CanvasMsg>, shader_type: u32) -> Option<Root<WebGLShader>> { - let (sender, receiver) = webgl_channel().unwrap(); - renderer.send(WebGLCommand::CreateShader(shader_type, sender)).unwrap(); + let (sender, receiver) = webrender_api::channel::msg_channel().unwrap(); + renderer.send(CanvasMsg::WebGL(WebGLCommand::CreateShader(shader_type, sender))).unwrap(); let result = receiver.recv().unwrap(); result.map(|shader_id| WebGLShader::new(window, renderer, shader_id, shader_type)) } pub fn new(window: &Window, - renderer: WebGLMsgSender, + renderer: IpcSender<CanvasMsg>, id: WebGLShaderId, shader_type: u32) -> Root<WebGLShader> { @@ -115,7 +118,7 @@ impl WebGLShader { // will succeed. // It could be interesting to retrieve the info log from the paint thread though let msg = WebGLCommand::CompileShader(self.id, translated_source); - self.renderer.send(msg).unwrap(); + self.renderer.send(CanvasMsg::WebGL(msg)).unwrap(); self.compilation_status.set(ShaderCompilationStatus::Succeeded); }, Err(error) => { @@ -139,7 +142,7 @@ impl WebGLShader { pub fn delete(&self) { if !self.is_deleted.get() { self.is_deleted.set(true); - let _ = self.renderer.send(WebGLCommand::DeleteShader(self.id)); + let _ = self.renderer.send(CanvasMsg::WebGL(WebGLCommand::DeleteShader(self.id))); } } @@ -167,8 +170,8 @@ impl WebGLShader { /// glGetParameter pub fn parameter(&self, param_id: u32) -> WebGLResult<WebGLParameter> { - let (sender, receiver) = webgl_channel().unwrap(); - self.renderer.send(WebGLCommand::GetShaderParameter(self.id, param_id, sender)).unwrap(); + let (sender, receiver) = webrender_api::channel::msg_channel().unwrap(); + self.renderer.send(CanvasMsg::WebGL(WebGLCommand::GetShaderParameter(self.id, param_id, sender))).unwrap(); receiver.recv().unwrap() } diff --git a/components/script/dom/webgltexture.rs b/components/script/dom/webgltexture.rs index 048af5d10e0..88d5faaf5c8 100644 --- a/components/script/dom/webgltexture.rs +++ b/components/script/dom/webgltexture.rs @@ -3,8 +3,7 @@ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ // https://www.khronos.org/registry/webgl/specs/latest/1.0/webgl.idl - -use canvas_traits::webgl::{webgl_channel, WebGLCommand, WebGLError, WebGLMsgSender, WebGLResult, WebGLTextureId}; +use canvas_traits::CanvasMsg; use dom::bindings::cell::DOMRefCell; use dom::bindings::codegen::Bindings::WebGLRenderingContextBinding::WebGLRenderingContextConstants as constants; use dom::bindings::codegen::Bindings::WebGLTextureBinding; @@ -14,8 +13,11 @@ use dom::webgl_validations::types::{TexImageTarget, TexFormat, TexDataType}; use dom::webglobject::WebGLObject; use dom::window::Window; use dom_struct::dom_struct; +use ipc_channel::ipc::IpcSender; use std::cell::Cell; use std::cmp; +use webrender_api; +use webrender_api::{WebGLCommand, WebGLError, WebGLResult, WebGLTextureId}; pub enum TexParameterValue { Float(f32), @@ -44,11 +46,11 @@ pub struct WebGLTexture { min_filter: Cell<Option<u32>>, mag_filter: Cell<Option<u32>>, #[ignore_heap_size_of = "Defined in ipc-channel"] - renderer: WebGLMsgSender, + renderer: IpcSender<CanvasMsg>, } impl WebGLTexture { - fn new_inherited(renderer: WebGLMsgSender, + fn new_inherited(renderer: IpcSender<CanvasMsg>, id: WebGLTextureId) -> WebGLTexture { WebGLTexture { @@ -65,17 +67,17 @@ impl WebGLTexture { } } - pub fn maybe_new(window: &Window, renderer: WebGLMsgSender) + pub fn maybe_new(window: &Window, renderer: IpcSender<CanvasMsg>) -> Option<Root<WebGLTexture>> { - let (sender, receiver) = webgl_channel().unwrap(); - renderer.send(WebGLCommand::CreateTexture(sender)).unwrap(); + let (sender, receiver) = webrender_api::channel::msg_channel().unwrap(); + renderer.send(CanvasMsg::WebGL(WebGLCommand::CreateTexture(sender))).unwrap(); let result = receiver.recv().unwrap(); result.map(|texture_id| WebGLTexture::new(window, renderer, texture_id)) } pub fn new(window: &Window, - renderer: WebGLMsgSender, + renderer: IpcSender<CanvasMsg>, id: WebGLTextureId) -> Root<WebGLTexture> { reflect_dom_object(box WebGLTexture::new_inherited(renderer, id), @@ -111,7 +113,7 @@ impl WebGLTexture { self.target.set(Some(target)); } - let msg = WebGLCommand::BindTexture(target, Some(self.id)); + let msg = CanvasMsg::WebGL(WebGLCommand::BindTexture(target, Some(self.id))); self.renderer.send(msg).unwrap(); Ok(()) @@ -166,7 +168,7 @@ impl WebGLTexture { return Err(WebGLError::InvalidOperation); } - self.renderer.send(WebGLCommand::GenerateMipmap(target)).unwrap(); + self.renderer.send(CanvasMsg::WebGL(WebGLCommand::GenerateMipmap(target))).unwrap(); if self.base_mipmap_level + base_image_info.get_max_mimap_levels() == 0 { return Err(WebGLError::InvalidOperation); @@ -179,7 +181,7 @@ impl WebGLTexture { pub fn delete(&self) { if !self.is_deleted.get() { self.is_deleted.set(true); - let _ = self.renderer.send(WebGLCommand::DeleteTexture(self.id)); + let _ = self.renderer.send(CanvasMsg::WebGL(WebGLCommand::DeleteTexture(self.id))); } } @@ -214,7 +216,7 @@ impl WebGLTexture { constants::LINEAR_MIPMAP_LINEAR => { self.min_filter.set(Some(int_value as u32)); self.renderer - .send(WebGLCommand::TexParameteri(target, name, int_value)) + .send(CanvasMsg::WebGL(WebGLCommand::TexParameteri(target, name, int_value))) .unwrap(); Ok(()) }, @@ -228,7 +230,7 @@ impl WebGLTexture { constants::LINEAR => { self.mag_filter.set(Some(int_value as u32)); self.renderer - .send(WebGLCommand::TexParameteri(target, name, int_value)) + .send(CanvasMsg::WebGL(WebGLCommand::TexParameteri(target, name, int_value))) .unwrap(); Ok(()) }, @@ -243,7 +245,7 @@ impl WebGLTexture { constants::MIRRORED_REPEAT | constants::REPEAT => { self.renderer - .send(WebGLCommand::TexParameteri(target, name, int_value)) + .send(CanvasMsg::WebGL(WebGLCommand::TexParameteri(target, name, int_value))) .unwrap(); Ok(()) }, diff --git a/components/script/dom/webgluniformlocation.rs b/components/script/dom/webgluniformlocation.rs index 47292adeb18..228808303c4 100644 --- a/components/script/dom/webgluniformlocation.rs +++ b/components/script/dom/webgluniformlocation.rs @@ -3,12 +3,12 @@ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ // https://www.khronos.org/registry/webgl/specs/latest/1.0/webgl.idl -use canvas_traits::webgl::WebGLProgramId; use dom::bindings::codegen::Bindings::WebGLUniformLocationBinding; use dom::bindings::js::Root; use dom::bindings::reflector::{Reflector, reflect_dom_object}; use dom::window::Window; use dom_struct::dom_struct; +use webrender_api::WebGLProgramId; #[dom_struct] pub struct WebGLUniformLocation { diff --git a/components/script/dom/window.rs b/components/script/dom/window.rs index 2da650ee1ee..90693a2ccbf 100644 --- a/components/script/dom/window.rs +++ b/components/script/dom/window.rs @@ -5,7 +5,6 @@ use app_units::Au; use base64; use bluetooth_traits::BluetoothRequest; -use canvas_traits::webgl::WebGLChan; use cssparser::{Parser, ParserInput}; use devtools_traits::{ScriptToDevtoolsControlMsg, TimelineMarker, TimelineMarkerType}; use dom::bindings::cell::DOMRefCell; @@ -265,11 +264,7 @@ pub struct Window { /// A handle for communicating messages to the webvr thread, if available. #[ignore_heap_size_of = "channels are hard"] - webgl_chan: WebGLChan, - - /// A handle for communicating messages to the webvr thread, if available. - #[ignore_heap_size_of = "channels are hard"] - webvr_chan: Option<IpcSender<WebVRMsg>>, + webvr_thread: Option<IpcSender<WebVRMsg>>, /// A map for storing the previous permission state read results. permission_state_invocation_results: DOMRefCell<HashMap<String, PermissionState>>, @@ -385,12 +380,8 @@ impl Window { self.current_viewport.clone().get() } - pub fn webgl_chan(&self) -> WebGLChan { - self.webgl_chan.clone() - } - pub fn webvr_thread(&self) -> Option<IpcSender<WebVRMsg>> { - self.webvr_chan.clone() + self.webvr_thread.clone() } fn new_paint_worklet(&self) -> Root<Worklet> { @@ -1809,8 +1800,7 @@ impl Window { origin: MutableOrigin, navigation_start: u64, navigation_start_precise: f64, - webgl_chan: WebGLChan, - webvr_chan: Option<IpcSender<WebVRMsg>>) + webvr_thread: Option<IpcSender<WebVRMsg>>) -> Root<Window> { let layout_rpc: Box<LayoutRPC + Send> = { let (rpc_send, rpc_recv) = channel(); @@ -1876,8 +1866,7 @@ impl Window { scroll_offsets: DOMRefCell::new(HashMap::new()), media_query_lists: WeakMediaQueryListVec::new(), test_runner: Default::default(), - webgl_chan: webgl_chan, - webvr_chan: webvr_chan, + webvr_thread: webvr_thread, permission_state_invocation_results: DOMRefCell::new(HashMap::new()), pending_layout_images: DOMRefCell::new(HashMap::new()), unminified_js_dir: DOMRefCell::new(None), diff --git a/components/script/script_thread.rs b/components/script/script_thread.rs index 4a05002637a..ea8038897ac 100644 --- a/components/script/script_thread.rs +++ b/components/script/script_thread.rs @@ -18,7 +18,6 @@ //! loop. use bluetooth_traits::BluetoothRequest; -use canvas_traits::webgl::WebGLPipeline; use devtools; use devtools_traits::{DevtoolScriptControlMsg, DevtoolsPageInfo}; use devtools_traits::{ScriptToDevtoolsControlMsg, WorkerId}; @@ -509,11 +508,8 @@ pub struct ScriptThread { /// The unit of related similar-origin browsing contexts' list of MutationObserver objects mutation_observers: DOMRefCell<Vec<JS<MutationObserver>>>, - /// A handle to the webgl thread - webgl_chan: WebGLPipeline, - /// A handle to the webvr thread, if available - webvr_chan: Option<IpcSender<WebVRMsg>>, + webvr_thread: Option<IpcSender<WebVRMsg>>, /// The worklet thread pool worklet_thread_pool: DOMRefCell<Option<Rc<WorkletThreadPool>>>, @@ -885,8 +881,7 @@ impl ScriptThread { layout_to_constellation_chan: state.layout_to_constellation_chan, - webgl_chan: state.webgl_chan, - webvr_chan: state.webvr_chan, + webvr_thread: state.webvr_thread, worklet_thread_pool: Default::default(), @@ -2033,8 +2028,7 @@ impl ScriptThread { origin, incomplete.navigation_start, incomplete.navigation_start_precise, - self.webgl_chan.channel(), - self.webvr_chan.clone()); + self.webvr_thread.clone()); // Initialize the browsing context for the window. let window_proxy = self.local_window_proxy(&window, |