[SPInvalidation] Handle pixel-snapping of paint invalidation rects

third_party/WebKit/Source/core/paint/BoxPaintInvalidator.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/BoxPaintInvalidator.h"
 
 #include "core/frame/Settings.h"
 #include "core/layout/LayoutView.h"
 #include "core/paint/ObjectPaintInvalidator.h"
 #include "core/paint/PaintInvalidator.h"
@@ skipping 47 matching lines @@
   }
   if (delta < 0) {
     return LayoutRect(location.x(),
                       location.y() + newSize.height() - extraHeight,
                       oldSize.width(), -delta + extraHeight);
   }
   return LayoutRect();
 }
 
 bool BoxPaintInvalidator::incrementallyInvalidatePaint() {
-  DCHECK(m_context.oldBounds.location() == m_context.newBounds.location());
-  LayoutRect rightDelta = computeRightDelta(m_context.newBounds.location(),
-                                            m_context.oldBounds.size(),
-                                            m_context.newBounds.size(), 0);
-  LayoutRect bottomDelta = computeBottomDelta(m_context.newBounds.location(),
-                                              m_context.oldBounds.size(),
-                                              m_context.newBounds.size(), 0);
+  const LayoutRect& oldRect = m_context.oldBounds.rect;
+  const LayoutRect& newRect = m_context.newBounds.rect;
+  DCHECK(oldRect.location() == newRect.location());
+  LayoutRect rightDelta =
+      computeRightDelta(newRect.location(), oldRect.size(), newRect.size(), 0);
+  LayoutRect bottomDelta =
+      computeBottomDelta(newRect.location(), oldRect.size(), newRect.size(), 0);
 
   if (m_box.styleRef().hasBorder() || m_box.styleRef().hasBackground()) {
-    LayoutSize oldBorderBoxSize =
-        computePreviousBorderBoxSize(m_context.oldBounds.size());
+    LayoutSize oldBorderBoxSize = computePreviousBorderBoxSize(oldRect.size());
     LayoutSize newBorderBoxSize = m_box.size();
     DCHECK(m_context.oldLocation == m_context.newLocation);
     rightDelta.unite(computeRightDelta(m_context.newLocation, oldBorderBoxSize,
                                        newBorderBoxSize, m_box.borderRight()));
     bottomDelta.unite(computeBottomDelta(m_context.newLocation,
                                          oldBorderBoxSize, newBorderBoxSize,
                                          m_box.borderBottom()));
   }
 
   if (rightDelta.isEmpty() && bottomDelta.isEmpty())
     return false;
 
   invalidatePaintRectClippedByOldAndNewBounds(rightDelta);
   invalidatePaintRectClippedByOldAndNewBounds(bottomDelta);
   return true;
 }
 
 void BoxPaintInvalidator::invalidatePaintRectClippedByOldAndNewBounds(
     const LayoutRect& rect) {
   if (rect.isEmpty())
     return;
 
   ObjectPaintInvalidator objectPaintInvalidator(m_box);
-  LayoutRect rectClippedByOldBounds = intersection(rect, m_context.oldBounds);
-  LayoutRect rectClippedByNewBounds = intersection(rect, m_context.newBounds);
+  LayoutRect rectClippedByOldBounds =
+      intersection(rect, m_context.oldBounds.rect);
+  LayoutRect rectClippedByNewBounds =
+      intersection(rect, m_context.newBounds.rect);
   // Invalidate only once if the clipped rects equal.
   if (rectClippedByOldBounds == rectClippedByNewBounds) {
     objectPaintInvalidator.invalidatePaintUsingContainer(
         *m_context.paintInvalidationContainer, rectClippedByOldBounds,
         PaintInvalidationIncremental);
     return;
   }
   // Invalidate the bigger one if one contains another. Otherwise invalidate
   // both.
   if (!rectClippedByNewBounds.contains(rectClippedByOldBounds))
@@ skipping 36 matching lines @@
     // invalidated for box changes, because the background always covers the
     // whole document rect and clipping is done by
     // compositor()->m_containerLayer. Also the scrollbars are always
     // composited. There are no other box decoration on the LayoutView thus we
     // can safely exit here.
     if (layoutView.usesCompositing() &&
         !RuntimeEnabledFeatures::rootLayerScrollingEnabled())
       return reason;
   }
 
