Fix paint invalidation rect tracking within composited scrolling layers.

Source/core/layout/LayoutObject.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2000 Dirk Mueller (mueller@kde.org)
  *           (C) 2004 Allan Sandfeld Jensen (kde@carewolf.com)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2009 Google Inc. All rights reserved.
  * Copyright (C) 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  *
  * This library is free software; you can redistribute it and/or
@@ skipping 1291 matching lines @@
 }
 
 PaintInvalidationReason LayoutObject::invalidatePaintIfNeeded(PaintInvalidationState& paintInvalidationState, const LayoutBoxModelObject& paintInvalidationContainer)
 {
     LayoutView* v = view();
     if (v->document().printing())
         return PaintInvalidationNone; // Don't invalidate paints if we're printing.
 
     const LayoutRect oldBounds = previousPaintInvalidationRect();
     const LayoutPoint oldLocation = previousPositionFromPaintInvalidationBacking();
-    const LayoutRect newBounds = boundsRectForPaintInvalidation(&paintInvalidationContainer, &paintInvalidationState);
-    const LayoutPoint newLocation = DeprecatedPaintLayer::positionFromPaintInvalidationBacking(this, &paintInvalidationContainer, &paintInvalidationState);
+    LayoutRect newBounds = boundsRectForPaintInvalidation(&paintInvalidationContainer, &paintInvalidationState);
+    LayoutPoint newLocation = DeprecatedPaintLayer::positionFromPaintInvalidationBacking(this, &paintInvalidationContainer, &paintInvalidationState);
+
+    // Composited scrolling should not be included in the bounds and position tracking, because the graphics layer backing the scroller
+    // does not move on scroll.
+    if (paintInvalidationContainer.usesCompositedScrolling() && &paintInvalidationContainer != this) {
+        LayoutSize inverseOffset(toLayoutBox(&paintInvalidationContainer)->scrolledContentOffset());
+        newLocation.move(inverseOffset);
+        newBounds.move(inverseOffset);
+    }
+
     setPreviousPaintInvalidationRect(newBounds);
     setPreviousPositionFromPaintInvalidationBacking(newLocation);
 
     PaintInvalidationReason invalidationReason = paintInvalidationReason(paintInvalidationContainer, oldBounds, oldLocation, newBounds, newLocation);
 
     // We need to invalidate the selection before checking for whether we are doing a full invalidation.
     // This is because we need to update the old rect regardless.
     invalidateSelectionIfNeeded(paintInvalidationContainer, invalidationReason);
 
     // If we are set to do a full paint invalidation that means the LayoutView will issue
@@ skipping 81 matching lines @@
     // into the incremental invalidation we'll issue two invalidations instead
     // of one.
     if (oldBounds.isEmpty())
         return PaintInvalidationBecameVisible;
     if (newBounds.isEmpty())
         return PaintInvalidationBecameInvisible;
 
     return PaintInvalidationIncremental;
 }
 
