Update webrender

components/canvas/canvas_data.rs

@@ -17,6 +17,7 @@ use ipc_channel::ipc::{IpcSender, IpcSharedMemory};
 use num_traits::ToPrimitive;
 use std::mem;
 use std::sync::Arc;
+use webrender::api::DirtyRect;
 
 pub struct CanvasData<'a> {
     drawtarget: DrawTarget,
@@ -462,7 +463,7 @@ impl<'a> CanvasData<'a> {
         let size = self.drawtarget.get_size();
 
         let descriptor = webrender_api::ImageDescriptor {
-            size: webrender_api::DeviceUintSize::new(size.width as u32, size.height as u32),
+            size: webrender_api::DeviceIntSize::new(size.width, size.height),
             stride: None,
             format: webrender_api::ImageFormat::BGRA8,
             offset: 0,
@@ -478,7 +479,7 @@ impl<'a> CanvasData<'a> {
         match self.image_key {
             Some(image_key) => {
                 debug!("Updating image {:?}.", image_key);
-                txn.update_image(image_key, descriptor, data, None);
+                txn.update_image(image_key, descriptor, data, &DirtyRect::All);
             },
             None => {
                 self.image_key = Some(self.webrender_api.generate_image_key());

components/canvas/webgl_thread.rs

@@ -566,7 +566,7 @@ impl<VR: WebVRRenderHandler + 'static> WebGLThread<VR> {
         let data = Self::external_image_data(context_id);
 
         let mut txn = webrender_api::Transaction::new();
-        txn.update_image(image_key, descriptor, data, None);
+        txn.update_image(image_key, descriptor, data, &webrender_api::DirtyRect::All);
         webrender_api.update_resources(txn.resource_updates);
     }
 
@@ -600,14 +600,14 @@ impl<VR: WebVRRenderHandler + 'static> WebGLThread<VR> {
         let data = webrender_api::ImageData::new(data);
 
         let mut txn = webrender_api::Transaction::new();
-        txn.update_image(image_key, descriptor, data, None);
+        txn.update_image(image_key, descriptor, data, &webrender_api::DirtyRect::All);
         webrender_api.update_resources(txn.resource_updates);
     }
 
     /// Helper function to create a `webrender_api::ImageDescriptor`.
     fn image_descriptor(size: Size2D<i32>, alpha: bool) -> webrender_api::ImageDescriptor {
         webrender_api::ImageDescriptor {
-            size: webrender_api::DeviceUintSize::new(size.width as u32, size.height as u32),
+            size: webrender_api::DeviceIntSize::new(size.width, size.height),
             stride: None,
             format: webrender_api::ImageFormat::BGRA8,
             offset: 0,

components/compositing/compositor.rs

@@ -1182,8 +1182,12 @@ impl<Window: WindowMethods> IOCompositor<Window> {
         &mut self,
         target: CompositeTarget,
     ) -> Result<Option<Image>, UnableToComposite> {
-        let width = self.embedder_coordinates.framebuffer.width_typed();
-        let height = self.embedder_coordinates.framebuffer.height_typed();
+        let width = self.embedder_coordinates.framebuffer.to_u32().width_typed();
+        let height = self
+            .embedder_coordinates
+            .framebuffer
+            .to_u32()
+            .height_typed();
         if !self.window.prepare_for_composite() {
             return Err(UnableToComposite::WindowUnprepared);
         }

components/compositing/compositor_thread.rs

@@ -17,7 +17,7 @@ use profile_traits::time;
 use script_traits::{AnimationState, ConstellationMsg, EventResult};
 use std::fmt::{Debug, Error, Formatter};
 use style_traits::viewport::ViewportConstraints;
-use webrender_api::{self, DeviceIntPoint, DeviceUintSize};
+use webrender_api::{self, DeviceIntPoint, DeviceIntSize};
 
 /// Sends messages to the compositor.
 pub struct CompositorProxy {
@@ -106,11 +106,11 @@ pub enum Msg {
     LoadComplete(TopLevelBrowsingContextId),
 
     /// Get Window Informations size and position.
-    GetClientWindow(IpcSender<(DeviceUintSize, DeviceIntPoint)>),
+    GetClientWindow(IpcSender<(DeviceIntSize, DeviceIntPoint)>),
     /// Get screen size.
-    GetScreenSize(IpcSender<DeviceUintSize>),
+    GetScreenSize(IpcSender<DeviceIntSize>),
     /// Get screen available size.
-    GetScreenAvailSize(IpcSender<DeviceUintSize>),
+    GetScreenAvailSize(IpcSender<DeviceIntSize>),
 }
 
 impl Debug for Msg {

components/compositing/windowing.rs

@@ -17,7 +17,7 @@ use std::fmt::{Debug, Error, Formatter};
 #[cfg(feature = "gl")]
 use std::rc::Rc;
 use style_traits::DevicePixel;
-use webrender_api::{DeviceIntPoint, DevicePoint, DeviceUintRect, DeviceUintSize, ScrollLocation};
+use webrender_api::{DeviceIntPoint, DeviceIntRect, DeviceIntSize, DevicePoint, ScrollLocation};
 
 #[derive(Clone)]
 pub enum MouseWindowEvent {
@@ -149,13 +149,13 @@ pub struct EmbedderCoordinates {
     /// The pixel density of the display.
     pub hidpi_factor: TypedScale<f32, DeviceIndependentPixel, DevicePixel>,
     /// Size of the screen.
-    pub screen: DeviceUintSize,
+    pub screen: DeviceIntSize,
     /// Size of the available screen space (screen without toolbars and docks).
-    pub screen_avail: DeviceUintSize,
+    pub screen_avail: DeviceIntSize,
     /// Size of the native window.
-    pub window: (DeviceUintSize, DeviceIntPoint),
+    pub window: (DeviceIntSize, DeviceIntPoint),
     /// Size of the GL buffer in the window.
-    pub framebuffer: DeviceUintSize,
+    pub framebuffer: DeviceIntSize,
     /// Coordinates of the document within the framebuffer.
-    pub viewport: DeviceUintRect,
+    pub viewport: DeviceIntRect,
 }

components/embedder_traits/lib.rs

@@ -18,7 +18,7 @@ use msg::constellation_msg::{InputMethodType, TopLevelBrowsingContextId};
 use servo_url::ServoUrl;
 use std::fmt::{Debug, Error, Formatter};
 use style_traits::cursor::CursorKind;
-use webrender_api::{DeviceIntPoint, DeviceUintSize};
+use webrender_api::{DeviceIntPoint, DeviceIntSize};
 
 /// Used to wake up the event loop, provided by the servo port/embedder.
 pub trait EventLoopWaker: 'static + Send {
@@ -76,7 +76,7 @@ pub enum EmbedderMsg {
     /// Move the window to a point
     MoveTo(DeviceIntPoint),
     /// Resize the window to size
-    ResizeTo(DeviceUintSize),
+    ResizeTo(DeviceIntSize),
     // Show an alert message.
     Alert(String, IpcSender<()>),
     /// Wether or not to follow a link

components/layout/display_list/border.rs

@@ -181,18 +181,18 @@ pub fn image_width(
     )
 }
 
-fn resolve_percentage(value: NumberOrPercentage, length: u32) -> u32 {
+fn resolve_percentage(value: NumberOrPercentage, length: i32) -> i32 {
     match value {
-        NumberOrPercentage::Percentage(p) => (p.0 * length as f32).round() as u32,
-        NumberOrPercentage::Number(n) => n.round() as u32,
+        NumberOrPercentage::Percentage(p) => (p.0 * length as f32).round() as i32,
+        NumberOrPercentage::Number(n) => n.round() as i32,
     }
 }
 
 pub fn image_slice(
     border_image_slice: &StyleRect<NumberOrPercentage>,
-    width: u32,
-    height: u32,
-) -> SideOffsets2D<u32> {
+    width: i32,
+    height: i32,
+) -> SideOffsets2D<i32> {
     SideOffsets2D::new(
         resolve_percentage(border_image_slice.0, height),
         resolve_percentage(border_image_slice.1, width),

components/layout/display_list/builder.rs

@@ -1459,9 +1459,9 @@ impl FragmentDisplayListBuilding for Fragment {
 
         let details = BorderDetails::NinePatch(NinePatchBorder {
             source,
-            width,
-            height,
-            slice: border::image_slice(border_image_slice, width, height),
+            width: width as i32,
+            height: height as i32,
+            slice: border::image_slice(border_image_slice, width as i32, height as i32),
             fill: border_image_fill,
             repeat_horizontal: border_image_repeat.0.to_layout(),
             repeat_vertical: border_image_repeat.1.to_layout(),

components/layout/display_list/webrender_helpers.rs

@@ -104,37 +104,43 @@ impl WebRenderDisplayItemConverter for DisplayItem {
 
         match *self {
             DisplayItem::Rectangle(ref item) => {
-                builder.push_item(SpecificDisplayItem::Rectangle(item.item), &self.prim_info());
+                builder.push_item(
+                    &SpecificDisplayItem::Rectangle(item.item),
+                    &self.prim_info(),
+                );
             },
             DisplayItem::Text(ref item) => {
-                builder.push_item(SpecificDisplayItem::Text(item.item), &self.prim_info());
+                builder.push_item(&SpecificDisplayItem::Text(item.item), &self.prim_info());
                 builder.push_iter(item.data.iter());
             },
             DisplayItem::Image(ref item) => {
-                builder.push_item(SpecificDisplayItem::Image(item.item), &self.prim_info());
+                builder.push_item(&SpecificDisplayItem::Image(item.item), &self.prim_info());
             },
             DisplayItem::Border(ref item) => {
                 if !item.data.is_empty() {
                     builder.push_stops(item.data.as_ref());
                 }
-                builder.push_item(SpecificDisplayItem::Border(item.item), &self.prim_info());
+                builder.push_item(&SpecificDisplayItem::Border(item.item), &self.prim_info());
             },
             DisplayItem::Gradient(ref item) => {
                 builder.push_stops(item.data.as_ref());
-                builder.push_item(SpecificDisplayItem::Gradient(item.item), &self.prim_info());
+                builder.push_item(&SpecificDisplayItem::Gradient(item.item), &self.prim_info());
             },
             DisplayItem::RadialGradient(ref item) => {
                 builder.push_stops(item.data.as_ref());
                 builder.push_item(
-                    SpecificDisplayItem::RadialGradient(item.item),
+                    &SpecificDisplayItem::RadialGradient(item.item),
                     &self.prim_info(),
                 );
             },
             DisplayItem::Line(ref item) => {
-                builder.push_item(SpecificDisplayItem::Line(item.item), &self.prim_info());
+                builder.push_item(&SpecificDisplayItem::Line(item.item), &self.prim_info());
             },
             DisplayItem::BoxShadow(ref item) => {
-                builder.push_item(SpecificDisplayItem::BoxShadow(item.item), &self.prim_info());
+                builder.push_item(
+                    &SpecificDisplayItem::BoxShadow(item.item),
+                    &self.prim_info(),
+                );
             },
             DisplayItem::PushTextShadow(ref item) => {
                 builder.push_shadow(&self.prim_info(), item.shadow);

components/net/image_cache.rs

@@ -72,7 +72,7 @@ fn set_webrender_image_key(webrender_api: &webrender_api::RenderApi, image: &mut
         },
     };
     let descriptor = webrender_api::ImageDescriptor {
-        size: webrender_api::DeviceUintSize::new(image.width, image.height),
+        size: webrender_api::DeviceIntSize::new(image.width as i32, image.height as i32),
         stride: None,
         format: webrender_api::ImageFormat::BGRA8,
         offset: 0,

components/script/dom/htmlmediaelement.rs

@@ -88,8 +88,8 @@ impl MediaFrameRenderer {
 impl FrameRenderer for MediaFrameRenderer {
     fn render(&mut self, frame: Frame) {
         let descriptor = ImageDescriptor::new(
-            frame.get_width() as u32,
-            frame.get_height() as u32,
+            frame.get_width(),
+            frame.get_height(),
             ImageFormat::BGRA8,
             false,
             false,
@@ -107,7 +107,12 @@ impl FrameRenderer for MediaFrameRenderer {
             Some((ref image_key, ref mut width, ref mut height))
                 if *width == frame.get_width() && *height == frame.get_height() =>
             {
-                txn.update_image(*image_key, descriptor, image_data, None);
+                txn.update_image(
+                    *image_key,
+                    descriptor,
+                    image_data,
+                    &webrender_api::DirtyRect::All,
+                );
 
                 if let Some(old_image_key) = self.old_frame.take() {
                     txn.delete_image(old_image_key);

components/script/dom/screen.rs

@@ -16,7 +16,7 @@ use euclid::TypedSize2D;
 use profile_traits::ipc;
 use script_traits::ScriptMsg;
 use style_traits::CSSPixel;
-use webrender_api::DeviceUintSize;
+use webrender_api::DeviceIntSize;
 
 #[dom_struct]
 pub struct Screen {
@@ -42,7 +42,7 @@ impl Screen {
 
     fn screen_size(&self) -> TypedSize2D<u32, CSSPixel> {
         let (send, recv) =
-            ipc::channel::<DeviceUintSize>(self.global().time_profiler_chan().clone()).unwrap();
+            ipc::channel::<DeviceIntSize>(self.global().time_profiler_chan().clone()).unwrap();
         self.window
             .upcast::<GlobalScope>()
             .script_to_constellation_chan()
@@ -55,7 +55,7 @@ impl Screen {
 
     fn screen_avail_size(&self) -> TypedSize2D<u32, CSSPixel> {
         let (send, recv) =
-            ipc::channel::<DeviceUintSize>(self.global().time_profiler_chan().clone()).unwrap();
+            ipc::channel::<DeviceIntSize>(self.global().time_profiler_chan().clone()).unwrap();
         self.window
             .upcast::<GlobalScope>()
             .script_to_constellation_chan()

components/script/dom/window.rs

@@ -129,9 +129,7 @@ use style::str::HTML_SPACE_CHARACTERS;
 use style::stylesheets::CssRuleType;
 use style_traits::{CSSPixel, DevicePixel, ParsingMode};
 use url::Position;
-use webrender_api::{
-    DeviceIntPoint, DeviceUintSize, DocumentId, ExternalScrollId, RenderApiSender,
-};
+use webrender_api::{DeviceIntPoint, DeviceIntSize, DocumentId, ExternalScrollId, RenderApiSender};
 use webvr_traits::WebVRMsg;
 
 /// Current state of the window object
@@ -1042,7 +1040,7 @@ impl WindowMethods for Window {
         //TODO determine if this operation is allowed
         let dpr = self.device_pixel_ratio();
         let size = TypedSize2D::new(width, height).to_f32() * dpr;
-        self.send_to_embedder(EmbedderMsg::ResizeTo(size.to_u32()));
+        self.send_to_embedder(EmbedderMsg::ResizeTo(size.to_i32()));
     }
 
     // https://drafts.csswg.org/cssom-view/#dom-window-resizeby
@@ -1326,7 +1324,7 @@ impl Window {
     fn client_window(&self) -> (TypedSize2D<u32, CSSPixel>, TypedPoint2D<i32, CSSPixel>) {
         let timer_profile_chan = self.global().time_profiler_chan().clone();
         let (send, recv) =
-            ProfiledIpc::channel::<(DeviceUintSize, DeviceIntPoint)>(timer_profile_chan).unwrap();
+            ProfiledIpc::channel::<(DeviceIntSize, DeviceIntPoint)>(timer_profile_chan).unwrap();
         self.send_to_constellation(ScriptMsg::GetClientWindow(send));
         let (size, point) = recv
             .recv()

components/script_traits/lib.rs

@@ -54,7 +54,7 @@ use style_traits::cursor::CursorKind;
 use style_traits::CSSPixel;
 use style_traits::SpeculativePainter;
 use webrender_api::{
-    DevicePixel, DeviceUintSize, DocumentId, ExternalScrollId, ImageKey, RenderApiSender,
+    DeviceIntSize, DevicePixel, DocumentId, ExternalScrollId, ImageKey, RenderApiSender,
 };
 use webvr_traits::{WebVREvent, WebVRMsg};
 
@@ -701,7 +701,7 @@ pub enum WebDriverCommandMsg {
     /// Set the window size.
     SetWindowSize(
         TopLevelBrowsingContextId,
-        DeviceUintSize,
+        DeviceIntSize,
         IpcSender<WindowSizeData>,
     ),
     /// Take a screenshot of the window.

components/script_traits/script_msg.rs

@@ -28,7 +28,7 @@ use std::fmt;
 use style_traits::cursor::CursorKind;
 use style_traits::viewport::ViewportConstraints;
 use style_traits::CSSPixel;
-use webrender_api::{DeviceIntPoint, DeviceUintSize};
+use webrender_api::{DeviceIntPoint, DeviceIntSize};
 
 /// Messages from the layout to the constellation.
 #[derive(Deserialize, Serialize)]
@@ -185,11 +185,11 @@ pub enum ScriptMsg {
     /// Store the data required to activate a service worker for the given scope
     RegisterServiceWorker(ScopeThings, ServoUrl),
     /// Get Window Informations size and position
-    GetClientWindow(IpcSender<(DeviceUintSize, DeviceIntPoint)>),
+    GetClientWindow(IpcSender<(DeviceIntSize, DeviceIntPoint)>),
     /// Get the screen size (pixel)
-    GetScreenSize(IpcSender<(DeviceUintSize)>),
+    GetScreenSize(IpcSender<(DeviceIntSize)>),
     /// Get the available screen size (pixel)
-    GetScreenAvailSize(IpcSender<(DeviceUintSize)>),
+    GetScreenAvailSize(IpcSender<(DeviceIntSize)>),
 }
 
 impl fmt::Debug for ScriptMsg {

components/webdriver_server/lib.rs

@@ -527,8 +527,11 @@ impl Handler {
         };
         let size = TypedSize2D::new(width as u32, height as u32);
         let top_level_browsing_context_id = self.session()?.top_level_browsing_context_id;
-        let cmd_msg =
-            WebDriverCommandMsg::SetWindowSize(top_level_browsing_context_id, size, sender.clone());
+        let cmd_msg = WebDriverCommandMsg::SetWindowSize(
+            top_level_browsing_context_id,
+            size.to_i32(),
+            sender.clone(),
+        );
 
         self.constellation_chan
             .send(ConstellationMsg::WebDriverCommand(cmd_msg))

ports/libmlservo/src/lib.rs

@@ -392,16 +392,16 @@ impl WindowMethods for WindowInstance {
     fn get_coordinates(&self) -> EmbedderCoordinates {
         EmbedderCoordinates {
             hidpi_factor: TypedScale::new(self.hidpi),
-            screen: TypedSize2D::new(self.width, self.height),
-            screen_avail: TypedSize2D::new(self.width, self.height),
+            screen: TypedSize2D::new(self.width as i32, self.height as i32),
+            screen_avail: TypedSize2D::new(self.width as i32, self.height as i32),
             window: (
-                TypedSize2D::new(self.width, self.height),
+                TypedSize2D::new(self.width as i32, self.height as i32),
                 TypedPoint2D::new(0, 0),
             ),
-            framebuffer: TypedSize2D::new(self.width, self.height),
+            framebuffer: TypedSize2D::new(self.width as i32, self.height as i32),
             viewport: TypedRect::new(
                 TypedPoint2D::new(0, 0),
-                TypedSize2D::new(self.width, self.height),
+                TypedSize2D::new(self.width as i32, self.height as i32),
             ),
         }
     }