-  // If the transform is not identity or translation, incremental invalidation
-  // is not applicable because the difference between oldBounds and newBounds
-  // doesn't cover all area needing invalidation.
-  // FIXME: Should also consider ancestor transforms since
-  // paintInvalidationContainer. crbug.com/426111.
   if (reason == PaintInvalidationIncremental &&
-      m_context.oldBounds != m_context.newBounds &&
-      m_context.paintInvalidationContainer != m_box && m_box.hasLayer() &&
-      m_box.layer()->transform() &&
-      !m_box.layer()->transform()->isIdentityOrTranslation())
-    return PaintInvalidationBoundsChange;
+      m_context.oldBounds.rect != m_context.newBounds.rect) {
+    if (m_context.newBounds.coversExtraPixels ||
+        m_context.oldBounds.coversExtraPixels) {
+      // Incremental invalidation is not applicable because the difference
+      // between oldBounds and newBounds may not cover all changed pixels along
+      // the edges.
+      return PaintInvalidationBoundsChange;
+    }
+
+    // If the transform is not identity or translation, incremental invalidation
+    // is not applicable because the difference between oldBounds and newBounds
+    // doesn't cover all area needing invalidation.
+    // TODO(crbug.com/426111): Should also consider ancestor transforms
+    // since paintInvalidationContainer. Combine this logic into the above
+    // boundsCoversExtraPixels logic.
+    if (m_context.paintInvalidationContainer != m_box && m_box.hasLayer() &&
+        m_box.layer()->transform() &&
+        !m_box.layer()->transform()->isIdentityOrTranslation())
+      return PaintInvalidationBoundsChange;
+  }
 
   const ComputedStyle& style = m_box.styleRef();
   if (style.backgroundLayers().thisOrNextLayersUseContentBox() ||
       style.maskLayers().thisOrNextLayersUseContentBox() ||
       style.boxSizing() == BoxSizingBorderBox) {
     if (previousBoxSizesMap().get(&m_box).contentBoxRect !=
         m_box.contentBoxRect())
       return PaintInvalidationContentBoxChange;
   }
 
   if (!style.hasBackground() && !style.hasBoxDecorations()) {
     if (reason == PaintInvalidationIncremental &&
-        m_context.oldBounds != m_context.newBounds &&
+        m_context.oldBounds.rect != m_context.newBounds.rect &&
         m_box.hasNonCompositedScrollbars())
       return PaintInvalidationBorderBoxChange;
     return reason;
   }
 
   if (style.backgroundLayers().thisOrNextLayersHaveLocalAttachment()) {
     if (previousBoxSizesMap().get(&m_box).layoutOverflowRect !=
         m_box.layoutOverflowRect())
       return PaintInvalidationLayoutOverflowBoxChange;
   }
 
   LayoutSize oldBorderBoxSize =
-      computePreviousBorderBoxSize(m_context.oldBounds.size());
+      computePreviousBorderBoxSize(m_context.oldBounds.rect.size());
   LayoutSize newBorderBoxSize = m_box.size();
 
   if (oldBorderBoxSize == newBorderBoxSize)
     return reason;
 
   // See another hasNonCompositedScrollbars() callsite above.
   if (m_box.hasNonCompositedScrollbars())
     return PaintInvalidationBorderBoxChange;
 
   if (style.hasVisualOverflowingEffect() || style.hasAppearance() ||
@@ skipping 37 matching lines @@
   if (PaintLayerScrollableArea* area = m_box.getScrollableArea())
     area->invalidatePaintOfScrollControlsIfNeeded(m_context);
 
   // This is for the next invalidatePaintIfNeeded so must be at the end.
   savePreviousBoxSizesIfNeeded();
 
   return reason;
 }
 
 bool BoxPaintInvalidator::needsToSavePreviousBoxSizes() {
-  LayoutSize paintInvalidationSize = m_context.newBounds.size();
+  LayoutSize paintInvalidationSize = m_context.newBounds.rect.size();
   // Don't save old box sizes if the paint rect is empty because we'll
   // full invalidate once the paint rect becomes non-empty.
   if (paintInvalidationSize.isEmpty())
     return false;
 
   const ComputedStyle& style = m_box.styleRef();
 
   // If we use border-box sizing we need to track changes in the size of the
   // content box.
   if (style.boxSizing() == BoxSizingBorderBox)
@@ skipping 42 matching lines @@
   auto it = previousBoxSizesMap().find(&m_box);
   if (it != previousBoxSizesMap().end())
     return it->value.borderBoxSize;
 
   // We didn't save the old border box size because it was the same as the size
   // of oldBounds.
   return previousBoundsSize;
 }
 
 }  // namespace blink