[SPInvalidation] Handle pixel-snapping of paint invalidation rects

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

 // Copyright 2016 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/PaintInvalidator.h"
 
 #include "core/editing/FrameSelection.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Settings.h"
@@ skipping 29 matching lines @@
   return result;
 }
 
 // TODO(wangxianzhu): Combine this into
 // PaintInvalidator::mapLocalRectToPaintInvalidationBacking() when removing
 // PaintInvalidationState.
 static LayoutRect mapLocalRectToPaintInvalidationBacking(
     GeometryMapper& geometryMapper,
     const LayoutObject& object,
     const FloatRect& localRect,
-    const PaintInvalidatorContext& context) {
+    const PaintInvalidatorContext& context,
+    bool& coversExtraPixels) {
   // TODO(wkorman): The flip below is required because visual rects are
   // currently in "physical coordinates with flipped block-flow direction"
   // (see LayoutBoxModelObject.h) but we need them to be in physical
   // coordinates.
   FloatRect rect = localRect;
   // Writing-mode flipping doesn't apply to non-root SVG.
   if (!object.isSVG() || object.isSVGRoot()) {
     if (object.isBox()) {
       toLayoutBox(object).flipForWritingMode(rect);
     } else if (!(context.forcedSubtreeInvalidationFlags &
                  PaintInvalidatorContext::ForcedSubtreeSlowPathRect)) {
       // For SPv2 and the GeometryMapper path, we also need to convert the rect
       // for non-boxes into physical coordinates before applying paint offset.
       // (Otherwise we'll call mapToVisualrectInAncestorSpace() which requires
       // physical coordinates for boxes, but "physical coordinates with flipped
       // block-flow direction" for non-boxes for which we don't need to flip.)
       // TODO(wangxianzhu): Avoid containingBlock().
       object.containingBlock()->flipForWritingMode(rect);
     }
   }
 
   if (RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
     // In SPv2, visual rects are in the space of their local transform node.
     rect.moveBy(FloatPoint(context.treeBuilderContext.current.paintOffset));
+    // Use enclosingIntRect to ensure the final visual rect will cover the
+    // rect in source coordinates no matter if the painting will use pixel
+    // snapping.
+    IntRect intRect = enclosingIntRect(rect);
+    if (FloatRect(intRect) != rect) {
+      coversExtraPixels = true;
+      return LayoutRect(intRect);
+    }
     return LayoutRect(rect);
   }
 
   LayoutRect result;
   if (context.forcedSubtreeInvalidationFlags &
       PaintInvalidatorContext::ForcedSubtreeSlowPathRect) {
     result = slowMapToVisualRectInAncestorSpace(
         object, *context.paintInvalidationContainer, rect);
   } else if (object == context.paintInvalidationContainer) {
     result = LayoutRect(rect);
   } else {
     rect.moveBy(FloatPoint(context.treeBuilderContext.current.paintOffset));
+    if ((!object.isSVG() || object.isSVGRoot()) && !rect.isEmpty()) {
+      // Use enclosingIntRect to ensure the final visual rect will cover the
+      // rect in source coordinates no matter if the painting will use pixel
+      // snapping.
+      IntRect intRect = enclosingIntRect(rect);
+      if (FloatRect(intRect) != rect) {
+        coversExtraPixels = true;
+        rect = intRect;
+      }
+    }
 
     PropertyTreeState currentTreeState(
         context.treeBuilderContext.current.transform,
         context.treeBuilderContext.current.clip,
         context.treeBuilderContext.currentEffect,
         context.treeBuilderContext.current.scroll);
     const auto* containerPaintProperties =
         context.paintInvalidationContainer->paintProperties();
     auto containerContentsProperties =
         containerPaintProperties->contentsProperties();
 
+    // TODO(wangxianzhu): Set coversExtraPixels if there are any non-translate
+    // transforms. Currently this case is handled in BoxPaintInvalidator by
+    // checking transforms.
     bool success = false;
     result = LayoutRect(geometryMapper.mapToVisualRectInDestinationSpace(
         rect, currentTreeState, containerContentsProperties.propertyTreeState,
         success));
     DCHECK(success);
 
     // Convert the result to the container's contents space.
     result.moveBy(-containerContentsProperties.paintOffset);
   }
 
   if (context.paintInvalidationContainer->layer()->groupedMapping())
     PaintLayer::mapRectInPaintInvalidationContainerToBacking(
         *context.paintInvalidationContainer, result);
   return result;
 }
 
 void PaintInvalidatorContext::mapLocalRectToPaintInvalidationBacking(
     const LayoutObject& object,
     LayoutRect& rect) const {
   GeometryMapper geometryMapper;
-  rect = blink::mapLocalRectToPaintInvalidationBacking(geometryMapper, object,
-                                                       FloatRect(rect), *this);
+  bool coversExtraPixels;
+  rect = blink::mapLocalRectToPaintInvalidationBacking(
+      geometryMapper, object, FloatRect(rect), *this, coversExtraPixels);
 }
 
 LayoutRect PaintInvalidator::mapLocalRectToPaintInvalidationBacking(
     const LayoutObject& object,
     const FloatRect& localRect,
-    const PaintInvalidatorContext& context) {
-  return blink::mapLocalRectToPaintInvalidationBacking(m_geometryMapper, object,
-                                                       localRect, context);
+    const PaintInvalidatorContext& context,
+    bool& coversExtraPixels) {
+  return blink::mapLocalRectToPaintInvalidationBacking(
+      m_geometryMapper, object, localRect, context, coversExtraPixels);
 }
 
 LayoutRect PaintInvalidator::computePaintInvalidationRectInBacking(
     const LayoutObject& object,
-    const PaintInvalidatorContext& context) {
+    const PaintInvalidatorContext& context,
+    bool& coversExtraPixels) {
   FloatRect localRect;
   if (object.isSVG() && !object.isSVGRoot())
     localRect = SVGLayoutSupport::localOverflowRectForPaintInvalidation(object);
   else
     localRect = FloatRect(object.localOverflowRectForPaintInvalidation());
 
-  return mapLocalRectToPaintInvalidationBacking(object, localRect, context);
+  return mapLocalRectToPaintInvalidationBacking(object, localRect, context,
+                                                coversExtraPixels);
 }
 
 LayoutPoint PaintInvalidator::computeLocationFromPaintInvalidationBacking(
     const LayoutObject& object,
     const PaintInvalidatorContext& context) {
   FloatPoint point;
   if (object != context.paintInvalidationContainer) {
     point.moveBy(FloatPoint(context.treeBuilderContext.current.paintOffset));
 
     PropertyTreeState currentTreeState(
@@ skipping 154 matching lines @@
         PaintInvalidatorContext::ForcedSubtreeInvalidationChecking;
 
   // TODO(crbug.com/637313): This is temporary before we support filters in
   // paint property tree.
   // TODO(crbug.com/648274): This is a workaround for multi-column contents.
   if (object.hasFilterInducingProperty() || object.isLayoutFlowThread())
     context.forcedSubtreeInvalidationFlags |=
         PaintInvalidatorContext::ForcedSubtreeSlowPathRect;
 
   context.oldBounds = object.previousPaintInvalidationRect();
+  context.oldBoundsCoversExtraPixels =
+      object.previousPaintInvalidationRectCoversExtraPixels();
   context.oldLocation = object.previousPositionFromPaintInvalidationBacking();
-  context.newBounds = computePaintInvalidationRectInBacking(object, context);
+  context.newBounds = computePaintInvalidationRectInBacking(
+      object, context, context.newBoundsCoversExtraPixels);
   context.newLocation =
       computeLocationFromPaintInvalidationBacking(object, context);
 
   IntSize adjustment = object.scrollAdjustmentForPaintInvalidation(
       *context.paintInvalidationContainer);
   context.newLocation.move(adjustment);
   context.newBounds.move(adjustment);
 
   object.getMutableForPainting().setPreviousPaintInvalidationRect(
-      context.newBounds);
+      context.newBounds, context.newBoundsCoversExtraPixels);
   object.getMutableForPainting()
       .setPreviousPositionFromPaintInvalidationBacking(context.newLocation);
 }
 
 void PaintInvalidator::invalidatePaintIfNeeded(
     FrameView& frameView,
     PaintInvalidatorContext& context) {
   LayoutView* layoutView = frameView.layoutView();
   CHECK(layoutView);
 
@@ skipping 104 matching lines @@
   object.getMutableForPainting().clearPaintInvalidationFlags();
 }
 
 void PaintInvalidator::processPendingDelayedPaintInvalidations() {
   for (auto target : m_pendingDelayedPaintInvalidations)
     target->getMutableForPainting().setShouldDoFullPaintInvalidation(
         PaintInvalidationDelayedFull);
 }
 
 }  // namespace blink