Update WR (various optimizations, gradient improvements).

components/canvas/canvas_paint_thread.rs

@@ -18,6 +18,7 @@ use ipc_channel::ipc::{self, IpcSender};
 use num_traits::ToPrimitive;
 use std::borrow::ToOwned;
 use std::mem;
+use std::sync::Arc;
 use std::thread;
 use webrender_traits;
 
@@ -60,7 +61,7 @@ pub struct CanvasPaintThread<'a> {
     state: CanvasPaintState<'a>,
     saved_states: Vec<CanvasPaintState<'a>>,
     webrender_api: webrender_traits::RenderApi,
-    webrender_image_key: webrender_traits::ImageKey,
+    image_key: Option<webrender_traits::ImageKey>,
 }
 
 #[derive(Clone)]
@@ -106,14 +107,13 @@ impl<'a> CanvasPaintThread<'a> {
         let draw_target = CanvasPaintThread::create(size);
         let path_builder = draw_target.create_path_builder();
         let webrender_api = webrender_api_sender.create_api();
-        let webrender_image_key = webrender_api.generate_image_key();
         CanvasPaintThread {
             drawtarget: draw_target,
             path_builder: path_builder,
             state: CanvasPaintState::new(antialias),
             saved_states: vec![],
             webrender_api: webrender_api,
-            webrender_image_key: webrender_image_key,
+            image_key: None,
         }
     }
 
