Set paintingLayerNeedsRepaint() in layout tree

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 1212 matching lines @@
 
     // This conditional handles situations where non-rooted (and hence non-composited) frames are
     // painted, such as SVG images.
     if (!paintInvalidationContainer.isPaintInvalidationContainer())
         invalidatePaintRectangleOnWindow(paintInvalidationContainer, enclosingIntRect(dirtyRect));
 
     if (paintInvalidationContainer.view()->usesCompositing() && paintInvalidationContainer.isPaintInvalidationContainer())
         paintInvalidationContainer.setBackingNeedsPaintInvalidationInRect(dirtyRect, invalidationReason, *this);
 }
 
-void LayoutObject::invalidateDisplayItemClient(const DisplayItemClient& displayItemClient) const
+void LayoutObject::invalidateDisplayItemClient(const DisplayItemClient& displayItemClient)
 {
+    setPaintingLayerNeedsRepaint();
+
+    // TODO(wangxianzhu): Let FrameView instead of the paint invalidation container track object paint invalidations.
+#if !DCHECK_IS_ON()
+    // This is a fast path when we don't need to inform the GraphicsLayer about this paint invalidation.
+    FrameView* frameView = this->frameView();
+    if (!frameView || !frameView->isTrackingPaintInvalidations()) {
+        displayItemClient.setDisplayItemsUncached();
+        return;
+    }
+#endif
+
     if (PaintLayer* paintingLayer = this->paintingLayer()) {
-        paintingLayer->setNeedsRepaint();
-
-#if !ENABLE(ASSERT)
-        // This is a fast path when we don't need to inform the GraphicsLayer about this paint invalidation.
-        FrameView* frameView = this->frameView();
-        if (!frameView || !frameView->isTrackingPaintInvalidations()) {
-            displayItemClient.setDisplayItemsUncached();
-            return;
-        }
-#endif
         // This is valid because we want to invalidate the client in the display item list of the current backing.
         DisableCompositingQueryAsserts disabler;
         if (const PaintLayer* paintInvalidationLayer = paintingLayer->enclosingLayerForPaintInvalidationCrossingFrameBoundaries())
             paintInvalidationLayer->layoutObject()->invalidateDisplayItemClientOnBacking(displayItemClient, PaintInvalidationFull);
     }
 }
 
-void LayoutObject::setPaintingLayerNeedsRepaint() const
+void LayoutObject::setPaintingLayerNeedsRepaint()
 {
-    if (PaintLayer* paintingLayer = this->paintingLayer())
-        paintingLayer->setNeedsRepaint();
+    m_bitfields.setPaintingLayerNeedsRepaint(true);
+    markAncestorsForPaintInvalidation();
 }
 
