[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 23 matching lines @@
   LayoutRect result(rect);
   if (object.isLayoutView())
     toLayoutView(object).mapToVisualRectInAncestorSpace(
         &ancestor, result, InputIsInFrameCoordinates, DefaultVisualRectFlags);
   else
     object.mapToVisualRectInAncestorSpace(&ancestor, result);
   return result;
 }
 
 // TODO(wangxianzhu): Combine this into
-// PaintInvalidator::mapLocalRectToPaintInvalidationBacking() when removing
+// PaintInvalidator::mapLocalRectToBacking() when removing
 // PaintInvalidationState.
-static LayoutRect mapLocalRectToPaintInvalidationBacking(
+static PaintInvalidationRectInBacking mapLocalRectToPaintInvalidationBacking(
     GeometryMapper& geometryMapper,
     const LayoutObject& object,
     const FloatRect& localRect,
     const PaintInvalidatorContext& context) {
   // 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);
     }
   }
 
+  PaintInvalidationRectInBacking result;
   if (RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
     // In SPv2, visual rects are in the space of their local transform node.
     rect.moveBy(FloatPoint(context.treeBuilderContext.current.paintOffset));
-    return LayoutRect(rect);
+    // Use enclosingIntRect to ensure the final visual rect will cover the
+    // rect in source coordinates no matter if the painting will use pixel
+    // snapping.
+    result.rect = LayoutRect(enclosingIntRect(rect));
+    if (FloatRect(result.rect) != rect)
+      result.coversExtraPixels = true;
+    return result;
   }
 
-  LayoutRect result;
   if (context.forcedSubtreeInvalidationFlags &
       PaintInvalidatorContext::ForcedSubtreeSlowPathRect) {
-    result = slowMapToVisualRectInAncestorSpace(
+    result.rect = slowMapToVisualRectInAncestorSpace(
         object, *context.paintInvalidationContainer, rect);
   } else if (object == context.paintInvalidationContainer) {
-    result = LayoutRect(rect);
+    result.rect = 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) {
+        result.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(
+    result.rect = LayoutRect(geometryMapper.mapToVisualRectInDestinationSpace(
         rect, currentTreeState, containerContentsProperties.propertyTreeState,
         success));
     DCHECK(success);
 
     // Convert the result to the container's contents space.
-    result.moveBy(-containerContentsProperties.paintOffset);
+    result.rect.moveBy(-containerContentsProperties.paintOffset);
   }
 
-  if (context.paintInvalidationContainer->layer()->groupedMapping())
+  if (context.paintInvalidationContainer->layer()->groupedMapping()) {
     PaintLayer::mapRectInPaintInvalidationContainerToBacking(
-        *context.paintInvalidationContainer, result);
+        *context.paintInvalidationContainer, result.rect);
+  }
   return result;
 }
 
 void PaintInvalidatorContext::mapLocalRectToPaintInvalidationBacking(
     const LayoutObject& object,
     LayoutRect& rect) const {
   GeometryMapper geometryMapper;
   rect = blink::mapLocalRectToPaintInvalidationBacking(geometryMapper, object,
-                                                       FloatRect(rect), *this);
+                                                       FloatRect(rect), *this)
+             .rect;
 }
 
-LayoutRect PaintInvalidator::mapLocalRectToPaintInvalidationBacking(
+PaintInvalidationRectInBacking
+PaintInvalidator::mapLocalRectToPaintInvalidationBacking(
     const LayoutObject& object,
     const FloatRect& localRect,
     const PaintInvalidatorContext& context) {
   return blink::mapLocalRectToPaintInvalidationBacking(m_geometryMapper, object,
                                                        localRect, context);
 }
 
-LayoutRect PaintInvalidator::computePaintInvalidationRectInBacking(
+PaintInvalidationRectInBacking
+PaintInvalidator::computePaintInvalidationRectInBacking(
     const LayoutObject& object,
     const PaintInvalidatorContext& context) {
   FloatRect localRect;
   if (object.isSVG() && !object.isSVGRoot())
     localRect = SVGLayoutSupport::localOverflowRectForPaintInvalidation(object);
   else
     localRect = FloatRect(object.localOverflowRectForPaintInvalidation());
 
   return mapLocalRectToPaintInvalidationBacking(object, localRect, context);
 }
@@ skipping 162 matching lines @@
     context.forcedSubtreeInvalidationFlags |=
         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.oldBounds.rect = object.previousPaintInvalidationRect();
+  context.oldBounds.coversExtraPixels =
+      object.previousPaintInvalidationRectCoversExtraPixels();
   context.oldLocation = object.previousPositionFromPaintInvalidationBacking();
   context.newBounds = computePaintInvalidationRectInBacking(object, context);
   context.newLocation =
       computeLocationFromPaintInvalidationBacking(object, context);
 
   IntSize adjustment = object.scrollAdjustmentForPaintInvalidation(
       *context.paintInvalidationContainer);
   context.newLocation.move(adjustment);
-  context.newBounds.move(adjustment);
+  context.newBounds.rect.move(adjustment);
 
   object.getMutableForPainting().setPreviousPaintInvalidationRect(
-      context.newBounds);
+      context.newBounds.rect, context.newBounds.coversExtraPixels);
   object.getMutableForPainting()
       .setPreviousPositionFromPaintInvalidationBacking(context.newLocation);
 }
 
 void PaintInvalidator::invalidatePaintIfNeeded(
     FrameView& frameView,
     PaintInvalidatorContext& context) {
   LayoutView* layoutView = frameView.layoutView();
   CHECK(layoutView);
 
@@ skipping 86 matching lines @@
   // TODO(crbug.com/533277): This is a workaround for the bug. Remove when we
   // detect paint offset change.
   if (reason != PaintInvalidationNone &&
       hasPercentageTransform(object.styleRef()))
     context.forcedSubtreeInvalidationFlags |=
         PaintInvalidatorContext::ForcedSubtreeInvalidationChecking;
 
   // TODO(crbug.com/490725): This is a workaround for the bug, to force
   // descendant to update paint invalidation rects on clipping change.
   if (!RuntimeEnabledFeatures::slimmingPaintV2Enabled() &&
-      context.oldBounds != context.newBounds
+      context.oldBounds.rect != context.newBounds.rect
       // Note that isLayoutView() below becomes unnecessary after the launch of
       // root layer scrolling.
       && (object.hasOverflowClip() || object.isLayoutView()) &&
       !toLayoutBox(object).usesCompositedScrolling())
     context.forcedSubtreeInvalidationFlags |=
         PaintInvalidatorContext::ForcedSubtreeInvalidationRectUpdate;
 
   object.getMutableForPainting().clearPaintInvalidationFlags();
 }
 
 void PaintInvalidator::processPendingDelayedPaintInvalidations() {
   for (auto target : m_pendingDelayedPaintInvalidations)
     target->getMutableForPainting().setShouldDoFullPaintInvalidation(
         PaintInvalidationDelayedFull);
 }
 
 }  // namespace blink