Plumb paint invalidation rects through the DisplayItemClient interfaces.

This will make it simpler to implement repaint-after-layout during paint. Sending
the rects along with invalidation should be considered a short-term measure until
we have an efficient way for the DisplayItemClient to invalidate itself by using
the paint property trees.

Also plumb it all the way to the DisplayItemList. This is currently unnecessary,
but will allow us to easily start recording the clipped paint rect in cc::Layer coordinates for each DisplayItem, in order to solve issue 529938.

BUG=529938,536999

Review URL: https://codereview.chromium.org/1380333003

Cr-Commit-Position: refs/heads/master@{#352266}

23 files changed, 135 insertions, 99 deletions

diff --git a/third_party/WebKit/Source/core/compositing/DisplayListCompositingBuilder.cpp b/third_party/WebKit/Source/core/compositing/DisplayListCompositingBuilder.cpp
index d8d3f45..a0bea57 100644
--- a/third_party/WebKit/Source/core/compositing/DisplayListCompositingBuilder.cpp
+++ b/third_party/WebKit/Source/core/compositing/DisplayListCompositingBuilder.cpp
@@ -13,7 +13,6 @@ void DisplayListCompositingBuilder::build(CompositedDisplayList& compositedDispl
 {
     // TODO(pdr): Properly implement simple layer compositing here.
     // See: https://docs.google.com/document/d/1qF7wpO_lhuxUO6YXKZ3CJuXi0grcb5gKZJBBgnoTd0k/view
-
     DisplayItemPropertyTreeBuilder treeBuilder;
     for (const auto& displayItem : m_displayItemList.displayItems())
         treeBuilder.processDisplayItem(displayItem);
diff --git a/third_party/WebKit/Source/core/compositing/DisplayListCompositingBuilder.h b/third_party/WebKit/Source/core/compositing/DisplayListCompositingBuilder.h
index dd2317f..6a38379 100644
--- a/third_party/WebKit/Source/core/compositing/DisplayListCompositingBuilder.h
+++ b/third_party/WebKit/Source/core/compositing/DisplayListCompositingBuilder.h
@@ -13,7 +13,7 @@ namespace blink {
 
 class CORE_EXPORT DisplayListCompositingBuilder {
 public:
-    DisplayListCompositingBuilder(const DisplayItemList& displayItemList, const DisplayListDiff&)
+    DisplayListCompositingBuilder(const DisplayItemList& displayItemList)
         : m_displayItemList(displayItemList) { }
 
     void build(CompositedDisplayList&);
diff --git a/third_party/WebKit/Source/core/compositing/DisplayListCompositingBuilderTest.cpp b/third_party/WebKit/Source/core/compositing/DisplayListCompositingBuilderTest.cpp
index d67a77e..f753e2e 100644
--- a/third_party/WebKit/Source/core/compositing/DisplayListCompositingBuilderTest.cpp
+++ b/third_party/WebKit/Source/core/compositing/DisplayListCompositingBuilderTest.cpp
@@ -32,10 +32,9 @@ private:
 TEST_F(DisplayListCompositingBuilderTest, BasicTransformPropertyTree)
 {
     OwnPtr<DisplayItemList> displayItemList = DisplayItemList::create();
-    DisplayListDiff displayListDiff;
-    displayItemList->commitNewDisplayItems(&displayListDiff);
+    displayItemList->commitNewDisplayItems();
 
-    DisplayListCompositingBuilder compositingBuilder(*displayItemList, displayListDiff);
+    DisplayListCompositingBuilder compositingBuilder(*displayItemList);
     CompositedDisplayList compositedDisplayList;
     compositingBuilder.build(compositedDisplayList);
 
diff --git a/third_party/WebKit/Source/core/frame/FrameView.cpp b/third_party/WebKit/Source/core/frame/FrameView.cpp
index 3c579bf..657de93 100644
--- a/third_party/WebKit/Source/core/frame/FrameView.cpp
+++ b/third_party/WebKit/Source/core/frame/FrameView.cpp
@@ -2491,10 +2491,8 @@ void FrameView::synchronizedPaintRecursively(GraphicsLayer* graphicsLayer, const
         GraphicsContext context(graphicsLayer->displayItemList());
         graphicsLayer->paint(context, roundedIntRect(interestRect));
 
-        if (!RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
-            DisplayListDiff diff;
-            graphicsLayer->commitIfNeeded(diff);
-        }
+        if (!RuntimeEnabledFeatures::slimmingPaintV2Enabled())
+            graphicsLayer->commitIfNeeded();
     }
 
     for (auto& child : graphicsLayer->children()) {
@@ -2516,10 +2514,9 @@ void FrameView::compositeForSlimmingPaintV2()
 
     lifecycle().advanceTo(DocumentLifecycle::InCompositingForSlimmingPaintV2);
 
-    DisplayListDiff displayListDiff;
-    rootGraphicsLayer->commitIfNeeded(displayListDiff);
+    rootGraphicsLayer->commitIfNeeded();
 
-    DisplayListCompositingBuilder compositingBuilder(*rootGraphicsLayer->displayItemList(), displayListDiff);
+    DisplayListCompositingBuilder compositingBuilder(*rootGraphicsLayer->displayItemList());
     OwnPtr<CompositedDisplayList> compositedDisplayList = adoptPtr(new CompositedDisplayList());
     compositingBuilder.build(*compositedDisplayList);
     page()->setCompositedDisplayList(compositedDisplayList.release());
diff --git a/third_party/WebKit/Source/core/layout/LayoutBlock.cpp b/third_party/WebKit/Source/core/layout/LayoutBlock.cpp
index 0c8b7e6..cced5e6 100644
--- a/third_party/WebKit/Source/core/layout/LayoutBlock.cpp
+++ b/third_party/WebKit/Source/core/layout/LayoutBlock.cpp
@@ -405,9 +405,9 @@ inline static void invalidateDisplayItemClientForStartOfContinuationsIfNeeded(co
         startOfContinuations->invalidateDisplayItemClient(*startOfContinuations);
 }
 
-void LayoutBlock::invalidateDisplayItemClients(const LayoutBoxModelObject& paintInvalidationContainer) const
+void LayoutBlock::invalidateDisplayItemClients(const LayoutBoxModelObject& paintInvalidationContainer, PaintInvalidationReason invalidationReason, const LayoutRect& previousPaintInvalidationRect, const LayoutRect& newPaintInvalidationRect) const
 {
-    LayoutBox::invalidateDisplayItemClients(paintInvalidationContainer);
+    LayoutBox::invalidateDisplayItemClients(paintInvalidationContainer, invalidationReason, previousPaintInvalidationRect, newPaintInvalidationRect);
     invalidateDisplayItemClientForStartOfContinuationsIfNeeded(*this);
 }
 
@@ -2387,26 +2387,26 @@ static bool shouldCheckLines(LayoutObject* obj)
         && (!obj->isDeprecatedFlexibleBox() || obj->style()->boxOrient() == VERTICAL);
 }
 
-static int getHeightForLineCount(LayoutBlock* block, int l, bool includeBottom, int& count)
+static int getHeightForLineCount(LayoutBlock* block, int lineCount, bool includeBottom, int& count)
 {
     if (block->style()->visibility() == VISIBLE) {
         if (block->isLayoutBlockFlow() && block->childrenInline()) {
             for (RootInlineBox* box = toLayoutBlockFlow(block)->firstRootBox(); box; box = box->nextRootBox()) {
-                if (++count == l)
+                if (++count == lineCount)
                     return box->lineBottom() + (includeBottom ? (block->borderBottom() + block->paddingBottom()) : LayoutUnit());
             }
         } else {
             LayoutBox* normalFlowChildWithoutLines = nullptr;
             for (LayoutBox* obj = block->firstChildBox(); obj; obj = obj->nextSiblingBox()) {
                 if (shouldCheckLines(obj)) {
-                    int result = getHeightForLineCount(toLayoutBlock(obj), l, false, count);
+                    int result = getHeightForLineCount(toLayoutBlock(obj), lineCount, false, count);
                     if (result != -1)
                         return result + obj->location().y() + (includeBottom ? (block->borderBottom() + block->paddingBottom()) : LayoutUnit());
                 } else if (!obj->isFloatingOrOutOfFlowPositioned()) {
                     normalFlowChildWithoutLines = obj;
                 }
             }
-            if (normalFlowChildWithoutLines && l == 0)
+            if (normalFlowChildWithoutLines && lineCount == 0)
                 return normalFlowChildWithoutLines->location().y() + normalFlowChildWithoutLines->size().height();
         }
     }
@@ -2469,10 +2469,10 @@ int LayoutBlock::lineCount(const RootInlineBox* stopRootInlineBox, bool* found)
     return count;
 }
 
-int LayoutBlock::heightForLineCount(int l)
+int LayoutBlock::heightForLineCount(int lineCount)
 {
     int count = 0;
-    return getHeightForLineCount(this, l, true, count);
+    return getHeightForLineCount(this, lineCount, true, count);
 }
 
 void LayoutBlock::clearTruncation()
diff --git a/third_party/WebKit/Source/core/layout/LayoutBlock.h b/third_party/WebKit/Source/core/layout/LayoutBlock.h
index 654d5aeb..258716b 100644
--- a/third_party/WebKit/Source/core/layout/LayoutBlock.h
+++ b/third_party/WebKit/Source/core/layout/LayoutBlock.h
@@ -213,7 +213,7 @@ public:
     // Helper methods for computing line counts and heights for line counts.
     RootInlineBox* lineAtIndex(int) const;
     int lineCount(const RootInlineBox* = nullptr, bool* = nullptr) const;
-    int heightForLineCount(int);
+    int heightForLineCount(int lineCount);
     void clearTruncation();
 
     LayoutBoxModelObject* virtualContinuation() const final { return continuation(); }
@@ -351,7 +351,7 @@ protected:
     bool isInlineBlockOrInlineTable() const final { return isInline() && isReplaced(); }
 
     void invalidatePaintOfSubtreesIfNeeded(PaintInvalidationState& childPaintInvalidationState) override;
-    void invalidateDisplayItemClients(const LayoutBoxModelObject& paintInvalidationContainer) const override;
+    void invalidateDisplayItemClients(const LayoutBoxModelObject& paintInvalidationContainer, PaintInvalidationReason, const LayoutRect& previousPaintInvalidationRect, const LayoutRect& newPaintInvalidationRect) const override;
 
 private:
     LayoutObjectChildList* virtualChildren() final { return children(); }
diff --git a/third_party/WebKit/Source/core/layout/LayoutBoxModelObject.cpp b/third_party/WebKit/Source/core/layout/LayoutBoxModelObject.cpp
index c0f483a..b2da36f 100644
--- a/third_party/WebKit/Source/core/layout/LayoutBoxModelObject.cpp
+++ b/third_party/WebKit/Source/core/layout/LayoutBoxModelObject.cpp
@@ -408,13 +408,13 @@ void LayoutBoxModelObject::setBackingNeedsPaintInvalidationInRect(const LayoutRe
     }
 }
 
-void LayoutBoxModelObject::invalidateDisplayItemClientOnBacking(const DisplayItemClientWrapper& displayItemClient) const
+void LayoutBoxModelObject::invalidateDisplayItemClientOnBacking(const DisplayItemClientWrapper& displayItemClient, PaintInvalidationReason invalidationReason, const LayoutRect& previousPaintInvalidationRect, const LayoutRect& newPaintInvalidationRect) const
 {
     if (layer()->groupedMapping()) {
         if (GraphicsLayer* squashingLayer = layer()->groupedMapping()->squashingLayer())
-            squashingLayer->invalidateDisplayItemClient(displayItemClient);
+            squashingLayer->invalidateDisplayItemClient(displayItemClient, invalidationReason, enclosingIntRect(previousPaintInvalidationRect), enclosingIntRect(newPaintInvalidationRect));
     } else if (CompositedLayerMapping* compositedLayerMapping = layer()->compositedLayerMapping()) {
-        compositedLayerMapping->invalidateDisplayItemClient(displayItemClient);
+        compositedLayerMapping->invalidateDisplayItemClient(displayItemClient, invalidationReason, previousPaintInvalidationRect, newPaintInvalidationRect);
     }
 }
 
diff --git a/third_party/WebKit/Source/core/layout/LayoutBoxModelObject.h b/third_party/WebKit/Source/core/layout/LayoutBoxModelObject.h
index d133d61..b7b82ea 100644
--- a/third_party/WebKit/Source/core/layout/LayoutBoxModelObject.h
+++ b/third_party/WebKit/Source/core/layout/LayoutBoxModelObject.h
@@ -271,7 +271,7 @@ public:
     // Indicate that the contents of this layoutObject need to be repainted. Only has an effect if compositing is being used,
     void setBackingNeedsPaintInvalidationInRect(const LayoutRect&, PaintInvalidationReason) const; // r is in the coordinate space of this layout object
 
-    void invalidateDisplayItemClientOnBacking(const DisplayItemClientWrapper&) const;
+    void invalidateDisplayItemClientOnBacking(const DisplayItemClientWrapper&, PaintInvalidationReason, const LayoutRect& previousPaintInvalidationRect, const LayoutRect& newPaintInvalidationRect) const;
 
     // http://www.w3.org/TR/css3-background/#body-background
     // <html> root element with no background steals background from its first <body> child.
diff --git a/third_party/WebKit/Source/core/layout/LayoutInline.cpp b/third_party/WebKit/Source/core/layout/LayoutInline.cpp
index 201e54d..4ca3a45 100644
--- a/third_party/WebKit/Source/core/layout/LayoutInline.cpp
+++ b/third_party/WebKit/Source/core/layout/LayoutInline.cpp
@@ -1404,11 +1404,11 @@ void LayoutInline::addAnnotatedRegions(Vector<AnnotatedRegionValue>& regions)
     regions.append(region);
 }
 
-void LayoutInline::invalidateDisplayItemClients(const LayoutBoxModelObject& paintInvalidationContainer) const
+void LayoutInline::invalidateDisplayItemClients(const LayoutBoxModelObject& paintInvalidationContainer, PaintInvalidationReason invalidationReason, const LayoutRect& previousPaintInvalidationRect, const LayoutRect& newPaintInvalidationRect) const
 {
-    LayoutBoxModelObject::invalidateDisplayItemClients(paintInvalidationContainer);
+    LayoutBoxModelObject::invalidateDisplayItemClients(paintInvalidationContainer, invalidationReason, previousPaintInvalidationRect, newPaintInvalidationRect);
     for (InlineFlowBox* box = firstLineBox(); box; box = box->nextLineBox())
-        paintInvalidationContainer.invalidateDisplayItemClientOnBacking(*box);
+        paintInvalidationContainer.invalidateDisplayItemClientOnBacking(*box, invalidationReason, previousPaintInvalidationRect, newPaintInvalidationRect);
 }
 
 } // namespace blink
diff --git a/third_party/WebKit/Source/core/layout/LayoutInline.h b/third_party/WebKit/Source/core/layout/LayoutInline.h
index 3e14907..64f6d9a 100644
--- a/third_party/WebKit/Source/core/layout/LayoutInline.h
+++ b/third_party/WebKit/Source/core/layout/LayoutInline.h
@@ -135,7 +135,7 @@ protected:
 
     void computeSelfHitTestRects(Vector<LayoutRect>& rects, const LayoutPoint& layerOffset) const override;
 
-    void invalidateDisplayItemClients(const LayoutBoxModelObject& paintInvalidationContainer) const override;
+    void invalidateDisplayItemClients(const LayoutBoxModelObject& paintInvalidationContainer, PaintInvalidationReason, const LayoutRect& previousPaintInvalidationRect, const LayoutRect& newPaintInvalidationRect) const override;
 
 private:
     LayoutObjectChildList* virtualChildren() final { return children(); }
diff --git a/third_party/WebKit/Source/core/layout/LayoutObject.cpp b/third_party/WebKit/Source/core/layout/LayoutObject.cpp
index 65c242a..4973d95 100644
--- a/third_party/WebKit/Source/core/layout/LayoutObject.cpp
+++ b/third_party/WebKit/Source/core/layout/LayoutObject.cpp
@@ -1165,6 +1165,9 @@ LayoutRect LayoutObject::computePaintInvalidationRect(const LayoutBoxModelObject
 
 void LayoutObject::invalidatePaintUsingContainer(const LayoutBoxModelObject& paintInvalidationContainer, const LayoutRect& r, PaintInvalidationReason invalidationReason) const
 {
+    if (RuntimeEnabledFeatures::slimmingPaintSynchronizedPaintingEnabled())
+        return;
+
     ASSERT(gDisablePaintInvalidationStateAsserts || document().lifecycle().state() == DocumentLifecycle::InPaintInvalidation);
 
     if (r.isEmpty())
@@ -1198,16 +1201,18 @@ 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;
         if (const PaintLayer* paintInvalidationLayer = enclosingLayer->enclosingLayerForPaintInvalidationCrossingFrameBoundaries())
-            paintInvalidationLayer->layoutObject()->invalidateDisplayItemClientOnBacking(displayItemClient);
+            paintInvalidationLayer->layoutObject()->invalidateDisplayItemClientOnBacking(displayItemClient, PaintInvalidationFull, invalidationRect, invalidationRect);
 
         enclosingLayer->setNeedsRepaint();
     }
 }
 
-void LayoutObject::invalidateDisplayItemClients(const LayoutBoxModelObject& paintInvalidationContainer) const
-{
-    paintInvalidationContainer.invalidateDisplayItemClientOnBacking(*this);
+void LayoutObject::invalidateDisplayItemClients(const LayoutBoxModelObject& paintInvalidationContainer, PaintInvalidationReason invalidationReason, const LayoutRect& previousPaintInvalidationRect, const LayoutRect& newPaintInvalidationRect) const
+{ 
+    paintInvalidationContainer.invalidateDisplayItemClientOnBacking(*this, invalidationReason, previousPaintInvalidationRect, newPaintInvalidationRect);
 
     if (PaintLayer* enclosingLayer = this->enclosingLayer())
         enclosingLayer->setNeedsRepaint();
@@ -1220,28 +1225,35 @@ LayoutRect LayoutObject::boundsRectForPaintInvalidation(const LayoutBoxModelObje
     return PaintLayer::computePaintInvalidationRect(this, paintInvalidationContainer->layer(), paintInvalidationState);
 }
 
-const LayoutBoxModelObject* LayoutObject::invalidatePaintRectangleInternal(const LayoutRect& r) const
+const LayoutBoxModelObject* LayoutObject::invalidatePaintRectangleInternal(LayoutRect& dirtyRect) const
 {
     RELEASE_ASSERT(isRooted());
 
-    if (r.isEmpty())
+    if (dirtyRect.isEmpty())
         return nullptr;
 
     if (view()->document().printing())
         return nullptr; // Don't invalidate paints if we're printing.
 
-    LayoutRect dirtyRect(r);
-
     const LayoutBoxModelObject& paintInvalidationContainer = containerForPaintInvalidationOnRootedTree();
     PaintLayer::mapRectToPaintInvalidationBacking(this, &paintInvalidationContainer, dirtyRect);
     invalidatePaintUsingContainer(paintInvalidationContainer, dirtyRect, PaintInvalidationRectangle);
     return &paintInvalidationContainer;
 }
 
-void LayoutObject::invalidatePaintRectangle(const LayoutRect& r) const
+void LayoutObject::invalidatePaintRectangle(const LayoutRect& rect) const
 {
-    if (const LayoutBoxModelObject* paintInvalidationContainer = invalidatePaintRectangleInternal(r))
-        invalidateDisplayItemClients(*paintInvalidationContainer);
+    LayoutRect dirtyRect(rect);
+    const LayoutBoxModelObject* paintInvalidationContainer = invalidatePaintRectangleInternal(dirtyRect);
+    if (paintInvalidationContainer) {
+        invalidateDisplayItemClients(*paintInvalidationContainer, PaintInvalidationRectangle, dirtyRect, dirtyRect);
+    }
+}
+
+void LayoutObject::invalidatePaintRectangleNotInvalidatingDisplayItemClients(const LayoutRect& r) const
+{
+    LayoutRect dirtyRect(r);
+    invalidatePaintRectangleInternal(dirtyRect);
 }
 
 void LayoutObject::invalidateTreeIfNeeded(PaintInvalidationState& paintInvalidationState)
@@ -1329,7 +1341,7 @@ inline void LayoutObject::invalidateSelectionIfNeeded(const LayoutBoxModelObject
     setPreviousSelectionRectForPaintInvalidation(newSelectionRect);
 
     if (shouldInvalidateSelection())
-        invalidateDisplayItemClients(paintInvalidationContainer);
+        invalidateDisplayItemClients(paintInvalidationContainer, PaintInvalidationSelection, oldSelectionRect, newSelectionRect);
 
     if (fullInvalidation)
         return;
@@ -1387,12 +1399,12 @@ 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);
+            invalidateDisplayItemClients(paintInvalidationContainer, invalidationReason, oldBounds, newBounds);
 
         return invalidationReason;
     }
 
-    invalidateDisplayItemClients(paintInvalidationContainer);
+    invalidateDisplayItemClients(paintInvalidationContainer, invalidationReason, oldBounds, newBounds);
 
     if (invalidationReason == PaintInvalidationIncremental) {
         incrementallyInvalidatePaint(paintInvalidationContainer, oldBounds, newBounds, newLocation);
@@ -3331,7 +3343,9 @@ void LayoutObject::invalidateDisplayItemClientForNonCompositingDescendantsOf(con
         explicit Functor(const LayoutBoxModelObject& paintInvalidationContainer) : m_paintInvalidationContainer(paintInvalidationContainer) { }
         void operator()(LayoutObject& object) const override
         {
-            object.invalidateDisplayItemClients(m_paintInvalidationContainer);
+            // Only the objects need to be invalidated, not any paint rectangles.
+            LayoutRect invalidationRect;
+            object.invalidateDisplayItemClients(m_paintInvalidationContainer, PaintInvalidationFull, invalidationRect, invalidationRect);
         }
     private:
         const LayoutBoxModelObject& m_paintInvalidationContainer;
@@ -3351,7 +3365,7 @@ void LayoutObject::invalidatePaintIncludingNonCompositingDescendants()
             LayoutRect invalidationRect = object.previousPaintInvalidationRect();
             object.adjustInvalidationRectForCompositedScrolling(invalidationRect, m_paintInvalidationContainer);
             object.invalidatePaintUsingContainer(m_paintInvalidationContainer, invalidationRect, PaintInvalidationLayer);
-            object.invalidateDisplayItemClients(m_paintInvalidationContainer);
+            object.invalidateDisplayItemClients(m_paintInvalidationContainer, PaintInvalidationLayer, invalidationRect, invalidationRect);
         }
     private:
         const LayoutBoxModelObject& m_paintInvalidationContainer;
diff --git a/third_party/WebKit/Source/core/layout/LayoutObject.h b/third_party/WebKit/Source/core/layout/LayoutObject.h
index e97e1a1..6df7725 100644
--- a/third_party/WebKit/Source/core/layout/LayoutObject.h
+++ b/third_party/WebKit/Source/core/layout/LayoutObject.h
@@ -980,7 +980,7 @@ public:
 
     // Invalidate the paint of a specific subrectangle within a given object. The rect |r| is in the object's coordinate space.
     void invalidatePaintRectangle(const LayoutRect&) const;
-    void invalidatePaintRectangleNotInvalidatingDisplayItemClients(const LayoutRect& r) const { invalidatePaintRectangleInternal(r); }
+    void invalidatePaintRectangleNotInvalidatingDisplayItemClients(const LayoutRect&) const;
 
     // Walk the tree after layout issuing paint invalidations for layoutObjects that have changed or moved, updating bounds that have changed, and clearing paint invalidation state.
     virtual void invalidateTreeIfNeeded(PaintInvalidationState&);
@@ -1363,7 +1363,7 @@ protected:
     // owned by this object, including the object itself, LayoutText/LayoutInline line boxes, etc.,
     // not including children which will be invalidated normally during invalidateTreeIfNeeded() and
     // parts which are invalidated separately (e.g. scrollbars).
-    virtual void invalidateDisplayItemClients(const LayoutBoxModelObject& paintInvalidationContainer) const;
+    virtual void invalidateDisplayItemClients(const LayoutBoxModelObject& paintInvalidationContainer, PaintInvalidationReason, const LayoutRect& previousPaintInvalidationRect, const LayoutRect& newPaintInvalidationRect) const;
 
     void setIsSlowRepaintObject(bool);
 
@@ -1436,7 +1436,8 @@ private:
 
     static bool isAllowedToModifyLayoutTreeStructure(Document&);
 
-    const LayoutBoxModelObject* invalidatePaintRectangleInternal(const LayoutRect&) const;
+    // The passed rect is mutated into the coordinate space of the paint invalidation container.
+    const LayoutBoxModelObject* invalidatePaintRectangleInternal(LayoutRect&) const;
 
     static LayoutPoint uninitializedPaintOffset() { return LayoutPoint(LayoutUnit::max(), LayoutUnit::max()); }
 
diff --git a/third_party/WebKit/Source/core/layout/LayoutObjectChildList.cpp b/third_party/WebKit/Source/core/layout/LayoutObjectChildList.cpp
index 81b0251..55f3d07 100644
--- a/third_party/WebKit/Source/core/layout/LayoutObjectChildList.cpp
+++ b/third_party/WebKit/Source/core/layout/LayoutObjectChildList.cpp
@@ -191,8 +191,9 @@ void LayoutObjectChildList::invalidatePaintOnRemoval(const LayoutObject& oldChil
     // FIXME: We should not allow paint invalidation out of paint invalidation state. crbug.com/457415
     DisablePaintInvalidationStateAsserts paintInvalidationAssertDisabler;
     const LayoutBoxModelObject& paintInvalidationContainer = *oldChild.containerForPaintInvalidation();
-    oldChild.invalidatePaintUsingContainer(paintInvalidationContainer, oldChild.previousPaintInvalidationRectIncludingCompositedScrolling(paintInvalidationContainer), PaintInvalidationLayoutObjectRemoval);
-    oldChild.invalidateDisplayItemClients(paintInvalidationContainer);
+    const LayoutRect& invalidationRect = oldChild.previousPaintInvalidationRectIncludingCompositedScrolling(paintInvalidationContainer);
+    oldChild.invalidatePaintUsingContainer(paintInvalidationContainer, invalidationRect, PaintInvalidationLayoutObjectRemoval);
+    oldChild.invalidateDisplayItemClients(paintInvalidationContainer, PaintInvalidationLayoutObjectRemoval, invalidationRect, invalidationRect);
 }
 
 } // namespace blink
diff --git a/third_party/WebKit/Source/core/layout/LayoutText.cpp b/third_party/WebKit/Source/core/layout/LayoutText.cpp
index c709cd6..237b48c 100644
--- a/third_party/WebKit/Source/core/layout/LayoutText.cpp
+++ b/third_party/WebKit/Source/core/layout/LayoutText.cpp
@@ -1874,14 +1874,16 @@ PassRefPtr<AbstractInlineTextBox> LayoutText::firstAbstractInlineTextBox()
     return AbstractInlineTextBox::getOrCreate(this, m_firstTextBox);
 }
 
-void LayoutText::invalidateDisplayItemClients(const LayoutBoxModelObject& paintInvalidationContainer) const
+void LayoutText::invalidateDisplayItemClients(const LayoutBoxModelObject& paintInvalidationContainer, PaintInvalidationReason invalidationReason, const LayoutRect& previousPaintInvalidationRect, const LayoutRect& newPaintInvalidationRect) const
 {
-    LayoutObject::invalidateDisplayItemClients(paintInvalidationContainer);
+    LayoutObject::invalidateDisplayItemClients(paintInvalidationContainer, invalidationReason, previousPaintInvalidationRect, newPaintInvalidationRect);
+
+    LayoutRect emptyInvalidationRect;
     for (InlineTextBox* box = firstTextBox(); box; box = box->nextTextBox()) {
-        paintInvalidationContainer.invalidateDisplayItemClientOnBacking(*box);
+        paintInvalidationContainer.invalidateDisplayItemClientOnBacking(*box, invalidationReason, emptyInvalidationRect, emptyInvalidationRect);
         if (box->truncation() != cNoTruncation) {
             if (EllipsisBox* ellipsisBox = box->root().ellipsisBox())
-                paintInvalidationContainer.invalidateDisplayItemClientOnBacking(*ellipsisBox);
+                paintInvalidationContainer.invalidateDisplayItemClientOnBacking(*ellipsisBox, invalidationReason, emptyInvalidationRect, emptyInvalidationRect);
         }
     }
 }
diff --git a/third_party/WebKit/Source/core/layout/LayoutText.h b/third_party/WebKit/Source/core/layout/LayoutText.h
index a6646c4..3717650 100644
--- a/third_party/WebKit/Source/core/layout/LayoutText.h
+++ b/third_party/WebKit/Source/core/layout/LayoutText.h
@@ -193,7 +193,7 @@ protected:
 
     virtual InlineTextBox* createTextBox(int start, unsigned short length); // Subclassed by SVG.
 
-    void invalidateDisplayItemClients(const LayoutBoxModelObject& paintInvalidationContainer) const override;
+    void invalidateDisplayItemClients(const LayoutBoxModelObject& paintInvalidationContainer, PaintInvalidationReason, const LayoutRect& previousPaintInvalidationRect, const LayoutRect& newPaintInvalidationRect) const override;
 
 private:
     void computePreferredLogicalWidths(float leadWidth);
diff --git a/third_party/WebKit/Source/core/layout/LayoutView.cpp b/third_party/WebKit/Source/core/layout/LayoutView.cpp
index 24becc1c..1fb603d 100644
--- a/third_party/WebKit/Source/core/layout/LayoutView.cpp
+++ b/third_party/WebKit/Source/core/layout/LayoutView.cpp
@@ -384,7 +384,7 @@ void LayoutView::invalidateTreeIfNeeded(PaintInvalidationState& paintInvalidatio
         const LayoutBoxModelObject& paintInvalidationContainer = paintInvalidationState.paintInvalidationContainer();
         PaintLayer::mapRectToPaintInvalidationBacking(this, &paintInvalidationContainer, dirtyRect, &paintInvalidationState);
         invalidatePaintUsingContainer(paintInvalidationContainer, dirtyRect, PaintInvalidationFull);
-        invalidateDisplayItemClients(paintInvalidationContainer);
+        invalidateDisplayItemClients(paintInvalidationContainer, PaintInvalidationFull, dirtyRect, dirtyRect);
     }
     LayoutBlock::invalidateTreeIfNeeded(paintInvalidationState);
 }
diff --git a/third_party/WebKit/Source/core/layout/compositing/CompositedLayerMapping.cpp b/third_party/WebKit/Source/core/layout/compositing/CompositedLayerMapping.cpp
index 3d987d6..993b68dc 100644
--- a/third_party/WebKit/Source/core/layout/compositing/CompositedLayerMapping.cpp
+++ b/third_party/WebKit/Source/core/layout/compositing/CompositedLayerMapping.cpp
@@ -2053,12 +2053,12 @@ void CompositedLayerMapping::setContentsNeedDisplayInRect(const LayoutRect& r, P
     ApplyToGraphicsLayers(this, functor, ApplyToContentLayers);
 }
 
-void CompositedLayerMapping::invalidateDisplayItemClient(const DisplayItemClientWrapper& displayItemClient)
+void CompositedLayerMapping::invalidateDisplayItemClient(const DisplayItemClientWrapper& displayItemClient, PaintInvalidationReason paintInvalidationReason, const LayoutRect& previousPaintInvalidationRect, const LayoutRect& newPaintInvalidationRect)
 {
     // FIXME: need to split out paint invalidations for the background.
     // FIXME: need to distinguish invalidations for different layers (e.g. the main layer and scrolling layer). crbug.com/416535.
-    ApplyToGraphicsLayers(this, [&displayItemClient](GraphicsLayer* layer) {
-        layer->invalidateDisplayItemClient(displayItemClient);
+    ApplyToGraphicsLayers(this, [&displayItemClient, paintInvalidationReason, previousPaintInvalidationRect, newPaintInvalidationRect](GraphicsLayer* layer) {
+        layer->invalidateDisplayItemClient(displayItemClient, paintInvalidationReason, enclosingIntRect(previousPaintInvalidationRect), enclosingIntRect(newPaintInvalidationRect));
     }, ApplyToContentLayers);
 }
 
diff --git a/third_party/WebKit/Source/core/layout/compositing/CompositedLayerMapping.h b/third_party/WebKit/Source/core/layout/compositing/CompositedLayerMapping.h
index c9df972..ff8ea94 100644
--- a/third_party/WebKit/Source/core/layout/compositing/CompositedLayerMapping.h
+++ b/third_party/WebKit/Source/core/layout/compositing/CompositedLayerMapping.h
@@ -122,7 +122,7 @@ public:
     // LayoutRect is in the coordinate space of the layer's layout object.
     void setContentsNeedDisplayInRect(const LayoutRect&, PaintInvalidationReason);
 
-    void invalidateDisplayItemClient(const DisplayItemClientWrapper&);
+    void invalidateDisplayItemClient(const DisplayItemClientWrapper&, PaintInvalidationReason, const LayoutRect& previousPaintInvalidationRect, const LayoutRect& newPaintInvalidationRect);
 
     // Notification from the layoutObject that its content changed.
     void contentChanged(ContentChangeType);
diff --git a/third_party/WebKit/Source/platform/graphics/GraphicsLayer.cpp b/third_party/WebKit/Source/platform/graphics/GraphicsLayer.cpp
index f708160..13e59eb 100644
--- a/third_party/WebKit/Source/platform/graphics/GraphicsLayer.cpp
+++ b/third_party/WebKit/Source/platform/graphics/GraphicsLayer.cpp
@@ -999,11 +999,11 @@ bool GraphicsLayer::needsDisplay() const
     return m_needsDisplay;
 }
 
-bool GraphicsLayer::commitIfNeeded(DisplayListDiff& displayListDiff)
+bool GraphicsLayer::commitIfNeeded()
 {
     ASSERT(RuntimeEnabledFeatures::slimmingPaintSynchronizedPaintingEnabled());
     if (m_needsDisplay) {
-        displayItemList()->commitNewDisplayItems(&displayListDiff);
+        displayItemList()->commitNewDisplayItems(this);
         m_needsDisplay = false;
         return true;
     }
@@ -1027,9 +1027,10 @@ void GraphicsLayer::setNeedsDisplayInRect(const IntRect& rect, PaintInvalidation
         m_linkHighlights[i]->invalidate();
 }
 
-void GraphicsLayer::invalidateDisplayItemClient(const DisplayItemClientWrapper& displayItemClient)
+void GraphicsLayer::invalidateDisplayItemClient(const DisplayItemClientWrapper& displayItemClient, PaintInvalidationReason paintInvalidationReason, const IntRect& previousPaintInvalidationRect, const IntRect& newPaintInvalidationRect)
 {
-    displayItemList()->invalidate(displayItemClient);
+    m_needsDisplay = true;
+    displayItemList()->invalidate(displayItemClient, paintInvalidationReason, previousPaintInvalidationRect, newPaintInvalidationRect);
     if (isTrackingPaintInvalidations())
         trackPaintInvalidationObject(displayItemClient.debugName());
 }
diff --git a/third_party/WebKit/Source/platform/graphics/GraphicsLayer.h b/third_party/WebKit/Source/platform/graphics/GraphicsLayer.h
index 51f5ea7..7e1c8a2 100644
--- a/third_party/WebKit/Source/platform/graphics/GraphicsLayer.h
+++ b/third_party/WebKit/Source/platform/graphics/GraphicsLayer.h
@@ -192,9 +192,9 @@ public:
 
     bool needsDisplay() const;
     // Commites new display items only if m_needsDisplay is true.
-    bool commitIfNeeded(DisplayListDiff&);
+    bool commitIfNeeded();
 
-    void invalidateDisplayItemClient(const DisplayItemClientWrapper&);
+    void invalidateDisplayItemClient(const DisplayItemClientWrapper&, PaintInvalidationReason, const IntRect& previousPaintInvalidationRect, const IntRect& newPaintInvalidationRect);
 
     // Set that the position/size of the contents (image or video).
     void setContentsRect(const IntRect&);
diff --git a/third_party/WebKit/Source/platform/graphics/paint/DisplayItemList.cpp b/third_party/WebKit/Source/platform/graphics/paint/DisplayItemList.cpp
index 344b432..706927c 100644
--- a/third_party/WebKit/Source/platform/graphics/paint/DisplayItemList.cpp
+++ b/third_party/WebKit/Source/platform/graphics/paint/DisplayItemList.cpp
@@ -7,6 +7,7 @@
 
 #include "platform/NotImplemented.h"
 #include "platform/TraceEvent.h"
+#include "platform/graphics/GraphicsLayer.h"
 #include "platform/graphics/paint/DrawingDisplayItem.h"
 
 #ifndef NDEBUG
@@ -99,9 +100,18 @@ void DisplayItemList::endScope()
     endSkippingCache();
 }
 
-void DisplayItemList::invalidate(const DisplayItemClientWrapper& client)
+void DisplayItemList::invalidate(const DisplayItemClientWrapper& client, PaintInvalidationReason paintInvalidationReason, const IntRect& previousPaintInvalidationRect, const IntRect& newPaintInvalidationRect)
 {
     invalidateUntracked(client.displayItemClient());
+    if (RuntimeEnabledFeatures::slimmingPaintSynchronizedPaintingEnabled()) {
+        Invalidation invalidation = { previousPaintInvalidationRect, paintInvalidationReason };
+        if (!previousPaintInvalidationRect.isEmpty())
+            m_invalidations.append(invalidation);
+        if (newPaintInvalidationRect != previousPaintInvalidationRect && !newPaintInvalidationRect.isEmpty()) {
+            invalidation.rect = newPaintInvalidationRect;
+            m_invalidations.append(invalidation);
+        }
+    }
 
     if (RuntimeEnabledFeatures::slimmingPaintV2Enabled() && m_trackedPaintInvalidationObjects)
         m_trackedPaintInvalidationObjects->append(client.debugName());
@@ -251,12 +261,17 @@ void DisplayItemList::copyCachedSubsequence(DisplayItems::iterator& currentIt, D
 // Coefficients are related to the ratio of out-of-order CachedDisplayItems
 // and the average number of (Drawing|Subsequence)DisplayItems per client.
 //
-// TODO(pdr): Implement the DisplayListDiff algorithm for SlimmingPaintV2.
-void DisplayItemList::commitNewDisplayItems(DisplayListDiff*)
+void DisplayItemList::commitNewDisplayItems(GraphicsLayer* graphicsLayer)
 {
     TRACE_EVENT2("blink,benchmark", "DisplayItemList::commitNewDisplayItems", "current_display_list_size", (int)m_currentDisplayItems.size(),
         "num_non_cached_new_items", (int)m_newDisplayItems.size() - m_numCachedItems);
 
+    if (RuntimeEnabledFeatures::slimmingPaintSynchronizedPaintingEnabled()) {
+        for (const auto& invalidation : m_invalidations)
+            graphicsLayer->setNeedsDisplayInRect(invalidation.rect, invalidation.invalidationReason);
+        m_invalidations.clear();
+    }
+
     // These data structures are used during painting only.
     ASSERT(m_scopeStack.isEmpty());
     m_scopeStack.clear();
diff --git a/third_party/WebKit/Source/platform/graphics/paint/DisplayItemList.h b/third_party/WebKit/Source/platform/graphics/paint/DisplayItemList.h
index e4a0ab1..8827a61 100644
--- a/third_party/WebKit/Source/platform/graphics/paint/DisplayItemList.h
+++ b/third_party/WebKit/Source/platform/graphics/paint/DisplayItemList.h
@@ -7,8 +7,10 @@
 
 #include "platform/PlatformExport.h"
 #include "platform/RuntimeEnabledFeatures.h"
+#include "platform/geometry/IntRect.h"
 #include "platform/geometry/LayoutPoint.h"
 #include "platform/graphics/ContiguousContainer.h"
+#include "platform/graphics/PaintInvalidationReason.h"
 #include "platform/graphics/paint/DisplayItem.h"
 #include "platform/graphics/paint/Transform3DDisplayItem.h"
 #include "wtf/Alignment.h"
@@ -19,6 +21,7 @@
 
 namespace blink {
 
+class GraphicsLayer;
 class GraphicsContext;
 
 // kDisplayItemAlignment must be a multiple of alignof(derived display item) for
@@ -29,10 +32,6 @@ static const size_t kDisplayItemAlignment = WTF_ALIGN_OF(BeginTransform3DDisplay
 static const size_t kInitialDisplayItemsCapacity = 64;
 static const size_t kMaximumDisplayItemSize = sizeof(BeginTransform3DDisplayItem);
 
-// Map from SimpleLayer.startPoint to the DrawingDisplayItems within its range
-// which were invalidated on this frame and do not change SimpleLayers.
-using DisplayListDiff = HashMap<DisplayItemClient, DisplayItem*>;
-
 class DisplayItems : public ContiguousContainer<DisplayItem, kDisplayItemAlignment> {
 public:
     DisplayItems(size_t initialSizeBytes)
@@ -64,8 +63,8 @@ public:
         return adoptPtr(new DisplayItemList());
     }
 
-    // These methods are called during paint invalidation.
-    void invalidate(const DisplayItemClientWrapper&);
+    // These methods are called during paint invalidation (or paint if SlimmingPaintSynchronizedPainting is on).
+    void invalidate(const DisplayItemClientWrapper&, PaintInvalidationReason, const IntRect& previousPaintInvalidationRect, const IntRect& newPaintInvalidationRect);
     void invalidateUntracked(DisplayItemClient);
     void invalidateAll();
 
@@ -103,9 +102,9 @@ public:
     void endSkippingCache() { ASSERT(m_skippingCacheCount > 0); --m_skippingCacheCount; }
     bool skippingCache() const { return m_skippingCacheCount; }
 
-    // Must be called when a painting is finished. If passed, a DisplayListDiff
-    // is initialized and created.
-    void commitNewDisplayItems(DisplayListDiff* = 0);
+    // Must be called when a painting is finished. If passed, invalidations are recorded on the given
+    // GraphicsLayer.
+    void commitNewDisplayItems(GraphicsLayer* = 0);
 
     // Returns the approximate memory usage, excluding memory likely to be
     // shared with the embedder after copying to WebDisplayItemList.
@@ -223,6 +222,13 @@ private:
     unsigned m_nextScope;
     Vector<unsigned> m_scopeStack;
 
+    struct Invalidation {
+        IntRect rect;
+        PaintInvalidationReason invalidationReason;
+    };
+
+    Vector<Invalidation> m_invalidations;
+
 #if ENABLE(ASSERT)
     // This is used to check duplicated ids during add(). We could also check during
     // updatePaintList(), but checking during add() helps developer easily find where
diff --git a/third_party/WebKit/Source/platform/graphics/paint/DisplayItemListTest.cpp b/third_party/WebKit/Source/platform/graphics/paint/DisplayItemListTest.cpp
index e9f98e1..7da8aff 100644
--- a/third_party/WebKit/Source/platform/graphics/paint/DisplayItemListTest.cpp
+++ b/third_party/WebKit/Source/platform/graphics/paint/DisplayItemListTest.cpp
@@ -131,7 +131,7 @@ TEST_F(DisplayItemListTest, UpdateBasic)
         TestDisplayItem(second, backgroundDrawingType),
         TestDisplayItem(first, foregroundDrawingType));
 
-    displayItemList().invalidate(second);
+    displayItemList().invalidate(second, PaintInvalidationFull, IntRect(), IntRect());
     drawRect(context, first, backgroundDrawingType, FloatRect(100, 100, 300, 300));
     drawRect(context, first, foregroundDrawingType, FloatRect(100, 100, 300, 300));
     displayItemList().commitNewDisplayItems();
@@ -158,7 +158,7 @@ TEST_F(DisplayItemListTest, UpdateSwapOrder)
         TestDisplayItem(second, backgroundDrawingType),
         TestDisplayItem(unaffected, backgroundDrawingType));
 
-    displayItemList().invalidate(second);
+    displayItemList().invalidate(second, PaintInvalidationFull, IntRect(), IntRect());
     drawRect(context, second, backgroundDrawingType, FloatRect(100, 100, 50, 200));
     drawRect(context, first, backgroundDrawingType, FloatRect(100, 100, 100, 100));
     drawRect(context, unaffected, backgroundDrawingType, FloatRect(300, 300, 10, 10));
@@ -219,7 +219,7 @@ TEST_F(DisplayItemListTest, UpdateInvalidationWithPhases)
         TestDisplayItem(second, foregroundDrawingType),
         TestDisplayItem(third, foregroundDrawingType));
 
-    displayItemList().invalidate(second);
+    displayItemList().invalidate(second, PaintInvalidationFull, IntRect(), IntRect());
     drawRect(context, first, backgroundDrawingType, FloatRect(100, 100, 100, 100));
     drawRect(context, second, backgroundDrawingType, FloatRect(100, 100, 50, 200));
     drawRect(context, third, backgroundDrawingType, FloatRect(300, 100, 50, 50));
@@ -251,8 +251,8 @@ TEST_F(DisplayItemListTest, UpdateAddFirstOverlap)
         TestDisplayItem(second, backgroundDrawingType),
         TestDisplayItem(second, foregroundDrawingType));
 
-    displayItemList().invalidate(first);
-    displayItemList().invalidate(second);
+    displayItemList().invalidate(first, PaintInvalidationFull, IntRect(), IntRect());
+    displayItemList().invalidate(second, PaintInvalidationFull, IntRect(), IntRect());
     drawRect(context, first, backgroundDrawingType, FloatRect(100, 100, 150, 150));
     drawRect(context, first, foregroundDrawingType, FloatRect(100, 100, 150, 150));
     drawRect(context, second, backgroundDrawingType, FloatRect(200, 200, 50, 50));
@@ -265,7 +265,7 @@ TEST_F(DisplayItemListTest, UpdateAddFirstOverlap)
         TestDisplayItem(second, backgroundDrawingType),
         TestDisplayItem(second, foregroundDrawingType));
 
-    displayItemList().invalidate(first);
+    displayItemList().invalidate(first, PaintInvalidationFull, IntRect(), IntRect());
     drawRect(context, second, backgroundDrawingType, FloatRect(200, 200, 50, 50));
     drawRect(context, second, foregroundDrawingType, FloatRect(200, 200, 50, 50));
     displayItemList().commitNewDisplayItems();
@@ -289,8 +289,8 @@ TEST_F(DisplayItemListTest, UpdateAddLastOverlap)
         TestDisplayItem(first, backgroundDrawingType),
         TestDisplayItem(first, foregroundDrawingType));
 
-    displayItemList().invalidate(first);
-    displayItemList().invalidate(second);
+    displayItemList().invalidate(first, PaintInvalidationFull, IntRect(), IntRect());
+    displayItemList().invalidate(second, PaintInvalidationFull, IntRect(), IntRect());
     drawRect(context, first, backgroundDrawingType, FloatRect(100, 100, 150, 150));
     drawRect(context, first, foregroundDrawingType, FloatRect(100, 100, 150, 150));
     drawRect(context, second, backgroundDrawingType, FloatRect(200, 200, 50, 50));
@@ -303,8 +303,8 @@ TEST_F(DisplayItemListTest, UpdateAddLastOverlap)
         TestDisplayItem(second, backgroundDrawingType),
         TestDisplayItem(second, foregroundDrawingType));
 
-    displayItemList().invalidate(first);
-    displayItemList().invalidate(second);
+    displayItemList().invalidate(first, PaintInvalidationFull, IntRect(), IntRect());
+    displayItemList().invalidate(second, PaintInvalidationFull, IntRect(), IntRect());
     drawRect(context, first, backgroundDrawingType, FloatRect(100, 100, 150, 150));
     drawRect(context, first, foregroundDrawingType, FloatRect(100, 100, 150, 150));
     displayItemList().commitNewDisplayItems();
@@ -333,7 +333,7 @@ TEST_F(DisplayItemListTest, UpdateClip)
         TestDisplayItem(second, backgroundDrawingType),
         TestDisplayItem(first, DisplayItem::clipTypeToEndClipType(clipType)));
 
