Make HTMLCanvasElement::get_size return a Size2D<u32>

The changes keep trickling down.

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();
@@ -939,8 +940,9 @@ impl ToAzurePattern for FillOrStrokeStyle {
             FillOrStrokeStyle::Surface(ref surface_style) => {
                 let source_surface = drawtarget.create_source_surface_from_data(
                     &surface_style.surface_data,
-                    surface_style.surface_size,
-                    surface_style.surface_size.width * 4,
+                    // 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(

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 {

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())
             }
         }
     }

components/canvas/webgl_thread.rs

@@ -219,7 +219,7 @@ impl<VR: WebVRRenderHandler + 'static> WebGLThread<VR> {
     fn create_webgl_context(
         &mut self,
         version: WebGLVersion,
-        size: Size2D<i32>,
+        size: Size2D<u32>,
         attributes: GLContextAttributes,
     ) -> Result<(WebGLContextId, GLLimits, WebGLContextShareMode), String> {
         // Creating a new GLContext may make the current bound context_id dirty.
@@ -239,7 +239,7 @@ impl<VR: WebVRRenderHandler + 'static> WebGLThread<VR> {
                 let ctx = self.gl_factory.new_context(version, size, attributes)?;
                 Ok((ctx, WebGLContextShareMode::Readback))
             })
-            .map_err(|msg| msg.to_owned())?;
+            .map_err(|msg: &str| msg.to_owned())?;
 
         let id = WebGLContextId(self.next_webgl_id);
         let (size, texture_id, limits) = ctx.get_info();
@@ -261,10 +261,12 @@ impl<VR: WebVRRenderHandler + 'static> WebGLThread<VR> {
     }
 
     /// 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,
@@ -796,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) =>

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,15 +143,15 @@ 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,
 }
 
 impl SurfaceStyle {
     pub fn new(
         surface_data: Vec<u8>,
-        surface_size: Size2D<i32>,
+        surface_size: Size2D<u32>,
         repeat_x: bool,
         repeat_y: bool,
     ) -> Self {

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),

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,
         )) {

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> {