Let synchronized painting generate correct paint invalidation rects

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 1186 matching lines @@
     paintRect.intersect(frameView->visibleContentRect());
     if (paintRect.isEmpty())
         return;
 
     if (HostWindow* window = frameView->hostWindow())
         window->invalidateRect(frameView->contentsToRootFrame(paintRect));
 }
 
 void LayoutObject::invalidatePaintUsingContainer(const LayoutBoxModelObject& paintInvalidationContainer, const LayoutRect& dirtyRect, PaintInvalidationReason invalidationReason) const
 {
-    if (RuntimeEnabledFeatures::slimmingPaintSynchronizedPaintingEnabled())
-        return;
+    // TODO(wangxianzhu): Enable the following assert after paint invalidation for spv2 is ready.
+    // ASSERT(!RuntimeEnabledFeatures::slimmingPaintV2Enabled());
 
     if (paintInvalidationContainer.frameView()->shouldThrottleRendering())
         return;
 
     ASSERT(gDisablePaintInvalidationStateAsserts || document().lifecycle().state() == DocumentLifecycle::InPaintInvalidation);
 
     if (dirtyRect.isEmpty())
         return;
 
     RELEASE_ASSERT(isRooted());
@@ skipping 11 matching lines @@
     // painted, such as SVG images. 
     if (!paintInvalidationContainer.isPaintInvalidationContainer())
         invalidatePaintRectangleOnWindow(paintInvalidationContainer, enclosingIntRect(dirtyRect));
 
     if (paintInvalidationContainer.view()->usesCompositing() && paintInvalidationContainer.isPaintInvalidationContainer())
         paintInvalidationContainer.setBackingNeedsPaintInvalidationInRect(dirtyRect, invalidationReason);
 }
 
 void LayoutObject::invalidateDisplayItemClient(const DisplayItemClientWrapper& displayItemClient) const
 {
+    // TODO(wangxianzhu): Ensure correct bounds for the client will be or has been passed to PaintController. crbug.com/547119.
     // Not using enclosingCompositedContainer() directly because this object may be in an orphaned subtree.
     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, PaintInvalidationFull, invalidationRect, invalidationRect);
-
+            paintInvalidationLayer->layoutObject()->invalidateDisplayItemClientOnBacking(displayItemClient, PaintInvalidationFull, nullptr);
         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 LayoutRect* paintInvalidationRect) const
 { 
-    paintInvalidationContainer.invalidateDisplayItemClientOnBacking(*this, invalidationReason, previousPaintInvalidationRect, newPaintInvalidationRect);
+    paintInvalidationContainer.invalidateDisplayItemClientOnBacking(*this, invalidationReason, paintInvalidationRect);
 
     if (PaintLayer* enclosingLayer = this->enclosingLayer())
         enclosingLayer->setNeedsRepaint();
 }
 
 LayoutRect LayoutObject::boundsRectForPaintInvalidation(const LayoutBoxModelObject* paintInvalidationContainer, const PaintInvalidationState* paintInvalidationState) const
 {
     if (!paintInvalidationContainer)
         return computePaintInvalidationRect(paintInvalidationContainer, paintInvalidationState);
     return PaintLayer::computePaintInvalidationRect(this, paintInvalidationContainer->layer(), paintInvalidationState);
 }
 
-const LayoutBoxModelObject* LayoutObject::invalidatePaintRectangleInternal(LayoutRect& dirtyRect) const
+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 = containerForPaintInvalidationOnRootedTree();
-    PaintLayer::mapRectToPaintInvalidationBacking(this, &paintInvalidationContainer, dirtyRect);
-    invalidatePaintUsingContainer(paintInvalidationContainer, dirtyRect, PaintInvalidationRectangle);
+    LayoutRect dirtyRectOnBacking = dirtyRect;
+    PaintLayer::mapRectToPaintInvalidationBacking(this, &paintInvalidationContainer, dirtyRectOnBacking);
+    invalidatePaintUsingContainer(paintInvalidationContainer, dirtyRectOnBacking, PaintInvalidationRectangle);
     return &paintInvalidationContainer;
 }
 
 void LayoutObject::invalidatePaintRectangle(const LayoutRect& rect) const
 {
-    LayoutRect dirtyRect(rect);
-    const LayoutBoxModelObject* paintInvalidationContainer = invalidatePaintRectangleInternal(dirtyRect);
+    const LayoutBoxModelObject* paintInvalidationContainer = invalidatePaintRectangleInternal(rect);
     if (paintInvalidationContainer) {
-        invalidateDisplayItemClients(*paintInvalidationContainer, PaintInvalidationRectangle, dirtyRect, dirtyRect);
+        // Don't need to change the paint invalidation bounds of the client, so pass nullptr.
+        invalidateDisplayItemClients(*paintInvalidationContainer, PaintInvalidationRectangle, nullptr);
     }
 }
 
 void LayoutObject::invalidatePaintRectangleNotInvalidatingDisplayItemClients(const LayoutRect& r) const
 {
-    LayoutRect dirtyRect(r);
-    invalidatePaintRectangleInternal(dirtyRect);
+    invalidatePaintRectangleInternal(r);
 }
 
 void LayoutObject::invalidateTreeIfNeeded(PaintInvalidationState& paintInvalidationState)
 {
     ASSERT(!needsLayout());
 
     // If we didn't need paint invalidation then our children don't need as well.
     // Skip walking down the tree as everything should be fine below us.
     if (!shouldCheckForPaintInvalidation(paintInvalidationState))
         return;
@@ skipping 67 matching lines @@
     // 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());
         newSelectionRect.move(inverseOffset);
     }
 
     setPreviousSelectionRectForPaintInvalidation(newSelectionRect);
 
     if (shouldInvalidateSelection())