-    displayItemList().invalidate(first);
+    displayItemList().invalidate(first, PaintInvalidationFull, IntRect(), IntRect());
     drawRect(context, first, backgroundDrawingType, FloatRect(100, 100, 150, 150));
     drawRect(context, second, backgroundDrawingType, FloatRect(100, 100, 150, 150));
     displayItemList().commitNewDisplayItems();
@@ -342,7 +342,7 @@ TEST_F(DisplayItemListTest, UpdateClip)
         TestDisplayItem(first, backgroundDrawingType),
         TestDisplayItem(second, backgroundDrawingType));
 
-    displayItemList().invalidate(second);
+    displayItemList().invalidate(second, PaintInvalidationFull, IntRect(), IntRect());
     drawRect(context, first, backgroundDrawingType, FloatRect(100, 100, 150, 150));
     {
         ClipRecorder clipRecorder(context, second, clipType, LayoutRect(1, 1, 2, 2));
@@ -375,7 +375,7 @@ TEST_F(DisplayItemListTest, CachedDisplayItems)
     const SkPicture* firstPicture = static_cast<const DrawingDisplayItem&>(displayItemList().displayItems()[0]).picture();
     const SkPicture* secondPicture = static_cast<const DrawingDisplayItem&>(displayItemList().displayItems()[1]).picture();
 
-    displayItemList().invalidate(first);
+    displayItemList().invalidate(first, PaintInvalidationFull, IntRect(), IntRect());
     EXPECT_FALSE(displayItemList().clientCacheIsValid(first.displayItemClient()));
     EXPECT_TRUE(displayItemList().clientCacheIsValid(second.displayItemClient()));
 
@@ -427,7 +427,7 @@ TEST_F(DisplayItemListTest, ComplexUpdateSwapOrder)
         TestDisplayItem(container2, foregroundDrawingType));
 
     // Simulate the situation when container1 e.g. gets a z-index that is now greater than container2.