+void LayoutObject::adjustInvalidationRectForCompositedScrolling(LayoutRect& rect, const LayoutBoxModelObject& paintInvalidationContainer) const
+{
+    if (paintInvalidationContainer.usesCompositedScrolling() && &paintInvalidationContainer != this) {
+        LayoutSize offset(-toLayoutBox(&paintInvalidationContainer)->scrolledContentOffset());
+        rect.move(offset);
+    }
+}
+
+LayoutRect LayoutObject::previousPaintInvalidationRectIncludingCompositedScrolling(const LayoutBoxModelObject& paintInvalidationContainer) const
+{
+    LayoutRect invalidationRect = previousPaintInvalidationRect();
+    adjustInvalidationRectForCompositedScrolling(invalidationRect, paintInvalidationContainer);
+    return invalidationRect;
+}
+
+void LayoutObject::adjustPreviousPaintInvalidationForScrollIfNeeded(const DoubleSize& scrollDelta)
+{
+    if (containerForPaintInvalidation()->usesCompositedScrolling())
+        return;
+    m_previousPaintInvalidationRect.move(LayoutSize(scrollDelta));
+}
+
 void LayoutObject::incrementallyInvalidatePaint(const LayoutBoxModelObject& paintInvalidationContainer, const LayoutRect& oldBounds, const LayoutRect& newBounds, const LayoutPoint& positionFromPaintInvalidationBacking)
 {
     ASSERT(oldBounds.location() == newBounds.location());
 
     LayoutUnit deltaRight = newBounds.maxX() - oldBounds.maxX();
-    if (deltaRight > 0)
-        invalidatePaintUsingContainer(paintInvalidationContainer, LayoutRect(oldBounds.maxX(), newBounds.y(), deltaRight, newBounds.height()), PaintInvalidationIncremental);
-    else if (deltaRight < 0)
-        invalidatePaintUsingContainer(paintInvalidationContainer, LayoutRect(newBounds.maxX(), oldBounds.y(), -deltaRight, oldBounds.height()), PaintInvalidationIncremental);
+    if (deltaRight > 0) {
+        LayoutRect invalidationRect(oldBounds.maxX(), newBounds.y(), deltaRight, newBounds.height());
+        adjustInvalidationRectForCompositedScrolling(invalidationRect, paintInvalidationContainer);
+        invalidatePaintUsingContainer(paintInvalidationContainer, invalidationRect, PaintInvalidationIncremental);
+    } else if (deltaRight < 0) {
+        LayoutRect invalidationRect(newBounds.maxX(), oldBounds.y(), -deltaRight, oldBounds.height());
+        adjustInvalidationRectForCompositedScrolling(invalidationRect, paintInvalidationContainer);
+        invalidatePaintUsingContainer(paintInvalidationContainer, invalidationRect, PaintInvalidationIncremental);
+    }
 
     LayoutUnit deltaBottom = newBounds.maxY() - oldBounds.maxY();
-    if (deltaBottom > 0)
-        invalidatePaintUsingContainer(paintInvalidationContainer, LayoutRect(newBounds.x(), oldBounds.maxY(), newBounds.width(), deltaBottom), PaintInvalidationIncremental);
-    else if (deltaBottom < 0)
-        invalidatePaintUsingContainer(paintInvalidationContainer, LayoutRect(oldBounds.x(), newBounds.maxY(), oldBounds.width(), -deltaBottom), PaintInvalidationIncremental);
+    if (deltaBottom > 0) {
+        LayoutRect invalidationRect(newBounds.x(), oldBounds.maxY(), newBounds.width(), deltaBottom);
+        adjustInvalidationRectForCompositedScrolling(invalidationRect, paintInvalidationContainer);
+        invalidatePaintUsingContainer(paintInvalidationContainer, invalidationRect, PaintInvalidationIncremental);
+    } else if (deltaBottom < 0) {
+        LayoutRect invalidationRect(oldBounds.x(), newBounds.maxY(), oldBounds.width(), -deltaBottom);
+        adjustInvalidationRectForCompositedScrolling(invalidationRect, paintInvalidationContainer);
+        invalidatePaintUsingContainer(paintInvalidationContainer, invalidationRect, PaintInvalidationIncremental);
+    }
 }
 
 void LayoutObject::fullyInvalidatePaint(const LayoutBoxModelObject& paintInvalidationContainer, PaintInvalidationReason invalidationReason, const LayoutRect& oldBounds, const LayoutRect& newBounds)
 {
     // Otherwise do full paint invalidation.
-    invalidatePaintUsingContainer(paintInvalidationContainer, oldBounds, invalidationReason);
-    if (newBounds != oldBounds)
-        invalidatePaintUsingContainer(paintInvalidationContainer, newBounds, invalidationReason);
+    LayoutRect invalidationRect = oldBounds;
+    adjustInvalidationRectForCompositedScrolling(invalidationRect, paintInvalidationContainer);
+    invalidatePaintUsingContainer(paintInvalidationContainer, invalidationRect, invalidationReason);
+    if (newBounds != oldBounds) {
+        invalidationRect = newBounds;
+        adjustInvalidationRectForCompositedScrolling(invalidationRect, paintInvalidationContainer);
+        invalidatePaintUsingContainer(paintInvalidationContainer, invalidationRect, invalidationReason);
+    }
 }
 
 void LayoutObject::invalidatePaintForOverflow()
 {
 }
 
 void LayoutObject::invalidatePaintForOverflowIfNeeded()
 {
     if (shouldInvalidateOverflowForPaint())
         invalidatePaintForOverflow();
@@ skipping 1822 matching lines @@
     traverseNonCompositingDescendants(const_cast<LayoutObject&>(object), Functor(paintInvalidationContainer));
 }
 
 void LayoutObject::invalidatePaintIncludingNonCompositingDescendants()
 {
     class Functor : public LayoutObjectTraversalFunctor {
     public:
         explicit Functor(const LayoutBoxModelObject& paintInvalidationContainer) : m_paintInvalidationContainer(paintInvalidationContainer) { }
         void operator()(LayoutObject& object) const override
         {
-            object.invalidatePaintUsingContainer(m_paintInvalidationContainer, object.previousPaintInvalidationRect(), PaintInvalidationLayer);
+            LayoutRect invalidationRect = object.previousPaintInvalidationRect();
+            object.adjustInvalidationRectForCompositedScrolling(invalidationRect, m_paintInvalidationContainer);
+            object.invalidatePaintUsingContainer(m_paintInvalidationContainer, invalidationRect, PaintInvalidationLayer);
             if (RuntimeEnabledFeatures::slimmingPaintEnabled())
                 object.invalidateDisplayItemClients(m_paintInvalidationContainer);
         }
     private:
         const LayoutBoxModelObject& m_paintInvalidationContainer;
     };
 
     // Since we're only painting non-composited layers, we know that they all share the same paintInvalidationContainer.
     const LayoutBoxModelObject& paintInvalidationContainer = containerForPaintInvalidationOnRootedTree();
     traverseNonCompositingDescendants(*this, Functor(paintInvalidationContainer));
@@ skipping 58 matching lines @@
         const blink::LayoutObject* root = object1;
         while (root->parent())
             root = root->parent();
         root->showLayoutTreeAndMark(object1, "*", object2, "-", 0);
     } else {
         fprintf(stderr, "Cannot showLayoutTree. Root is (nil)\n");
     }
 }
 
 #endif