Auto merge of #5652 - dmarcos:webgl, r=jdm

@jdm @ecoal95 I'm working on making VR happen in the Browser and I want to bring to Servo the [webVR APIs](https://github.com/MozVR/webvr-spec/blob/master/webvr.idl) we already have in Gecko. Before anything happens we need a working implementation of WebGL (and also the [fullscreen API](https://fullscreen.spec.whatwg.org/)). My implementation is very basic and probably naive (I just recently started to contribute to Servo). My patch is just a starting point: 

- It only implements ```clearColor``` and ```clear``` methods of the [WebGL spec](https://www.khronos.org/registry/webgl/specs/latest/).
- It uses the readback strategy that ```canvasRenderingContext2D``` is using (The webgl task paints stuff independently on it's own buffer and the compositor task request the pixels back to the webgl task when it needs them) I'm sure there are much better ways to handle this. Latency and FPS are critical in VR so we have to figure out the fastest way to push pixels to the screen. I've read something about layerizing the canvas but I'm still not sure what that even means :)
- There's an included test you can try ```./mach run tests/ref/webgl-context/clearcolor.html``` 

@ecoal95 I know you'll be working on this for the next three months. With a foundation in place we will be able to make quick progress in parallel. This is exciting!

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

1 files changed, 42 insertions, 41 deletions

diff --git a/components/script/dom/canvasrenderingcontext2d.rs b/components/script/dom/canvasrenderingcontext2d.rs
index f19b32242ae..f21d23cd073 100644
--- a/components/script/dom/canvasrenderingcontext2d.rs
+++ b/components/script/dom/canvasrenderingcontext2d.rs
@@ -27,7 +27,8 @@ use geom::point::Point2D;
 use geom::rect::Rect;
 use geom::size::Size2D;
 
-use canvas::canvas_paint_task::{CanvasMsg, CanvasPaintTask, FillOrStrokeStyle};
+use canvas::canvas_msg::{CanvasMsg, Canvas2dMsg, CanvasCommonMsg};
+use canvas::canvas_paint_task::{CanvasPaintTask, FillOrStrokeStyle};
 use canvas::canvas_paint_task::{LinearGradientStyle, RadialGradientStyle};
 use canvas::canvas_paint_task::{LineCapStyle, LineJoinStyle};
 
@@ -112,11 +113,11 @@ impl CanvasRenderingContext2D {
     }
 
     pub fn recreate(&self, size: Size2D<i32>) {
-        self.renderer.send(CanvasMsg::Recreate(size)).unwrap();
+        self.renderer.send(CanvasMsg::Common(CanvasCommonMsg::Recreate(size))).unwrap();
     }
 
     fn update_transform(&self) {
-        self.renderer.send(CanvasMsg::SetTransform(self.state.borrow().transform)).unwrap()
+        self.renderer.send(CanvasMsg::Canvas2d(Canvas2dMsg::SetTransform(self.state.borrow().transform))).unwrap()
     }
 
     // It is used by DrawImage to calculate the size of the source and destination rectangles based
@@ -204,16 +205,16 @@ impl CanvasRenderingContext2D {
 
         // If the source and target canvas are the same
         let msg = if self.canvas.root().r() == canvas {
-            CanvasMsg::DrawImageSelf(image_size, dest_rect, source_rect, smoothing_enabled)
+            CanvasMsg::Canvas2d(Canvas2dMsg::DrawImageSelf(image_size, dest_rect, source_rect, smoothing_enabled))
         } else { // Source and target canvases are different
             let context = canvas.get_2d_context().root();
             let renderer = context.r().get_renderer();
             let (sender, receiver) = channel::<Vec<u8>>();
             // Reads pixels from source image
-            renderer.send(CanvasMsg::GetImageData(source_rect, image_size, sender)).unwrap();
+            renderer.send(CanvasMsg::Canvas2d(Canvas2dMsg::GetImageData(source_rect, image_size, sender))).unwrap();
             let imagedata = receiver.recv().unwrap();
             // Writes pixels to destination canvas
-            CanvasMsg::DrawImage(imagedata, source_rect.size, dest_rect, source_rect, smoothing_enabled)
+            CanvasMsg::Canvas2d(Canvas2dMsg::DrawImage(imagedata, source_rect.size, dest_rect, source_rect, smoothing_enabled))
         };
 
         self.renderer.send(msg).unwrap();
@@ -233,9 +234,9 @@ impl CanvasRenderingContext2D {
         }
 
         let smoothing_enabled = self.state.borrow().image_smoothing_enabled;
-        self.renderer.send(CanvasMsg::DrawImage(
+        self.renderer.send(CanvasMsg::Canvas2d(Canvas2dMsg::DrawImage(
                            image_data, image_size, dest_rect,
-                           source_rect, smoothing_enabled)).unwrap();
+                           source_rect, smoothing_enabled))).unwrap();
         Ok(())
     }
 
@@ -337,7 +338,7 @@ impl<'a> CanvasRenderingContext2DMethods for JSRef<'a, CanvasRenderingContext2D>
     // https://html.spec.whatwg.org/multipage/#dom-context-2d-save
     fn Save(self) {
         self.saved_states.borrow_mut().push(self.state.borrow().clone());
-        self.renderer.send(CanvasMsg::SaveContext).unwrap();
+        self.renderer.send(CanvasMsg::Canvas2d(Canvas2dMsg::SaveContext)).unwrap();
     }
 
     // https://html.spec.whatwg.org/multipage/#dom-context-2d-restore
@@ -345,7 +346,7 @@ impl<'a> CanvasRenderingContext2DMethods for JSRef<'a, CanvasRenderingContext2D>
         let mut saved_states = self.saved_states.borrow_mut();
         if let Some(state) = saved_states.pop() {
             self.state.borrow_mut().clone_from(&state);
-            self.renderer.send(CanvasMsg::RestoreContext).unwrap();
+            self.renderer.send(CanvasMsg::Canvas2d(Canvas2dMsg::RestoreContext)).unwrap();
         }
     }
 