-void LayoutObject::invalidateDisplayItemClients(const LayoutBoxModelObject& paintInvalidationContainer, PaintInvalidationReason invalidationReason) const
+void LayoutObject::invalidateDisplayItemClients(const LayoutBoxModelObject& paintInvalidationContainer, PaintInvalidationReason invalidationReason)
 {
-    // It's caller's responsibility to ensure enclosingSelfPaintingLayer's needsRepaint is set.
-    // Don't set the flag here because getting enclosingSelfPaintLayer has cost and the caller can use
-    // various ways (e.g. PaintInvalidatinState::enclosingSelfPaintingLayer()) to reduce the cost.
-    ASSERT(!paintingLayer() || paintingLayer()->needsRepaint());
+    setPaintingLayerNeedsRepaint();
     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
+void LayoutObject::invalidatePaintRectangle(const LayoutRect& dirtyRect)
 {
     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 = 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);
-}
-
-void LayoutObject::invalidatePaintRectangleNotInvalidatingDisplayItemClients(const LayoutRect& r) const
-{
-    invalidatePaintRectangleInternal(r);
+    invalidateDisplayItemClients(paintInvalidationContainer, PaintInvalidationRectangle);
 }
 
 void LayoutObject::invalidateTreeIfNeeded(const 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;
 
     PaintInvalidationState newPaintInvalidationState(paintInvalidationState, *this);
 
     if (mayNeedPaintInvalidationSubtree())
         newPaintInvalidationState.setForceSubtreeInvalidationCheckingWithinContainer();
 
     PaintInvalidationReason reason = invalidatePaintIfNeeded(newPaintInvalidationState);
-    clearPaintInvalidationFlags(newPaintInvalidationState);
-
     newPaintInvalidationState.updateForChildren(reason);
     invalidatePaintOfSubtreesIfNeeded(newPaintInvalidationState);
+    clearPaintInvalidationFlags(newPaintInvalidationState);
 }
 
 void LayoutObject::invalidatePaintOfSubtreesIfNeeded(const PaintInvalidationState& childPaintInvalidationState)
 {
     for (LayoutObject* child = slowFirstChild(); child; child = child->nextSibling()) {
         // Column spanners are invalidated through their placeholders.
         // See LayoutMultiColumnSpannerPlaceholder::invalidatePaintOfSubtreesIfNeeded().
         if (child->isColumnSpanAll())
             continue;
         child->invalidateTreeIfNeeded(childPaintInvalidationState);
@@ skipping 61 matching lines @@
             newSelectionRect.move(inverseOffset);
         }
     }
 
     setPreviousSelectionRectForPaintInvalidation(newSelectionRect);
 
     // TODO(wangxianzhu): Combine the following two conditions when removing LayoutView::doingFullPaintInvalidation().
     if (!fullInvalidation)
         fullyInvalidatePaint(paintInvalidationContainer, PaintInvalidationSelection, oldSelectionRect, newSelectionRect);
     if (shouldInvalidateSelection())
-        invalidateDisplayItemClientsWithPaintInvalidationState(paintInvalidationContainer, paintInvalidationState, PaintInvalidationSelection);
+        invalidateDisplayItemClients(paintInvalidationContainer, PaintInvalidationSelection);
 }
 
 PaintInvalidationReason LayoutObject::invalidatePaintIfNeeded(const PaintInvalidationState& paintInvalidationState)
 {
     ASSERT(&paintInvalidationState.currentObject() == this);
 
     if (styleRef().hasOutline()) {
         PaintLayer& layer = paintInvalidationState.paintingLayer();
         if (layer.layoutObject() != this)
             layer.setNeedsPaintPhaseDescendantOutlines();
@@ skipping 43 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::slimmingPaintInvalidationEnabled() && paintInvalidationState.forcedSubtreeInvalidationCheckingWithinContainer())
-            invalidateDisplayItemClientsWithPaintInvalidationState(paintInvalidationContainer, paintInvalidationState, invalidationReason);
+            invalidateDisplayItemClients(paintInvalidationContainer, invalidationReason);
 
         return invalidationReason;
     }
 
     if (invalidationReason == PaintInvalidationIncremental)
         incrementallyInvalidatePaint(paintInvalidationContainer, oldBounds, newBounds, newLocation);
     else
         fullyInvalidatePaint(paintInvalidationContainer, invalidationReason, oldBounds, newBounds);
 
