Reland of Skip PaintLayer empty paint phases if it previously painted nothing

third_party/WebKit/Source/core/paint/PaintLayerPainter.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/paint/PaintLayerPainter.h"
 
 #include "core/frame/LocalFrame.h"
 #include "core/layout/LayoutInline.h"
 #include "core/layout/LayoutView.h"
 #include "core/paint/ClipPathClipper.h"
@@ skipping 132 matching lines @@
 
     // When in FOUC-avoidance mode, don't cache any subsequences, to avoid having
     // to invalidate all of them when leaving this mode. There is an early-out in BlockPainter::paintContents that may result
     // in nothing getting painted in thos mode, in addition to early-out logic in PaintLayerPainter.
     if (paintLayer.layoutObject()->document().didLayoutWithPendingStylesheets())
         return false;
 
     return true;
 }
 
-static bool shouldRepaintSubsequence(PaintLayer& paintLayer, const PaintLayerPaintingInfo& paintingInfo, ShouldRespectOverflowClipType respectOverflowClip, const LayoutSize& subpixelAccumulation)
+static bool shouldRepaintSubsequence(PaintLayer& paintLayer, const PaintLayerPaintingInfo& paintingInfo, ShouldRespectOverflowClipType respectOverflowClip, const LayoutSize& subpixelAccumulation, bool& shouldClearEmptyPaintPhaseFlags)
 {
     bool needsRepaint = false;
 
+    // We should set shouldResetEmptyPaintPhaseFlags if some previously unpainted objects may begin
+    // to be painted, causing a previously empty paint phase to become non-empty.
+
     // Repaint subsequence if the layer is marked for needing repaint.
+    // We don't set needsResetEmptyPaintPhase here, but clear the empty paint phase flags
+    // in PaintLayer::setNeedsPaintPhaseXXX(), to ensure that we won't clear
+    // previousPaintPhaseXXXEmpty flags when unrelated things changed which won't
+    // cause the paint phases to become non-empty.
     if (paintLayer.needsRepaint())
         needsRepaint = true;
 
     // Repaint if layer's clip changes.
     ClipRects& clipRects = paintLayer.clipper().paintingClipRects(paintingInfo.rootLayer, respectOverflowClip, subpixelAccumulation);
     ClipRects* previousClipRects = paintLayer.previousPaintingClipRects();
-    if (!needsRepaint && &clipRects != previousClipRects && (!previousClipRects || clipRects != *previousClipRects))
+    if (&clipRects != previousClipRects && (!previousClipRects || clipRects != *previousClipRects)) {
         needsRepaint = true;
+        shouldClearEmptyPaintPhaseFlags = true;
+    }
     paintLayer.setPreviousPaintingClipRects(clipRects);
 
     // Repaint if previously the layer might be clipped by paintDirtyRect and paintDirtyRect changes.
-    if (!needsRepaint && paintLayer.previousPaintResult() == PaintLayerPainter::MayBeClippedByPaintDirtyRect && paintLayer.previousPaintDirtyRect() != paintingInfo.paintDirtyRect)
+    if (paintLayer.previousPaintResult() == PaintLayerPainter::MayBeClippedByPaintDirtyRect && paintLayer.previousPaintDirtyRect() != paintingInfo.paintDirtyRect) {
         needsRepaint = true;
+        shouldClearEmptyPaintPhaseFlags = true;
+    }
     paintLayer.setPreviousPaintDirtyRect(paintingInfo.paintDirtyRect);
 
     // Repaint if scroll offset accumulation changes.
-    if (!needsRepaint && paintingInfo.scrollOffsetAccumulation != paintLayer.previousScrollOffsetAccumulationForPainting())
+    if (paintingInfo.scrollOffsetAccumulation != paintLayer.previousScrollOffsetAccumulationForPainting()) {
         needsRepaint = true;
+        shouldClearEmptyPaintPhaseFlags = true;
+    }
     paintLayer.setPreviousScrollOffsetAccumulationForPainting(paintingInfo.scrollOffsetAccumulation);
 
     return needsRepaint;
 }
 
 PaintLayerPainter::PaintResult PaintLayerPainter::paintLayerContents(GraphicsContext& context, const PaintLayerPaintingInfo& paintingInfoArg, PaintLayerFlags paintFlags, FragmentPolicy fragmentPolicy)
 {
     ASSERT(m_paintLayer.isSelfPaintingLayer() || m_paintLayer.hasSelfPaintingLayerDescendant());
     ASSERT(!(paintFlags & PaintLayerAppliedTransform));
 
@@ skipping 23 matching lines @@
     if (m_paintLayer.layoutObject()->view()->frame() && m_paintLayer.layoutObject()->view()->frame()->shouldThrottleRendering())
         return result;
 
     // Ensure our lists are up to date.
     m_paintLayer.stackingNode()->updateLayerListsIfNeeded();
 
     LayoutSize subpixelAccumulation = m_paintLayer.compositingState() == PaintsIntoOwnBacking ? m_paintLayer.subpixelAccumulation() : paintingInfoArg.subPixelAccumulation;
     ShouldRespectOverflowClipType respectOverflowClip = shouldRespectOverflowClip(paintFlags, m_paintLayer.layoutObject());
 
     Optional<SubsequenceRecorder> subsequenceRecorder;
+    bool shouldClearEmptyPaintPhaseFlags = false;
     if (shouldCreateSubsequence(m_paintLayer, context, paintingInfoArg, paintFlags)) {
-        if (!shouldRepaintSubsequence(m_paintLayer, paintingInfoArg, respectOverflowClip, subpixelAccumulation)
+        if (!shouldRepaintSubsequence(m_paintLayer, paintingInfoArg, respectOverflowClip, subpixelAccumulation, shouldClearEmptyPaintPhaseFlags)
             && SubsequenceRecorder::useCachedSubsequenceIfPossible(context, m_paintLayer))
             return result;
         subsequenceRecorder.emplace(context, m_paintLayer);
+    } else {
+        shouldClearEmptyPaintPhaseFlags = true;
+    }
+
+    if (shouldClearEmptyPaintPhaseFlags) {
+        m_paintLayer.setPreviousPaintPhaseDescendantOutlinesEmpty(false);
+        m_paintLayer.setPreviousPaintPhaseFloatEmpty(false);
+        m_paintLayer.setPreviousPaintPhaseDescendantBlockBackgroundsEmpty(false);
     }
 
     PaintLayerPaintingInfo paintingInfo = paintingInfoArg;
 
     LayoutPoint offsetFromRoot;
     m_paintLayer.convertToLayerCoords(paintingInfo.rootLayer, offsetFromRoot);
     offsetFromRoot.move(subpixelAccumulation);
 
     LayoutRect bounds = m_paintLayer.physicalBoundingBox(offsetFromRoot);
     if (!paintingInfo.paintDirtyRect.contains(bounds))
@@ skipping 445 matching lines @@
     if (shouldClip && needsToClip(localPaintingInfo, layerFragments[0].foregroundRect)) {
         clipRecorder.emplace(context, *m_paintLayer.layoutObject(), DisplayItem::kClipLayerForeground, layerFragments[0].foregroundRect, &localPaintingInfo, layerFragments[0].paginationOffset, paintFlags);
         clipState = HasClipped;
     }
 
     // We have to loop through every fragment multiple times, since we have to issue paint invalidations in each specific phase in order for
     // interleaving of the fragments to work properly.
     if (selectionOnly) {
         paintForegroundForFragmentsWithPhase(PaintPhaseSelection, layerFragments, context, localPaintingInfo, paintFlags, clipState);
     } else {
-        if (m_paintLayer.needsPaintPhaseDescendantBlockBackgrounds())
+        if (RuntimeEnabledFeatures::slimmingPaintUnderInvalidationCheckingEnabled() || m_paintLayer.needsPaintPhaseDescendantBlockBackgrounds()) {
+            size_t sizeBefore = context.getPaintController().newDisplayItemList().size();
             paintForegroundForFragmentsWithPhase(PaintPhaseDescendantBlockBackgroundsOnly, layerFragments, context, localPaintingInfo, paintFlags, clipState);
-        if (m_paintLayer.needsPaintPhaseFloat())
+            // Don't set the empty flag if we are not painting the whole background.
+            if (!(paintFlags & PaintLayerPaintingSkipRootBackground)) {
+                bool phaseIsEmpty = context.getPaintController().newDisplayItemList().size() == sizeBefore;
+                DCHECK(phaseIsEmpty || m_paintLayer.needsPaintPhaseDescendantBlockBackgrounds());
+                m_paintLayer.setPreviousPaintPhaseDescendantBlockBackgroundsEmpty(phaseIsEmpty);
+            }
+        }
+
+        if (RuntimeEnabledFeatures::slimmingPaintUnderInvalidationCheckingEnabled() || m_paintLayer.needsPaintPhaseFloat()) {
+            size_t sizeBefore = context.getPaintController().newDisplayItemList().size();
             paintForegroundForFragmentsWithPhase(PaintPhaseFloat, layerFragments, context, localPaintingInfo, paintFlags, clipState);
+            bool phaseIsEmpty = context.getPaintController().newDisplayItemList().size() == sizeBefore;
+            DCHECK(phaseIsEmpty || m_paintLayer.needsPaintPhaseFloat());
+            m_paintLayer.setPreviousPaintPhaseFloatEmpty(phaseIsEmpty);
+        }
+
         paintForegroundForFragmentsWithPhase(PaintPhaseForeground, layerFragments, context, localPaintingInfo, paintFlags, clipState);
-        if (m_paintLayer.needsPaintPhaseDescendantOutlines())
+
+        if (RuntimeEnabledFeatures::slimmingPaintUnderInvalidationCheckingEnabled() || m_paintLayer.needsPaintPhaseDescendantOutlines()) {
+            size_t sizeBefore = context.getPaintController().newDisplayItemList().size();
             paintForegroundForFragmentsWithPhase(PaintPhaseDescendantOutlinesOnly, layerFragments, context, localPaintingInfo, paintFlags, clipState);
+            bool phaseIsEmpty = context.getPaintController().newDisplayItemList().size() == sizeBefore;
+            DCHECK(phaseIsEmpty || m_paintLayer.needsPaintPhaseDescendantOutlines());
+            m_paintLayer.setPreviousPaintPhaseDescendantOutlinesEmpty(phaseIsEmpty);
+        }
     }
 }
 
 void PaintLayerPainter::paintForegroundForFragmentsWithPhase(PaintPhase phase,
     const PaintLayerFragments& layerFragments, GraphicsContext& context,
     const PaintLayerPaintingInfo& localPaintingInfo, PaintLayerFlags paintFlags, ClipState clipState)
 {
     Optional<DisplayItemCacheSkipper> cacheSkipper;
     if (layerFragments.size() > 1)
         cacheSkipper.emplace(context);
@@ skipping 44 matching lines @@
     if (!m_paintLayer.containsDirtyOverlayScrollbars())
         return;
 
     PaintLayerPaintingInfo paintingInfo(&m_paintLayer, LayoutRect(enclosingIntRect(damageRect)), paintFlags, LayoutSize());
     paintLayer(context, paintingInfo, PaintLayerPaintingOverlayScrollbars);
 
     m_paintLayer.setContainsDirtyOverlayScrollbars(false);
 }
 
 } // namespace blink