@@ -417,48 +418,48 @@ impl<'a> CanvasRenderingContext2DMethods for JSRef<'a, CanvasRenderingContext2D>
         }
 
         self.state.borrow_mut().global_alpha = alpha;
-        self.renderer.send(CanvasMsg::SetGlobalAlpha(alpha as f32)).unwrap()
+        self.renderer.send(CanvasMsg::Canvas2d(Canvas2dMsg::SetGlobalAlpha(alpha as f32))).unwrap()
     }
 
     // https://html.spec.whatwg.org/multipage/#dom-context-2d-fillrect
     fn FillRect(self, x: f64, y: f64, width: f64, height: f64) {
         if let Some(rect) = self.create_drawable_rect(x, y, width, height) {
-            self.renderer.send(CanvasMsg::FillRect(rect)).unwrap();
+            self.renderer.send(CanvasMsg::Canvas2d(Canvas2dMsg::FillRect(rect))).unwrap();
         }
     }
 
     // https://html.spec.whatwg.org/multipage/#dom-context-2d-clearrect
     fn ClearRect(self, x: f64, y: f64, width: f64, height: f64) {
         if let Some(rect) = self.create_drawable_rect(x, y, width, height) {
-            self.renderer.send(CanvasMsg::ClearRect(rect)).unwrap();
+            self.renderer.send(CanvasMsg::Canvas2d(Canvas2dMsg::ClearRect(rect))).unwrap();
         }
     }
 
     // https://html.spec.whatwg.org/multipage/#dom-context-2d-strokerect
     fn StrokeRect(self, x: f64, y: f64, width: f64, height: f64) {
         if let Some(rect) = self.create_drawable_rect(x, y, width, height) {
-            self.renderer.send(CanvasMsg::StrokeRect(rect)).unwrap();
+            self.renderer.send(CanvasMsg::Canvas2d(Canvas2dMsg::StrokeRect(rect))).unwrap();
         }
     }
 
     // https://html.spec.whatwg.org/multipage/#dom-context-2d-beginpath
     fn BeginPath(self) {
-        self.renderer.send(CanvasMsg::BeginPath).unwrap();
+        self.renderer.send(CanvasMsg::Canvas2d(Canvas2dMsg::BeginPath)).unwrap();
     }
 
     // https://html.spec.whatwg.org/multipage/#dom-context-2d-closepath
     fn ClosePath(self) {
-        self.renderer.send(CanvasMsg::ClosePath).unwrap();
+        self.renderer.send(CanvasMsg::Canvas2d(Canvas2dMsg::ClosePath)).unwrap();
     }
 
     // https://html.spec.whatwg.org/multipage/#dom-context-2d-fill
     fn Fill(self, _: CanvasWindingRule) {
-        self.renderer.send(CanvasMsg::Fill).unwrap();
+        self.renderer.send(CanvasMsg::Canvas2d(Canvas2dMsg::Fill)).unwrap();
     }
 
     // https://html.spec.whatwg.org/multipage/#dom-context-2d-stroke
     fn Stroke(self) {
-        self.renderer.send(CanvasMsg::Stroke).unwrap();
+        self.renderer.send(CanvasMsg::Canvas2d(Canvas2dMsg::Stroke)).unwrap();
     }
 
     // https://html.spec.whatwg.org/multipage/#dom-context-2d-drawimage
