Auto merge of #21850 - servo:webgl, r=jdm

Don't use an intermediate PNG buffer in HTMLCanvasElement::ToDataURL

<!-- Reviewable:start -->
This change is [<img src="https://reviewable.io/review_button.svg" height="34" align="absmiddle" alt="Reviewable"/>](https://reviewable.io/reviews/servo/servo/21850)
<!-- Reviewable:end -->

16 files changed, 210 insertions, 175 deletions

diff --git a/components/canvas/canvas_data.rs b/components/canvas/canvas_data.rs
index b1768fe8744..c91dbd8c826 100644
--- a/components/canvas/canvas_data.rs
+++ b/components/canvas/canvas_data.rs
@@ -35,7 +35,7 @@ pub struct CanvasData<'a> {
 
 impl<'a> CanvasData<'a> {
     pub fn new(
-        size: Size2D<i32>,
+        size: Size2D<u32>,
         webrender_api_sender: webrender_api::RenderApiSender,
         antialias: AntialiasMode,
         canvas_id: CanvasId
@@ -369,11 +369,12 @@ impl<'a> CanvasData<'a> {
         self.state.draw_options.set_composition_op(op.to_azure_style());
     }
 
-    pub fn create(size: Size2D<i32>) -> DrawTarget {
-        DrawTarget::new(BackendType::Skia, size, SurfaceFormat::B8G8R8A8)
+    pub fn create(size: Size2D<u32>) -> DrawTarget {
+        // FIXME(nox): Why is the size made of i32 values?
+        DrawTarget::new(BackendType::Skia, size.to_i32(), SurfaceFormat::B8G8R8A8)
     }
 
-    pub fn recreate(&mut self, size: Size2D<i32>) {
+    pub fn recreate(&mut self, size: Size2D<u32>) {
         self.drawtarget = CanvasData::create(size);
         self.state = CanvasPaintState::new(self.state.draw_options.antialias);
         self.saved_states.clear();
@@ -901,9 +902,9 @@ pub trait ToAzurePattern {
 
 impl ToAzurePattern for FillOrStrokeStyle {
     fn to_azure_pattern(&self, drawtarget: &DrawTarget) -> Option<Pattern> {
-        match *self {
+        Some(match *self {
             FillOrStrokeStyle::Color(ref color) => {
-                Some(Pattern::Color(ColorPattern::new(color.to_azure_style())))
+                Pattern::Color(ColorPattern::new(color.to_azure_style()))
             },
             FillOrStrokeStyle::LinearGradient(ref linear_gradient_style) => {
                 let gradient_stops: Vec<GradientStop> = linear_gradient_style.stops.iter().map(|s| {
@@ -913,11 +914,12 @@ impl ToAzurePattern for FillOrStrokeStyle {
                     }
                 }).collect();
 
-                Some(Pattern::LinearGradient(LinearGradientPattern::new(
+                Pattern::LinearGradient(LinearGradientPattern::new(
                     &Point2D::new(linear_gradient_style.x0 as AzFloat, linear_gradient_style.y0 as AzFloat),
                     &Point2D::new(linear_gradient_style.x1 as AzFloat, linear_gradient_style.y1 as AzFloat),
                     drawtarget.create_gradient_stops(&gradient_stops, ExtendMode::Clamp),
-                    &Transform2D::identity())))
+                    &Transform2D::identity(),
+                ))
             },
             FillOrStrokeStyle::RadialGradient(ref radial_gradient_style) => {
                 let gradient_stops: Vec<GradientStop> = radial_gradient_style.stops.iter().map(|s| {
@@ -927,27 +929,30 @@ impl ToAzurePattern for FillOrStrokeStyle {
                     }
                 }).collect();
 
-                Some(Pattern::RadialGradient(RadialGradientPattern::new(
+                Pattern::RadialGradient(RadialGradientPattern::new(
                     &Point2D::new(radial_gradient_style.x0 as AzFloat, radial_gradient_style.y0 as AzFloat),
                     &Point2D::new(radial_gradient_style.x1 as AzFloat, radial_gradient_style.y1 as AzFloat),
                     radial_gradient_style.r0 as AzFloat, radial_gradient_style.r1 as AzFloat,
                     drawtarget.create_gradient_stops(&gradient_stops, ExtendMode::Clamp),
-                    &Transform2D::identity())))
+                    &Transform2D::identity(),
+                ))
             },
             FillOrStrokeStyle::Surface(ref surface_style) => {
-                drawtarget.create_source_surface_from_data(&surface_style.surface_data,
-                                                           surface_style.surface_size,
-                                                           surface_style.surface_size.width * 4,
-                                                           SurfaceFormat::B8G8R8A8)
-                          .map(|source_surface| {
-                    Pattern::Surface(SurfacePattern::new(
-                        source_surface.azure_source_surface,
-                        surface_style.repeat_x,
-                        surface_style.repeat_y,
-                        &Transform2D::identity()))
-                    })
+                let source_surface = drawtarget.create_source_surface_from_data(
+                    &surface_style.surface_data,
+                    // FIXME(nox): Why are those i32 values?
+                    surface_style.surface_size.to_i32(),
+                    surface_style.surface_size.width as i32 * 4,
+                    SurfaceFormat::B8G8R8A8,
+                )?;
+                Pattern::Surface(SurfacePattern::new(
+                    source_surface.azure_source_surface,
+                    surface_style.repeat_x,
+                    surface_style.repeat_y,
+                    &Transform2D::identity(),
+                ))
             }
-        }
+        })
     }
 }
 
diff --git a/components/canvas/canvas_paint_thread.rs b/components/canvas/canvas_paint_thread.rs
index 3e66194e94c..90d338e9a4e 100644
--- a/components/canvas/canvas_paint_thread.rs
+++ b/components/canvas/canvas_paint_thread.rs
@@ -80,7 +80,7 @@ impl<'a> CanvasPaintThread <'a> {
 
     pub fn create_canvas(
         &mut self,
-        size: Size2D<i32>,
+        size: Size2D<u32>,
         webrender_api_sender: webrender_api::RenderApiSender,
         antialias: bool
     ) -> CanvasId {
diff --git a/components/canvas/gl_context.rs b/components/canvas/gl_context.rs
index c90ecec9cca..77cbc20e55b 100644
--- a/components/canvas/gl_context.rs
+++ b/components/canvas/gl_context.rs
@@ -47,63 +47,71 @@ impl GLContextFactory {
     pub fn new_shared_context(
         &self,
         webgl_version: WebGLVersion,
-        size: Size2D<i32>,
+        size: Size2D<u32>,
         attributes: GLContextAttributes
     ) -> Result<GLContextWrapper, &'static str> {
-        match *self {
+        Ok(match *self {
             GLContextFactory::Native(ref handle, ref dispatcher) => {
                 let dispatcher = dispatcher.as_ref().map(|d| Box::new(d.clone()) as Box<_>);
-                let ctx = GLContext::<NativeGLContext>::new_shared_with_dispatcher(size,
-                                                                                   attributes,
-                                                                                   ColorAttachmentType::Texture,
-                                                                                   gl::GlType::default(),
-                                                                                   Self::gl_version(webgl_version),
-                                                                                   Some(handle),
-                                                                                   dispatcher);
-                ctx.map(GLContextWrapper::Native)
+                GLContextWrapper::Native(GLContext::new_shared_with_dispatcher(
+                    // FIXME(nox): Why are those i32 values?
+                    size.to_i32(),
+                    attributes,
+                    ColorAttachmentType::Texture,
+                    gl::GlType::default(),
+                    Self::gl_version(webgl_version),
+                    Some(handle),
+                    dispatcher,
+                )?)
             }
             GLContextFactory::OSMesa(ref handle) => {
-                let ctx = GLContext::<OSMesaContext>::new_shared_with_dispatcher(size.to_untyped(),
-                                                                                 attributes,
-                                                                                 ColorAttachmentType::Texture,
-                                                                                 gl::GlType::default(),
-                                                                                 Self::gl_version(webgl_version),
-                                                                                 Some(handle),
-                                                                                 None);
-                ctx.map(GLContextWrapper::OSMesa)
+                GLContextWrapper::OSMesa(GLContext::new_shared_with_dispatcher(
+                    // FIXME(nox): Why are those i32 values?
+                    size.to_i32(),
+                    attributes,
+                    ColorAttachmentType::Texture,
+                    gl::GlType::default(),
+                    Self::gl_version(webgl_version),
+                    Some(handle),
+                    None,
+                )?)
             }
-        }
+        })
     }
 
     /// Creates a new non-shared GLContext
     pub fn new_context(
         &self,
         webgl_version: WebGLVersion,
-        size: Size2D<i32>,
+        size: Size2D<u32>,
         attributes: GLContextAttributes
     ) -> Result<GLContextWrapper, &'static str> {
-        match *self {
+        Ok(match *self {
             GLContextFactory::Native(..) => {
-                let ctx = GLContext::<NativeGLContext>::new_shared_with_dispatcher(size,
-                                                                                   attributes,
-                                                                                   ColorAttachmentType::Texture,
-                                                                                   gl::GlType::default(),
-                                                                                   Self::gl_version(webgl_version),
-                                                                                   None,
-                                                                                   None);
-                ctx.map(GLContextWrapper::Native)
+                GLContextWrapper::Native(GLContext::new_shared_with_dispatcher(
+                    // FIXME(nox): Why are those i32 values?
+                    size.to_i32(),
+                    attributes,
+                    ColorAttachmentType::Texture,
+                    gl::GlType::default(),
+                    Self::gl_version(webgl_version),
+                    None,
+                    None,
+                )?)
             }
             GLContextFactory::OSMesa(_) => {
-                let ctx = GLContext::<OSMesaContext>::new_shared_with_dispatcher(size.to_untyped(),
-                                                                                 attributes,
-                                                                                 ColorAttachmentType::Texture,
-                                                                                 gl::GlType::default(),
-                                                                                 Self::gl_version(webgl_version),
-                                                                                 None,
-                                                                                 None);
-                ctx.map(GLContextWrapper::OSMesa)
+                GLContextWrapper::OSMesa(GLContext::new_shared_with_dispatcher(
+                    // FIXME(nox): Why are those i32 values?
+                    size.to_i32(),
+                    attributes,
+                    ColorAttachmentType::Texture,
+                    gl::GlType::default(),
+                    Self::gl_version(webgl_version),
+                    None,
+                    None,
+                )?)
             }
-        }
+        })
     }
 
     fn gl_version(webgl_version: WebGLVersion) -> GLVersion {
@@ -196,13 +204,15 @@ impl GLContextWrapper {
         }
     }
 
-    pub fn resize(&mut self, size: Size2D<i32>) -> Result<(), &'static str> {
+    pub fn resize(&mut self, size: Size2D<u32>) -> Result<(), &'static str> {
         match *self {
             GLContextWrapper::Native(ref mut ctx) => {
-                ctx.resize(size)
+                // FIXME(nox): Why are those i32 values?
+                ctx.resize(size.to_i32())
             }
             GLContextWrapper::OSMesa(ref mut ctx) => {
-                ctx.resize(size)
+                // FIXME(nox): Why are those i32 values?
+                ctx.resize(size.to_i32())
             }
         }
     }
diff --git a/components/canvas/webgl_thread.rs b/components/canvas/webgl_thread.rs
index 4d8a4c044a2..413566e7817 100644
--- a/components/canvas/webgl_thread.rs
+++ b/components/canvas/webgl_thread.rs
@@ -216,57 +216,57 @@ impl<VR: WebVRRenderHandler + 'static> WebGLThread<VR> {
     }
 
     /// Creates a new WebGLContext
-    fn create_webgl_context(&mut self,
-                            version: WebGLVersion,
-                            size: Size2D<i32>,
-                            attributes: GLContextAttributes)
-                            -> Result<(WebGLContextId, GLLimits, WebGLContextShareMode), String> {
-        // First try to create a shared context for the best performance.
-        // Fallback to readback mode if the shared context creation fails.
-        let result = self.gl_factory.new_shared_context(version, size, attributes)
-                                    .map(|r| (r, WebGLContextShareMode::SharedTexture))
-                                    .or_else(|err| {
-                                        warn!("Couldn't create shared GL context ({}), using slow \
-                                               readback context instead.", err);
-                                        let ctx = self.gl_factory.new_context(version, size, attributes);
-                                        ctx.map(|r| (r, WebGLContextShareMode::Readback))
-                                    });
-
+    fn create_webgl_context(
+        &mut self,
+        version: WebGLVersion,
+        size: Size2D<u32>,
+        attributes: GLContextAttributes,
+    ) -> Result<(WebGLContextId, GLLimits, WebGLContextShareMode), String> {
         // Creating a new GLContext may make the current bound context_id dirty.
         // Clear it to ensure that  make_current() is called in subsequent commands.
         self.bound_context_id = None;
 
-        match result {
-            Ok((ctx, share_mode)) => {
-                let id = WebGLContextId(self.next_webgl_id);
-                let (size, texture_id, limits) = ctx.get_info();
-                self.next_webgl_id += 1;
-                self.contexts.insert(id, GLContextData {
-                    ctx,
-                    state: Default::default(),
-                });
-                self.cached_context_info.insert(id, WebGLContextInfo {
-                    texture_id,
-                    size,
-                    alpha: attributes.alpha,
-                    image_key: None,
-                    share_mode,
-                    gl_sync: None,
-                });
-
-                Ok((id, limits, share_mode))
-            },
-            Err(msg) => {
-                Err(msg.to_owned())
-            }
-        }
+        // First try to create a shared context for the best performance.
+        // Fallback to readback mode if the shared context creation fails.
+        let (ctx, share_mode) = self.gl_factory
+            .new_shared_context(version, size, attributes)
+            .map(|r| (r, WebGLContextShareMode::SharedTexture))
+            .or_else(|err| {
+                warn!(
+                    "Couldn't create shared GL context ({}), using slow readback context instead.",
+                    err
+                );
+                let ctx = self.gl_factory.new_context(version, size, attributes)?;
+                Ok((ctx, WebGLContextShareMode::Readback))
+            })
+            .map_err(|msg: &str| msg.to_owned())?;
+
+        let id = WebGLContextId(self.next_webgl_id);
+        let (size, texture_id, limits) = ctx.get_info();
+        self.next_webgl_id += 1;
+        self.contexts.insert(id, GLContextData {
+            ctx,
+            state: Default::default(),
+        });
+        self.cached_context_info.insert(id, WebGLContextInfo {
+            texture_id,
+            size,
+            alpha: attributes.alpha,
+            image_key: None,
+            share_mode,
+            gl_sync: None,
+        });
+
+        Ok((id, limits, share_mode))
     }
 
     /// Resizes a WebGLContext
-    fn resize_webgl_context(&mut self,
-                            context_id: WebGLContextId,
-                            size: Size2D<i32>,
-                            sender: WebGLSender<Result<(), String>>) {
+    fn resize_webgl_context(
+        &mut self,
+        context_id: WebGLContextId,
+        size: Size2D<u32>,
+        sender: WebGLSender<Result<(), String>>,
+    ) {
         let data = Self::make_current_if_needed_mut(
             context_id,
             &mut self.contexts,
@@ -798,8 +798,12 @@ impl WebGLImpl {
                 ctx.gl().renderbuffer_storage(target, format, width, height),
             WebGLCommand::SampleCoverage(value, invert) =>
                 ctx.gl().sample_coverage(value, invert),
-            WebGLCommand::Scissor(x, y, width, height) =>
-                ctx.gl().scissor(x, y, width, height),
+            WebGLCommand::Scissor(x, y, width, height) => {
+                // FIXME(nox): Kinda unfortunate that some u32 values could
+                // end up as negative numbers here, but I don't even think
+                // that can happen in the real world.
+                ctx.gl().scissor(x, y, width as i32, height as i32);
+            },
             WebGLCommand::StencilFunc(func, ref_, mask) =>
                 ctx.gl().stencil_func(func, ref_, mask),
             WebGLCommand::StencilFuncSeparate(face, func, ref_, mask) =>
diff --git a/components/canvas_traits/canvas.rs b/components/canvas_traits/canvas.rs
index a9d47d252a4..ec3f623e634 100644
--- a/components/canvas_traits/canvas.rs
+++ b/components/canvas_traits/canvas.rs
@@ -22,10 +22,10 @@ pub struct CanvasId(pub u64);
 #[derive(Clone, Deserialize, Serialize)]
 pub enum CanvasMsg {
     Canvas2d(Canvas2dMsg, CanvasId),
-    Create(IpcSender<CanvasId>, Size2D<i32>, webrender_api::RenderApiSender, bool),
+    Create(IpcSender<CanvasId>, Size2D<u32>, webrender_api::RenderApiSender, bool),
     FromLayout(FromLayoutMsg, CanvasId),
     FromScript(FromScriptMsg, CanvasId),
-    Recreate(Size2D<i32>, CanvasId),
+    Recreate(Size2D<u32>, CanvasId),
     Close(CanvasId),
 }
 
@@ -143,7 +143,7 @@ impl RadialGradientStyle {
 #[derive(Clone, Deserialize, Serialize)]
 pub struct SurfaceStyle {
     pub surface_data: ByteBuf,
-    pub surface_size: Size2D<i32>,
+    pub surface_size: Size2D<u32>,
     pub repeat_x: bool,
     pub repeat_y: bool,
 }
@@ -151,7 +151,7 @@ pub struct SurfaceStyle {
 impl SurfaceStyle {
     pub fn new(
         surface_data: Vec<u8>,
-        surface_size: Size2D<i32>,
+        surface_size: Size2D<u32>,
         repeat_x: bool,
         repeat_y: bool,
     ) -> Self {
diff --git a/components/canvas_traits/webgl.rs b/components/canvas_traits/webgl.rs
index ad10ed7edd0..4c392972b8e 100644
--- a/components/canvas_traits/webgl.rs
+++ b/components/canvas_traits/webgl.rs
@@ -36,10 +36,14 @@ pub struct WebGLCommandBacktrace {
 #[derive(Deserialize, Serialize)]
 pub enum WebGLMsg {
     /// Creates a new WebGLContext.
-    CreateContext(WebGLVersion, Size2D<i32>, GLContextAttributes,
-                  WebGLSender<Result<(WebGLCreateContextResult), String>>),
+    CreateContext(
+        WebGLVersion,
+        Size2D<u32>,
+        GLContextAttributes,
+        WebGLSender<Result<(WebGLCreateContextResult), String>>,
+    ),
     /// Resizes a WebGLContext.
-    ResizeContext(WebGLContextId, Size2D<i32>, WebGLSender<Result<(), String>>),
+    ResizeContext(WebGLContextId, Size2D<u32>, WebGLSender<Result<(), String>>),
     /// Drops a WebGLContext.
     RemoveContext(WebGLContextId),
     /// Runs a WebGLCommand in a specific WebGLContext.
@@ -141,10 +145,11 @@ impl WebGLMsgSender {
 
     /// Send a resize message
     #[inline]
-    pub fn send_resize(&self,
-                       size: Size2D<i32>,
-                       sender: WebGLSender<Result<(), String>>)
-                       -> WebGLSendResult {
+    pub fn send_resize(
+        &self,
+        size: Size2D<u32>,
+        sender: WebGLSender<Result<(), String>>,
+    ) -> WebGLSendResult {
         self.sender.send(WebGLMsg::ResizeContext(self.ctx_id, size, sender))
     }
 
@@ -224,7 +229,7 @@ pub enum WebGLCommand {
     RenderbufferStorage(u32, u32, i32, i32),
     ReadPixels(i32, i32, i32, i32, u32, u32, IpcBytesSender),
     SampleCoverage(f32, bool),
-    Scissor(i32, i32, i32, i32),
+    Scissor(i32, i32, u32, u32),
     StencilFunc(u32, i32, u32),
     StencilFuncSeparate(u32, u32, i32, u32),
     StencilMask(u32),
diff --git a/components/constellation/constellation.rs b/components/constellation/constellation.rs
index a71a487127e..4513058be02 100644
--- a/components/constellation/constellation.rs
+++ b/components/constellation/constellation.rs
@@ -1195,7 +1195,7 @@ where
                 }
             },
             FromScriptMsg::CreateCanvasPaintThread(size, sender) => {
-                self.handle_create_canvas_paint_thread_msg(&size, sender)
+                self.handle_create_canvas_paint_thread_msg(size, sender)
             },
             FromScriptMsg::SetDocumentState(state) => {
                 self.document_states.insert(source_pipeline_id, state);
@@ -2850,7 +2850,7 @@ where
 
     fn handle_create_canvas_paint_thread_msg(
         &mut self,
-        size: &Size2D<i32>,
+        size: Size2D<u32>,
         response_sender: IpcSender<(IpcSender<CanvasMsg>, CanvasId)>,
     ) {
         let webrender_api = self.webrender_api_sender.clone();
@@ -2860,7 +2860,7 @@ where
 
         if let Err(e) = sender.send(CanvasMsg::Create(
             canvas_id_sender,
-            *size,
+            size,
             webrender_api,
             opts::get().enable_canvas_antialiasing,
         )) {
diff --git a/components/script/dom/bindings/trace.rs b/components/script/dom/bindings/trace.rs
index 2c395094e7f..a3c4c7814ea 100644
--- a/components/script/dom/bindings/trace.rs
+++ b/components/script/dom/bindings/trace.rs
@@ -261,7 +261,13 @@ unsafe impl<T: JSTraceable> JSTraceable for VecDeque<T> {
     }
 }
 
-unsafe impl<T: JSTraceable> JSTraceable for (T, T, T, T) {
+unsafe impl<A, B, C, D> JSTraceable for (A, B, C, D)
+where
+    A: JSTraceable,
+    B: JSTraceable,
+    C: JSTraceable,
+    D: JSTraceable,
+{
     unsafe fn trace(&self, trc: *mut JSTracer) {
         self.0.trace(trc);
         self.1.trace(trc);
@@ -616,6 +622,13 @@ unsafe impl<U> JSTraceable for TypedSize2D<f32, U> {
     }
 }
 
+unsafe impl<U> JSTraceable for TypedSize2D<u32, U> {
+    #[inline]
+    unsafe fn trace(&self, _trc: *mut JSTracer) {
+        // Do nothing
+    }
+}
+
 unsafe impl JSTraceable for StyleLocked<FontFaceRule> {
     unsafe fn trace(&self, _trc: *mut JSTracer) {
         // Do nothing.
diff --git a/components/script/dom/canvaspattern.rs b/components/script/dom/canvaspattern.rs
index ced7a6bb11b..bcc6e35f5f5 100644
--- a/components/script/dom/canvaspattern.rs
+++ b/components/script/dom/canvaspattern.rs
@@ -16,7 +16,7 @@ use euclid::Size2D;
 pub struct CanvasPattern {
     reflector_: Reflector,
     surface_data: Vec<u8>,
-    surface_size: Size2D<i32>,
+    surface_size: Size2D<u32>,
     repeat_x: bool,
     repeat_y: bool,
     origin_clean: bool,
@@ -25,7 +25,7 @@ pub struct CanvasPattern {
 impl CanvasPattern {
     fn new_inherited(
         surface_data: Vec<u8>,
-        surface_size: Size2D<i32>,
+        surface_size: Size2D<u32>,
         repeat: RepetitionStyle,
         origin_clean: bool,
     ) -> CanvasPattern {
@@ -39,7 +39,7 @@ impl CanvasPattern {
         CanvasPattern {
             reflector_: Reflector::new(),
             surface_data: surface_data,
-            surface_size: surface_size,
+            surface_size,
             repeat_x: x,
             repeat_y: y,
             origin_clean: origin_clean,
@@ -48,7 +48,7 @@ impl CanvasPattern {
     pub fn new(
         global: &GlobalScope,
         surface_data: Vec<u8>,
-        surface_size: Size2D<i32>,
+        surface_size: Size2D<u32>,
         repeat: RepetitionStyle,
         origin_clean: bool,
     ) -> DomRoot<CanvasPattern> {
diff --git a/components/script/dom/canvasrenderingcontext2d.rs b/components/script/dom/canvasrenderingcontext2d.rs
index e3ca01c311e..2b364c3702d 100644
--- a/components/script/dom/canvasrenderingcontext2d.rs
+++ b/components/script/dom/canvasrenderingcontext2d.rs
@@ -128,7 +128,7 @@ impl CanvasRenderingContext2D {
         canvas: Option<&HTMLCanvasElement>,
         image_cache: Arc<ImageCache>,
         base_url: ServoUrl,
-        size: Size2D<i32>,
+        size: Size2D<u32>,
     ) -> CanvasRenderingContext2D {
         debug!("Creating new canvas rendering context.");
         let (sender, receiver) =
@@ -157,7 +157,7 @@ impl CanvasRenderingContext2D {
     pub fn new(
         global: &GlobalScope,
         canvas: &HTMLCanvasElement,
-        size: Size2D<i32>,
+        size: Size2D<u32>,
     ) -> DomRoot<CanvasRenderingContext2D> {
         let window = window_from_node(canvas);
         let image_cache = window.image_cache();
@@ -173,7 +173,7 @@ impl CanvasRenderingContext2D {
     }
 
     // https://html.spec.whatwg.org/multipage/#concept-canvas-set-bitmap-dimensions
-    pub fn set_bitmap_dimensions(&self, size: Size2D<i32>) {
+    pub fn set_bitmap_dimensions(&self, size: Size2D<u32>) {
         self.reset_to_initial_state();
         self.ipc_renderer
             .send(CanvasMsg::Recreate(size, self.get_canvas_id()))
@@ -456,7 +456,7 @@ impl CanvasRenderingContext2D {
         Ok(())
     }
 
-    fn fetch_image_data(&self, url: ServoUrl) -> Option<(Vec<u8>, Size2D<i32>)> {
+    fn fetch_image_data(&self, url: ServoUrl) -> Option<(Vec<u8>, Size2D<u32>)> {
         let img = match self.request_image_from_cache(url) {
             ImageResponse::Loaded(img, _) => img,
             ImageResponse::PlaceholderLoaded(_, _) |
@@ -466,7 +466,7 @@ impl CanvasRenderingContext2D {
             },
         };
 
-        let image_size = Size2D::new(img.width as i32, img.height as i32);
+        let image_size = Size2D::new(img.width, img.height);
         let image_data = match img.format {
             PixelFormat::BGRA8 => img.bytes.to_vec(),
             PixelFormat::K8 => panic!("K8 color type not supported"),
diff --git a/components/script/dom/htmlcanvaselement.rs b/components/script/dom/htmlcanvaselement.rs
index 00b04db7ee8..09114a95d0a 100644
--- a/components/script/dom/htmlcanvaselement.rs
+++ b/components/script/dom/htmlcanvaselement.rs
@@ -98,8 +98,8 @@ impl HTMLCanvasElement {
         }
     }
 
-    pub fn get_size(&self) -> Size2D<i32> {
-        Size2D::new(self.Width() as i32, self.Height() as i32)
+    pub fn get_size(&self) -> Size2D<u32> {
+        Size2D::new(self.Width(), self.Height())
     }
 
     pub fn origin_is_clean(&self) -> bool {
@@ -277,7 +277,7 @@ impl HTMLCanvasElement {
         self.Height() != 0 && self.Width() != 0
     }
 
-    pub fn fetch_all_data(&self) -> Option<(Vec<u8>, Size2D<i32>)> {
+    pub fn fetch_all_data(&self) -> Option<(Vec<u8>, Size2D<u32>)> {
         let size = self.get_size();
 
         if size.width == 0 || size.height == 0 {
@@ -383,12 +383,11 @@ impl HTMLCanvasElementMethods for HTMLCanvasElement {
                     None => return Ok(USVString("data:,".into())),
                 }
             },
-            Some(CanvasContext::WebGL2(ref context)) => match context
-                .base_context()
-                .get_image_data(self.Width(), self.Height())
-            {
-                Some(data) => data,
-                None => return Ok(USVString("data:,".into())),
+            Some(CanvasContext::WebGL2(ref context)) => {
+                match context.base_context().get_image_data(self.Width(), self.Height()) {
+                    Some(data) => data,
+                    None => return Ok(USVString("data:,".into())),
+                }
             },
             None => {
                 // Each pixel is fully-transparent black.
@@ -396,19 +395,16 @@ impl HTMLCanvasElementMethods for HTMLCanvasElement {
             },
         };
 
-        // Only handle image/png for now.
-        let mime_type = "image/png";
-
-        let mut encoded = Vec::new();
-        {
-            let encoder: PNGEncoder<&mut Vec<u8>> = PNGEncoder::new(&mut encoded);
-            encoder
-                .encode(&raw_data, self.Width(), self.Height(), ColorType::RGBA(8))
-                .unwrap();
-        }
-
-        let encoded = base64::encode(&encoded);
-        Ok(USVString(format!("data:{};base64,{}", mime_type, encoded)))
+        // FIXME: Only handle image/png for now.
+        let mut png = Vec::new();
+        PNGEncoder::new(&mut png)
+            .encode(&raw_data, self.Width(), self.Height(), ColorType::RGBA(8))
+            .unwrap();
+        let mut url = "data:image/png;base64,".to_owned();
+        // FIXME(nox): Should this use base64::URL_SAFE?
+        // FIXME(nox): https://github.com/alicemaz/rust-base64/pull/56
+        base64::encode_config_buf(&png, base64::STANDARD, &mut url);
+        Ok(USVString(url))
     }
 }
 
diff --git a/components/script/dom/imagedata.rs b/components/script/dom/imagedata.rs
index d37e0092ba4..ea65d533ffe 100644
--- a/components/script/dom/imagedata.rs
+++ b/components/script/dom/imagedata.rs
@@ -149,8 +149,8 @@ impl ImageData {
         }
     }
 
-    pub fn get_size(&self) -> Size2D<i32> {
-        Size2D::new(self.Width() as i32, self.Height() as i32)
+    pub fn get_size(&self) -> Size2D<u32> {
+        Size2D::new(self.Width(), self.Height())
     }
 }
 
diff --git a/components/script/dom/paintrenderingcontext2d.rs b/components/script/dom/paintrenderingcontext2d.rs
index 43124e30c76..1389dddcf3a 100644
--- a/components/script/dom/paintrenderingcontext2d.rs
+++ b/components/script/dom/paintrenderingcontext2d.rs
@@ -85,8 +85,7 @@ impl PaintRenderingContext2D {
     ) {
         let size = size * device_pixel_ratio;
         self.device_pixel_ratio.set(device_pixel_ratio);
-        self.context
-            .set_bitmap_dimensions(size.to_untyped().to_i32());
+        self.context.set_bitmap_dimensions(size.to_untyped().to_u32());
         self.scale_by_device_pixel_ratio();
     }
 
diff --git a/components/script/dom/webgl2renderingcontext.rs b/components/script/dom/webgl2renderingcontext.rs
index a674cd719a6..ec839bf3fbf 100644
--- a/components/script/dom/webgl2renderingcontext.rs
+++ b/components/script/dom/webgl2renderingcontext.rs
@@ -49,7 +49,7 @@ impl WebGL2RenderingContext {
     fn new_inherited(
         window: &Window,
         canvas: &HTMLCanvasElement,
-        size: Size2D<i32>,
+        size: Size2D<u32>,
         attrs: GLContextAttributes,
     ) -> Option<WebGL2RenderingContext> {
         let base = WebGLRenderingContext::new(window, canvas, WebGLVersion::WebGL2, size, attrs)?;
@@ -63,7 +63,7 @@ impl WebGL2RenderingContext {
     pub fn new(
         window: &Window,
         canvas: &HTMLCanvasElement,
-        size: Size2D<i32>,
+        size: Size2D<u32>,
         attrs: GLContextAttributes,
     ) -> Option<DomRoot<WebGL2RenderingContext>> {
         WebGL2RenderingContext::new_inherited(window, canvas, size, attrs).map(|ctx| {
@@ -73,7 +73,7 @@ impl WebGL2RenderingContext {
 }
 
 impl WebGL2RenderingContext {
-    pub fn recreate(&self, size: Size2D<i32>) {
+    pub fn recreate(&self, size: Size2D<u32>) {
         self.base.recreate(size)
     }
 
diff --git a/components/script/dom/webglrenderingcontext.rs b/components/script/dom/webglrenderingcontext.rs
index 754637ad52b..7972201b9ce 100644
--- a/components/script/dom/webglrenderingcontext.rs
+++ b/components/script/dom/webglrenderingcontext.rs
@@ -157,7 +157,7 @@ pub struct WebGLRenderingContext {
     #[ignore_malloc_size_of = "Because it's small"]
     current_vertex_attrib_0: Cell<(f32, f32, f32, f32)>,
     #[ignore_malloc_size_of = "Because it's small"]
-    current_scissor: Cell<(i32, i32, i32, i32)>,
+    current_scissor: Cell<(i32, i32, u32, u32)>,
     #[ignore_malloc_size_of = "Because it's small"]
     current_clear_color: Cell<(f32, f32, f32, f32)>,
     extension_manager: WebGLExtensions,
@@ -172,7 +172,7 @@ impl WebGLRenderingContext {
         window: &Window,
         canvas: &HTMLCanvasElement,
         webgl_version: WebGLVersion,
-        size: Size2D<i32>,
+        size: Size2D<u32>,
         attrs: GLContextAttributes,
     ) -> Result<WebGLRenderingContext, String> {
         if let Some(true) = PREFS
@@ -229,7 +229,7 @@ impl WebGLRenderingContext {
         window: &Window,
         canvas: &HTMLCanvasElement,
         webgl_version: WebGLVersion,
-        size: Size2D<i32>,
+        size: Size2D<u32>,
         attrs: GLContextAttributes,
     ) -> Option<DomRoot<WebGLRenderingContext>> {
         match WebGLRenderingContext::new_inherited(window, canvas, webgl_version, size, attrs) {
@@ -266,7 +266,7 @@ impl WebGLRenderingContext {
         })
     }
 
-    pub fn recreate(&self, size: Size2D<i32>) {
+    pub fn recreate(&self, size: Size2D<u32>) {
         let (sender, receiver) = webgl_channel().unwrap();
         self.webgl_sender.send_resize(size, sender).unwrap();
 
@@ -517,7 +517,7 @@ impl WebGLRenderingContext {
     fn get_image_pixels(
         &self,
         source: TexImageSource,
-    ) -> Fallible<Option<(Vec<u8>, Size2D<i32>, bool)>> {
+    ) -> Fallible<Option<(Vec<u8>, Size2D<u32>, bool)>> {
         Ok(Some(match source {
             TexImageSource::ImageData(image_data) => {
                 (image_data.get_data_array(), image_data.get_size(), false)
@@ -542,7 +542,7 @@ impl WebGLRenderingContext {
                     ImageResponse::MetadataLoaded(_) => return Ok(None),
                 };
 
-                let size = Size2D::new(img.width as i32, img.height as i32);
+                let size = Size2D::new(img.width, img.height);
 
                 // For now Servo's images are all stored as BGRA8 internally.
                 let mut data = match img.format {
@@ -2940,6 +2940,9 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext {
             return self.webgl_error(InvalidValue);
         }
 
+        let width = width as u32;
+        let height = height as u32;
+
         self.current_scissor.set((x, y, width, height));
         self.send_command(WebGLCommand::Scissor(x, y, width, height));
     }
@@ -3791,8 +3794,8 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext {
             target,
             level,
             internal_format,
-            size.width,
-            size.height,
+            size.width as i32,
+            size.height as i32,
             0,
             format,
             data_type,
@@ -4003,8 +4006,8 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext {
             target,
             level,
             format,
-            size.width,
-            size.height,
+            size.width as i32,
+            size.height as i32,
             0,
             format,
             data_type,
diff --git a/components/script_traits/script_msg.rs b/components/script_traits/script_msg.rs
index 14edaee58b6..3ec82114126 100644
--- a/components/script_traits/script_msg.rs
+++ b/components/script_traits/script_msg.rs
@@ -103,7 +103,7 @@ pub enum ScriptMsg {
     ChangeRunningAnimationsState(AnimationState),
     /// Requests that a new 2D canvas thread be created. (This is done in the constellation because
     /// 2D canvases may use the GPU and we don't want to give untrusted content access to the GPU.)
-    CreateCanvasPaintThread(Size2D<i32>, IpcSender<(IpcSender<CanvasMsg>, CanvasId)>),
+    CreateCanvasPaintThread(Size2D<u32>, IpcSender<(IpcSender<CanvasMsg>, CanvasId)>),
     /// Notifies the constellation that this frame has received focus.
     Focus,
     /// Requests that the constellation retrieve the current contents of the clipboard