Improve handling of PaintInvalidationLayer (renamed to PaintInvalidationSubtree)

third_party/WebKit/Source/core/layout/PaintInvalidationState.cpp

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/layout/PaintInvalidationState.h"
 
 #include "core/frame/FrameView.h"
 #include "core/frame/Settings.h"
 #include "core/layout/LayoutInline.h"
 #include "core/layout/LayoutPart.h"
@@ skipping 11 matching lines @@
         && !object.hasReflection()
         && !object.hasFilterInducingProperty()
         && !object.isLayoutFlowThread()
         && !object.isLayoutMultiColumnSpannerPlaceholder()
         && !object.styleRef().isFlippedBlocksWritingMode()
         && !(object.isLayoutBlock() && object.isSVG());
 }
 
 PaintInvalidationState::PaintInvalidationState(const LayoutView& layoutView, Vector<LayoutObject*>& pendingDelayedPaintInvalidations)
     : m_currentObject(layoutView)
-    , m_forcedSubtreeInvalidationWithinContainer(false)
-    , m_forcedSubtreeInvalidationRectUpdateWithinContainer(false)
+    , m_forcedSubtreeInvalidationFlags(0)
     , m_clipped(false)
     , m_clippedForAbsolutePosition(false)
     , m_cachedOffsetsEnabled(true)
     , m_cachedOffsetsForAbsolutePositionEnabled(true)
     , m_paintInvalidationContainer(&layoutView.containerForPaintInvalidation())
     , m_paintInvalidationContainerForStackedContents(m_paintInvalidationContainer)
     , m_containerForAbsolutePosition(layoutView)
     , m_pendingDelayedPaintInvalidations(pendingDelayedPaintInvalidations)
     , m_enclosingSelfPaintingLayer(*layoutView.layer())
 #if ENABLE(ASSERT)
     , m_didUpdateForChildren(false)
 #endif
 #ifdef CHECK_FAST_PATH_SLOW_PATH_EQUALITY
     , m_canCheckFastPathSlowPathEquality(layoutView == m_paintInvalidationContainer)
 #endif
 {
     if (!supportsCachedOffsets(layoutView)) {
         m_cachedOffsetsEnabled = false;
         return;
     }
 
     FloatPoint point = layoutView.localToAncestorPoint(FloatPoint(), m_paintInvalidationContainer, TraverseDocumentBoundaries | InputIsInFrameCoordinates);
     m_paintOffset = LayoutSize(point.x(), point.y());
     m_paintOffsetForAbsolutePosition = m_paintOffset;
 }
 
 PaintInvalidationState::PaintInvalidationState(const PaintInvalidationState& parentState, const LayoutObject& currentObject)
     : m_currentObject(currentObject)
-    , m_forcedSubtreeInvalidationWithinContainer(parentState.m_forcedSubtreeInvalidationWithinContainer)
-    , m_forcedSubtreeInvalidationRectUpdateWithinContainer(parentState.m_forcedSubtreeInvalidationRectUpdateWithinContainer)
+    , m_forcedSubtreeInvalidationFlags(parentState.m_forcedSubtreeInvalidationFlags)
     , m_clipped(parentState.m_clipped)
     , m_clippedForAbsolutePosition(parentState.m_clippedForAbsolutePosition)
     , m_clipRect(parentState.m_clipRect)
     , m_clipRectForAbsolutePosition(parentState.m_clipRectForAbsolutePosition)
     , m_paintOffset(parentState.m_paintOffset)
     , m_paintOffsetForAbsolutePosition(parentState.m_paintOffsetForAbsolutePosition)
     , m_cachedOffsetsEnabled(parentState.m_cachedOffsetsEnabled)
     , m_cachedOffsetsForAbsolutePositionEnabled(parentState.m_cachedOffsetsForAbsolutePositionEnabled)
     , m_paintInvalidationContainer(parentState.m_paintInvalidationContainer)
     , m_paintInvalidationContainerForStackedContents(parentState.m_paintInvalidationContainerForStackedContents)
@@ skipping 36 matching lines @@
         // The current object is stacked, so we should use m_paintInvalidationContainerForStackedContents as its
         // paint invalidation container on which the current object is painted.
         m_paintInvalidationContainer = m_paintInvalidationContainerForStackedContents;
         // We are changing paintInvalidationContainer to m_paintInvalidationContainerForStackedContents. Must disable
         // cached offsets because we didn't track paint offset from m_paintInvalidationContainerForStackedContents.
         // TODO(wangxianzhu): There are optimization opportunities:
         // - Like what we do for fixed-position, calculate the paint offset in slow path and enable fast path for
         //   descendants if possible; or
         // - Track offset between the two paintInvalidationContainers.
         m_cachedOffsetsEnabled = false;
+        if (m_forcedSubtreeInvalidationFlags & FullInvalidationForStackedContents)

[chrishtr, 2016/05/09 22:20:42]

Where was this logic previously?

[Xianzhu, 2016/05/10 17:17:12]

It was in traverseNonCompositingDescendants() called from
LayoutObject::setShouldDoFullPaintInvalidationIncludingNonCompositingDescendants().
It's for the following case (the same case in which we are required to track two
paint invalidation containers):

  <paint invalidation container of stacked contents>
    <paint invalidation container of normal contents>
      <stacked content>

This ensures that the stacked contents whose paint invalidaiton container is not
the nearest isPaintInvalidationContainer ancestor in the layout tree are
invalidated.

Links to old code:
(the call site)
https://codereview.chromium.org/1950573003/diff/100001/third_party/WebKit/Sou...

(the traversal)
https://codereview.chromium.org/1950573003/diff/100001/third_party/WebKit/Sou...

