Fix fixed-pos jitter related to physical pixel snapping.

cc/trees/layer_tree_host_common.cc

 // Copyright 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/trees/layer_tree_host_common.h"
 
 #include <algorithm>
 
 #include "base/debug/trace_event.h"
 #include "cc/base/math_util.h"
@@ skipping 1500 matching lines @@
     // LT = Tr[origin] * Tr[origin2anchor] * M[layer]
     combined_transform.PreconcatTransform(layer->transform());
     // LT = Tr[origin] * Tr[origin2anchor] * M[layer] * Tr[anchor2origin]
     combined_transform.Translate3d(-anchor_point.x() * bounds.width(),
                                    -anchor_point.y() * bounds.height(),
                                    -layer->anchor_point_z());
   } else {
     combined_transform.Translate(position.x(), position.y());
   }
 
-  gfx::Vector2dF effective_scroll_delta = GetEffectiveScrollDelta(layer);
-  if (!animating_transform_to_target && layer->scrollable() &&
-      combined_transform.IsScaleOrTranslation()) {
-    // Align the scrollable layer's position to screen space pixels to avoid
-    // blurriness.  To avoid side-effects, do this only if the transform is
-    // simple.
-    gfx::Vector2dF previous_translation = combined_transform.To2dTranslation();
-    RoundTranslationComponents(&combined_transform);
-    gfx::Vector2dF current_translation = combined_transform.To2dTranslation();
-
-    // This rounding changes the scroll delta, and so must be included
-    // in the scroll compensation matrix.
-    effective_scroll_delta -= current_translation - previous_translation;
-  }
-
-  // Apply adjustment from position constraints.
-  ApplyPositionAdjustment(layer, data_from_ancestor.fixed_container,
-      data_from_ancestor.scroll_compensation_matrix, &combined_transform);
-
   // Compute the 2d scale components of the transform hierarchy up to the target
   // surface. From there, we can decide on a contents scale for the layer.
   float layer_scale_factors = globals.device_scale_factor;
   if (data_from_ancestor.in_subtree_of_page_scale_application_layer)
     layer_scale_factors *= globals.page_scale_factor;
   gfx::Vector2dF combined_transform_scales =
       MathUtil::ComputeTransform2dScaleComponents(
           combined_transform,
           layer_scale_factors);
 
   float ideal_contents_scale =
       globals.can_adjust_raster_scales
       ? std::max(combined_transform_scales.x(),
                  combined_transform_scales.y())
       : layer_scale_factors;
   UpdateLayerContentsScale(
       layer,
       globals.can_adjust_raster_scales,
       ideal_contents_scale,
       globals.device_scale_factor,
       data_from_ancestor.in_subtree_of_page_scale_application_layer ?
           globals.page_scale_factor : 1.f,
       animating_transform_to_screen);
 
+  gfx::Vector2dF effective_scroll_delta = GetEffectiveScrollDelta(layer);
+  if (!animating_transform_to_target && layer->scrollable() &&
+      combined_transform.IsScaleOrTranslation()) {
+    // Align the scrollable layer's position to screen space pixels to avoid
+    // blurriness.  To avoid side-effects, do this only if the transform is
+    // simple.
+    gfx::Vector2dF previous_translation = combined_transform.To2dTranslation();
+    RoundTranslationComponents(&combined_transform);
+    gfx::Vector2dF current_translation = combined_transform.To2dTranslation();
+
+    // This rounding changes the scroll delta, and so must be included
+    // in the scroll compensation matrix.

[enne (OOO), 2014/03/31 22:45:22]

Can you also mention why you're scaling the offset?  If I understand this bug
correctly, it's because there's a scale earlier in the tree, so the scroll delta
gets multiplied by that scale when applied to children, and so you have to
correct for that here.

[aelias_OOO_until_Jul13, 2014/04/01 06:24:20]

Added a longer comment.

+    effective_scroll_delta -=
+        gfx::ScaleVector2d(current_translation - previous_translation,
+                           1 / combined_transform_scales.x(),

[enne (OOO), 2014/03/31 22:45:22]

style nit: 1.f

[aelias_OOO_until_Jul13, 2014/04/01 06:24:20]

Done.

+                           1 / combined_transform_scales.y());
+  }
+
+  // Apply adjustment from position constraints.
+  ApplyPositionAdjustment(layer,
+                          data_from_ancestor.fixed_container,
+                          data_from_ancestor.scroll_compensation_matrix,
+                          &combined_transform);
+
   // The draw_transform that gets computed below is effectively the layer's
   // draw_transform, unless the layer itself creates a render_surface. In that
   // case, the render_surface re-parents the transforms.
   layer_draw_properties.target_space_transform = combined_transform;
   // M[draw] = M[parent] * LT * S[layer2content]
   layer_draw_properties.target_space_transform.Scale(
       SK_MScalar1 / layer->contents_scale_x(),
       SK_MScalar1 / layer->contents_scale_y());
 
   // The layer's screen_space_transform represents the transform between root
@@ skipping 823 matching lines @@
   // At this point, we think the point does hit the touch event handler region
   // on the layer, but we need to walk up the parents to ensure that the layer
   // was not clipped in such a way that the hit point actually should not hit
   // the layer.
   if (PointIsClippedBySurfaceOrClipRect(screen_space_point, layer_impl))
     return false;
 
   return true;
 }
 }  // namespace cc