Remove display item scope

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"
 #include "core/layout/LayoutView.h"
 #include "core/layout/svg/LayoutSVGResourceClipper.h"
 #include "core/page/Page.h"
 #include "core/paint/FilterPainter.h"
 #include "core/paint/LayerClipRecorder.h"
 #include "core/paint/ObjectPaintProperties.h"
 #include "core/paint/PaintInfo.h"
 #include "core/paint/PaintLayer.h"
 #include "core/paint/SVGClipPainter.h"
-#include "core/paint/ScopeRecorder.h"
 #include "core/paint/ScrollRecorder.h"
 #include "core/paint/ScrollableAreaPainter.h"
 #include "core/paint/Transform3DRecorder.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/geometry/FloatPoint3D.h"
 #include "platform/graphics/GraphicsLayer.h"
 #include "platform/graphics/paint/ClipPathRecorder.h"
 #include "platform/graphics/paint/ClipRecorder.h"
 #include "platform/graphics/paint/CompositingRecorder.h"
+#include "platform/graphics/paint/DisplayItemCacheSkipper.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)
 {
@@ skipping 61 matching lines @@
 PaintLayerPainter::PaintResult PaintLayerPainter::paintLayerContentsAndReflection(GraphicsContext& context, const PaintLayerPaintingInfo& paintingInfo, PaintLayerFlags paintFlags, FragmentPolicy fragmentPolicy)
 {
     ASSERT(m_paintLayer.isSelfPaintingLayer() || m_paintLayer.hasSelfPaintingLayerDescendant());
 
     PaintLayerFlags localPaintFlags = paintFlags & ~(PaintLayerAppliedTransform);
 
     PaintResult result = FullyPainted;
 
     // Paint the reflection first if we have one.
     if (m_paintLayer.reflectionInfo() && !RuntimeEnabledFeatures::cssBoxReflectFilterEnabled()) {
-        ScopeRecorder scopeRecorder(context);
+        DisplayItemCacheSkipper skipper(context);
         if (m_paintLayer.reflectionInfo()->paint(context, paintingInfo, localPaintFlags) == MayBeClippedByPaintDirtyRect)
             result = MayBeClippedByPaintDirtyRect;
     }
 
     localPaintFlags |= PaintLayerPaintingCompositingAllPhases;
     if (paintLayerContents(context, paintingInfo, localPaintFlags, fragmentPolicy) == MayBeClippedByPaintDirtyRect)
         result = MayBeClippedByPaintDirtyRect;
 
     return result;
 }
@@ skipping 387 matching lines @@
     } else {
         // We don't need to collect any fragments in the regular way here. We have already
         // calculated a clip rectangle for the ancestry if it was needed, and clipping this
         // layer is something that can be done further down the path, when the transform has
         // been applied.
         PaintLayerFragment fragment;
         fragment.backgroundRect = paintingInfo.paintDirtyRect;
         fragments.append(fragment);
     }
 
