Remove old rendering backend.

This removes paint threads, rust-layers dependency, and changes
optional webrender types to be required.

The use_webrender option has been removed, however I've left
the "-w" command line option in place so that wpt
runner can continue to pass that. Once it's removed from there
we can also remove the -w option.

Once this stage is complete, it should be fine to change the
display list building code to generate webrender display
lists directly and avoid the conversion step.

components/canvas/canvas_paint_thread.rs

@@ -58,8 +58,8 @@ pub struct CanvasPaintThread<'a> {
     path_builder: PathBuilder,
     state: CanvasPaintState<'a>,
     saved_states: Vec<CanvasPaintState<'a>>,
-    webrender_api: Option<webrender_traits::RenderApi>,
-    webrender_image_key: Option<webrender_traits::ImageKey>,
+    webrender_api: webrender_traits::RenderApi,
+    webrender_image_key: webrender_traits::ImageKey,
 }
 
 #[derive(Clone)]
@@ -100,12 +100,12 @@ impl<'a> CanvasPaintState<'a> {
 
 impl<'a> CanvasPaintThread<'a> {
     fn new(size: Size2D<i32>,
-           webrender_api_sender: Option<webrender_traits::RenderApiSender>,
+           webrender_api_sender: webrender_traits::RenderApiSender,
            antialias: bool) -> CanvasPaintThread<'a> {
         let draw_target = CanvasPaintThread::create(size);
         let path_builder = draw_target.create_path_builder();
-        let webrender_api = webrender_api_sender.map(|wr| wr.create_api());
-        let webrender_image_key = webrender_api.as_ref().map(|wr| wr.alloc_image());
+        let webrender_api = webrender_api_sender.create_api();
+        let webrender_image_key = webrender_api.alloc_image();
         CanvasPaintThread {
             drawtarget: draw_target,
             path_builder: path_builder,
@@ -119,7 +119,7 @@ impl<'a> CanvasPaintThread<'a> {
     /// Creates a new `CanvasPaintThread` and returns an `IpcSender` to
     /// communicate with it.
     pub fn start(size: Size2D<i32>,
-                 webrender_api_sender: Option<webrender_traits::RenderApiSender>,
+                 webrender_api_sender: webrender_traits::RenderApiSender,
                  antialias: bool)
                  -> IpcSender<CanvasMsg> {
         let (sender, receiver) = ipc::channel::<CanvasMsg>().unwrap();
@@ -542,14 +542,12 @@ impl<'a> CanvasPaintThread<'a> {
 
     fn send_data(&mut self, chan: IpcSender<CanvasData>) {
         self.drawtarget.snapshot().get_data_surface().with_data(|element| {
-            if let Some(ref webrender_api) = self.webrender_api {
-                let size = self.drawtarget.get_size();
-                webrender_api.update_image(self.webrender_image_key.unwrap(),
-                                           size.width as u32,
-                                           size.height as u32,
-                                           webrender_traits::ImageFormat::RGBA8,
-                                           element.into());
-            }
+            let size = self.drawtarget.get_size();
+            self.webrender_api.update_image(self.webrender_image_key,
+                                            size.width as u32,
+                                            size.height as u32,
+                                            webrender_traits::ImageFormat::RGBA8,
+                                            element.into());
 
             let pixel_data = CanvasPixelData {
                 image_data: IpcSharedMemory::from_bytes(element),
@@ -710,9 +708,7 @@ impl<'a> CanvasPaintThread<'a> {
 
 impl<'a> Drop for CanvasPaintThread<'a> {
     fn drop(&mut self) {
-        if let Some(ref mut wr) = self.webrender_api {
-            wr.delete_image(self.webrender_image_key.unwrap());
-        }
+        self.webrender_api.delete_image(self.webrender_image_key);
     }
 }
 

components/canvas/webgl_paint_thread.rs

@@ -87,7 +87,7 @@ impl GLContextWrapper {
 
 enum WebGLPaintTaskData {
     WebRender(webrender_traits::RenderApi, webrender_traits::WebGLContextId),
-    Readback(GLContextWrapper, (Option<(webrender_traits::RenderApi, webrender_traits::ImageKey)>)),
+    Readback(GLContextWrapper, webrender_traits::RenderApi, webrender_traits::ImageKey),
 }
 
 pub struct WebGLPaintThread {
@@ -97,17 +97,14 @@ pub struct WebGLPaintThread {
 
 fn create_readback_painter(size: Size2D<i32>,
                            attrs: GLContextAttributes,
-                           webrender_api: Option<webrender_traits::RenderApi>)
+                           webrender_api: webrender_traits::RenderApi)
     -> Result<(WebGLPaintThread, GLLimits), String> {
     let context = try!(GLContextWrapper::new(size, attrs));
     let limits = context.get_limits();
-    let webrender_api_and_image_key = webrender_api.map(|wr| {
-        let key = wr.alloc_image();
-        (wr, key)
-    });
+    let image_key = webrender_api.alloc_image();
     let painter = WebGLPaintThread {
         size: size,
-        data: WebGLPaintTaskData::Readback(context, webrender_api_and_image_key)
+        data: WebGLPaintTaskData::Readback(context, webrender_api, image_key)
     };
 
     Ok((painter, limits))
@@ -116,25 +113,21 @@ fn create_readback_painter(size: Size2D<i32>,
 impl WebGLPaintThread {
     fn new(size: Size2D<i32>,
            attrs: GLContextAttributes,
-           webrender_api_sender: Option<webrender_traits::RenderApiSender>)
+           webrender_api_sender: webrender_traits::RenderApiSender)
         -> Result<(WebGLPaintThread, GLLimits), String> {
-        if let Some(sender) = webrender_api_sender {
-            let wr_api = sender.create_api();
-            match wr_api.request_webgl_context(&size, attrs) {
-                Ok((id, limits)) => {
-                    let painter = WebGLPaintThread {
-                        data: WebGLPaintTaskData::WebRender(wr_api, id),
-                        size: size
-                    };
-                    Ok((painter, limits))
-                },
-                Err(msg) => {
-                    warn!("Initial context creation failed, falling back to readback: {}", msg);
-                    create_readback_painter(size, attrs, Some(wr_api))
-                }
+        let wr_api = webrender_api_sender.create_api();
+        match wr_api.request_webgl_context(&size, attrs) {
+            Ok((id, limits)) => {
+                let painter = WebGLPaintThread {
+                    data: WebGLPaintTaskData::WebRender(wr_api, id),
+                    size: size
+                };
+                Ok((painter, limits))
+            },
+            Err(msg) => {
+                warn!("Initial context creation failed, falling back to readback: {}", msg);
+                create_readback_painter(size, attrs, wr_api)
             }
-        } else {
-            create_readback_painter(size, attrs, None)
         }
     }
 
@@ -144,7 +137,7 @@ impl WebGLPaintThread {
             WebGLPaintTaskData::WebRender(ref api, id) => {
                 api.send_webgl_command(id, message);
             }
-            WebGLPaintTaskData::Readback(ref ctx, _) => {
+            WebGLPaintTaskData::Readback(ref ctx, _, _) => {
                 ctx.apply_command(message);
             }
         }
@@ -154,7 +147,7 @@ impl WebGLPaintThread {
     /// communicate with it.
     pub fn start(size: Size2D<i32>,
                  attrs: GLContextAttributes,
-                 webrender_api_sender: Option<webrender_traits::RenderApiSender>)
+                 webrender_api_sender: webrender_traits::RenderApiSender)
                  -> Result<(IpcSender<CanvasMsg>, GLLimits), String> {
         let (sender, receiver) = ipc::channel::<CanvasMsg>().unwrap();
         let (result_chan, result_port) = channel();
@@ -196,7 +189,7 @@ impl WebGLPaintThread {
 
     fn send_data(&mut self, chan: IpcSender<CanvasData>) {
         match self.data {
-            WebGLPaintTaskData::Readback(_, ref webrender_api_and_image_key) => {
+            WebGLPaintTaskData::Readback(_, ref webrender_api, image_key) => {
                 let width = self.size.width as usize;
                 let height = self.size.height as usize;
 
@@ -217,19 +210,17 @@ impl WebGLPaintThread {
                 // rgba -> bgra
                 byte_swap(&mut pixels);
 
-                if let Some((ref wr, wr_image_key)) = *webrender_api_and_image_key {
-                    // TODO: This shouldn't be a common path, but try to avoid
-                    // the spurious clone().
-                    wr.update_image(wr_image_key,
-                                    width as u32,
-                                    height as u32,
-                                    webrender_traits::ImageFormat::RGBA8,
-                                    pixels.clone());
-                }
+                // TODO: This shouldn't be a common path, but try to avoid
+                // the spurious clone().
+                webrender_api.update_image(image_key,
+                                           width as u32,
+                                           height as u32,
+                                           webrender_traits::ImageFormat::RGBA8,
+                                           pixels.clone());
 
                 let pixel_data = CanvasPixelData {
                     image_data: IpcSharedMemory::from_bytes(&pixels[..]),
-                    image_key: webrender_api_and_image_key.as_ref().map(|&(_, key)| key),
+                    image_key: image_key,
                 };
 
                 chan.send(CanvasData::Pixels(pixel_data)).unwrap();
@@ -243,7 +234,7 @@ impl WebGLPaintThread {
     #[allow(unsafe_code)]
     fn recreate(&mut self, size: Size2D<i32>) -> Result<(), &'static str> {
         match self.data {
-            WebGLPaintTaskData::Readback(ref mut context, _) => {
+            WebGLPaintTaskData::Readback(ref mut context, _, _) => {
                 if size.width > self.size.width ||
                    size.height > self.size.height {
                     self.size = try!(context.resize(size));
@@ -261,15 +252,15 @@ impl WebGLPaintThread {
     }
 
     fn init(&mut self) {
-        if let WebGLPaintTaskData::Readback(ref context, _) = self.data {
+        if let WebGLPaintTaskData::Readback(ref context, _, _) = self.data {
             context.make_current();
         }
     }
 }
 
 impl Drop for WebGLPaintThread {
     fn drop(&mut self) {
-        if let WebGLPaintTaskData::Readback(_, Some((ref mut wr, image_key))) = self.data {
+        if let WebGLPaintTaskData::Readback(_, ref mut wr, image_key) = self.data {
             wr.delete_image(image_key);
         }
     }

components/canvas_traits/lib.rs

@@ -69,7 +69,7 @@ pub enum CanvasData {
 #[derive(Clone, Deserialize, Serialize)]
 pub struct CanvasPixelData {
     pub image_data: IpcSharedMemory,
-    pub image_key: Option<webrender_traits::ImageKey>,
+    pub image_key: webrender_traits::ImageKey,
 }
 
 #[derive(Clone, Deserialize, Serialize)]

components/compositing/Cargo.toml

@@ -10,14 +10,11 @@ name = "compositing"
 path = "lib.rs"
 
 [dependencies]
-app_units = "0.3"
-azure = {git = "https://github.com/servo/rust-azure", features = ["plugins"]}
 euclid = "0.10.1"
 gfx_traits = {path = "../gfx_traits"}
 gleam = "0.2.8"
 image = "0.10"
 ipc-channel = "0.5"
-layers = {git = "https://github.com/servo/rust-layers", features = ["plugins"]}
 log = "0.3.5"
 msg = {path = "../msg"}
 net_traits = {path = "../net_traits"}