-    displayItemList().invalidate(container1);
+    displayItemList().invalidate(container1, PaintInvalidationFull, IntRect(), IntRect());
     drawRect(context, container2, backgroundDrawingType, FloatRect(100, 200, 100, 100));
     drawRect(context, content2, backgroundDrawingType, FloatRect(100, 200, 50, 200));
     drawRect(context, content2, foregroundDrawingType, FloatRect(100, 200, 50, 200));
@@ -589,12 +589,13 @@ TEST_F(DisplayItemListTest, CachedNestedSubsequenceUpdate)
         TestDisplayItem(container2, endSubsequenceType));
 
     // Invalidate container1 but not content1.
-    displayItemList().invalidate(container1);
+    displayItemList().invalidate(container1, PaintInvalidationFull, IntRect(), IntRect());
 
     // Container2 itself now becomes empty (but still has the 'content2' child),
     // and chooses not to output subsequence info.
-    displayItemList().invalidate(container2);
-    displayItemList().invalidate(content2);
+
+    displayItemList().invalidate(container2, PaintInvalidationFull, IntRect(), IntRect());
+    displayItemList().invalidate(content2, PaintInvalidationFull, IntRect(), IntRect());
     EXPECT_FALSE(SubsequenceRecorder::useCachedSubsequenceIfPossible(context, container2, subsequenceType));
     EXPECT_FALSE(SubsequenceRecorder::useCachedSubsequenceIfPossible(context, content2, subsequenceType));
     // Content2 now outputs foreground only.
