Clip incremental invalidation rects for RenderBox

Source/core/rendering/RenderBox.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2005 Allan Sandfeld Jensen (kde@carewolf.com)
  *           (C) 2005, 2006 Samuel Weinig (sam.weinig@gmail.com)
  * Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010 Apple Inc. All rights reserved.
  * Copyright (C) 2013 Adobe Systems Incorporated. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
@@ skipping 4081 matching lines @@
 {
     RenderObject::incrementallyInvalidatePaint(paintInvalidationContainer, oldBounds, newBounds, positionFromPaintInvalidationContainer);
 
     bool hasBoxDecorations = style()->hasBoxDecorations();
     if (!style()->hasBackground() && !hasBoxDecorations)
         return;
 
     LayoutSize oldBorderBoxSize = computePreviousBorderBoxSize(oldBounds.size());
     LayoutSize newBorderBoxSize = size();
 
-    // If border box size didn't change, RenderBox's incrementallyInvalidatePaint() is good.
+    // If border box size didn't change, RenderObject's incrementallyInvalidatePaint() is good.
     if (oldBorderBoxSize == newBorderBoxSize)
         return;
 
     // If size of the paint invalidation rect equals to size of border box, RenderObject::incrementallyInvalidatePaint()
     // is good for boxes having background without box decorations.
     ASSERT(oldBounds.location() == newBounds.location()); // Otherwise we won't do incremental invalidation.
     if (!hasBoxDecorations
         && positionFromPaintInvalidationContainer == newBounds.location()
         && oldBorderBoxSize == oldBounds.size()
         && newBorderBoxSize == newBounds.size())
         return;
 
     // Invalidate the right delta part and the right border of the old or new box which has smaller width.
     LayoutUnit deltaWidth = absoluteValue(oldBorderBoxSize.width() - newBorderBoxSize.width());
     if (deltaWidth) {
         LayoutUnit smallerWidth = std::min(oldBorderBoxSize.width(), newBorderBoxSize.width());
         LayoutUnit borderTopRightRadiusWidth = valueForLength(style()->borderTopRightRadius().width(), smallerWidth);
         LayoutUnit borderBottomRightRadiusWidth = valueForLength(style()->borderBottomRightRadius().width(), smallerWidth);
         LayoutUnit borderWidth = std::max<LayoutUnit>(borderRight(), std::max(borderTopRightRadiusWidth, borderBottomRightRadiusWidth));
         LayoutRect rightDeltaRect(positionFromPaintInvalidationContainer.x() + smallerWidth - borderWidth,
             positionFromPaintInvalidationContainer.y(),
             deltaWidth + borderWidth,
             std::max(oldBorderBoxSize.height(), newBorderBoxSize.height()));
-        invalidatePaintUsingContainer(&paintInvalidationContainer, rightDeltaRect, InvalidationIncremental);
+        invalidatePaintRectClippedByOldAndNewBounds(paintInvalidationContainer, rightDeltaRect, oldBounds, newBounds);
     }
 
     // Invalidate the bottom delta part and the bottom border of the old or new box which has smaller height.
     LayoutUnit deltaHeight = absoluteValue(oldBorderBoxSize.height() - newBorderBoxSize.height());
     if (deltaHeight) {
         LayoutUnit smallerHeight = std::min(oldBorderBoxSize.height(), newBorderBoxSize.height());
         LayoutUnit borderBottomLeftRadiusHeight = valueForLength(style()->borderBottomLeftRadius().height(), smallerHeight);
         LayoutUnit borderBottomRightRadiusHeight = valueForLength(style()->borderBottomRightRadius().height(), smallerHeight);
         LayoutUnit borderHeight = std::max<LayoutUnit>(borderBottom(), std::max(borderBottomLeftRadiusHeight, borderBottomRightRadiusHeight));
         LayoutRect bottomDeltaRect(positionFromPaintInvalidationContainer.x(),
             positionFromPaintInvalidationContainer.y() + smallerHeight - borderHeight,
             std::max(oldBorderBoxSize.width(), newBorderBoxSize.width()),
             deltaHeight + borderHeight);
-        invalidatePaintUsingContainer(&paintInvalidationContainer, bottomDeltaRect, InvalidationIncremental);
+        invalidatePaintRectClippedByOldAndNewBounds(paintInvalidationContainer, bottomDeltaRect, oldBounds, newBounds);
     }
 }
 
+void RenderBox::invalidatePaintRectClippedByOldAndNewBounds(const RenderLayerModelObject& paintInvalidationContainer, const LayoutRect& rect, const LayoutRect& oldBounds, const LayoutRect& newBounds)
+{
+    if (rect.isEmpty())
+        return;
+    LayoutRect rectClippedByOldBounds = intersection(rect, oldBounds);
+    LayoutRect rectClippedByNewBounds = intersection(rect, newBounds);
+    // - Invalidate only once if they equal;
+    // - Invalidate the bigger one if one contains another;
+    // - Otherwise invalidate both.
+    bool equal = rectClippedByOldBounds == rectClippedByNewBounds;

[Julien - ping for review, 2014/09/16 18:22:52]

(FYI as it's on the old patch) coding style violation: booleans should include a
verb (usually be or do).

[Xianzhu, 2014/09/16 18:36:13]

Acknowledged.

+    if (equal || !rectClippedByNewBounds.contains(rectClippedByOldBounds))
+        invalidatePaintUsingContainer(&paintInvalidationContainer, rectClippedByOldBounds, InvalidationIncremental);
+    if (!equal && !rectClippedByOldBounds.contains(rectClippedByNewBounds))
+        invalidatePaintUsingContainer(&paintInvalidationContainer, rectClippedByNewBounds, InvalidationIncremental);

[dsinclair, 2014/09/16 15:24:01]

This maybe a bit easier to read if the conditions are broken apart.

if (rectClippedByOldBounds == rectClippedByNewBounds) {
  invalidatePaintUsingContainer(..., rectClipedByOldBounds, ...);
  return;
}

if (!rectClippedByNewBounds.contains(rectClippedByOldBounds))
  invalidatePaintUsingContainer(..., rectClippedByOldBounds, ...)

if (!rectClippedByOldBounds.contains(rectClippedByNewBounds))
  invalidatePaintUsingContainer(..., rectClippedByNewBounds))

[Xianzhu, 2014/09/16 15:53:27]

Good idea. Done.

+}
+
 void RenderBox::markForPaginationRelayoutIfNeeded(SubtreeLayoutScope& layoutScope)
 {
     ASSERT(!needsLayout());
     // If fragmentation height has changed, we need to lay out. No need to enter the renderer if it
     // is childless, though.
     if (view()->layoutState()->pageLogicalHeightChanged() && slowFirstChild())
         layoutScope.setChildNeedsLayout(this);
 }
 
 void RenderBox::addVisualEffectOverflow()
@@ skipping 592 matching lines @@
 RenderBox::BoxDecorationData::BoxDecorationData(const RenderStyle& style)
 {
     backgroundColor = style.visitedDependentColor(CSSPropertyBackgroundColor);
     hasBackground = backgroundColor.alpha() || style.hasBackgroundImage();
     ASSERT(hasBackground == style.hasBackground());
     hasBorder = style.hasBorder();
     hasAppearance = style.hasAppearance();
 }
 
 } // namespace blink