WR update: new viewport semantic

components/canvas/webgl_mode/inprocess.rs

@@ -151,7 +151,7 @@ impl webrender::OutputImageHandler for OutputHandler {
     fn lock(
         &mut self,
         id: webrender_api::PipelineId,
-    ) -> Option<(u32, webrender_api::DeviceIntSize)> {
+    ) -> Option<(u32, webrender_api::FramebufferIntSize)> {
         // Insert a fence in the WR command queue
         let gl_sync = self
             .webrender_gl
@@ -164,7 +164,7 @@ impl webrender::OutputImageHandler for OutputHandler {
         self.lock_channel.1.recv().unwrap().map(|(tex_id, size)| {
             (
                 tex_id,
-                webrender_api::DeviceIntSize::new(size.width, size.height),
+                webrender_api::FramebufferIntSize::new(size.width, size.height),
             )
         })
     }

components/compositing/compositor.rs

@@ -41,7 +41,10 @@ use std::rc::Rc;
 use style_traits::viewport::ViewportConstraints;
 use style_traits::{CSSPixel, DevicePixel, PinchZoomFactor};
 use time::{now, precise_time_ns, precise_time_s};
-use webrender_api::{self, DeviceIntPoint, DevicePoint, HitTestFlags, HitTestResult};
+use webrender_api::{
+    self, DeviceIntPoint, DevicePoint, FramebufferIntRect, FramebufferIntSize, HitTestFlags,
+    HitTestResult,
+};
 use webrender_api::{LayoutVector2D, ScrollLocation};
 use webvr_traits::WebVRMainThreadHeartbeat;
 
@@ -575,10 +578,16 @@ impl<Window: WindowMethods> IOCompositor<Window> {
     fn send_window_size(&self, size_type: WindowSizeType) {
         let dppx = self.page_zoom * self.embedder_coordinates.hidpi_factor;
 
-        self.webrender_api.set_window_parameters(
+        let flipped_viewport = {
+            let fb_height = self.embedder_coordinates.framebuffer.height;
+            let mut view = self.embedder_coordinates.viewport.clone();
+            view.origin.y = fb_height - view.origin.y - view.size.height;
+            FramebufferIntRect::from_untyped(&view.to_untyped())
+        };
+
+        self.webrender_api.set_document_view(
             self.webrender_document,
-            self.embedder_coordinates.framebuffer,
-            self.embedder_coordinates.viewport,
+            flipped_viewport,
             self.embedder_coordinates.hidpi_factor.get(),
         );
 
@@ -612,9 +621,7 @@ impl<Window: WindowMethods> IOCompositor<Window> {
             self.update_zoom_transform();
         }
 
-        if self.embedder_coordinates.viewport == old_coords.viewport &&
-            self.embedder_coordinates.framebuffer == old_coords.framebuffer
-        {
+        if self.embedder_coordinates.viewport == old_coords.viewport {
             return;
         }
 
@@ -1203,11 +1210,13 @@ impl<Window: WindowMethods> IOCompositor<Window> {
             || {
                 debug!("compositor: compositing");
 
+                let size = FramebufferIntSize::from_untyped(
+                    &self.embedder_coordinates.framebuffer.to_untyped(),
+                );
+
                 // Paint the scene.
                 // TODO(gw): Take notice of any errors the renderer returns!
-                self.webrender
-                    .render(self.embedder_coordinates.framebuffer)
-                    .ok();
+                self.webrender.render(size).ok();
             },
         );
 

components/compositing/gl.rs

@@ -4,7 +4,7 @@
 
 use gleam::gl;
 use image::RgbImage;
-use servo_geometry::DeviceUintLength;
+use servo_geometry::FramebufferUintLength;
 
 #[derive(Default)]
 pub struct RenderTargetInfo {
@@ -15,8 +15,8 @@ pub struct RenderTargetInfo {
 
 pub fn initialize_png(
     gl: &dyn gl::Gl,
-    width: DeviceUintLength,
-    height: DeviceUintLength,
+    width: FramebufferUintLength,
+    height: FramebufferUintLength,
 ) -> RenderTargetInfo {
     let framebuffer_ids = gl.gen_framebuffers(1);
     gl.bind_framebuffer(gl::FRAMEBUFFER, framebuffer_ids[0]);
@@ -82,8 +82,8 @@ pub fn initialize_png(
 pub fn draw_img(
     gl: &dyn gl::Gl,
     render_target_info: RenderTargetInfo,
-    width: DeviceUintLength,
-    height: DeviceUintLength,
+    width: FramebufferUintLength,
+    height: FramebufferUintLength,
 ) -> RgbImage {
     let width = width.get() as usize;
     let height = height.get() as usize;

components/compositing/windowing.rs

@@ -17,7 +17,9 @@ use std::fmt::{Debug, Error, Formatter};
 #[cfg(feature = "gl")]
 use std::rc::Rc;
 use style_traits::DevicePixel;
-use webrender_api::{DeviceIntPoint, DeviceIntRect, DeviceIntSize, DevicePoint, ScrollLocation};
+use webrender_api::{
+    DeviceIntPoint, DeviceIntRect, DeviceIntSize, DevicePoint, FramebufferIntSize, ScrollLocation,
+};
 use webvr::VRServiceManager;
 use webvr_traits::WebVRMainThreadHeartbeat;
 
@@ -167,7 +169,7 @@ pub struct EmbedderCoordinates {
     /// Size of the native window.
     pub window: (DeviceIntSize, DeviceIntPoint),
     /// Size of the GL buffer in the window.
-    pub framebuffer: DeviceIntSize,
+    pub framebuffer: FramebufferIntSize,
     /// Coordinates of the document within the framebuffer.
     pub viewport: DeviceIntRect,
 }

components/geometry/lib.rs

@@ -8,12 +8,11 @@ extern crate malloc_size_of_derive;
 use app_units::{Au, MAX_AU, MIN_AU};
 use euclid::{Length, Point2D, Rect, Size2D};
 use std::f32;
-use style_traits::DevicePixel;
-use webrender_api::{LayoutPoint, LayoutRect, LayoutSize};
+use webrender_api::{FramebufferPixel, LayoutPoint, LayoutRect, LayoutSize};
 
 // Units for use with euclid::length and euclid::scale_factor.
 
-pub type DeviceUintLength = Length<u32, DevicePixel>;
+pub type FramebufferUintLength = Length<u32, FramebufferPixel>;
 
 /// A normalized "pixel" at the default resolution for the display.
 ///