@@ -558,20 +558,35 @@ impl<'a> CanvasPaintThread<'a> {
     fn send_data(&mut self, chan: IpcSender<CanvasData>) {
         self.drawtarget.snapshot().get_data_surface().with_data(|element| {
             let size = self.drawtarget.get_size();
-            self.webrender_api.update_image(self.webrender_image_key,
-                                            webrender_traits::ImageDescriptor {
-                                                width: size.width as u32,
-                                                height: size.height as u32,
-                                                stride: None,
-                                                format: webrender_traits::ImageFormat::RGBA8,
-                                                offset: 0,
-                                                is_opaque: false,
-                                            },
-                                            element.into(),
-                                            None);
+
+            let descriptor = webrender_traits::ImageDescriptor {
+                width: size.width as u32,
+                height: size.height as u32,
+                stride: None,
+                format: webrender_traits::ImageFormat::RGBA8,
+                offset: 0,
+                is_opaque: false,
+            };
+            let data = webrender_traits::ImageData::Raw(Arc::new(element.into()));
+
+            match self.image_key {
+                Some(image_key) => {
+                    self.webrender_api.update_image(image_key,
+                                                    descriptor,
+                                                    data,
+                                                    None);
+                }
+                None => {
+                    self.image_key = Some(self.webrender_api.generate_image_key());
+                    self.webrender_api.add_image(self.image_key.unwrap(),
+                                                 descriptor,
+                                                 data,
+                                                 None);
+                }
+            }
 
             let data = CanvasImageData {
-                image_key: self.webrender_image_key,
+                image_key: self.image_key.unwrap(),
             };
             chan.send(CanvasData::Image(data)).unwrap();
         })
@@ -728,7 +743,9 @@ impl<'a> CanvasPaintThread<'a> {
 
 impl<'a> Drop for CanvasPaintThread<'a> {
     fn drop(&mut self) {
-        self.webrender_api.delete_image(self.webrender_image_key);
+        if let Some(image_key) = self.image_key {
+            self.webrender_api.delete_image(image_key);
+        }
     }
 }
 

components/canvas/webgl_paint_thread.rs

@@ -11,6 +11,7 @@ use offscreen_gl_context::{ColorAttachmentType, GLContext, GLLimits};
 use offscreen_gl_context::{GLContextAttributes, NativeGLContext, OSMesaContext};
 use servo_config::opts;
 use std::borrow::ToOwned;
+use std::sync::Arc;
 use std::sync::mpsc::channel;
 use std::thread;
 use webrender_traits;
@@ -101,7 +102,7 @@ impl GLContextWrapper {
 
 enum WebGLPaintTaskData {
     WebRender(webrender_traits::RenderApi, webrender_traits::WebGLContextId),
-    Readback(GLContextWrapper, webrender_traits::RenderApi, webrender_traits::ImageKey),
+    Readback(GLContextWrapper, webrender_traits::RenderApi, Option<webrender_traits::ImageKey>),
 }
 
 pub struct WebGLPaintThread {
@@ -116,10 +117,9 @@ fn create_readback_painter(size: Size2D<i32>,
     -> Result<(WebGLPaintThread, GLLimits), String> {
     let context = try!(GLContextWrapper::new(size, attrs, gl_type));
     let limits = context.get_limits();
-    let image_key = webrender_api.generate_image_key();
     let painter = WebGLPaintThread {
         size: size,
-        data: WebGLPaintTaskData::Readback(context, webrender_api, image_key)
+        data: WebGLPaintTaskData::Readback(context, webrender_api, None)
     };
 
     Ok((painter, limits))
@@ -229,7 +229,7 @@ impl WebGLPaintThread {
 
     fn send_data(&mut self, chan: IpcSender<CanvasData>) {
         match self.data {
-            WebGLPaintTaskData::Readback(ref ctx, ref webrender_api, image_key) => {
+            WebGLPaintTaskData::Readback(ref ctx, ref webrender_api, ref mut image_key) => {
                 let width = self.size.width as usize;
                 let height = self.size.height as usize;
 
@@ -250,22 +250,34 @@ impl WebGLPaintThread {
                 // rgba -> bgra
                 byte_swap(&mut pixels);
 
-                // TODO: This shouldn't be a common path, but try to avoid
-                // the spurious clone().
-                webrender_api.update_image(image_key,
-                                           webrender_traits::ImageDescriptor {
-                                               width: width as u32,
-                                               height: height as u32,
-                                               stride: None,
-                                               format: webrender_traits::ImageFormat::RGBA8,
-                                               offset: 0,
-                                               is_opaque: false,
-                                           },
-                                           pixels.clone(),
-                                           None);
+                let descriptor = webrender_traits::ImageDescriptor {
+                    width: width as u32,
+                    height: height as u32,
+                    stride: None,
+                    format: webrender_traits::ImageFormat::RGBA8,
+                    offset: 0,
+                    is_opaque: false,
+                };
+                let data = webrender_traits::ImageData::Raw(Arc::new(pixels));
+
+                match *image_key {
+                    Some(image_key) => {
+                        webrender_api.update_image(image_key,
+                                                   descriptor,
+                                                   data,
+                                                   None);
+                    }
+                    None => {
+                        *image_key = Some(webrender_api.generate_image_key());
+                        webrender_api.add_image(image_key.unwrap(),
+                                                descriptor,
+                                                data,
+                                                None);
+                    }
+                }
 
                 let image_data = CanvasImageData {
-                    image_key: image_key,
+                    image_key: image_key.unwrap(),
                 };
 
                 chan.send(CanvasData::Image(image_data)).unwrap();
@@ -307,7 +319,9 @@ impl WebGLPaintThread {
 impl Drop for WebGLPaintThread {
     fn drop(&mut self) {
         if let WebGLPaintTaskData::Readback(_, ref mut wr, image_key) = self.data {
-            wr.delete_image(image_key);
+            if let Some(image_key) = image_key {
+                wr.delete_image(image_key);
+            }
         }
     }
 }

components/compositing/compositor.rs

@@ -76,9 +76,12 @@ trait ConvertScrollRootIdFromWebRender {
     fn from_webrender(&self) -> ScrollRootId;
 }
 
-impl ConvertScrollRootIdFromWebRender for usize {
+impl ConvertScrollRootIdFromWebRender for u64 {
     fn from_webrender(&self) -> ScrollRootId {
-        ScrollRootId(*self)
+        // This conversion is lossy on 32 bit platforms,
+        // but we only actually use the bottom 32 bits
+        // on Servo anyway.
+        ScrollRootId(*self as usize)
     }
 }
 
@@ -794,7 +797,7 @@ impl<Window: WindowMethods> IOCompositor<Window> {
                                 pipeline_id: PipelineId,
                                 scroll_root_id: ScrollRootId,
                                 point: Point2D<f32>) {
-        let id = ScrollLayerId::new(scroll_root_id.0, pipeline_id.to_webrender());
+        let id = ScrollLayerId::new(scroll_root_id.0 as u64, pipeline_id.to_webrender());
         self.webrender_api.scroll_layer_with_id(LayoutPoint::from_untyped(&point), id);
     }
 

components/layout/webrender_helpers.rs

@@ -425,7 +425,7 @@ impl WebRenderDisplayItemConverter for DisplayItem {
                                                    vec![],
                                                    None);
 
-                let provided_id = ScrollLayerId::new(item.scroll_root.id.0, builder.pipeline_id);
+                let provided_id = ScrollLayerId::new(item.scroll_root.id.0 as u64, builder.pipeline_id);
                 let id = builder.define_clip(clip,
                                              item.scroll_root.size.to_sizef(),
                                              Some(provided_id));
@@ -444,7 +444,7 @@ impl WebRenderScrollRootIdConverter for ScrollRootId {
         if *self == ScrollRootId::root() {
             ScrollLayerId::root_scroll_layer(pipeline_id)
         } else {
-            ScrollLayerId::new(self.0, pipeline_id)
+            ScrollLayerId::new(self.0 as u64, pipeline_id)
         }
     }
 }