Snap paint offset paint property to pixel boundaries

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 "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Settings.h"
 #include "core/layout/LayoutInline.h"
@@ skipping 59 matching lines @@
     if (object.isBoxModelObject()) {
         // TODO(trchen): Eliminate PaintLayer dependency.
         PaintLayer* layer = toLayoutBoxModelObject(object).layer();
         if (!layer || !layer->paintsWithTransform(GlobalPaintNormalPhase))
             return;
     }
 
     if (context.paintOffset == LayoutPoint())
         return;
 
+    // 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 roundedPaintOffset = roundedIntPoint(context.paintOffset);
+    LayoutPoint fractionalPaintOffset = LayoutPoint(context.paintOffset - roundedPaintOffset);
+
     RefPtr<TransformPaintPropertyNode> paintOffsetTranslation = TransformPaintPropertyNode::create(
-        TransformationMatrix().translate(context.paintOffset.x(), context.paintOffset.y()),
+        TransformationMatrix().translate(roundedPaintOffset.x(), roundedPaintOffset.y()),
         FloatPoint3D(), context.currentTransform);
     context.currentTransform = paintOffsetTranslation.get();
-    context.paintOffset = LayoutPoint();
+    context.paintOffset = fractionalPaintOffset;
     object.getMutableForPainting().ensureObjectPaintProperties().setPaintOffsetTranslation(paintOffsetTranslation.release());
 }
 
 static FloatPoint3D transformOrigin(const LayoutBox& box)
 {
     const ComputedStyle& style = box.styleRef();
     FloatSize borderBoxSize(box.size());
     return FloatPoint3D(
         floatValueForLength(style.transformOriginX(), borderBoxSize.width()),
         floatValueForLength(style.transformOriginY(), borderBoxSize.height()),
         style.transformOriginZ());
 }
 
 void PaintPropertyTreeBuilder::updateTransform(const LayoutObject& object, PaintPropertyTreeBuilderContext& context)
 {
     if (object.isSVG() && !object.isSVGRoot()) {
-        // SVG does not use paint offset internally and the root should have already accounted for
-        // any paint offset in the root's svgLocalToBorderBox transform.
+        // SVG does not use paint offset internally.
         DCHECK(context.paintOffset == LayoutPoint());
 
         // FIXME(pdr): Check for the presence of a transform instead of the value. Checking for an
         // identity matrix will cause the property tree structure to change during animations if
         // the animation passes through the identity matrix.
         // FIXME(pdr): Refactor this so all non-root SVG objects use the same transform function.
         const AffineTransform& transform = object.isSVGForeignObject() ? object.localSVGTransform() : object.localToSVGParentTransform();
         if (transform.isIdentity())
             return;
 
         // The origin is included in the local transform, so use an empty origin.
         RefPtr<TransformPaintPropertyNode> svgTransform = TransformPaintPropertyNode::create(
             transform, FloatPoint3D(0, 0, 0), context.currentTransform);
         context.currentTransform = svgTransform.get();
         object.getMutableForPainting().ensureObjectPaintProperties().setTransform(svgTransform.release());
         return;
     }
 
     const ComputedStyle& style = object.styleRef();
     if (!object.isBox() || !style.hasTransform())
         return;
-    ASSERT(context.paintOffset == LayoutPoint());
 
     TransformationMatrix matrix;
     style.applyTransform(matrix, toLayoutBox(object).size(), ComputedStyle::ExcludeTransformOrigin,
         ComputedStyle::IncludeMotionPath, ComputedStyle::IncludeIndependentTransformProperties);
     RefPtr<TransformPaintPropertyNode> transformNode = TransformPaintPropertyNode::create(
         matrix, transformOrigin(toLayoutBox(object)), context.currentTransform);
     context.currentTransform = transformNode.get();
     object.getMutableForPainting().ensureObjectPaintProperties().setTransform(transformNode.release());
 }
 
@@ skipping 265 matching lines @@
     updateOverflowClip(object, context);
     // TODO(trchen): Insert flattening transform here, as specified by
     // http://www.w3.org/TR/css3-transforms/#transform-style-property
     updatePerspective(object, context);
     updateSvgLocalToBorderBoxTransform(object, context);
     updateScrollTranslation(object, context);
     updateOutOfFlowContext(object, context);
 }
 
 } // namespace blink