+            m_forcedSubtreeInvalidationFlags |= FullInvalidation;
     }
 
     if (!currentObject.isBoxModelObject() && !currentObject.isSVG())
         return;
 
     if (m_cachedOffsetsEnabled || currentObject == m_paintInvalidationContainer)
         m_cachedOffsetsEnabled = supportsCachedOffsets(currentObject);
 
     if (currentObject.isSVG()) {
         if (currentObject.isSVGRoot()) {
             m_svgTransform = toLayoutSVGRoot(currentObject).localToBorderBoxTransform();
             // Don't early return here, because the SVGRoot object needs to execute the later code
             // as a normal LayoutBox.
         } else {
             ASSERT(currentObject != m_paintInvalidationContainer);
             m_svgTransform *= currentObject.localToSVGParentTransform();
             return;
         }
     }
 
     if (currentObject == m_paintInvalidationContainer) {
         // When we hit a new paint invalidation container, we don't need to
         // continue forcing a check for paint invalidation, since we're
         // descending into a different invalidation container. (For instance if
         // our parents were moved, the entire container will just move.)
-        m_forcedSubtreeInvalidationWithinContainer = false;
-        m_forcedSubtreeInvalidationRectUpdateWithinContainer = false;
-
-        if (currentObject == m_paintInvalidationContainerForStackedContents
-            && currentObject != m_containerForAbsolutePosition
-            && m_cachedOffsetsForAbsolutePositionEnabled
-            && m_cachedOffsetsEnabled) {
-            // The current object is the new paintInvalidationContainer for absolute-position descendants but is not their container.
-            // Call updateForCurrentObject() before resetting m_paintOffset to get paint offset of the current object
-            // from the original paintInvalidationContainerForStackingContents, then use this paint offset to adjust
-            // m_paintOffsetForAbsolutePosition.
-            updateForCurrentObject(parentState);
-            m_paintOffsetForAbsolutePosition -= m_paintOffset;
-            if (m_clippedForAbsolutePosition)
-                m_clipRectForAbsolutePosition.move(-m_paintOffset);
+        // However, we need to keep the FullInvalidationForStackedContents flag
+        // if the current object isn't the paint invalidation container of
+        // stacked contents.
+        if (currentObject != m_paintInvalidationContainerForStackedContents) {
+            m_forcedSubtreeInvalidationFlags &= FullInvalidationForStackedContents;
+        } else {
+            m_forcedSubtreeInvalidationFlags = 0;
+            if (currentObject != m_containerForAbsolutePosition
+                && m_cachedOffsetsForAbsolutePositionEnabled
+                && m_cachedOffsetsEnabled) {
+                // The current object is the new paintInvalidationContainer for absolute-position descendants but is not their container.
+                // Call updateForCurrentObject() before resetting m_paintOffset to get paint offset of the current object
+                // from the original paintInvalidationContainerForStackingContents, then use this paint offset to adjust
+                // m_paintOffsetForAbsolutePosition.
+                updateForCurrentObject(parentState);
+                m_paintOffsetForAbsolutePosition -= m_paintOffset;
+                if (m_clippedForAbsolutePosition)
+                    m_clipRectForAbsolutePosition.move(-m_paintOffset);
+            }
         }
 
         m_clipped = false; // Will be updated in updateForChildren().
         m_paintOffset = LayoutSize();
 #ifdef CHECK_FAST_PATH_SLOW_PATH_EQUALITY
         m_canCheckFastPathSlowPathEquality = true;
 #endif
         return;
     }
 
@@ skipping 52 matching lines @@
             m_paintOffset += toLayoutInline(container).offsetForInFlowPositionedInline(toLayoutBox(m_currentObject));
     }
 
     if (m_currentObject.isBox())
         m_paintOffset += toLayoutBox(m_currentObject).locationOffset();
 
     if (m_currentObject.isInFlowPositioned() && m_currentObject.hasLayer())
         m_paintOffset += toLayoutBoxModelObject(m_currentObject).layer()->offsetForInFlowPosition();
 }
 
-void PaintInvalidationState::updateForChildren()
+void PaintInvalidationState::updateForChildren(PaintInvalidationReason reason)
 {
 #if ENABLE(ASSERT)
     ASSERT(!m_didUpdateForChildren);
     m_didUpdateForChildren = true;
 #endif
 
+    switch (reason) {
+    case PaintInvalidationDelayedFull:
+        pushDelayedPaintInvalidationTarget(const_cast<LayoutObject&>(m_currentObject));
+        break;
+    case PaintInvalidationSubtree:
+        m_forcedSubtreeInvalidationFlags |= (FullInvalidation | FullInvalidationForStackedContents);
+        break;
+    case PaintInvalidationSVGResourceChange:
+        setForceSubtreeInvalidationCheckingWithinContainer();
+        break;
+    default:
+        break;
+    }
+
     updateForNormalChildren();
 
     if (m_currentObject == m_containerForAbsolutePosition) {
         if (m_paintInvalidationContainer == m_paintInvalidationContainerForStackedContents) {
             m_cachedOffsetsForAbsolutePositionEnabled = m_cachedOffsetsEnabled;
             if (m_cachedOffsetsEnabled) {
                 m_paintOffsetForAbsolutePosition = m_paintOffset;
                 m_clippedForAbsolutePosition = m_clipped;
                 m_clipRectForAbsolutePosition = m_clipRect;
             }
@@ skipping 220 matching lines @@
     WTFLogAlways("Fast path paint invalidation rect differs from slow path: fast: %s vs slow: %s",
         fastPathRect.toString().ascii().data(), slowPathRect.toString().ascii().data());
     showLayoutTree(&m_currentObject);
 
     ASSERT_NOT_REACHED();
 }
 
 #endif // CHECK_FAST_PATH_SLOW_PATH_EQUALITY
 
 } // namespace blink