Don't pass subpixel offsets through non-translation transforms

third_party/WebKit/Source/core/paint/PaintPropertyTreeBuilder.cpp

 // Copyright 2015 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 "core/paint/PaintPropertyTreeBuilder.h"
 
 #include <memory>
 #include "core/dom/DOMNodeIds.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
@@ skipping 247 matching lines @@
       (object.IsLayoutView() ||
        context.current.paint_offset != LayoutPoint())) {
     auto& properties = *object.GetMutableForPainting().PaintProperties();
     // We should use the same subpixel paint offset values for snapping
     // regardless of whether a transform is present. If there is a transform
     // we round the paint offset but keep around the residual fractional
     // component for the transformed content to paint with.  In spv1 this was
     // called "subpixel accumulation". For more information, see
     // PaintLayer::subpixelAccumulation() and
     // PaintLayerPainter::paintFragmentByApplyingTransform.
-    IntPoint rounded_paint_offset =
-        RoundedIntPoint(context.current.paint_offset);
-    LayoutPoint fractional_paint_offset =
-        LayoutPoint(context.current.paint_offset - rounded_paint_offset);
+    LayoutPoint used_paint_offset(context.current.paint_offset.X().Round(),
+                                  context.current.paint_offset.Y().Round());
+    LayoutPoint remainder_paint_offset =
+        LayoutPoint(context.current.paint_offset - used_paint_offset);
+
+    if (remainder_paint_offset != LayoutPoint()) {
+      // However, if the object has a non-translation transform, we can't pass
+      // subpixel offsets through the transform to descendants.
+      TransformationMatrix matrix;
+      object.StyleRef().ApplyTransform(
+          matrix, LayoutSize(), ComputedStyle::kExcludeTransformOrigin,
+          ComputedStyle::kIncludeMotionPath,
+          ComputedStyle::kIncludeIndependentTransformProperties);
+      if (!matrix.IsIdentityOrTranslation()) {
+        remainder_paint_offset = LayoutPoint();
+        used_paint_offset = context.current.paint_offset;
+      }
+    }
 
     force_subtree_update |= properties.UpdatePaintOffsetTranslation(
         context.current.transform,
-        TransformationMatrix().Translate(rounded_paint_offset.X(),
-                                         rounded_paint_offset.Y()),
+        TransformationMatrix().Translate(used_paint_offset.X().ToDouble(),
+                                         used_paint_offset.Y().ToDouble()),
         FloatPoint3D(), context.current.should_flatten_inherited_transform,
         context.current.rendering_context_id);
 
     context.current.transform = properties.PaintOffsetTranslation();
-    context.current.paint_offset = fractional_paint_offset;
+    context.current.paint_offset = remainder_paint_offset;
     if (RuntimeEnabledFeatures::rootLayerScrollingEnabled() &&
         object.IsLayoutView()) {
       context.absolute_position.transform = properties.PaintOffsetTranslation();
       context.fixed_position.transform = properties.PaintOffsetTranslation();
-      context.absolute_position.paint_offset = LayoutPoint();
-      context.fixed_position.paint_offset = LayoutPoint();
+      context.absolute_position.paint_offset = remainder_paint_offset;
+      context.fixed_position.paint_offset = remainder_paint_offset;
     }
   } else {
     if (auto* properties = object.GetMutableForPainting().PaintProperties())
       force_subtree_update |= properties->ClearPaintOffsetTranslation();
   }
 }
 
 static bool NeedsTransformForNonRootSVG(const LayoutObject& object) {
   // TODO(pdr): Check for the presence of a transform instead of the value.
   // Checking for an identity matrix will cause the property tree structure
@@ skipping 972 matching lines @@
                            context.force_subtree_update);
 
     context.force_subtree_update |= object.SubtreeNeedsPaintPropertyUpdate();
   }
 
   if (object.CanContainAbsolutePositionObjects())
     context.container_for_absolute_position = &object;
 }
 
 }  // namespace blink