Simplify ctx.drawImage a bit

There is no need to swap between RGBA and BGRA twice.

components/canvas/canvas_paint_thread.rs

@@ -7,7 +7,6 @@ use canvas_data::*;
 use canvas_traits::canvas::*;
 use euclid::Size2D;
 use ipc_channel::ipc::{self, IpcSender};
-use pixels;
 use std::borrow::ToOwned;
 use std::collections::HashMap;
 use std::thread;
@@ -139,13 +138,10 @@ impl<'a> CanvasPaintThread <'a> {
                 source_rect,
                 smoothing_enabled,
             ) => {
-                let data = match imagedata {
+                let data = imagedata.map_or_else(
-                    None => vec![0; image_size.width as usize * image_size.height as usize * 4],
+                    || vec![0; image_size.width as usize * image_size.height as usize * 4],
-                    Some(mut data) => {
+                    |bytes| bytes.into(),
-                        pixels::byte_swap_colors_inplace(&mut data);
+                );
-                        data.into()
-                    },
-                };
                 self.canvas(canvas_id).draw_image(
                     data,
                     image_size,

components/script/dom/canvasrenderingcontext2d.rs

@@ -403,39 +403,16 @@ impl CanvasRenderingContext2D {
         dh: Option<f64>,
     ) -> ErrorResult {
         debug!("Fetching image {}.", url);
-        // https://html.spec.whatwg.org/multipage/#img-error
+        let (mut image_data, image_size) =
-        // If the image argument is an HTMLImageElement object that is in the broken state,
+            self.fetch_image_data(url).ok_or(Error::InvalidState)?;
-        // then throw an InvalidStateError exception
+        pixels::premultiply_inplace(&mut image_data);
-        let (image_data, image_size) = match self.fetch_image_data(url) {
+        let image_size = image_size.to_f64();
-            Some((mut data, size)) => {
+
-                // Pixels come from cache in BGRA order and drawImage expects RGBA so we
-                // have to swap the color values
-                pixels::byte_swap_and_premultiply_inplace(&mut data);
-                let size = Size2D::new(size.width as f64, size.height as f64);
-                (data, size)
-            },
-            None => return Err(Error::InvalidState),
-        };
         let dw = dw.unwrap_or(image_size.width);
         let dh = dh.unwrap_or(image_size.height);
         let sw = sw.unwrap_or(image_size.width);
         let sh = sh.unwrap_or(image_size.height);
-        self.draw_image_data(image_data, image_size, sx, sy, sw, sh, dx, dy, dw, dh)
-    }
 
-    fn draw_image_data(
-        &self,
-        image_data: Vec<u8>,
-        image_size: Size2D<f64>,
-        sx: f64,
-        sy: f64,
-        sw: f64,
-        sh: f64,
-        dx: f64,
-        dy: f64,
-        dw: f64,
-        dh: f64,
-    ) -> ErrorResult {
         // Establish the source and destination rectangles
         let (source_rect, dest_rect) =
             self.adjust_source_dest_rects(image_size, sx, sy, sw, sh, dx, dy, dw, dh);