Avoid false-positives of paint offset change detection (method 2)

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/dom/DOMNodeIds.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Settings.h"
@@ skipping 197 matching lines @@
   context.containerForAbsolutePosition = nullptr;
   context.fixedPosition = context.current;
   context.fixedPosition.transform = fixedTransformNode;
   context.fixedPosition.scroll = fixedScrollNode;
 
   std::unique_ptr<PropertyTreeState> contentsState(new PropertyTreeState(
       context.current.transform, context.current.clip, context.currentEffect));
   frameView.setTotalPropertyTreeStateForContents(std::move(contentsState));
 }
 
-void PaintPropertyTreeBuilder::updatePaintOffsetTranslation(
+static bool calculatePaintOffsetTranslation(
     const LayoutObject& object,
-    PaintPropertyTreeBuilderContext& context) {
+    const LayoutPoint& paintOffset,
+    IntPoint& roundedPaintOffset,
+    LayoutPoint& fractionalPaintOffset) {
   bool usesPaintOffsetTranslation = false;
   if (RuntimeEnabledFeatures::rootLayerScrollingEnabled() &&
       object.isLayoutView()) {
     // Root layer scrolling always creates a translation node for LayoutView to
     // ensure fixed and absolute contexts use the correct transform space.
     usesPaintOffsetTranslation = true;
-  } else if (object.isBoxModelObject() &&
-             context.current.paintOffset != LayoutPoint()) {
+  } else if (object.isBoxModelObject() && paintOffset != LayoutPoint()) {
     PaintLayer* layer = toLayoutBoxModelObject(object).layer();
     if (layer &&
         layer->paintsWithTransform(GlobalPaintFlattenCompositingLayers))
       usesPaintOffsetTranslation = true;
   }
 
   // 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.current.paintOffset);
-  LayoutPoint fractionalPaintOffset =
-      LayoutPoint(context.current.paintOffset - roundedPaintOffset);
+  if (usesPaintOffsetTranslation) {
+    roundedPaintOffset = roundedIntPoint(paintOffset);
+    fractionalPaintOffset = LayoutPoint(paintOffset - roundedPaintOffset);
+  }
 
+  return usesPaintOffsetTranslation;
+}
+
+void PaintPropertyTreeBuilder::updatePaintOffsetTranslation(
+    const LayoutObject& object,
+    PaintPropertyTreeBuilderContext& context) {
+  IntPoint roundedPaintOffset;
+  LayoutPoint fractionalPaintOffset;
+  bool usesPaintOffsetTranslation = calculatePaintOffsetTranslation(
+      object, context.current.paintOffset, roundedPaintOffset,
+      fractionalPaintOffset);
   if (object.needsPaintPropertyUpdate() || context.forceSubtreeUpdate) {
     if (usesPaintOffsetTranslation) {
       auto& properties = object.getMutableForPainting().ensurePaintProperties();
       context.forceSubtreeUpdate |= properties.updatePaintOffsetTranslation(
           context.current.transform,
           TransformationMatrix().translate(roundedPaintOffset.x(),
                                            roundedPaintOffset.y()),
           FloatPoint3D(), context.current.shouldFlattenInheritedTransform,
           context.current.renderingContextId);
     } else {
@@ skipping 600 matching lines @@
       return;
     }
   }
 
   if (object.needsPaintPropertyUpdate() || context.forceSubtreeUpdate) {
     if (auto* properties = object.getMutableForPainting().paintProperties())
       context.forceSubtreeUpdate |= properties->clearCssClipFixedPosition();
   }
 }
 
-void PaintPropertyTreeBuilder::updateContextForBoxPosition(
+void PaintPropertyTreeBuilder::updateContextForLocation(
     const LayoutObject& object,
     PaintPropertyTreeBuilderContext& context) {
   if (!object.isBoxModelObject())
     return;
 
   const LayoutBoxModelObject& boxModelObject = toLayoutBoxModelObject(object);
 
   if (boxModelObject.isFloating())
     context.current.paintOffset = context.paintOffsetForFloat;
 
@@ skipping 46 matching lines @@
     // but their location have the row's location baked-in.
     // Similar adjustment is done in LayoutTableCell::offsetFromContainer().
     if (boxModelObject.isTableCell()) {
       LayoutObject* parentRow = boxModelObject.parent();
       DCHECK(parentRow && parentRow->isTableRow());
       context.current.paintOffset.moveBy(
           -toLayoutBox(parentRow)->physicalLocation());
     }
   }
 
+  IntPoint roundedPaintOffset;
+  LayoutPoint paintOffsetAfterTranslation = context.current.paintOffset;
+  if (calculatePaintOffsetTranslation(
+          toLayoutBoxModelObject(object), context.current.paintOffset,
+          roundedPaintOffset, paintOffsetAfterTranslation)) {
+    const auto* properties = object.paintProperties();
+    if (!properties || !properties->paintOffsetTranslation() ||
+        properties->paintOffsetTranslation()->matrix().to2DTranslation() !=
+            FloatSize(roundedPaintOffset.x(), roundedPaintOffset.y()))
+      object.getMutableForPainting().setNeedsPaintPropertyUpdate();
+  }
+
   // Many paint properties depend on paint offset so we force an update of
   // the entire subtree on paint offset changes.
-  if (object.paintOffset() != context.current.paintOffset)
+  if (object.paintOffset() != paintOffsetAfterTranslation)
     context.forceSubtreeUpdate = true;
 }
 
 void PaintPropertyTreeBuilder::updatePropertiesForSelf(
     const LayoutObject& object,
     PaintPropertyTreeBuilderContext& context) {
+  updateContextForLocation(object, context);
+
 #if DCHECK_IS_ON()
   FindObjectPropertiesNeedingUpdateScope checkNeedsUpdateScope(object, context);
 #endif
 
   if (object.isBoxModelObject() || object.isSVG()) {
     updatePaintOffsetTranslation(object, context);
     updateTransform(object, context);
     if (RuntimeEnabledFeatures::slimmingPaintV2Enabled())
       updateEffect(object, context);
     updateCssClip(object, context);
@@ skipping 25 matching lines @@
   updateOverflowClip(object, context);
   updatePerspective(object, context);
   updateSvgLocalToBorderBoxTransform(object, context);
   updateScrollAndScrollTranslation(object, context);
   updateOutOfFlowContext(object, context);
 
   context.forceSubtreeUpdate |= object.subtreeNeedsPaintPropertyUpdate();
 }
 
 }  // namespace blink