Adjust for composited scrolling when invalidating paint rectangles.

third_party/WebKit/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 1250 matching lines @@
     ASSERT(!paintingLayer() || paintingLayer()->needsRepaint());
     paintInvalidationContainer.invalidateDisplayItemClientOnBacking(*this, invalidationReason, this);
 }
 
 void LayoutObject::invalidateDisplayItemClientsWithPaintInvalidationState(const LayoutBoxModelObject& paintInvalidationContainer, const PaintInvalidationState& paintInvalidationState, PaintInvalidationReason invalidationReason) const
 {
     paintInvalidationState.paintingLayer().setNeedsRepaint();
     invalidateDisplayItemClients(paintInvalidationContainer, invalidationReason);
 }
 
+
+bool LayoutObject::compositedScrollsWithRespectTo(const LayoutBoxModelObject& paintInvalidationContainer) const
+{
+    return paintInvalidationContainer.usesCompositedScrolling() && this != &paintInvalidationContainer;
+}
+
 const LayoutBoxModelObject* LayoutObject::invalidatePaintRectangleInternal(const LayoutRect& dirtyRect) const
 {
     RELEASE_ASSERT(isRooted());
 
     if (dirtyRect.isEmpty())
         return nullptr;
 
     if (view()->document().printing())
         return nullptr; // Don't invalidate paints if we're printing.
 
     const LayoutBoxModelObject& paintInvalidationContainer = containerForPaintInvalidation();
     LayoutRect dirtyRectOnBacking = dirtyRect;
     PaintLayer::mapRectToPaintInvalidationBacking(*this, paintInvalidationContainer, dirtyRectOnBacking);
+
+    // Composited scrolling should not be included in the bounds of composited-scrolled items.
+    if (compositedScrollsWithRespectTo(paintInvalidationContainer)) {
+        LayoutSize inverseOffset(toLayoutBox(&paintInvalidationContainer)->scrolledContentOffset());
+        dirtyRectOnBacking.move(inverseOffset);
+    }
+
     invalidatePaintUsingContainer(paintInvalidationContainer, dirtyRectOnBacking, PaintInvalidationRectangle);
     return &paintInvalidationContainer;
 }
 
 void LayoutObject::invalidatePaintRectangle(const LayoutRect& rect) const
 {
     setPaintingLayerNeedsRepaint();
     const LayoutBoxModelObject* paintInvalidationContainer = invalidatePaintRectangleInternal(rect);
     if (paintInvalidationContainer)
         invalidateDisplayItemClients(*paintInvalidationContainer, PaintInvalidationRectangle);
@@ skipping 85 matching lines @@
     if (!fullInvalidation && !shouldInvalidateSelection())
         return;
 
     LayoutRect oldSelectionRect = previousSelectionRectForPaintInvalidation();
     LayoutRect newSelectionRect = localSelectionRect();
     if (!newSelectionRect.isEmpty()) {
         paintInvalidationState.mapLocalRectToPaintInvalidationBacking(newSelectionRect);
 
         // 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) {
+        if (compositedScrollsWithRespectTo(paintInvalidationContainer)) {
             LayoutSize inverseOffset(toLayoutBox(&paintInvalidationContainer)->scrolledContentOffset());
             newSelectionRect.move(inverseOffset);
         }
     }
 
     setPreviousSelectionRectForPaintInvalidation(newSelectionRect);
 
     // TODO(wangxianzhu): Combine the following two conditions when removing LayoutView::doingFullPaintInvalidation().
     if (!fullInvalidation)
         fullyInvalidatePaint(paintInvalidationContainer, PaintInvalidationSelection, oldSelectionRect, newSelectionRect);
@@ skipping 18 matching lines @@
     const LayoutBoxModelObject& paintInvalidationContainer = paintInvalidationState.paintInvalidationContainer();
     ASSERT(paintInvalidationContainer == containerForPaintInvalidation());
 
     const LayoutRect oldBounds = previousPaintInvalidationRect();
     const LayoutPoint oldLocation = RuntimeEnabledFeatures::slimmingPaintInvalidationEnabled() ? LayoutPoint() : previousPositionFromPaintInvalidationBacking();
     LayoutRect newBounds = paintInvalidationState.computePaintInvalidationRectInBacking();
     LayoutPoint newLocation = RuntimeEnabledFeatures::slimmingPaintInvalidationEnabled() ? LayoutPoint() : paintInvalidationState.computePositionFromPaintInvalidationBacking();
 
     // 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) {
+    if (compositedScrollsWithRespectTo(paintInvalidationContainer)) {
         LayoutSize inverseOffset(toLayoutBox(&paintInvalidationContainer)->scrolledContentOffset());
         newLocation.move(inverseOffset);
         newBounds.move(inverseOffset);
     }
 
     setPreviousPaintInvalidationRect(newBounds);
     if (!RuntimeEnabledFeatures::slimmingPaintInvalidationEnabled())
         setPreviousPositionFromPaintInvalidationBacking(newLocation);
 
     if (!shouldCheckForPaintInvalidationRegardlessOfPaintInvalidationState() && paintInvalidationState.forcedSubtreeInvalidationRectUpdateWithinContainerOnly()) {
@@ skipping 82 matching lines @@
         return PaintInvalidationBecameInvisible;
 
     if (locationChanged)
         return PaintInvalidationLocationChange;
 
     return PaintInvalidationIncremental;
 }
 
 void LayoutObject::adjustInvalidationRectForCompositedScrolling(LayoutRect& rect, const LayoutBoxModelObject& paintInvalidationContainer) const
 {
-    if (paintInvalidationContainer.usesCompositedScrolling() && &paintInvalidationContainer != this) {
+    if (compositedScrollsWithRespectTo(paintInvalidationContainer)) {
         LayoutSize offset(-toLayoutBox(&paintInvalidationContainer)->scrolledContentOffset());
         rect.move(offset);
     }
 }
 
 LayoutRect LayoutObject::previousPaintInvalidationRectIncludingCompositedScrolling(const LayoutBoxModelObject& paintInvalidationContainer) const
 {
     LayoutRect invalidationRect = previousPaintInvalidationRect();
     adjustInvalidationRectForCompositedScrolling(invalidationRect, paintInvalidationContainer);
     return invalidationRect;
@@ skipping 2145 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