-    invalidateDisplayItemClientsWithPaintInvalidationState(paintInvalidationContainer, paintInvalidationState, invalidationReason);
+    invalidateDisplayItemClients(paintInvalidationContainer, invalidationReason);
     return invalidationReason;
 }
 
 PaintInvalidationReason LayoutObject::getPaintInvalidationReason(const PaintInvalidationState& paintInvalidationState,
     const LayoutRect& oldBounds, const LayoutPoint& oldPositionFromPaintInvalidationBacking,
     const LayoutRect& newBounds, const LayoutPoint& newPositionFromPaintInvalidationBacking) const
 {
     if (paintInvalidationState.forcedSubtreeFullInvalidationWithinContainer())
         return PaintInvalidationSubtree;
 
@@ skipping 1971 matching lines @@
 void LayoutObject::setMayNeedPaintInvalidationSubtree()
 {
     if (mayNeedPaintInvalidationSubtree())
         return;
     m_bitfields.setMayNeedPaintInvalidationSubtree(true);
     setMayNeedPaintInvalidation();
 }
 
 void LayoutObject::clearPaintInvalidationFlags(const PaintInvalidationState& paintInvalidationState)
 {
-    // paintInvalidationStateIsDirty should be kept in sync with the
+    // paintInvalidationFlagsAreDirty should be kept in sync with the
     // booleans that are cleared below.
-    ASSERT(!shouldCheckForPaintInvalidationRegardlessOfPaintInvalidationState() || paintInvalidationStateIsDirty());
+#if DCHECK_IS_ON()
+    DCHECK(!shouldCheckForPaintInvalidationRegardlessOfPaintInvalidationState() || paintInvalidationFlagsAreDirty());
+#endif
+
     clearShouldDoFullPaintInvalidation();
     m_bitfields.setChildShouldCheckForPaintInvalidation(false);
     m_bitfields.setNeededLayoutBecauseOfChildren(false);
     m_bitfields.setShouldInvalidateOverflowForPaint(false);
     m_bitfields.setMayNeedPaintInvalidation(false);
     m_bitfields.setMayNeedPaintInvalidationSubtree(false);
     m_bitfields.setShouldInvalidateSelection(false);
+
+    if (m_bitfields.paintingLayerNeedsRepaint()) {
+        paintInvalidationState.paintingLayer().setNeedsRepaint();
+        m_bitfields.setPaintingLayerNeedsRepaint(false);
+    }
+
+#if DCHECK_IS_ON()
+    DCHECK(!paintInvalidationFlagsAreDirty());
+#endif
 }
 
 bool LayoutObject::isAllowedToModifyLayoutTreeStructure(Document& document)
 {
     return DeprecatedDisableModifyLayoutTreeStructureAsserts::canModifyLayoutTreeStateInAnyState()
         || document.lifecycle().stateAllowsLayoutTreeMutations();
 }
 
 DeprecatedDisableModifyLayoutTreeStructureAsserts::DeprecatedDisableModifyLayoutTreeStructureAsserts()
     : m_disabler(gModifyLayoutTreeStructureAnyState, true)
@@ skipping 65 matching lines @@
 
         // If a paint invalidation container is not a stacking context,
         // some of its descendants may belong to the parent container.
         findNonCompositedDescendantLayerToTraverse(*descendant, functor);
         descendant = descendant->nextInPreOrderAfterChildren(&object);
     }
 }
 
 } // unnamed namespace
 