-        invalidateDisplayItemClients(paintInvalidationContainer, PaintInvalidationSelection, oldSelectionRect, newSelectionRect);
+        invalidateDisplayItemClients(paintInvalidationContainer, PaintInvalidationSelection, nullptr);
 
     if (fullInvalidation)
         return;
 
     fullyInvalidatePaint(paintInvalidationContainer, PaintInvalidationSelection, oldSelectionRect, newSelectionRect);
 }
 
 PaintInvalidationReason LayoutObject::invalidatePaintIfNeeded(PaintInvalidationState& paintInvalidationState, const LayoutBoxModelObject& paintInvalidationContainer)
 {
     LayoutView* v = view();
@@ skipping 37 matching lines @@
         invalidationReason = PaintInvalidationBackgroundObscurationChange;
     m_bitfields.setLastBoxDecorationBackgroundObscured(boxDecorationBackgroundObscured);
 
     if (invalidationReason == PaintInvalidationNone) {
         // TODO(trchen): Currently we don't keep track of paint offset of layout objects.
         // There are corner cases that the display items need to be invalidated for paint offset
         // mutation, but incurs no pixel difference (i.e. bounds stay the same) so no rect-based
         // 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, &newBounds);
 
         return invalidationReason;
     }
 
-    invalidateDisplayItemClients(paintInvalidationContainer, invalidationReason, oldBounds, newBounds);
+    invalidateDisplayItemClients(paintInvalidationContainer, invalidationReason, &newBounds);
 
     if (invalidationReason == PaintInvalidationIncremental) {
         incrementallyInvalidatePaint(paintInvalidationContainer, oldBounds, newBounds, newLocation);
         return invalidationReason;
     }
 
     fullyInvalidatePaint(paintInvalidationContainer, invalidationReason, oldBounds, newBounds);
 
     return invalidationReason;
 }
 