@@ -627,7 +628,7 @@ impl<'a> CanvasRenderingContext2DMethods for JSRef<'a, CanvasRenderingContext2D>
             return;
         }
 
-        self.renderer.send(CanvasMsg::MoveTo(Point2D(x as f32, y as f32))).unwrap();
+        self.renderer.send(CanvasMsg::Canvas2d(Canvas2dMsg::MoveTo(Point2D(x as f32, y as f32)))).unwrap();
     }
 
     // https://html.spec.whatwg.org/multipage/#dom-context-2d-lineto
@@ -636,7 +637,7 @@ impl<'a> CanvasRenderingContext2DMethods for JSRef<'a, CanvasRenderingContext2D>
             return;
         }
 
-        self.renderer.send(CanvasMsg::LineTo(Point2D(x as f32, y as f32))).unwrap();
+        self.renderer.send(CanvasMsg::Canvas2d(Canvas2dMsg::LineTo(Point2D(x as f32, y as f32)))).unwrap();
     }
 
     // https://html.spec.whatwg.org/multipage/#dom-context-2d-quadraticcurveto
@@ -646,8 +647,8 @@ impl<'a> CanvasRenderingContext2DMethods for JSRef<'a, CanvasRenderingContext2D>
             return;
         }
 
-        self.renderer.send(CanvasMsg::QuadraticCurveTo(Point2D(cpx as f32, cpy as f32),
-                                                       Point2D(x as f32, y as f32))).unwrap();
+        self.renderer.send(CanvasMsg::Canvas2d(Canvas2dMsg::QuadraticCurveTo(Point2D(cpx as f32, cpy as f32),
+                                                            Point2D(x as f32, y as f32)))).unwrap();
     }
 
     // https://html.spec.whatwg.org/multipage/#dom-context-2d-beziercurveto
@@ -657,9 +658,9 @@ impl<'a> CanvasRenderingContext2DMethods for JSRef<'a, CanvasRenderingContext2D>
             return;
         }
 
-        self.renderer.send(CanvasMsg::BezierCurveTo(Point2D(cp1x as f32, cp1y as f32),
-                                                    Point2D(cp2x as f32, cp2y as f32),
-                                                    Point2D(x as f32, y as f32))).unwrap();
+        self.renderer.send(CanvasMsg::Canvas2d(Canvas2dMsg::BezierCurveTo(Point2D(cp1x as f32, cp1y as f32),
+                                                            Point2D(cp2x as f32, cp2y as f32),
+                                                            Point2D(x as f32, y as f32)))).unwrap();
     }
 
     // https://html.spec.whatwg.org/multipage/#dom-context-2d-arc