-void LayoutObject::invalidateDisplayItemClientsIncludingNonCompositingDescendants(const LayoutBoxModelObject* paintInvalidationContainer, PaintInvalidationReason paintInvalidationReason) const
+void LayoutObject::invalidateDisplayItemClientsIncludingNonCompositingDescendants(const LayoutBoxModelObject* paintInvalidationContainer, PaintInvalidationReason paintInvalidationReason)
 {
     // This is valid because we want to invalidate the client in the display item list of the current backing.
     DisableCompositingQueryAsserts disabler;
     if (!paintInvalidationContainer) {
         paintInvalidationContainer = enclosingCompositedContainer();
         if (!paintInvalidationContainer)
             return;
     }
 
     traverseNonCompositingDescendants(const_cast<LayoutObject&>(*this), [&paintInvalidationContainer, paintInvalidationReason](LayoutObject& object) {
-        if (object.hasLayer())
-            toLayoutBoxModelObject(object).layer()->setNeedsRepaint();
         object.invalidateDisplayItemClients(*paintInvalidationContainer, paintInvalidationReason);
     });
 }
 
 void LayoutObject::invalidatePaintOfPreviousPaintInvalidationRect(const LayoutBoxModelObject& paintInvalidationContainer, PaintInvalidationReason reason)
 {
-    // It's caller's responsibility to ensure enclosingSelfPaintingLayer's needsRepaint is set.
-    // Don't set the flag here because getting enclosingSelfPaintLayer has cost and the caller can use
-    // various ways (e.g. PaintInvalidatinState::enclosingSelfPaintingLayer()) to reduce the cost.
-    ASSERT(!paintingLayer() || paintingLayer()->needsRepaint());
-
     // These disablers are valid because we want to use the current compositing/invalidation status.
     DisablePaintInvalidationStateAsserts invalidationDisabler;
     DisableCompositingQueryAsserts compositingDisabler;
 
     LayoutRect invalidationRect = previousPaintInvalidationRect();
     invalidatePaintUsingContainer(paintInvalidationContainer, invalidationRect, reason);
     invalidateDisplayItemClients(paintInvalidationContainer, reason);
 
     // This method may be used to invalidate paint of an object changing paint invalidation container.
     // Clear previous paint invalidation rect on the original paint invalidation container to avoid
     // under-invalidation if the new paint invalidation rect on the new paint invalidation container
     // happens to be the same as the old one.
     clearPreviousPaintInvalidationRects();
 }
 
 void LayoutObject::invalidatePaintIncludingNonCompositingDescendants()
 {
     // Since we're only painting non-composited layers, we know that they all share the same paintInvalidationContainer.
     const LayoutBoxModelObject& paintInvalidationContainer = containerForPaintInvalidation();
     traverseNonCompositingDescendants(*this, [&paintInvalidationContainer](LayoutObject& object) {
-        if (object.hasLayer())
-            toLayoutBoxModelObject(object).layer()->setNeedsRepaint();
         object.invalidatePaintOfPreviousPaintInvalidationRect(paintInvalidationContainer, PaintInvalidationSubtree);
     });
 }
 
 void LayoutObject::setShouldDoFullPaintInvalidationIncludingNonCompositingDescendants()
 {
     // Clear first because PaintInvalidationSubtree overrides other full paint invalidation reasons.
     clearShouldDoFullPaintInvalidation();
     setShouldDoFullPaintInvalidation(PaintInvalidationSubtree);
 }
 
-void LayoutObject::invalidatePaintIncludingNonSelfPaintingLayerDescendantsInternal(const LayoutBoxModelObject& paintInvalidationContainer)
-{
-    invalidatePaintOfPreviousPaintInvalidationRect(paintInvalidationContainer, PaintInvalidationSubtree);
-    for (LayoutObject* child = slowFirstChild(); child; child = child->nextSibling()) {
-        if (child->hasLayer())
-            toLayoutBoxModelObject(child)->layer()->setNeedsRepaint();
-        if (!child->hasLayer() || !toLayoutBoxModelObject(child)->layer()->isSelfPaintingLayer())
-            child->invalidatePaintIncludingNonSelfPaintingLayerDescendantsInternal(paintInvalidationContainer);
-    }
-}
-
 void LayoutObject::invalidatePaintIncludingNonSelfPaintingLayerDescendants(const LayoutBoxModelObject& paintInvalidationContainer)
 {
-    setPaintingLayerNeedsRepaint();
-    invalidatePaintIncludingNonSelfPaintingLayerDescendantsInternal(paintInvalidationContainer);
+    invalidatePaintOfPreviousPaintInvalidationRect(paintInvalidationContainer, PaintInvalidationSubtree);
+    for (LayoutObject* child = slowFirstChild(); child; child = child->nextSibling()) {
+        if (!child->hasLayer() || !toLayoutBoxModelObject(child)->layer()->isSelfPaintingLayer())
+            child->invalidatePaintIncludingNonSelfPaintingLayerDescendants(paintInvalidationContainer);
+    }
 }
 
 void LayoutObject::setIsBackgroundAttachmentFixedObject(bool isBackgroundAttachmentFixedObject)
 {
     ASSERT(frameView());
     if (m_bitfields.isBackgroundAttachmentFixedObject() == isBackgroundAttachmentFixedObject)
         return;
     m_bitfields.setIsBackgroundAttachmentFixedObject(isBackgroundAttachmentFixedObject);
     if (isBackgroundAttachmentFixedObject)
         frameView()->addBackgroundAttachmentFixedObject(this);
@@ skipping 54 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