-void LayoutObject::invalidatePaintIfNeededForSynchronizedPainting(const PaintInfo& paintInfo)
-{
-    ASSERT(RuntimeEnabledFeatures::slimmingPaintSynchronizedPaintingEnabled());
-    ASSERT(document().lifecycle().state() == DocumentLifecycle::InPaint);
-    ASSERT(paintInfo.paintInvalidationState);
-    ASSERT(paintInfo.paintContainer());
-
-    PaintController& paintController = paintInfo.context->paintController();
-    if (paintController.clientHasCheckedPaintInvalidation(displayItemClient())) {
-        ASSERT(paintController.clientCacheIsValid(displayItemClient())
-            == (invalidatePaintIfNeeded(*paintInfo.paintInvalidationState, *paintInfo.paintContainer()) == PaintInvalidationNone));
-        return;
-    }
-
-    PaintInvalidationReason reason = invalidatePaintIfNeeded(*paintInfo.paintInvalidationState, *paintInfo.paintContainer());
-    clearPaintInvalidationState(*paintInfo.paintInvalidationState);
-
-    if (reason == PaintInvalidationDelayedFull)
-        paintInfo.paintInvalidationState->pushDelayedPaintInvalidationTarget(*this);
-
-    paintController.setClientHasCheckedPaintInvalidation(displayItemClient());
-}
-
 PaintInvalidationReason LayoutObject::paintInvalidationReason(const LayoutBoxModelObject& paintInvalidationContainer,
     const LayoutRect& oldBounds, const LayoutPoint& oldPositionFromPaintInvalidationBacking,
     const LayoutRect& newBounds, const LayoutPoint& newPositionFromPaintInvalidationBacking) const
 {
     // First check for InvalidationLocationChange to avoid it from being hidden by other
     // invalidation reasons because we'll need to force check for paint invalidation for
     // children when location of this object changed.
     if (newPositionFromPaintInvalidationBacking != oldPositionFromPaintInvalidationBacking)
         return PaintInvalidationLocationChange;
 
@@ skipping 1881 matching lines @@
         findNonCompositedDescendantLayerToTraverse(*descendant, functor);
         descendant = descendant->nextInPreOrderAfterChildren(&object);
     }
 }
 
 } // unnamed namespace
 
 void LayoutObject::invalidateDisplayItemClientForNonCompositingDescendantsOf(const LayoutObject& object) const
 {
     // Not using enclosingCompositedContainer() directly because this object may be in an orphaned subtree.
-    const PaintLayer* enclosingLayer = this->enclosingLayer();
+    PaintLayer* enclosingLayer = this->enclosingLayer();
     if (!enclosingLayer)
         return;
 
+    // TODO(wangxianzhu): This is a workaround for invalidation of detached custom scrollbar parts which can't find
+    // their own enclosing layers. May remove this when fixing crbug.com/547119 for scrollbars.
+    enclosingLayer->setNeedsRepaint();

[chrishtr, 2015/10/23 19:57:49]

If they can't find their layers, how can they call a function which finds the
enclosing layer? What's the call stack?

[Xianzhu, 2015/10/23 20:56:53]

Here the |this| object is the LayoutBox containing the custom scrollbars. The
LayoutBox can find its containingLayer. Normally we should expect the
descendants call enclosingLayer->setNeedsRepaint() when they are traversed and
call their invalidateDisplayItemClients(), but a custom scrollbar part can't
find its enclosingLayer.

This is also why we had
invalidateDisplayItemClientForNonCompositingDescendants*Of*() which lets an
object in the layout tree (|this|) to invalidate some object not in the layout
tree (|object|) but painted onto the same backing.

[chrishtr, 2015/10/23 20:59:45]

How is the containing LayoutBox getting called into if the scrollbar can't find
its inclosing layer?

[Xianzhu, 2015/10/23 21:28:22]

I should have included the following in the previous reply:

The function is called from:
- PaintLayerScrollableArea::invalidateScrollCornerRect():
  
box().invalidateDisplayItemClientForNonCompositingDescendantsOf(*m_scrollCorner);
   box().invalidateDisplayItemClientForNonCompositingDescendantsOf(*m_resizer);
- LayoutScrollbar::invalidateRect()
  
owningLayoutObject()->invalidateDisplayItemClientForNonCompositingDescendantsOf(*part.value)

LayoutObject::enclosingLayer() doesn't work for scrollbar parts which are not in
the layout tree, but they have other ways to find their containing box. I ever
filed crbug.com/484263 about whether we can hookup scrollbar parts into the
layout tree to avoid such complications.
 

+
     // This is valid because we want to invalidate the client in the display item list of the current backing.
     DisableCompositingQueryAsserts disabler;
     const PaintLayer* paintInvalidationLayer = enclosingLayer->enclosingLayerForPaintInvalidationCrossingFrameBoundaries();
     if (!paintInvalidationLayer)
         return;
 
     class Functor : public LayoutObjectTraversalFunctor {
     public:
         explicit Functor(const LayoutBoxModelObject& paintInvalidationContainer) : m_paintInvalidationContainer(paintInvalidationContainer) { }
         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);
+            // TODO(wangxianzhu): Ensure correct bounds for the client will be or has been passed to PaintController. crbug.com/547119.
+            object.invalidateDisplayItemClients(m_paintInvalidationContainer, PaintInvalidationFull, nullptr);
         }
     private:
         const LayoutBoxModelObject& m_paintInvalidationContainer;
     };
 
     const LayoutBoxModelObject& paintInvalidationContainer = *paintInvalidationLayer->layoutObject();
     traverseNonCompositingDescendants(const_cast<LayoutObject&>(object), Functor(paintInvalidationContainer));
 }
 
 void LayoutObject::invalidatePaintOfPreviousPaintInvalidationRect(const LayoutBoxModelObject& paintInvalidationContainer, PaintInvalidationReason reason) const
 {
     // These disablers are valid because we want to use the current compositing/invalidation status.
     DisablePaintInvalidationStateAsserts invalidationDisabler;
     DisableCompositingQueryAsserts compositingDisabler;
 
     LayoutRect invalidationRect = previousPaintInvalidationRect();
     adjustInvalidationRectForCompositedScrolling(invalidationRect, paintInvalidationContainer);
     invalidatePaintUsingContainer(paintInvalidationContainer, invalidationRect, PaintInvalidationLayer);
-    invalidateDisplayItemClients(paintInvalidationContainer, PaintInvalidationLayer, invalidationRect, invalidationRect);
+
+    // The PaintController may have changed. Pass the previous paint invalidation rect to the new PaintController.
+    // The rect will be updated if it changes during the next paint invalidation.
+    invalidateDisplayItemClients(paintInvalidationContainer, PaintInvalidationLayer, &invalidationRect);
 }
 
 void LayoutObject::invalidatePaintIncludingNonCompositingDescendants()
 {
     class Functor : public LayoutObjectTraversalFunctor {
     public:
         explicit Functor(const LayoutBoxModelObject& paintInvalidationContainer) : m_paintInvalidationContainer(paintInvalidationContainer) { }
         void operator()(LayoutObject& object) const override
         {
             object.invalidatePaintOfPreviousPaintInvalidationRect(m_paintInvalidationContainer, PaintInvalidationLayer);
@@ skipping 95 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