Upgrade to the latest version of WebRender

Author: mrobinson

Cargo.lock

@@ -20,4 +20,4 @@ log = "0.3.5"
 num-traits = "0.1.32"
 offscreen_gl_context = { version = "0.11", features = ["serde"] }
 servo_config = {path = "../config"}
-webrender_traits = {git = "https://github.com/servo/webrender", features = ["ipc"]}
+webrender_api = {git = "https://github.com/servo/webrender", features = ["ipc"]}

components/canvas/Cargo.toml

@@ -17,7 +17,7 @@ use std::borrow::ToOwned;
 use std::mem;
 use std::sync::Arc;
 use std::thread;
-use webrender_traits;
+use webrender_api;
 
 impl<'a> CanvasPaintThread<'a> {
     /// It reads image data from the canvas
@@ -57,8 +57,8 @@ pub struct CanvasPaintThread<'a> {
     path_builder: PathBuilder,
     state: CanvasPaintState<'a>,
     saved_states: Vec<CanvasPaintState<'a>>,
-    webrender_api: webrender_traits::RenderApi,
-    image_key: Option<webrender_traits::ImageKey>,
+    webrender_api: webrender_api::RenderApi,
+    image_key: Option<webrender_api::ImageKey>,
 }
 
 #[derive(Clone)]