@@ -675,8 +676,8 @@ impl<'a> CanvasRenderingContext2DMethods for JSRef<'a, CanvasRenderingContext2D>
             return Err(IndexSize);
         }
 
-        self.renderer.send(CanvasMsg::Arc(Point2D(x as f32, y as f32), r as f32,
-                                          start as f32, end as f32, ccw)).unwrap();
+        self.renderer.send(CanvasMsg::Canvas2d(Canvas2dMsg::Arc(Point2D(x as f32, y as f32), r as f32,
+                                                                start as f32, end as f32, ccw))).unwrap();
         Ok(())
     }
 
@@ -688,9 +689,9 @@ impl<'a> CanvasRenderingContext2DMethods for JSRef<'a, CanvasRenderingContext2D>
         if r < 0.0 {
             return Err(IndexSize);
         }
-        self.renderer.send(CanvasMsg::ArcTo(Point2D(cp1x as f32, cp1y as f32),
-                                            Point2D(cp2x as f32, cp2y as f32),
-                                            r as f32)).unwrap();
+        self.renderer.send(CanvasMsg::Canvas2d(Canvas2dMsg::ArcTo(Point2D(cp1x as f32, cp1y as f32),
+                                                                  Point2D(cp2x as f32, cp2y as f32),
+                                                                  r as f32))).unwrap();
         Ok(())
     }
 
@@ -723,7 +724,7 @@ impl<'a> CanvasRenderingContext2DMethods for JSRef<'a, CanvasRenderingContext2D>
                     Ok(rgba) => {
                         self.state.borrow_mut().stroke_color = rgba;
                         self.renderer
-                            .send(CanvasMsg::SetStrokeStyle(FillOrStrokeStyle::Color(rgba)))
+                            .send(CanvasMsg::Canvas2d(Canvas2dMsg::SetStrokeStyle(FillOrStrokeStyle::Color(rgba))))
                             .unwrap();
                     }
                     _ => {}
@@ -753,14 +754,14 @@ impl<'a> CanvasRenderingContext2DMethods for JSRef<'a, CanvasRenderingContext2D>
                     Ok(rgba) => {
                         self.state.borrow_mut().fill_color = rgba;
                         self.renderer
-                            .send(CanvasMsg::SetFillStyle(FillOrStrokeStyle::Color(rgba)))
+                            .send(CanvasMsg::Canvas2d(Canvas2dMsg::SetFillStyle(FillOrStrokeStyle::Color(rgba))))
                             .unwrap()
                     }
                     _ => {}
                 }
             }
             StringOrCanvasGradientOrCanvasPattern::eCanvasGradient(gradient) => {
-                self.renderer.send(CanvasMsg::SetFillStyle(gradient.root().r().to_fill_or_stroke_style())).unwrap();
+                self.renderer.send(CanvasMsg::Canvas2d(Canvas2dMsg::SetFillStyle(gradient.root().r().to_fill_or_stroke_style()))).unwrap();
             }
             _ => {}
         }
@@ -799,7 +800,7 @@ impl<'a> CanvasRenderingContext2DMethods for JSRef<'a, CanvasRenderingContext2D>
         let dest_rect = Rect(Point2D(sx as f64, sy as f64), Size2D(sw as f64, sh as f64));
         let canvas_size = self.canvas.root().r().get_size();
         let canvas_size = Size2D(canvas_size.width as f64, canvas_size.height as f64);
-        self.renderer.send(CanvasMsg::GetImageData(dest_rect, canvas_size, sender)).unwrap();
+        self.renderer.send(CanvasMsg::Canvas2d(Canvas2dMsg::GetImageData(dest_rect, canvas_size, sender))).unwrap();
         let data = receiver.recv().unwrap();
         Ok(ImageData::new(self.global.root().r(), sw.abs().to_u32().unwrap(), sh.abs().to_u32().unwrap(), Some(data)))
     }
