Bug 1611601 - Stop snapping when calculating uv rects on the CPU side…

…. r=gw

In bug 1574493, we moved most snapping to scene building and a minority
to frame building. No snapping is done in the shader. However there was
some left over code that still tried to replicate the past behaviour and
this caused wobbling during the rendering. This patch removes the extra
snapping on the CPU side and trusts scene/frame building to do the job.

Differential Revision: https://phabricator.services.mozilla.com/D61590

[ghsync] From https://hg.mozilla.org/mozilla-central/rev/9867a7bc911e2d3abc2312826c9f14cfa7b10a63

webrender/src/picture.rs

@@ -105,7 +105,7 @@ use smallvec::SmallVec;
 use std::{mem, u8, marker, u32};
 use std::sync::atomic::{AtomicUsize, Ordering};
 use crate::texture_cache::TextureCacheHandle;
-use crate::util::{TransformedRectKind, MatrixHelpers, MaxRect, scale_factors, VecHelper, RectHelpers};
+use crate::util::{MaxRect, scale_factors, VecHelper, RectHelpers};
 use crate::filterdata::{FilterDataHandle};
 #[cfg(any(feature = "capture", feature = "replay"))]
 use ron;
@@ -3843,7 +3843,6 @@ impl PicturePrimitive {
                             &transform,
                             &device_rect,
                             device_pixel_scale,
-                            true,
                         );
 
                         let picture_task_id = frame_state.render_tasks.add().init(
@@ -3906,7 +3905,6 @@ impl PicturePrimitive {
                             &transform,
                             &device_rect,
                             device_pixel_scale,
-                            true,
                         );
 
                         let picture_task_id = frame_state.render_tasks.add().init({
@@ -3955,7 +3953,6 @@ impl PicturePrimitive {
                             &transform,
                             &clipped,
                             device_pixel_scale,
-                            true,
                         );
 
                         let readback_task_id = frame_state.render_tasks.add().init(
@@ -3991,7 +3988,6 @@ impl PicturePrimitive {
                             &transform,
                             &clipped,
                             device_pixel_scale,
-                            true,
                         );
 
                         let render_task_id = frame_state.render_tasks.add().init(
@@ -4016,7 +4012,6 @@ impl PicturePrimitive {
                             &transform,
                             &clipped,
                             device_pixel_scale,
-                            true,
                         );
 
                         let render_task_id = frame_state.render_tasks.add().init(
@@ -4276,19 +4271,11 @@ impl PicturePrimitive {
                     }
                     PictureCompositeMode::MixBlend(..) |
                     PictureCompositeMode::Blit(_) => {
-                        // The SplitComposite shader used for 3d contexts doesn't snap
-                        // to pixels, so we shouldn't snap our uv coordinates either.
-                        let supports_snapping = match self.context_3d {
-                            Picture3DContext::In{ .. } => false,
-                            _ => true,
-                        };
-
                         let uv_rect_kind = calculate_uv_rect_kind(
                             &pic_rect,
                             &transform,
                             &clipped,
                             device_pixel_scale,
-                            supports_snapping,
                         );
 
                         let render_task_id = frame_state.render_tasks.add().init(
@@ -4313,7 +4300,6 @@ impl PicturePrimitive {
                             &transform,
                             &clipped,
                             device_pixel_scale,
-                            true,
                         );
 
                         let picture_task_id = frame_state.render_tasks.add().init(
@@ -5010,32 +4996,14 @@ fn calculate_screen_uv(
     transform: &PictureToRasterTransform,
     rendered_rect: &DeviceRect,
     device_pixel_scale: DevicePixelScale,
-    supports_snapping: bool,
 ) -> DeviceHomogeneousVector {
     let raster_pos = transform.transform_point2d_homogeneous(*local_pos);
 
-    let mut device_vec = DeviceHomogeneousVector::new(
-        raster_pos.x * device_pixel_scale.0,
-        raster_pos.y * device_pixel_scale.0,
-        0.0,
-        raster_pos.w,
-    );
-
-    // Apply snapping for axis-aligned scroll nodes, as per prim_shared.glsl.
-    if transform.transform_kind() == TransformedRectKind::AxisAligned && supports_snapping {
-        device_vec = DeviceHomogeneousVector::new(
-            (device_vec.x / device_vec.w + 0.5).floor(),
-            (device_vec.y / device_vec.w + 0.5).floor(),
-            0.0,
-            1.0,
-        );
-    }
-
     DeviceHomogeneousVector::new(
-        (device_vec.x - rendered_rect.origin.x * device_vec.w) / rendered_rect.size.width,
-        (device_vec.y - rendered_rect.origin.y * device_vec.w) / rendered_rect.size.height,
+        (raster_pos.x * device_pixel_scale.0 - rendered_rect.origin.x * raster_pos.w) / rendered_rect.size.width,
+        (raster_pos.y * device_pixel_scale.0 - rendered_rect.origin.y * raster_pos.w) / rendered_rect.size.height,
         0.0,
-        device_vec.w,
+        raster_pos.w,
     )
 }
 
@@ -5046,7 +5014,6 @@ fn calculate_uv_rect_kind(
     transform: &PictureToRasterTransform,
     rendered_rect: &DeviceIntRect,
     device_pixel_scale: DevicePixelScale,
-    supports_snapping: bool,
 ) -> UvRectKind {
     let rendered_rect = rendered_rect.to_f32();
 
@@ -5055,31 +5022,27 @@ fn calculate_uv_rect_kind(
         transform,
         &rendered_rect,
         device_pixel_scale,
-        supports_snapping,
     );
 
     let top_right = calculate_screen_uv(
         &pic_rect.top_right(),
         transform,
         &rendered_rect,
         device_pixel_scale,
-        supports_snapping,
     );
 
     let bottom_left = calculate_screen_uv(
         &pic_rect.bottom_left(),
         transform,
         &rendered_rect,
         device_pixel_scale,
-        supports_snapping,
     );
 
     let bottom_right = calculate_screen_uv(
         &pic_rect.bottom_right(),
         transform,
         &rendered_rect,
         device_pixel_scale,
-        supports_snapping,
     );
 
     UvRectKind::Quad {