@@ -99,7 +99,7 @@ impl<'a> CanvasPaintState<'a> {
 
 impl<'a> CanvasPaintThread<'a> {
     fn new(size: Size2D<i32>,
-           webrender_api_sender: webrender_traits::RenderApiSender,
+           webrender_api_sender: webrender_api::RenderApiSender,
            antialias: bool) -> CanvasPaintThread<'a> {
         let draw_target = CanvasPaintThread::create(size);
         let path_builder = draw_target.create_path_builder();
@@ -117,7 +117,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: webrender_traits::RenderApiSender,
+                 webrender_api_sender: webrender_api::RenderApiSender,
                  antialias: bool)
                  -> IpcSender<CanvasMsg> {
         let (sender, receiver) = ipc::channel::<CanvasMsg>().unwrap();
@@ -562,15 +562,15 @@ impl<'a> CanvasPaintThread<'a> {
         self.drawtarget.snapshot().get_data_surface().with_data(|element| {
             let size = self.drawtarget.get_size();
 
-            let descriptor = webrender_traits::ImageDescriptor {
+            let descriptor = webrender_api::ImageDescriptor {
                 width: size.width as u32,
                 height: size.height as u32,
                 stride: None,
-                format: webrender_traits::ImageFormat::BGRA8,
+                format: webrender_api::ImageFormat::BGRA8,
                 offset: 0,
                 is_opaque: false,
             };
-            let data = webrender_traits::ImageData::Raw(Arc::new(element.into()));
+            let data = webrender_api::ImageData::Raw(Arc::new(element.into()));
 
             match self.image_key {
                 Some(image_key) => {

components/canvas/canvas_paint_thread.rs

@@ -15,7 +15,7 @@ extern crate log;
 extern crate num_traits;
 extern crate offscreen_gl_context;
 extern crate servo_config;
-extern crate webrender_traits;
+extern crate webrender_api;
 
 pub mod canvas_paint_thread;
 pub mod webgl_paint_thread;

components/canvas/lib.rs

@@ -14,7 +14,7 @@ use std::borrow::ToOwned;
 use std::sync::Arc;
 use std::sync::mpsc::channel;
 use std::thread;
-use webrender_traits;
+use webrender_api;
 
 enum GLContextWrapper {
     Native(GLContext<NativeGLContext>),
@@ -88,7 +88,7 @@ impl GLContextWrapper {
         }
     }
 
-    pub fn apply_command(&self, cmd: webrender_traits::WebGLCommand) {
+    pub fn apply_command(&self, cmd: webrender_api::WebGLCommand) {
         match *self {
             GLContextWrapper::Native(ref ctx) => {
                 cmd.apply(ctx);
@@ -101,8 +101,8 @@ impl GLContextWrapper {
 }
 
 enum WebGLPaintTaskData {
-    WebRender(webrender_traits::RenderApi, webrender_traits::WebGLContextId),
-    Readback(GLContextWrapper, webrender_traits::RenderApi, Option<webrender_traits::ImageKey>),
+    WebRender(webrender_api::RenderApi, webrender_api::WebGLContextId),
+    Readback(GLContextWrapper, webrender_api::RenderApi, Option<webrender_api::ImageKey>),
 }
 
 pub struct WebGLPaintThread {
@@ -112,7 +112,7 @@ pub struct WebGLPaintThread {
 
 fn create_readback_painter(size: Size2D<i32>,
                            attrs: GLContextAttributes,
-                           webrender_api: webrender_traits::RenderApi,
+                           webrender_api: webrender_api::RenderApi,
                            gl_type: gl::GlType)
     -> Result<(WebGLPaintThread, GLLimits), String> {
     let context = GLContextWrapper::new(size, attrs, gl_type)?;
@@ -128,11 +128,11 @@ fn create_readback_painter(size: Size2D<i32>,
 impl WebGLPaintThread {
     fn new(size: Size2D<i32>,
            attrs: GLContextAttributes,
-           webrender_api_sender: webrender_traits::RenderApiSender,
+           webrender_api_sender: webrender_api::RenderApiSender,
            gl_type: gl::GlType)
         -> Result<(WebGLPaintThread, GLLimits), String> {
         let wr_api = webrender_api_sender.create_api();
-        let device_size = webrender_traits::DeviceIntSize::from_untyped(&size);
+        let device_size = webrender_api::DeviceIntSize::from_untyped(&size);
         match wr_api.request_webgl_context(&device_size, attrs) {
             Ok((id, limits)) => {
                 let painter = WebGLPaintThread {
@@ -148,7 +148,7 @@ impl WebGLPaintThread {
         }
     }
 
-    fn handle_webgl_message(&self, message: webrender_traits::WebGLCommand) {
+    fn handle_webgl_message(&self, message: webrender_api::WebGLCommand) {
         debug!("WebGL message: {:?}", message);
         match self.data {
             WebGLPaintTaskData::WebRender(ref api, id) => {
@@ -160,7 +160,7 @@ impl WebGLPaintThread {
         }
     }
 
-    fn handle_webvr_message(&self, message: webrender_traits::VRCompositorCommand) {
+    fn handle_webvr_message(&self, message: webrender_api::VRCompositorCommand) {
         match self.data {
             WebGLPaintTaskData::WebRender(ref api, id) => {
                 api.send_vr_compositor_command(id, message);
@@ -176,7 +176,7 @@ impl WebGLPaintThread {
     /// communicate with it.
     pub fn start(size: Size2D<i32>,
                  attrs: GLContextAttributes,
-                 webrender_api_sender: webrender_traits::RenderApiSender)
+                 webrender_api_sender: webrender_api::RenderApiSender)
                  -> Result<(IpcSender<CanvasMsg>, GLLimits), String> {
         let (sender, receiver) = ipc::channel::<CanvasMsg>().unwrap();
         let (result_chan, result_port) = channel();
@@ -250,15 +250,15 @@ impl WebGLPaintThread {
                 // rgba -> bgra
                 byte_swap(&mut pixels);
 
-                let descriptor = webrender_traits::ImageDescriptor {
+                let descriptor = webrender_api::ImageDescriptor {
                     width: width as u32,
                     height: height as u32,
                     stride: None,
-                    format: webrender_traits::ImageFormat::BGRA8,
+                    format: webrender_api::ImageFormat::BGRA8,
                     offset: 0,
                     is_opaque: false,
                 };
-                let data = webrender_traits::ImageData::Raw(Arc::new(pixels));
+                let data = webrender_api::ImageData::Raw(Arc::new(pixels));
 
                 match *image_key {
                     Some(image_key) => {
@@ -305,7 +305,7 @@ impl WebGLPaintThread {
                 }
             }
             WebGLPaintTaskData::WebRender(ref api, id) => {
-                let device_size = webrender_traits::DeviceIntSize::from_untyped(&size);
+                let device_size = webrender_api::DeviceIntSize::from_untyped(&size);
                 api.resize_webgl_context(id, &device_size);
             }
         }

components/canvas/webgl_paint_thread.rs

@@ -16,4 +16,4 @@ heapsize = "0.4"
 heapsize_derive = "0.1"
 ipc-channel = "0.8"
 serde = "1.0"
-webrender_traits = {git = "https://github.com/servo/webrender", features = ["ipc"]}
+webrender_api = {git = "https://github.com/servo/webrender", features = ["ipc"]}

components/canvas_traits/Cargo.toml

@@ -13,14 +13,14 @@ extern crate heapsize;
 #[macro_use] extern crate heapsize_derive;
 extern crate ipc_channel;
 #[macro_use] extern crate serde;
-extern crate webrender_traits;
+extern crate webrender_api;
 
 use cssparser::RGBA;
 use euclid::{Transform2D, Point2D, Vector2D, Rect, Size2D};
 use ipc_channel::ipc::IpcSender;
 use std::default::Default;
 use std::str::FromStr;
-use webrender_traits::{WebGLCommand, WebGLContextId, VRCompositorCommand};
+use webrender_api::{WebGLCommand, WebGLContextId, VRCompositorCommand};
 
 #[derive(Clone, Deserialize, Serialize)]
 pub enum FillRule {
@@ -52,7 +52,7 @@ pub enum CanvasData {
 
 #[derive(Clone, Deserialize, Serialize)]
 pub struct CanvasImageData {
-    pub image_key: webrender_traits::ImageKey,
+    pub image_key: webrender_api::ImageKey,
 }
 
 #[derive(Clone, Deserialize, Serialize)]

components/canvas_traits/lib.rs

@@ -26,4 +26,4 @@ servo_url = {path = "../url"}
 style_traits = {path = "../style_traits"}
 time = "0.1.17"
 webrender = {git = "https://github.com/servo/webrender"}
-webrender_traits = {git = "https://github.com/servo/webrender", features = ["ipc"]}
+webrender_api = {git = "https://github.com/servo/webrender", features = ["ipc"]}

components/compositing/Cargo.toml

@@ -34,7 +34,7 @@ use style_traits::viewport::ViewportConstraints;
 use time::{precise_time_ns, precise_time_s};
 use touch::{TouchHandler, TouchAction};
 use webrender;
-use webrender_traits::{self, ClipId, LayoutPoint, LayoutVector2D, ScrollEventPhase, ScrollLocation, ScrollClamping};
+use webrender_api::{self, ClipId, LayoutPoint, LayoutVector2D, ScrollEventPhase, ScrollLocation, ScrollClamping};
 use windowing::{self, MouseWindowEvent, WindowEvent, WindowMethods, WindowNavigateMsg};
 
 #[derive(Debug, PartialEq)]
@@ -58,7 +58,7 @@ trait ConvertPipelineIdFromWebRender {
     fn from_webrender(&self) -> PipelineId;
 }
 
-impl ConvertPipelineIdFromWebRender for webrender_traits::PipelineId {
+impl ConvertPipelineIdFromWebRender for webrender_api::PipelineId {
     fn from_webrender(&self) -> PipelineId {
         PipelineId {
             namespace_id: PipelineNamespaceId(self.0),
@@ -180,7 +180,7 @@ pub struct IOCompositor<Window: WindowMethods> {
     webrender: webrender::Renderer,
 
     /// The webrender interface, if enabled.
-    webrender_api: webrender_traits::RenderApi,
+    webrender_api: webrender_api::RenderApi,
 
     /// GL functions interface (may be GL or GLES)
     gl: Rc<gl::Gl>,
@@ -315,7 +315,7 @@ impl RenderNotifier {
     }
 }
 
-impl webrender_traits::RenderNotifier for RenderNotifier {
+impl webrender_api::RenderNotifier for RenderNotifier {
     fn new_frame_ready(&mut self) {
         self.compositor_proxy.recomposite(CompositingReason::NewWebRenderFrame);
     }
@@ -330,7 +330,7 @@ struct CompositorThreadDispatcher {
     compositor_proxy: CompositorProxy
 }
 
-impl webrender_traits::RenderDispatcher for CompositorThreadDispatcher {
+impl webrender_api::RenderDispatcher for CompositorThreadDispatcher {
     fn dispatch(&self, f: Box<Fn() + Send>) {
         self.compositor_proxy.send(Msg::Dispatch(f));
     }
@@ -704,12 +704,12 @@ impl<Window: WindowMethods> IOCompositor<Window> {
         let dppx = self.page_zoom * self.hidpi_factor();
 
         let window_rect = {
-            let offset = webrender_traits::DeviceUintPoint::new(self.window_rect.origin.x, self.window_rect.origin.y);
-            let size = webrender_traits::DeviceUintSize::new(self.window_rect.size.width, self.window_rect.size.height);
-            webrender_traits::DeviceUintRect::new(offset, size)
+            let offset = webrender_api::DeviceUintPoint::new(self.window_rect.origin.x, self.window_rect.origin.y);
+            let size = webrender_api::DeviceUintSize::new(self.window_rect.size.width, self.window_rect.size.height);
+            webrender_api::DeviceUintRect::new(offset, size)
         };
 
-        let frame_size = webrender_traits::DeviceUintSize::new(self.frame_size.width, self.frame_size.height);
+        let frame_size = webrender_api::DeviceUintSize::new(self.frame_size.width, self.frame_size.height);
         self.webrender_api.set_window_parameters(frame_size, window_rect);
 
         let initial_viewport = self.window_rect.size.to_f32() / dppx;
@@ -988,7 +988,7 @@ impl<Window: WindowMethods> IOCompositor<Window> {
                 let cursor = TypedPoint2D::new(-1, -1);  // Make sure this hits the base layer.
                 self.pending_scroll_zoom_events.push(ScrollZoomEvent {
                     magnification: magnification,
-                    scroll_location: ScrollLocation::Delta(webrender_traits::LayoutVector2D::from_untyped(
+                    scroll_location: ScrollLocation::Delta(webrender_api::LayoutVector2D::from_untyped(
                                                            &scroll_delta.to_untyped())),
                     cursor: cursor,
                     phase: ScrollEventPhase::Move(true),
@@ -1128,8 +1128,8 @@ impl<Window: WindowMethods> IOCompositor<Window> {
 
                     let cursor =
                         (combined_event.cursor.to_f32() / self.scale).to_untyped();
-                    let location = webrender_traits::ScrollLocation::Delta(delta);
-                    let cursor = webrender_traits::WorldPoint::from_untyped(&cursor);
+                    let location = webrender_api::ScrollLocation::Delta(delta);
+                    let cursor = webrender_api::WorldPoint::from_untyped(&cursor);
                     self.webrender_api.scroll(location, cursor, combined_event.phase);
                     last_combined_event = None
                 }
@@ -1139,7 +1139,7 @@ impl<Window: WindowMethods> IOCompositor<Window> {
                 (last_combined_event @ &mut None, _) => {
                     *last_combined_event = Some(ScrollZoomEvent {
                         magnification: scroll_event.magnification,
-                        scroll_location: ScrollLocation::Delta(webrender_traits::LayoutVector2D::from_untyped(
+                        scroll_location: ScrollLocation::Delta(webrender_api::LayoutVector2D::from_untyped(
                                                                &this_delta.to_untyped())),
                         cursor: this_cursor,
                         phase: scroll_event.phase,
@@ -1178,14 +1178,14 @@ impl<Window: WindowMethods> IOCompositor<Window> {
                 ScrollLocation::Delta(delta) => {
                     let scaled_delta = (TypedVector2D::from_untyped(&delta.to_untyped()) / self.scale)
                                        .to_untyped();
-                    let calculated_delta = webrender_traits::LayoutVector2D::from_untyped(&scaled_delta);
+                    let calculated_delta = webrender_api::LayoutVector2D::from_untyped(&scaled_delta);
                                            ScrollLocation::Delta(calculated_delta)
                 },
                 // Leave ScrollLocation unchanged if it is Start or End location.
                 sl @ ScrollLocation::Start | sl @ ScrollLocation::End => sl,
             };
             let cursor = (combined_event.cursor.to_f32() / self.scale).to_untyped();
-            let cursor = webrender_traits::WorldPoint::from_untyped(&cursor);
+            let cursor = webrender_api::WorldPoint::from_untyped(&cursor);
             self.webrender_api.scroll(scroll_location, cursor, combined_event.phase);
             self.waiting_for_results_of_scroll = true
         }
@@ -1283,7 +1283,7 @@ impl<Window: WindowMethods> IOCompositor<Window> {
     }
 
     fn update_page_zoom_for_webrender(&mut self) {
-        let page_zoom = webrender_traits::ZoomFactor::new(self.page_zoom.get());
+        let page_zoom = webrender_api::ZoomFactor::new(self.page_zoom.get());
         self.webrender_api.set_page_zoom(page_zoom);
     }
 
@@ -1381,8 +1381,8 @@ impl<Window: WindowMethods> IOCompositor<Window> {
                 let mut pipeline_epochs = HashMap::new();
                 for (id, _) in &self.pipeline_details {
                     let webrender_pipeline_id = id.to_webrender();
-                    if let Some(webrender_traits::Epoch(epoch)) = self.webrender
-                                                                      .current_epoch(webrender_pipeline_id) {
+                    if let Some(webrender_api::Epoch(epoch)) = self.webrender
+                                                                   .current_epoch(webrender_pipeline_id) {
                         let epoch = Epoch(epoch);
                         pipeline_epochs.insert(*id, epoch);
                     }
@@ -1475,7 +1475,7 @@ impl<Window: WindowMethods> IOCompositor<Window> {
             debug!("compositor: compositing");
 
             // Paint the scene.
-            let size = webrender_traits::DeviceUintSize::from_untyped(&self.frame_size.to_untyped());
+            let size = webrender_api::DeviceUintSize::from_untyped(&self.frame_size.to_untyped());
             self.webrender.render(size);
         });
 

components/compositing/compositor.rs

@@ -19,7 +19,7 @@ use std::sync::mpsc::{Receiver, Sender};
 use style_traits::cursor::Cursor;
 use style_traits::viewport::ViewportConstraints;
 use webrender;
-use webrender_traits;
+use webrender_api;
 
 
 /// Used to wake up the event loop, provided by the servo port/embedder.
@@ -85,7 +85,7 @@ pub enum Msg {
     ShutdownComplete,
 
     /// Scroll a page in a window
-    ScrollFragmentPoint(webrender_traits::ClipId, Point2D<f32>, bool),
+    ScrollFragmentPoint(webrender_api::ClipId, Point2D<f32>, bool),
     /// Alerts the compositor that the current page has changed its title.
     ChangePageTitle(PipelineId, Option<String>),
     /// Alerts the compositor that the given pipeline has changed whether it is running animations.
@@ -194,5 +194,5 @@ pub struct InitialCompositorState {
     pub mem_profiler_chan: mem::ProfilerChan,
     /// Instance of webrender API
     pub webrender: webrender::Renderer,
-    pub webrender_api_sender: webrender_traits::RenderApiSender,
+    pub webrender_api_sender: webrender_api::RenderApiSender,
 }

components/compositing/compositor_thread.rs

@@ -22,7 +22,7 @@ extern crate servo_url;
 extern crate style_traits;
 extern crate time;
 extern crate webrender;
-extern crate webrender_traits;
+extern crate webrender_api;
 
 pub use compositor_thread::CompositorProxy;
 pub use compositor::IOCompositor;

components/compositing/lib.rs

@@ -16,7 +16,7 @@ use servo_url::ServoUrl;
 use std::fmt::{Debug, Error, Formatter};
 use std::rc::Rc;
 use style_traits::cursor::Cursor;
-use webrender_traits::ScrollLocation;
+use webrender_api::ScrollLocation;
 
 #[derive(Clone)]
 pub enum MouseWindowEvent {