-    bool needsScope = fragments.size() > 1;
+    Optional<DisplayItemCacheSkipper> cacheSkipper;
+    if (fragments.size() > 1)
+        cacheSkipper.emplace(context);
+
     PaintResult result = FullyPainted;
     for (const auto& fragment : fragments) {
-        Optional<ScopeRecorder> scopeRecorder;
-        if (needsScope)
-            scopeRecorder.emplace(context);
         Optional<LayerClipRecorder> clipRecorder;
         if (parentLayer) {
             ClipRect clipRectForFragment(ancestorBackgroundClipRect);
             // A fixed-position object is repeated on every page, but if it is clipped by an ancestor layer then
             // the repetitions are clipped out.
             if (!isFixedPosObjectInPagedMedia)
                 clipRectForFragment.moveBy(fragment.paginationOffset);
             clipRectForFragment.intersect(fragment.backgroundRect);
             if (clipRectForFragment.isEmpty())
                 continue;
@@ skipping 92 matching lines @@
         || ((paintFlags & PaintLayerPaintingReflection) && !m_paintLayer.has3DTransform())
         || paintForFixedRootBackground(&m_paintLayer, paintFlags);
 }
 
 void PaintLayerPainter::paintOverflowControlsForFragments(const PaintLayerFragments& layerFragments, GraphicsContext& context, const PaintLayerPaintingInfo& localPaintingInfo, PaintLayerFlags paintFlags)
 {
     PaintLayerScrollableArea* scrollableArea = m_paintLayer.getScrollableArea();
     if (!scrollableArea)
         return;
 
-    bool needsScope = layerFragments.size() > 1;
+    Optional<DisplayItemCacheSkipper> cacheSkipper;
+    if (layerFragments.size() > 1)
+        cacheSkipper.emplace(context);
+
     for (auto& fragment : layerFragments) {
-        Optional<ScopeRecorder> scopeRecorder;
-        if (needsScope)
-            scopeRecorder.emplace(context);
-
         // We need to apply the same clips and transforms that
         // paintFragmentWithPhase would have.
         LayoutRect cullRect = fragment.backgroundRect.rect();
 
         Optional<LayerClipRecorder> clipRecorder;
         if (needsToClip(localPaintingInfo, fragment.backgroundRect))
             clipRecorder.emplace(context, *m_paintLayer.layoutObject(), DisplayItem::ClipLayerOverflowControls, fragment.backgroundRect, &localPaintingInfo, fragment.paginationOffset, paintFlags);
 
         Optional<ScrollRecorder> scrollRecorder;
         if (!RuntimeEnabledFeatures::slimmingPaintV2Enabled() && !localPaintingInfo.scrollOffsetAccumulation.isZero()) {
@@ skipping 54 matching lines @@
     PaintInfo paintInfo(context, pixelSnappedIntRect(newCullRect), phase,
         paintingInfo.getGlobalPaintFlags(), paintFlags, paintingInfo.rootLayer->layoutObject());
 
     m_paintLayer.layoutObject()->paint(paintInfo, paintOffset);
 }
 
 void PaintLayerPainter::paintBackgroundForFragments(const PaintLayerFragments& layerFragments,
     GraphicsContext& context, const LayoutRect& transparencyPaintDirtyRect,
     const PaintLayerPaintingInfo& localPaintingInfo, PaintLayerFlags paintFlags)
 {
-    bool needsScope = layerFragments.size() > 1;
-    for (auto& fragment : layerFragments) {
-        Optional<ScopeRecorder> scopeRecorder;
-        if (needsScope)
-            scopeRecorder.emplace(context);
+    Optional<DisplayItemCacheSkipper> cacheSkipper;
+    if (layerFragments.size() > 1)
+        cacheSkipper.emplace(context);
+
+    for (auto& fragment : layerFragments)
         paintFragmentWithPhase(PaintPhaseSelfBlockBackgroundOnly, fragment, context, fragment.backgroundRect, localPaintingInfo, paintFlags, HasNotClipped);
-    }
 }
 
 void PaintLayerPainter::paintForegroundForFragments(const PaintLayerFragments& layerFragments,
     GraphicsContext& context, const LayoutRect& transparencyPaintDirtyRect,
     const PaintLayerPaintingInfo& localPaintingInfo, bool selectionOnly, PaintLayerFlags paintFlags)
 {
     // Optimize clipping for the single fragment case.
     bool shouldClip = localPaintingInfo.clipToDirtyRect && layerFragments.size() == 1 && !layerFragments[0].foregroundRect.isEmpty();
     ClipState clipState = HasNotClipped;
     Optional<LayerClipRecorder> clipRecorder;
@@ skipping 14 matching lines @@
         paintForegroundForFragmentsWithPhase(PaintPhaseForeground, layerFragments, context, localPaintingInfo, paintFlags, clipState);
         if (!RuntimeEnabledFeatures::paintOptimizationsEnabled() || m_paintLayer.needsPaintPhaseDescendantOutlines())
             paintForegroundForFragmentsWithPhase(PaintPhaseDescendantOutlinesOnly, layerFragments, context, localPaintingInfo, paintFlags, clipState);
     }
 }
 
 void PaintLayerPainter::paintForegroundForFragmentsWithPhase(PaintPhase phase,
     const PaintLayerFragments& layerFragments, GraphicsContext& context,
     const PaintLayerPaintingInfo& localPaintingInfo, PaintLayerFlags paintFlags, ClipState clipState)
 {
-    bool needsScope = layerFragments.size() > 1;
+    Optional<DisplayItemCacheSkipper> cacheSkipper;
+    if (layerFragments.size() > 1)
+        cacheSkipper.emplace(context);
+
     for (auto& fragment : layerFragments) {
-        if (!fragment.foregroundRect.isEmpty()) {
-            Optional<ScopeRecorder> scopeRecorder;
-            if (needsScope)
-                scopeRecorder.emplace(context);
+        if (!fragment.foregroundRect.isEmpty())
             paintFragmentWithPhase(phase, fragment, context, fragment.foregroundRect, localPaintingInfo, paintFlags, clipState);
-        }
     }
 }
 
 void PaintLayerPainter::paintSelfOutlineForFragments(const PaintLayerFragments& layerFragments,
     GraphicsContext& context, const PaintLayerPaintingInfo& localPaintingInfo, PaintLayerFlags paintFlags)
 {
-    bool needsScope = layerFragments.size() > 1;
+    Optional<DisplayItemCacheSkipper> cacheSkipper;
+    if (layerFragments.size() > 1)
+        cacheSkipper.emplace(context);
+
     for (auto& fragment : layerFragments) {
-        if (!fragment.backgroundRect.isEmpty()) {
-            Optional<ScopeRecorder> scopeRecorder;
-            if (needsScope)
-                scopeRecorder.emplace(context);
+        if (!fragment.backgroundRect.isEmpty())
             paintFragmentWithPhase(PaintPhaseSelfOutlineOnly, fragment, context, fragment.backgroundRect, localPaintingInfo, paintFlags, HasNotClipped);
-        }
     }
 }
 
 void PaintLayerPainter::paintMaskForFragments(const PaintLayerFragments& layerFragments,
     GraphicsContext& context, const PaintLayerPaintingInfo& localPaintingInfo, PaintLayerFlags paintFlags)
 {
-    bool needsScope = layerFragments.size() > 1;
-    for (auto& fragment : layerFragments) {
-        Optional<ScopeRecorder> scopeRecorder;
-        if (needsScope)
-            scopeRecorder.emplace(context);
+    Optional<DisplayItemCacheSkipper> cacheSkipper;
+    if (layerFragments.size() > 1)
+        cacheSkipper.emplace(context);
+
+    for (auto& fragment : layerFragments)
         paintFragmentWithPhase(PaintPhaseMask, fragment, context, fragment.backgroundRect, localPaintingInfo, paintFlags, HasNotClipped);
-    }
 }
 
 void PaintLayerPainter::paintChildClippingMaskForFragments(const PaintLayerFragments& layerFragments,
     GraphicsContext& context, const PaintLayerPaintingInfo& localPaintingInfo, PaintLayerFlags paintFlags)
 {
-    bool needsScope = layerFragments.size() > 1;
-    for (auto& fragment: layerFragments) {
-        Optional<ScopeRecorder> scopeRecorder;
-        if (needsScope)
-            scopeRecorder.emplace(context);
+    Optional<DisplayItemCacheSkipper> cacheSkipper;
+    if (layerFragments.size() > 1)
+        cacheSkipper.emplace(context);
+
+    for (auto& fragment: layerFragments)
         paintFragmentWithPhase(PaintPhaseClippingMask, fragment, context, fragment.foregroundRect, localPaintingInfo, paintFlags, HasNotClipped);
-    }
 }
 
 void PaintLayerPainter::paintOverlayScrollbars(GraphicsContext& context, const LayoutRect& damageRect, const GlobalPaintFlags paintFlags)
 {
     if (!m_paintLayer.containsDirtyOverlayScrollbars())
         return;
 
     PaintLayerPaintingInfo paintingInfo(&m_paintLayer, LayoutRect(enclosingIntRect(damageRect)), paintFlags, LayoutSize());
     paintLayer(context, paintingInfo, PaintLayerPaintingOverlayScrollbars);
 
     m_paintLayer.setContainsDirtyOverlayScrollbars(false);
 }
 
 } // namespace blink