Revert of Disable subsequence caching when didLayoutWithPendingStylesheets is true.

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/FrameView.h"
 #include "core/frame/Settings.h"
 #include "core/layout/ClipPathOperation.h"
 #include "core/layout/LayoutBlock.h"
@@ skipping 18 matching lines @@
 #include "platform/graphics/paint/ClipRecorder.h"
 #include "platform/graphics/paint/CompositingRecorder.h"
 #include "platform/graphics/paint/PaintChunkProperties.h"
 #include "platform/graphics/paint/ScopedPaintChunkProperties.h"
 #include "platform/graphics/paint/SubsequenceRecorder.h"
 #include "platform/graphics/paint/Transform3DDisplayItem.h"
 #include "wtf/Optional.h"
 
 namespace blink {
 
-static inline bool shouldSuppressPaintingLayer(const PaintLayer& layer)
+static inline bool shouldSuppressPaintingLayer(PaintLayer* layer)
 {
     // Avoid painting descendants of the root layer when stylesheets haven't loaded. This eliminates FOUC.
     // It's ok not to draw, because later on, when all the stylesheets do load, updateStyleSelector on the Document
     // will do a full paintInvalidationForWholeLayoutObject().
-    if (layer.layoutObject()->document().didLayoutWithPendingStylesheets() && !layer.isRootLayer() && !layer.layoutObject()->isDocumentElement())
+    if (layer->layoutObject()->document().didLayoutWithPendingStylesheets() && !layer->isRootLayer() && !layer->layoutObject()->isDocumentElement())
         return true;
 
     return false;
 }
 
 void PaintLayerPainter::paint(GraphicsContext& context, const LayoutRect& damageRect, const GlobalPaintFlags globalPaintFlags, PaintLayerFlags paintFlags)
 {
     PaintLayerPaintingInfo paintingInfo(&m_paintLayer, LayoutRect(enclosingIntRect(damageRect)), globalPaintFlags, LayoutSize());
     if (shouldPaintLayerInSoftwareMode(globalPaintFlags, paintFlags))
         paintLayer(context, paintingInfo, paintFlags);
@@ skipping 15 matching lines @@
             // FIXME: why isn't the code here global, as opposed to being set on each paintLayer() call?
             paintFlags |= PaintLayerUncachedClipRects;
         }
     }
 
     // Non self-painting layers without self-painting descendants don't need to be painted as their
     // layoutObject() should properly paint itself.
     if (!m_paintLayer.isSelfPaintingLayer() && !m_paintLayer.hasSelfPaintingLayerDescendant())
         return FullyPainted;
 
-    if (shouldSuppressPaintingLayer(m_paintLayer))
+    if (shouldSuppressPaintingLayer(&m_paintLayer))
         return FullyPainted;
 
     if (m_paintLayer.layoutObject()->isLayoutView() && toLayoutView(m_paintLayer.layoutObject())->frameView()->shouldThrottleRendering())
         return FullyPainted;
 
     // If this layer is totally invisible then there is nothing to paint.
     if (!m_paintLayer.layoutObject()->opacity() && !m_paintLayer.layoutObject()->hasBackdropFilter())
         return FullyPainted;
 
     if (m_paintLayer.paintsWithTransparency(paintingInfo.globalPaintFlags()))
@@ skipping 111 matching lines @@
         return false;
 
     // Create subsequence for only stacking contexts whose painting are atomic.
     if (!paintLayer.stackingNode()->isStackingContext())
         return false;
 
     // The layer doesn't have children. Subsequence caching is not worth because normally the actual painting will be cheap.
     if (!PaintLayerStackingNodeIterator(*paintLayer.stackingNode(), AllChildren).next())
         return false;
 
-    // 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, ShouldRespectOverflowClip respectOverflowClip, const LayoutSize& subpixelAccumulation)
 {
     bool needsRepaint = false;
 
     // Repaint subsequence if the layer is marked for needing repaint.
     if (paintLayer.needsRepaint())
         needsRepaint = true;
@@ skipping 545 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