Pass all the data layout needs from canvas elements at once.

components/layout/construct.rs

@@ -327,7 +327,8 @@ impl<'a> FlowConstructor<'a> {
             }
             Some(NodeTypeId::Element(ElementTypeId::HTMLElement(
                         HTMLElementTypeId::HTMLCanvasElement))) => {
-                SpecificFragmentInfo::Canvas(box CanvasFragmentInfo::new(node))
+                let data = node.canvas_data().unwrap();
+                SpecificFragmentInfo::Canvas(box CanvasFragmentInfo::new(node, data))
             }
             _ => {
                 // This includes pseudo-elements.

components/layout/fragment.rs

@@ -28,6 +28,7 @@ use msg::constellation_msg::PipelineId;
 use net_traits::image::base::Image;
 use net_traits::image_cache_task::UsePlaceholder;
 use rustc_serialize::{Encodable, Encoder};
+use script::dom::htmlcanvaselement::HTMLCanvasData;
 use std::borrow::ToOwned;
 use std::cmp::{max, min};
 use std::collections::LinkedList;
@@ -308,13 +309,13 @@ pub struct CanvasFragmentInfo {
 }
 
 impl CanvasFragmentInfo {
-    pub fn new(node: &ThreadSafeLayoutNode) -> CanvasFragmentInfo {
+    pub fn new(node: &ThreadSafeLayoutNode, data: HTMLCanvasData) -> CanvasFragmentInfo {
         CanvasFragmentInfo {
             replaced_image_fragment_info: ReplacedImageFragmentInfo::new(node,
-                Some(Au::from_px(node.canvas_width() as i32)),
+                Some(Au::from_px(data.width as i32)),
-                Some(Au::from_px(node.canvas_height() as i32))),
+                Some(Au::from_px(data.height as i32))),
-            renderer_id: node.canvas_renderer_id(),
+            renderer_id: data.renderer_id,
-            ipc_renderer: node.canvas_ipc_renderer()
+            ipc_renderer: data.ipc_renderer
                               .map(|renderer| Arc::new(Mutex::new(renderer))),
         }
     }

components/layout/wrapper.rs

@@ -30,13 +30,11 @@
 
 #![allow(unsafe_code)]
 
-use canvas_traits::CanvasMsg;
 use context::SharedLayoutContext;
 use data::{LayoutDataFlags, LayoutDataWrapper, PrivateLayoutData};
 use gfx::display_list::OpaqueNode;
 use gfx::text::glyph::CharIndex;
 use incremental::RestyleDamage;
-use ipc_channel::ipc::IpcSender;
 use msg::constellation_msg::PipelineId;
 use opaque_node::OpaqueNodeMethods;
 use script::dom::attr::AttrValue;
@@ -47,7 +45,7 @@ use script::dom::bindings::js::LayoutJS;
 use script::dom::characterdata::LayoutCharacterDataHelpers;
 use script::dom::element;
 use script::dom::element::{Element, LayoutElementHelpers, RawLayoutElementHelpers};
-use script::dom::htmlcanvaselement::LayoutHTMLCanvasElementHelpers;
+use script::dom::htmlcanvaselement::{LayoutHTMLCanvasElementHelpers, HTMLCanvasData};
 use script::dom::htmliframeelement::HTMLIFrameElement;
 use script::dom::htmlimageelement::LayoutHTMLImageElementHelpers;
 use script::dom::htmlinputelement::{HTMLInputElement, LayoutHTMLInputElementHelpers};
@@ -945,31 +943,10 @@ impl<'ln> ThreadSafeLayoutNode<'ln> {
         }
     }
 
-    pub fn canvas_renderer_id(&self) -> Option<usize> {
+    pub fn canvas_data(&self) -> Option<HTMLCanvasData> {
         unsafe {
             let canvas_element = self.get_jsmanaged().downcast();
-            canvas_element.and_then(|elem| elem.get_renderer_id())
+            canvas_element.map(|canvas| canvas.data())
-        }
-    }
-
-    pub fn canvas_ipc_renderer(&self) -> Option<IpcSender<CanvasMsg>> {
-        unsafe {
-            let canvas_element = self.get_jsmanaged().downcast();
-            canvas_element.and_then(|elem| elem.get_ipc_renderer())
-        }
-    }
-
-    pub fn canvas_width(&self) -> u32 {
-        unsafe {
-            let canvas_element = self.get_jsmanaged().downcast();
-            canvas_element.unwrap().get_canvas_width()
-        }
-    }
-
-    pub fn canvas_height(&self) -> u32 {
-        unsafe {
-            let canvas_element = self.get_jsmanaged().downcast();
-            canvas_element.unwrap().get_canvas_height()
         }
     }
 

components/script/dom/htmlcanvaselement.rs

@@ -89,48 +89,41 @@ impl HTMLCanvasElement {
     }
 }
 
+pub struct HTMLCanvasData {
+    pub renderer_id: Option<usize>,
+    pub ipc_renderer: Option<IpcSender<CanvasMsg>>,
+    pub width: u32,
+    pub height: u32,
+}
+
 pub trait LayoutHTMLCanvasElementHelpers {
-    #[allow(unsafe_code)]
+    fn data(&self) -> HTMLCanvasData;
-    unsafe fn get_renderer_id(&self) -> Option<usize>;
-    #[allow(unsafe_code)]
-    unsafe fn get_ipc_renderer(&self) -> Option<IpcSender<CanvasMsg>>;
-    #[allow(unsafe_code)]
-    unsafe fn get_canvas_width(&self) -> u32;
-    #[allow(unsafe_code)]
-    unsafe fn get_canvas_height(&self) -> u32;
 }
 
 impl LayoutHTMLCanvasElementHelpers for LayoutJS<HTMLCanvasElement> {
     #[allow(unsafe_code)]
-    unsafe fn get_renderer_id(&self) -> Option<usize> {
+    fn data(&self) -> HTMLCanvasData {
-        let ref canvas = *self.unsafe_get();
+        unsafe {
-        canvas.context.borrow_for_layout().as_ref().map(|context| {
+            let canvas = &*self.unsafe_get();
-            match *context {
+            let (renderer_id, ipc_renderer) = match canvas.context.borrow_for_layout().as_ref() {
-                CanvasContext::Context2d(ref context) => context.to_layout().get_renderer_id(),
+                Some(&CanvasContext::Context2d(ref context)) => {
-                CanvasContext::WebGL(ref context) => context.to_layout().get_renderer_id(),
+                    let context = context.to_layout();
-            }
+                    (Some(context.get_renderer_id()), Some(context.get_ipc_renderer()))
-        })
+                },
-    }
+                Some(&CanvasContext::WebGL(ref context)) => {
+                    let context = context.to_layout();
+                    (Some(context.get_renderer_id()), Some(context.get_ipc_renderer()))
+                },
+                None => (None, None),
+            };
 
-    #[allow(unsafe_code)]
+            HTMLCanvasData {
-    unsafe fn get_ipc_renderer(&self) -> Option<IpcSender<CanvasMsg>> {
+                renderer_id: renderer_id,
-        let ref canvas = *self.unsafe_get();
+                ipc_renderer: ipc_renderer,
-        canvas.context.borrow_for_layout().as_ref().map(|context| {
+                width: canvas.width.get(),
-            match *context {
+                height: canvas.height.get(),
-                CanvasContext::Context2d(ref context) => context.to_layout().get_ipc_renderer(),
-                CanvasContext::WebGL(ref context) => context.to_layout().get_ipc_renderer(),
             }
-        })
         }
-
-    #[allow(unsafe_code)]
-    unsafe fn get_canvas_width(&self) -> u32 {
-        (*self.unsafe_get()).width.get()
-    }
-
-    #[allow(unsafe_code)]
-    unsafe fn get_canvas_height(&self) -> u32 {
-        (*self.unsafe_get()).height.get()
     }
 }