Auto merge of #8206 - Ms2ger:dlb-canvas, r=jdm

Cleanup layout interaction with canvas elements. 



<!-- Reviewable:start -->
[<img src="https://reviewable.io/review_button.png" height=40 alt="Review on Reviewable"/>](https://reviewable.io/reviews/servo/servo/8206)
<!-- Reviewable:end -->

5 files changed, 40 insertions, 68 deletions

diff --git a/components/layout/construct.rs b/components/layout/construct.rs
index 2ed8f286db0..7d3a0b748b0 100644
--- a/components/layout/construct.rs
+++ b/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.
diff --git a/components/layout/display_list_builder.rs b/components/layout/display_list_builder.rs
index 406b439ad29..1794123bf39 100644
--- a/components/layout/display_list_builder.rs
+++ b/components/layout/display_list_builder.rs
@@ -1157,11 +1157,11 @@ impl FragmentDisplayListBuilding for Fragment {
                 let height = canvas_fragment_info.replaced_image_fragment_info
                     .computed_block_size.map_or(0, |h| h.to_px() as usize);
                 if width > 0 && height > 0 {
-                    let (sender, receiver) = ipc::channel::<IpcSharedMemory>().unwrap();
                     let layer_id = self.layer_id();
                     let canvas_data = match canvas_fragment_info.ipc_renderer {
                         Some(ref ipc_renderer) =>  {
                             let ipc_renderer = ipc_renderer.lock().unwrap();
+                            let (sender, receiver) = ipc::channel().unwrap();
                             ipc_renderer.send(CanvasMsg::FromLayout(
                                 FromLayoutMsg::SendPixelContents(sender))).unwrap();
                             let data = receiver.recv().unwrap();
diff --git a/components/layout/fragment.rs b/components/layout/fragment.rs
index 0364e4a2300..ce0047e3ce9 100644
--- a/components/layout/fragment.rs
+++ b/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(node.canvas_height() as i32))),
-            renderer_id: node.canvas_renderer_id(),
-            ipc_renderer: node.canvas_ipc_renderer()
+                Some(Au::from_px(data.width as i32)),
+                Some(Au::from_px(data.height as i32))),
+            renderer_id: data.renderer_id,
+            ipc_renderer: data.ipc_renderer
                               .map(|renderer| Arc::new(Mutex::new(renderer))),
         }
     }
diff --git a/components/layout/wrapper.rs b/components/layout/wrapper.rs
index e2c0bd89f19..438f63ec753 100644
--- a/components/layout/wrapper.rs
+++ b/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())
-        }
-    }
-
-    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()
+            canvas_element.map(|canvas| canvas.data())
         }
     }
 
diff --git a/components/script/dom/htmlcanvaselement.rs b/components/script/dom/htmlcanvaselement.rs
index d6e484a2f9d..2fdb8a129e6 100644
--- a/components/script/dom/htmlcanvaselement.rs
+++ b/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)]
-    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;
+    fn data(&self) -> HTMLCanvasData;
 }
 
 impl LayoutHTMLCanvasElementHelpers for LayoutJS<HTMLCanvasElement> {
     #[allow(unsafe_code)]
-    unsafe fn get_renderer_id(&self) -> Option<usize> {
-        let ref canvas = *self.unsafe_get();
-        canvas.context.borrow_for_layout().as_ref().map(|context| {
-            match *context {
-                CanvasContext::Context2d(ref context) => context.to_layout().get_renderer_id(),
-                CanvasContext::WebGL(ref context) => context.to_layout().get_renderer_id(),
-            }
-        })
-    }
+    fn data(&self) -> HTMLCanvasData {
+        unsafe {
+            let canvas = &*self.unsafe_get();
+            let (renderer_id, ipc_renderer) = match canvas.context.borrow_for_layout().as_ref() {
+                Some(&CanvasContext::Context2d(ref context)) => {
+                    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)]
-    unsafe fn get_ipc_renderer(&self) -> Option<IpcSender<CanvasMsg>> {
-        let ref canvas = *self.unsafe_get();
-        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(),
+            HTMLCanvasData {
+                renderer_id: renderer_id,
+                ipc_renderer: ipc_renderer,
+                width: canvas.width.get(),
+                height: canvas.height.get(),
             }
-        })
-    }
-
-    #[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()
+        }
     }
 }