1 files changed, 14 insertions, 37 deletions

diff --git a/components/script/dom/canvasrenderingcontext2d.rs b/components/script/dom/canvasrenderingcontext2d.rs
index 748f3746c6e..9a6443c052f 100644
--- a/components/script/dom/canvasrenderingcontext2d.rs
+++ b/components/script/dom/canvasrenderingcontext2d.rs
@@ -143,6 +143,10 @@ impl CanvasRenderingContext2D {
             .unwrap();
     }
 
+    pub fn ipc_renderer(&self) -> IpcSender<CanvasMsg> {
+        self.ipc_renderer.clone()
+    }
+
     fn mark_as_dirty(&self) {
         let canvas = self.canvas.root();
         let node = NodeCast::from_ref(canvas.r());
@@ -245,6 +249,7 @@ impl CanvasRenderingContext2D {
                         // Pixels come from cache in BGRA order and drawImage expects RGBA so we
                         // have to swap the color values
                         byte_swap(&mut data);
+                        let size = Size2D::new(size.width as f64, size.height as f64);
                         (data, size)
                     },
                     None => return Err(InvalidState),
@@ -338,7 +343,7 @@ impl CanvasRenderingContext2D {
 
     fn fetch_image_data(&self,
                         image_element: &HTMLImageElement)
-                        -> Option<(Vec<u8>, Size2D<f64>)> {
+                        -> Option<(Vec<u8>, Size2D<i32>)> {
         let url = match image_element.get_url() {
             Some(url) => url,
             None => return None,
@@ -351,7 +356,7 @@ impl CanvasRenderingContext2D {
             }
         };
 
-        let image_size = Size2D::new(img.width as f64, img.height as f64);
+        let image_size = Size2D::new(img.width as i32, img.height as i32);
         let image_data = match img.format {
             PixelFormat::RGBA8 => img.bytes.to_vec(),
             PixelFormat::K8 => panic!("K8 color type not supported"),
@@ -362,28 +367,6 @@ impl CanvasRenderingContext2D {
         Some((image_data, image_size))
     }
 
-    // TODO(ecoal95): Move this to `HTMLCanvasElement`, and support WebGL contexts
-    fn fetch_canvas_data(&self,
-                         canvas_element: &HTMLCanvasElement,
-                         source_rect: Rect<f64>)
-                         -> Option<(Vec<u8>, Size2D<f64>)> {
-        let context = match canvas_element.get_or_init_2d_context() {
-            Some(context) => context,
-            None => return None,
-        };
-
-        let canvas_size = canvas_element.get_size();
-        let image_size = Size2D::new(canvas_size.width as f64, canvas_size.height as f64);
-
-        let renderer = context.r().get_ipc_renderer();
-        let (sender, receiver) = ipc::channel::<Vec<u8>>().unwrap();
-        // Reads pixels from source canvas
-        renderer.send(CanvasMsg::Canvas2d(Canvas2dMsg::GetImageData(source_rect.to_i32(),
-                                                                    image_size, sender))).unwrap();
-
-        Some((receiver.recv().unwrap(), image_size))
-    }
-
     #[inline]
     fn request_image_from_cache(&self, url: Url) -> ImageResponse {
         let canvas = self.canvas.root();
@@ -975,26 +958,20 @@ impl CanvasRenderingContext2DMethods for CanvasRenderingContext2D {
                 }
             },
             HTMLImageElementOrHTMLCanvasElementOrCanvasRenderingContext2D::eHTMLCanvasElement(canvas) => {
-                let canvas_element = canvas.r();
-
-                let canvas_size = canvas_element.get_size();
-                let source_rect = Rect::new(Point2D::zero(),
-                                            Size2D::new(canvas_size.width as f64, canvas_size.height as f64));
+                let canvas = canvas.r();
+                let _ = canvas.get_or_init_2d_context();
 
-                match self.fetch_canvas_data(&canvas_element, source_rect) {
+                match canvas.fetch_all_data() {
                     Some((data, size)) => (data, size),
                     None => return Err(InvalidState),
                 }
             },
             HTMLImageElementOrHTMLCanvasElementOrCanvasRenderingContext2D::eCanvasRenderingContext2D(context) => {
                 let canvas = context.r().Canvas();
-                let canvas_element = canvas.r();
-
-                let canvas_size = canvas_element.get_size();
-                let source_rect = Rect::new(Point2D::zero(),
-                                            Size2D::new(canvas_size.width as f64, canvas_size.height as f64));
+                let canvas = canvas.r();
+                let _ = canvas.get_or_init_2d_context();
 
-                match self.fetch_canvas_data(&canvas_element, source_rect) {
+                match canvas.fetch_all_data() {
                     Some((data, size)) => (data, size),
                     None => return Err(InvalidState),
                 }
@@ -1004,7 +981,7 @@ impl CanvasRenderingContext2DMethods for CanvasRenderingContext2D {
         if let Ok(rep) = RepetitionStyle::from_str(&repetition) {
             return Ok(CanvasPattern::new(self.global.root().r(),
                                          image_data,
-                                         Size2D::new(image_size.width as i32, image_size.height as i32),
+                                         image_size,
                                          rep));
         }
         return Err(Syntax);