@@ -820,7 +821,7 @@ impl<'a> CanvasRenderingContext2DMethods for JSRef<'a, CanvasRenderingContext2D>
         let image_data_size = Size2D(image_data_size.width as f64, image_data_size.height as f64);
         let image_data_rect = Rect(Point2D(dx, dy), image_data_size);
         let dirty_rect = None;
-        self.renderer.send(CanvasMsg::PutImageData(data, image_data_rect, dirty_rect)).unwrap()
+        self.renderer.send(CanvasMsg::Canvas2d(Canvas2dMsg::PutImageData(data, image_data_rect, dirty_rect))).unwrap()
     }
 
     // https://html.spec.whatwg.org/multipage/#dom-context-2d-putimagedata
@@ -845,7 +846,7 @@ impl<'a> CanvasRenderingContext2DMethods for JSRef<'a, CanvasRenderingContext2D>
                                           imagedata.Height() as f64));
         let dirty_rect = Some(Rect(Point2D(dirtyX, dirtyY),
                                    Size2D(dirtyWidth, dirtyHeight)));
-        self.renderer.send(CanvasMsg::PutImageData(data, image_data_rect, dirty_rect)).unwrap()
+        self.renderer.send(CanvasMsg::Canvas2d(Canvas2dMsg::PutImageData(data, image_data_rect, dirty_rect))).unwrap()
     }
 
     // https://html.spec.whatwg.org/multipage/#dom-context-2d-createlineargradient
@@ -893,7 +894,7 @@ impl<'a> CanvasRenderingContext2DMethods for JSRef<'a, CanvasRenderingContext2D>
         }
 
         self.state.borrow_mut().line_width = width;
-        self.renderer.send(CanvasMsg::SetLineWidth(width as f32)).unwrap()
+        self.renderer.send(CanvasMsg::Canvas2d(Canvas2dMsg::SetLineWidth(width as f32))).unwrap()
     }
 
     // https://html.spec.whatwg.org/multipage/#dom-context-2d-linecap
@@ -910,7 +911,7 @@ impl<'a> CanvasRenderingContext2DMethods for JSRef<'a, CanvasRenderingContext2D>
     fn SetLineCap(self, cap_str: DOMString) {
         if let Some(cap) = LineCapStyle::from_str(&cap_str) {
             self.state.borrow_mut().line_cap = cap;
-            self.renderer.send(CanvasMsg::SetLineCap(cap)).unwrap()
+            self.renderer.send(CanvasMsg::Canvas2d(Canvas2dMsg::SetLineCap(cap))).unwrap()
         }
     }
 
@@ -928,7 +929,7 @@ impl<'a> CanvasRenderingContext2DMethods for JSRef<'a, CanvasRenderingContext2D>
     fn SetLineJoin(self, join_str: DOMString) {
         if let Some(join) = LineJoinStyle::from_str(&join_str) {
             self.state.borrow_mut().line_join = join;
-            self.renderer.send(CanvasMsg::SetLineJoin(join)).unwrap()
+            self.renderer.send(CanvasMsg::Canvas2d(Canvas2dMsg::SetLineJoin(join))).unwrap()
         }
     }
 
@@ -945,14 +946,14 @@ impl<'a> CanvasRenderingContext2DMethods for JSRef<'a, CanvasRenderingContext2D>
         }
 
         self.state.borrow_mut().miter_limit = limit;
-        self.renderer.send(CanvasMsg::SetMiterLimit(limit as f32)).unwrap()
+        self.renderer.send(CanvasMsg::Canvas2d(Canvas2dMsg::SetMiterLimit(limit as f32))).unwrap()
     }
 }
 
 #[unsafe_destructor]
 impl Drop for CanvasRenderingContext2D {
     fn drop(&mut self) {
-        self.renderer.send(CanvasMsg::Close).unwrap();
+        self.renderer.send(CanvasMsg::Common(CanvasCommonMsg::Close)).unwrap();
     }
 }