@@ -690,7 +691,7 @@ TEST_F(DisplayItemListTest, Scope)
     EXPECT_NE(picture2, static_cast<const DrawingDisplayItem&>(displayItemList().displayItems()[2]).picture());
 
     // Now the multicol becomes 3 columns and repaints.
-    displayItemList().invalidate(multicol);
+    displayItemList().invalidate(multicol, PaintInvalidationFull, IntRect(), IntRect());
     drawRect(context, multicol, backgroundDrawingType, FloatRect(100, 100, 100, 100));
 
     displayItemList().beginScope();
@@ -739,7 +740,7 @@ TEST_F(DisplayItemListTest, OptimizeNoopPairs)
         TestDisplayItem(second, DisplayItem::EndClipPath),
         TestDisplayItem(third, backgroundDrawingType));
 
-    displayItemList().invalidate(second);
+    displayItemList().invalidate(second, PaintInvalidationFull, IntRect(), IntRect());
     drawRect(context, first, backgroundDrawingType, FloatRect(0, 0, 100, 100));
     {
         ClipRecorder clipRecorder(context, second, clipType, LayoutRect(1, 1, 2, 2));
@@ -753,7 +754,7 @@ TEST_F(DisplayItemListTest, OptimizeNoopPairs)
         TestDisplayItem(first, backgroundDrawingType),
         TestDisplayItem(third, backgroundDrawingType));
 
-    displayItemList().invalidate(second);
+    displayItemList().invalidate(second, PaintInvalidationFull, IntRect(), IntRect());
     drawRect(context, first, backgroundDrawingType, FloatRect(0, 0, 100, 100));
     {
         ClipRecorder clipRecorder(context, second, clipType, LayoutRect(1, 1, 2, 2));