Statistics of LayoutBox rare data reasons

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/LayoutView.h"
 #include "core/paint/ClipPathClipper.h"
 #include "core/paint/FilterPainter.h"
@@ skipping 11 matching lines @@
 #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 {
 
+int paints[9];
+
+int* paintCounts() {
+  return paints;
+}
+
 static inline bool shouldSuppressPaintingLayer(const PaintLayer& layer) {
   // Avoid painting descendants of the root layer when stylesheets haven't
   // loaded. This avoids some FOUC.  It's ok not to draw, because later on, when
   // all the stylesheets do load, Document::styleResolverMayHaveChanged() will
   // invalidate all painted output via a call to
   // LayoutView::invalidatePaintForViewAndCompositedLayers().  We also avoid
   // caching subsequences in this mode; see shouldCreateSubsequence().
   if (layer.layoutObject().document().didLayoutWithPendingStylesheets() &&
       !layer.isRootLayer() && !layer.layoutObject().isDocumentElement())
     return true;
@@ skipping 993 matching lines @@
   Optional<LayerClipRecorder> clipRecorder;
   if (shouldClip &&
       needsToClip(localPaintingInfo, layerFragments[0].foregroundRect)) {
     clipRecorder.emplace(
         context, m_paintLayer.layoutObject(), DisplayItem::kClipLayerForeground,
         layerFragments[0].foregroundRect, localPaintingInfo.rootLayer,
         layerFragments[0].paginationOffset, paintFlags);
     clipState = HasClipped;
   }
 
+  size_t sizeBefore = context.getPaintController().newDisplayItemList().size();
   // 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 (RuntimeEnabledFeatures::paintUnderInvalidationCheckingEnabled() ||
         m_paintLayer.needsPaintPhaseDescendantBlockBackgrounds()) {
       size_t sizeBefore =
           context.getPaintController().newDisplayItemList().size();
       paintForegroundForFragmentsWithPhase(
           PaintPhaseDescendantBlockBackgroundsOnly, layerFragments, context,
           localPaintingInfo, paintFlags, clipState);
       // 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);
       }
+    } else {
+      paints[6]++;
     }
 
     if (RuntimeEnabledFeatures::paintUnderInvalidationCheckingEnabled() ||
         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);
+    } else {
+      paints[7]++;
     }
 
     paintForegroundForFragmentsWithPhase(PaintPhaseForeground, layerFragments,
                                          context, localPaintingInfo, paintFlags,
                                          clipState);
 
     if (RuntimeEnabledFeatures::paintUnderInvalidationCheckingEnabled() ||
         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);
+    } else {
+      paints[8]++;
     }
+
+    paints[5]++;
+    if (sizeBefore == context.getPaintController().newDisplayItemList().size())
+      paints[4]++;
   }
 }
 
 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);
 
+  int paintIndex = -1;
+  switch (phase) {
+    case PaintPhaseDescendantBlockBackgroundsOnly:
+      paintIndex = 0;
+      break;
+    case PaintPhaseFloat:
+      paintIndex = 1;
+      break;
+    case PaintPhaseForeground:
+      paintIndex = 2;
+      break;
+    case PaintPhaseDescendantOutlinesOnly:
+      paintIndex = 3;
+      break;
+    default:
+      break;
+  }
+
+  size_t sizeBefore = context.getPaintController().newDisplayItemList().size();
   for (auto& fragment : layerFragments) {
     if (!fragment.foregroundRect.isEmpty())
       paintFragmentWithPhase(phase, fragment, context, fragment.foregroundRect,
                              localPaintingInfo, paintFlags, clipState);
   }
+  if (paintIndex != -1 &&
+      sizeBefore == context.getPaintController().newDisplayItemList().size())
+    paints[paintIndex]++;
 }
 
 void PaintLayerPainter::paintSelfOutlineForFragments(
     const PaintLayerFragments& layerFragments,
     GraphicsContext& context,
     const PaintLayerPaintingInfo& localPaintingInfo,
     PaintLayerFlags paintFlags) {
   Optional<DisplayItemCacheSkipper> cacheSkipper;
   if (layerFragments.size() > 1)
     cacheSkipper.emplace(context);
@@ skipping 70 matching lines @@
           context, layoutObject, PaintPhaseClippingMask))
     return;
 
   IntRect snappedClipRect = pixelSnappedIntRect(clipRect.rect());
   LayoutObjectDrawingRecorder drawingRecorder(
       context, layoutObject, PaintPhaseClippingMask, snappedClipRect);
   context.fillRect(snappedClipRect, Color::black);
 }
 
 }  // namespace blink