Let synchronized painting generate correct paint invalidation rects

third_party/WebKit/Source/core/layout/LayoutObject.cpp

Index: third_party/WebKit/Source/core/layout/LayoutObject.cpp
diff --git a/third_party/WebKit/Source/core/layout/LayoutObject.cpp b/third_party/WebKit/Source/core/layout/LayoutObject.cpp
index 33ebe5d70e5514d82cfa6dbdc943c3469146d4cd..dfd8b14c5d93be04c7742c69b63332d441a764c6 100644
--- a/third_party/WebKit/Source/core/layout/LayoutObject.cpp
+++ b/third_party/WebKit/Source/core/layout/LayoutObject.cpp
@@ -1192,11 +1192,8 @@ static void invalidatePaintRectangleOnWindow(const LayoutBoxModelObject& paintIn
         window->invalidateRect(frameView->contentsToRootFrame(paintRect));
 }
 
-void LayoutObject::invalidatePaintUsingContainer(const LayoutBoxModelObject& paintInvalidationContainer, const LayoutRect& dirtyRect, PaintInvalidationReason invalidationReason) const
+void LayoutObject::invalidatePaintUsingContainer(const LayoutBoxModelObject& paintInvalidationContainer, const LayoutRect& dirtyRect, PaintInvalidationReason invalidationReason, Vector<LayoutRect>& paintInvalidationRects) const
 {
-    if (RuntimeEnabledFeatures::slimmingPaintSynchronizedPaintingEnabled())
-        return;
-
     if (paintInvalidationContainer.frameView()->shouldThrottleRendering())
         return;
 
@@ -1207,6 +1204,11 @@ void LayoutObject::invalidatePaintUsingContainer(const LayoutBoxModelObject& pai
 
     RELEASE_ASSERT(isRooted());
 
+    if (RuntimeEnabledFeatures::slimmingPaintSynchronizedPaintingEnabled()) {
+        paintInvalidationRects.append(dirtyRect);
+        return;
+    }
+
     // FIXME: Unify "devtools.timeline.invalidationTracking" and "blink.invalidation". crbug.com/413527.
     TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("devtools.timeline.invalidationTracking"),
         "PaintInvalidationTracking",
@@ -1231,18 +1233,17 @@ void LayoutObject::invalidateDisplayItemClient(const DisplayItemClientWrapper& d
     if (PaintLayer* enclosingLayer = this->enclosingLayer()) {
         // This is valid because we want to invalidate the client in the display item list of the current backing.
         DisableCompositingQueryAsserts disabler;
-        // Only the object needs to be invalidated, so use an empty invalidation rect.
-        LayoutRect invalidationRect;
+        // Only the objects need to be invalidated, not any paint rectangles.
         if (const PaintLayer* paintInvalidationLayer = enclosingLayer->enclosingLayerForPaintInvalidationCrossingFrameBoundaries())
-            paintInvalidationLayer->layoutObject()->invalidateDisplayItemClientOnBacking(displayItemClient, PaintInvalidationFull, invalidationRect, invalidationRect);
+            paintInvalidationLayer->layoutObject()->invalidateDisplayItemClientOnBacking(displayItemClient, PaintInvalidationFull, Vector<LayoutRect>());
 
         enclosingLayer->setNeedsRepaint();
     }
 }
 
-void LayoutObject::invalidateDisplayItemClients(const LayoutBoxModelObject& paintInvalidationContainer, PaintInvalidationReason invalidationReason, const LayoutRect& previousPaintInvalidationRect, const LayoutRect& newPaintInvalidationRect) const
+void LayoutObject::invalidateDisplayItemClients(const LayoutBoxModelObject& paintInvalidationContainer, PaintInvalidationReason invalidationReason, const Vector<LayoutRect>& paintInvalidationRects) const
 { 
-    paintInvalidationContainer.invalidateDisplayItemClientOnBacking(*this, invalidationReason, previousPaintInvalidationRect, newPaintInvalidationRect);
+    paintInvalidationContainer.invalidateDisplayItemClientOnBacking(*this, invalidationReason, paintInvalidationRects);
 
     if (PaintLayer* enclosingLayer = this->enclosingLayer())
         enclosingLayer->setNeedsRepaint();
@@ -1255,35 +1256,25 @@ LayoutRect LayoutObject::boundsRectForPaintInvalidation(const LayoutBoxModelObje
     return PaintLayer::computePaintInvalidationRect(this, paintInvalidationContainer->layer(), paintInvalidationState);
 }
 
-const LayoutBoxModelObject* LayoutObject::invalidatePaintRectangleInternal(LayoutRect& dirtyRect) const
+void LayoutObject::invalidatePaintRectangleForDisplayItemClient(const DisplayItemClientWrapper& displayItemClient, const LayoutRect& dirtyRect) const
 {
     RELEASE_ASSERT(isRooted());
 
     if (dirtyRect.isEmpty())
-        return nullptr;
+        return;
 
     if (view()->document().printing())
-        return nullptr; // Don't invalidate paints if we're printing.
+        return; // Don't invalidate paints if we're printing.
 
     const LayoutBoxModelObject& paintInvalidationContainer = containerForPaintInvalidationOnRootedTree();
-    PaintLayer::mapRectToPaintInvalidationBacking(this, &paintInvalidationContainer, dirtyRect);
-    invalidatePaintUsingContainer(paintInvalidationContainer, dirtyRect, PaintInvalidationRectangle);
-    return &paintInvalidationContainer;
-}
-
-void LayoutObject::invalidatePaintRectangle(const LayoutRect& rect) const
-{
-    LayoutRect dirtyRect(rect);
-    const LayoutBoxModelObject* paintInvalidationContainer = invalidatePaintRectangleInternal(dirtyRect);
-    if (paintInvalidationContainer) {
-        invalidateDisplayItemClients(*paintInvalidationContainer, PaintInvalidationRectangle, dirtyRect, dirtyRect);
-    }
-}
+    LayoutRect rect(dirtyRect);
+    PaintLayer::mapRectToPaintInvalidationBacking(this, &paintInvalidationContainer, rect);
+    Vector<LayoutRect> paintInvalidationRects;
+    invalidatePaintUsingContainer(paintInvalidationContainer, rect, PaintInvalidationRectangle, paintInvalidationRects);
+    paintInvalidationContainer.invalidateDisplayItemClientOnBacking(displayItemClient, PaintInvalidationRectangle, paintInvalidationRects);
 
-void LayoutObject::invalidatePaintRectangleNotInvalidatingDisplayItemClients(const LayoutRect& r) const
-{
-    LayoutRect dirtyRect(r);
-    invalidatePaintRectangleInternal(dirtyRect);
+    if (PaintLayer* enclosingLayer = this->enclosingLayer())
+        enclosingLayer->setNeedsRepaint();
 }
 
 void LayoutObject::invalidateTreeIfNeeded(PaintInvalidationState& paintInvalidationState)
@@ -1370,13 +1361,12 @@ inline void LayoutObject::invalidateSelectionIfNeeded(const LayoutBoxModelObject
 
     setPreviousSelectionRectForPaintInvalidation(newSelectionRect);
 
-    if (shouldInvalidateSelection())
-        invalidateDisplayItemClients(paintInvalidationContainer, PaintInvalidationSelection, oldSelectionRect, newSelectionRect);
-
-    if (fullInvalidation)
-        return;
+    Vector<LayoutRect> paintInvalidationRects;
+    if (!fullInvalidation)
+        fullyInvalidatePaint(paintInvalidationContainer, PaintInvalidationSelection, oldSelectionRect, newSelectionRect, paintInvalidationRects);
 
-    fullyInvalidatePaint(paintInvalidationContainer, PaintInvalidationSelection, oldSelectionRect, newSelectionRect);
+    if (shouldInvalidateSelection())
+        invalidateDisplayItemClients(paintInvalidationContainer, PaintInvalidationSelection, paintInvalidationRects);
 }
 
 PaintInvalidationReason LayoutObject::invalidatePaintIfNeeded(PaintInvalidationState& paintInvalidationState, const LayoutBoxModelObject& paintInvalidationContainer)
@@ -1429,19 +1419,18 @@ PaintInvalidationReason LayoutObject::invalidatePaintIfNeeded(PaintInvalidationS
         // invalidation is issued. See crbug.com/508383 and crbug.com/515977.
         // This is a workaround to force display items to update paint offset.
         if (!RuntimeEnabledFeatures::slimmingPaintOffsetCachingEnabled() && paintInvalidationState.forcedSubtreeInvalidationWithinContainer())
-            invalidateDisplayItemClients(paintInvalidationContainer, invalidationReason, oldBounds, newBounds);
+            invalidateDisplayItemClients(paintInvalidationContainer, invalidationReason, Vector<LayoutRect>());
 
         return invalidationReason;
     }
 
-    invalidateDisplayItemClients(paintInvalidationContainer, invalidationReason, oldBounds, newBounds);
-
-    if (invalidationReason == PaintInvalidationIncremental) {
-        incrementallyInvalidatePaint(paintInvalidationContainer, oldBounds, newBounds, newLocation);
-        return invalidationReason;
-    }
+    Vector<LayoutRect> paintInvalidationRects;
+    if (invalidationReason == PaintInvalidationIncremental)
+        incrementallyInvalidatePaint(paintInvalidationContainer, oldBounds, newBounds, newLocation, paintInvalidationRects);
+    else
+        fullyInvalidatePaint(paintInvalidationContainer, invalidationReason, oldBounds, newBounds, paintInvalidationRects);
 
-    fullyInvalidatePaint(paintInvalidationContainer, invalidationReason, oldBounds, newBounds);
+    invalidateDisplayItemClients(paintInvalidationContainer, invalidationReason, paintInvalidationRects);
 
     return invalidationReason;
 }
@@ -1540,7 +1529,7 @@ void LayoutObject::adjustPreviousPaintInvalidationForScrollIfNeeded(const Double
     m_previousPaintInvalidationRect.move(LayoutSize(scrollDelta));
 }
 
-void LayoutObject::incrementallyInvalidatePaint(const LayoutBoxModelObject& paintInvalidationContainer, const LayoutRect& oldBounds, const LayoutRect& newBounds, const LayoutPoint& positionFromPaintInvalidationBacking)
+void LayoutObject::incrementallyInvalidatePaint(const LayoutBoxModelObject& paintInvalidationContainer, const LayoutRect& oldBounds, const LayoutRect& newBounds, const LayoutPoint& positionFromPaintInvalidationBacking, Vector<LayoutRect>& paintInvalidationRects)
 {
     ASSERT(oldBounds.location() == newBounds.location());
 
@@ -1548,35 +1537,35 @@ void LayoutObject::incrementallyInvalidatePaint(const LayoutBoxModelObject& pain
     if (deltaRight > 0) {
         LayoutRect invalidationRect(oldBounds.maxX(), newBounds.y(), deltaRight, newBounds.height());
         adjustInvalidationRectForCompositedScrolling(invalidationRect, paintInvalidationContainer);
-        invalidatePaintUsingContainer(paintInvalidationContainer, invalidationRect, PaintInvalidationIncremental);
+        invalidatePaintUsingContainer(paintInvalidationContainer, invalidationRect, PaintInvalidationIncremental, paintInvalidationRects);
     } else if (deltaRight < 0) {
         LayoutRect invalidationRect(newBounds.maxX(), oldBounds.y(), -deltaRight, oldBounds.height());
         adjustInvalidationRectForCompositedScrolling(invalidationRect, paintInvalidationContainer);
-        invalidatePaintUsingContainer(paintInvalidationContainer, invalidationRect, PaintInvalidationIncremental);
+        invalidatePaintUsingContainer(paintInvalidationContainer, invalidationRect, PaintInvalidationIncremental, paintInvalidationRects);
     }
 
     LayoutUnit deltaBottom = newBounds.maxY() - oldBounds.maxY();
     if (deltaBottom > 0) {
         LayoutRect invalidationRect(newBounds.x(), oldBounds.maxY(), newBounds.width(), deltaBottom);
         adjustInvalidationRectForCompositedScrolling(invalidationRect, paintInvalidationContainer);
-        invalidatePaintUsingContainer(paintInvalidationContainer, invalidationRect, PaintInvalidationIncremental);
+        invalidatePaintUsingContainer(paintInvalidationContainer, invalidationRect, PaintInvalidationIncremental, paintInvalidationRects);
     } else if (deltaBottom < 0) {
         LayoutRect invalidationRect(oldBounds.x(), newBounds.maxY(), oldBounds.width(), -deltaBottom);
         adjustInvalidationRectForCompositedScrolling(invalidationRect, paintInvalidationContainer);
-        invalidatePaintUsingContainer(paintInvalidationContainer, invalidationRect, PaintInvalidationIncremental);
+        invalidatePaintUsingContainer(paintInvalidationContainer, invalidationRect, PaintInvalidationIncremental, paintInvalidationRects);
     }
 }
 
-void LayoutObject::fullyInvalidatePaint(const LayoutBoxModelObject& paintInvalidationContainer, PaintInvalidationReason invalidationReason, const LayoutRect& oldBounds, const LayoutRect& newBounds)
+void LayoutObject::fullyInvalidatePaint(const LayoutBoxModelObject& paintInvalidationContainer, PaintInvalidationReason invalidationReason, const LayoutRect& oldBounds, const LayoutRect& newBounds, Vector<LayoutRect>& paintInvalidationRects)
 {
     // Otherwise do full paint invalidation.
     LayoutRect invalidationRect = oldBounds;
     adjustInvalidationRectForCompositedScrolling(invalidationRect, paintInvalidationContainer);
-    invalidatePaintUsingContainer(paintInvalidationContainer, invalidationRect, invalidationReason);
+    invalidatePaintUsingContainer(paintInvalidationContainer, invalidationRect, invalidationReason, paintInvalidationRects);
     if (newBounds != oldBounds) {
         invalidationRect = newBounds;
         adjustInvalidationRectForCompositedScrolling(invalidationRect, paintInvalidationContainer);
-        invalidatePaintUsingContainer(paintInvalidationContainer, invalidationRect, invalidationReason);
+        invalidatePaintUsingContainer(paintInvalidationContainer, invalidationRect, invalidationReason, paintInvalidationRects);
     }
 }
 
@@ -3380,8 +3369,7 @@ void LayoutObject::invalidateDisplayItemClientForNonCompositingDescendantsOf(con
         void operator()(LayoutObject& object) const override
         {
             // Only the objects need to be invalidated, not any paint rectangles.
-            LayoutRect invalidationRect;
-            object.invalidateDisplayItemClients(m_paintInvalidationContainer, PaintInvalidationFull, invalidationRect, invalidationRect);
+            object.invalidateDisplayItemClients(m_paintInvalidationContainer, PaintInvalidationFull, Vector<LayoutRect>());
         }
     private:
         const LayoutBoxModelObject& m_paintInvalidationContainer;
@@ -3399,8 +3387,9 @@ void LayoutObject::invalidatePaintOfPreviousPaintInvalidationRect(const LayoutBo
 
     LayoutRect invalidationRect = previousPaintInvalidationRect();
     adjustInvalidationRectForCompositedScrolling(invalidationRect, paintInvalidationContainer);
-    invalidatePaintUsingContainer(paintInvalidationContainer, invalidationRect, PaintInvalidationLayer);
-    invalidateDisplayItemClients(paintInvalidationContainer, PaintInvalidationLayer, invalidationRect, invalidationRect);
+    Vector<LayoutRect> paintInvalidationRects;
+    invalidatePaintUsingContainer(paintInvalidationContainer, invalidationRect, PaintInvalidationLayer, paintInvalidationRects);
+    invalidateDisplayItemClients(paintInvalidationContainer, PaintInvalidationLayer, paintInvalidationRects);
 }
 
 void LayoutObject::invalidatePaintIncludingNonCompositingDescendants()