Generalize paint chunks to clips, and implement clips in LayerPainter.

Source/core/paint/LayerPainter.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 "config.h"
 #include "core/paint/LayerPainter.h"
 
 #include "core/frame/Settings.h"
 #include "core/page/Page.h"
 #include "core/rendering/ClipPathOperation.h"
@@ skipping 70 matching lines @@
                 LayerPainter(*m_renderLayer.parent()).beginTransparencyLayers(context, paintingInfo.rootLayer, paintingInfo.paintDirtyRect, paintingInfo.subPixelAccumulation, paintingInfo.paintBehavior);
             else
                 beginTransparencyLayers(context, paintingInfo.rootLayer, paintingInfo.paintDirtyRect, paintingInfo.subPixelAccumulation, paintingInfo.paintBehavior);
         }
 
         if (m_renderLayer.enclosingPaginationLayer()) {
             paintTransformedLayerIntoFragments(context, paintingInfo, paintFlags);
             return;
         }
 
+        PaintClipRecorder paintClipRecorder(&m_renderLayer, ClipDisplayItem::LayerParent);
+        PaintClipRecorder* paintClipRecorderPtr = 0;
+        if (RuntimeEnabledFeatures::slimmingPaintEnabled())
+            paintClipRecorderPtr = &paintClipRecorder;
+
         // Make sure the parent's clip rects have been calculated.
         ClipRect clipRect = paintingInfo.paintDirtyRect;
         if (m_renderLayer.parent()) {
             ClipRectsContext clipRectsContext(paintingInfo.rootLayer, (paintFlags & PaintLayerUncachedClipRects) ? UncachedClipRects : PaintingClipRects, IgnoreOverlayScrollbarSize);
             if (shouldRespectOverflowClip(paintFlags, m_renderLayer.renderer()) == IgnoreOverflowClip)
                 clipRectsContext.setIgnoreOverflowClip();
             clipRect = m_renderLayer.clipper().backgroundClipRect(clipRectsContext);
             clipRect.intersect(paintingInfo.paintDirtyRect);
 
             // Push the parent coordinate space's clip.
-            LayerPainter(*m_renderLayer.parent()).clipToRect(paintingInfo, context, clipRect, paintFlags);
+            LayerPainter(*m_renderLayer.parent()).clipToRect(paintingInfo, context, clipRect, paintFlags, paintClipRecorderPtr);
         }
 
         paintLayerByApplyingTransform(context, paintingInfo, paintFlags);
 
         // Restore the clip.
         if (m_renderLayer.parent())
-            LayerPainter(*m_renderLayer.parent()).restoreClip(context, paintingInfo.paintDirtyRect, clipRect);
+            LayerPainter(*m_renderLayer.parent()).restoreClip(context, paintingInfo.paintDirtyRect, clipRect, paintClipRecorderPtr);
 
         return;
     }
 
     paintLayerContentsAndReflection(context, paintingInfo, paintFlags);
 }
 
 void LayerPainter::beginTransparencyLayers(GraphicsContext* context, const RenderLayer* rootLayer, const LayoutRect& paintDirtyRect, const LayoutSize& subPixelAccumulation, PaintBehavior paintBehavior)
 {
     bool createTransparencyLayerForBlendMode = m_renderLayer.stackingNode()->isStackingContext() && m_renderLayer.hasDescendantWithBlendMode();
@@ skipping 139 matching lines @@
     LayerFragments layerFragments;
     if (shouldPaintContent || shouldPaintOutline || isPaintingOverlayScrollbars) {
         // Collect the fragments. This will compute the clip rectangles and paint offsets for each layer fragment, as well as whether or not the content of each
         // fragment should paint.
         m_renderLayer.collectFragments(layerFragments, localPaintingInfo.rootLayer, localPaintingInfo.paintDirtyRect,
             (paintFlags & PaintLayerUncachedClipRects) ? UncachedClipRects : PaintingClipRects, IgnoreOverlayScrollbarSize,
             shouldRespectOverflowClip(paintFlags, m_renderLayer.renderer()), &offsetFromRoot, localPaintingInfo.subPixelAccumulation);
         updatePaintingInfoForFragments(layerFragments, localPaintingInfo, paintFlags, shouldPaintContent, &offsetFromRoot);
     }
 
+    PaintClipRecorder filterPaintClipRecorder(&m_renderLayer, ClipDisplayItem::LayerFilter);
+    PaintClipRecorder* filterPaintClipRecorderPtr = 0;
+    if (RuntimeEnabledFeatures::slimmingPaintEnabled())
+        filterPaintClipRecorderPtr = &filterPaintClipRecorder;
+
     if (haveFilterEffect) {
         ASSERT(m_renderLayer.filterInfo());
 
         if (!rootRelativeBoundsComputed)
             rootRelativeBounds = m_renderLayer.physicalBoundingBoxIncludingReflectionAndStackingChildren(paintingInfo.rootLayer, offsetFromRoot);
 
         // Do transparency and clipping before starting filter processing.
         if (haveTransparency) {
             // If we have a filter and transparency, we have to eagerly start a transparency layer here, rather than risk a child layer lazily starts one after filter processing.
             beginTransparencyLayers(context, localPaintingInfo.rootLayer, paintingInfo.paintDirtyRect, paintingInfo.subPixelAccumulation, localPaintingInfo.paintBehavior);
         }
+
         // We'll handle clipping to the dirty rect before filter rasterization.
         // Filter processing will automatically expand the clip rect and the offscreen to accommodate any filter outsets.
         // FIXME: It is incorrect to just clip to the damageRect here once multiple fragments are involved.
         ClipRect backgroundRect = layerFragments.isEmpty() ? ClipRect() : layerFragments[0].backgroundRect;
-        clipToRect(localPaintingInfo, context, backgroundRect, paintFlags);
+        clipToRect(localPaintingInfo, context, backgroundRect, paintFlags, filterPaintClipRecorderPtr);
         // Subsequent code should not clip to the dirty rect, since we've already
         // done it above, and doing it later will defeat the outsets.
         localPaintingInfo.clipToDirtyRect = false;
         haveFilterEffect = m_renderLayer.filterRenderer()->beginFilterEffect(context, rootRelativeBounds);
         if (!haveFilterEffect) {
             // If the the filter failed to start, undo the clip immediately
-            restoreClip(context, localPaintingInfo.paintDirtyRect, backgroundRect);
+            restoreClip(context, localPaintingInfo.paintDirtyRect, backgroundRect, filterPaintClipRecorderPtr);
         }
     }
 
     // If this layer's renderer is a child of the paintingRoot, we render unconditionally, which
     // is done by passing a nil paintingRoot down to our renderer (as if no paintingRoot was ever set).
     // Else, our renderer tree may or may not contain the painting root, so we pass that root along
     // so it will be tested against as we descend through the renderers.
     RenderObject* paintingRootForRenderer = 0;
     if (localPaintingInfo.paintingRoot && !m_renderLayer.renderer()->isDescendantOf(localPaintingInfo.paintingRoot))
         paintingRootForRenderer = localPaintingInfo.paintingRoot;
@@ skipping 35 matching lines @@
         paintChildren(NormalFlowChildren | PositiveZOrderChildren, context, paintingInfo, paintFlags);
 
     if (shouldPaintOverlayScrollbars)
         paintOverflowControlsForFragments(layerFragments, context, localPaintingInfo, paintFlags);
 
     if (haveFilterEffect) {
         // Apply the correct clipping (ie. overflow: hidden).
         // FIXME: It is incorrect to just clip to the damageRect here once multiple fragments are involved.
         ClipRect backgroundRect = layerFragments.isEmpty() ? ClipRect() : layerFragments[0].backgroundRect;
         m_renderLayer.filterRenderer()->endFilterEffect(context);
-        restoreClip(context, localPaintingInfo.paintDirtyRect, backgroundRect);
+        restoreClip(context, localPaintingInfo.paintDirtyRect, backgroundRect, filterPaintClipRecorderPtr);
     }
 
     if (shouldPaintMask)
         paintMaskForFragments(layerFragments, context, localPaintingInfo, paintingRootForRenderer, paintFlags);
 
     if (shouldPaintClippingMask) {
         // Paint the border radius mask for the fragments.
         paintChildClippingMaskForFragments(layerFragments, context, localPaintingInfo, paintingRootForRenderer, paintFlags);
     }
 
@@ skipping 17 matching lines @@
     RenderView* view = startLayer->renderer()->view();
     for (RenderBlock* currentBlock = startLayer->renderer()->containingBlock(); currentBlock && currentBlock != view; currentBlock = currentBlock->containingBlock()) {
         if (currentBlock->layer() == endLayer)
             return true;
     }
 
     return false;
 }
 
 void LayerPainter::clipToRect(const LayerPaintingInfo& localPaintingInfo, GraphicsContext* context, const ClipRect& clipRect,
-    PaintLayerFlags paintFlags, BorderRadiusClippingRule rule)
+    PaintLayerFlags paintFlags, PaintClipRecorder* paintClipRecorder, BorderRadiusClippingRule rule)
 {
     if (clipRect.rect() == localPaintingInfo.paintDirtyRect && !clipRect.hasRadius())
         return;
-    context->save();
-    context->clip(pixelSnappedIntRect(clipRect.rect()));
 
-    if (!clipRect.hasRadius())
-        return;
+    IntRect pixelSnappedRect = pixelSnappedIntRect(clipRect.rect());
 
-    // If the clip rect has been tainted by a border radius, then we have to walk up our layer chain applying the clips from
-    // any layers with overflow. The condition for being able to apply these clips is that the overflow object be in our
-    // containing block chain so we check that also.
-    for (RenderLayer* layer = rule == IncludeSelfForBorderRadius ? &m_renderLayer : m_renderLayer.parent(); layer; layer = layer->parent()) {
-        // Composited scrolling layers handle border-radius clip in the compositor via a mask layer. We do not
-        // want to apply a border-radius clip to the layer contents itself, because that would require re-rastering
-        // every frame to update the clip. We only want to make sure that the mask layer is properly clipped so
-        // that it can in turn clip the scrolled contents in the compositor.
-        if (layer->needsCompositedScrolling() && !(paintFlags & PaintLayerPaintingChildClippingMaskPhase))
-            break;
+    if (paintClipRecorder) {

[leviw_travelin_and_unemployed, 2014/10/15 18:51:39]

Putting this if everywhere that calls clip seems ugly... Does it not make sense
to hang this on GraphicsContext and have it behave more like how we begin and
end recordings?

+        paintClipRecorder->setClipRect(pixelSnappedRect);
+    } else {
+        context->save();
+        context->clip(pixelSnappedIntRect(clipRect.rect()));
+    }
 
-        if (layer->renderer()->hasOverflowClip() && layer->renderer()->style()->hasBorderRadius() && inContainingBlockChain(&m_renderLayer, layer)) {
-            LayoutPoint delta;
-            layer->convertToLayerCoords(localPaintingInfo.rootLayer, delta);
-            context->clipRoundedRect(layer->renderer()->style()->getRoundedInnerBorderFor(LayoutRect(delta, layer->size())));
+    if (clipRect.hasRadius()) {
+        // If the clip rect has been tainted by a border radius, then we have to walk up our layer chain applying the clips from
+        // any layers with overflow. The condition for being able to apply these clips is that the overflow object be in our
+        // containing block chain so we check that also.
+        for (RenderLayer* layer = rule == IncludeSelfForBorderRadius ? &m_renderLayer : m_renderLayer.parent(); layer; layer = layer->parent()) {
+            // Composited scrolling layers handle border-radius clip in the compositor via a mask layer. We do not
+            // want to apply a border-radius clip to the layer contents itself, because that would require re-rastering
+            // every frame to update the clip. We only want to make sure that the mask layer is properly clipped so
+            // that it can in turn clip the scrolled contents in the compositor.
+            if (layer->needsCompositedScrolling() && !(paintFlags & PaintLayerPaintingChildClippingMaskPhase))
+                break;
+
+            if (layer->renderer()->hasOverflowClip() && layer->renderer()->style()->hasBorderRadius() && inContainingBlockChain(&m_renderLayer, layer)) {
+                LayoutPoint delta;
+                layer->convertToLayerCoords(localPaintingInfo.rootLayer, delta);
+                RoundedRect roundedRect = layer->renderer()->style()->getRoundedInnerBorderFor(LayoutRect(delta, layer->size()));
+                if (paintClipRecorder)
+                    paintClipRecorder->addRoundedRectClip(roundedRect);
+                else
+                    context->clipRoundedRect(roundedRect);
+            }
+
+            if (layer == localPaintingInfo.rootLayer)
+                break;
         }
+    }
 
-        if (layer == localPaintingInfo.rootLayer)
-            break;
-    }
+    if (paintClipRecorder)

[leviw_travelin_and_unemployed, 2014/10/15 18:51:39]

Why is it okay to unbalance this with the calls to restore in the
GraphicsContext?

+        paintClipRecorder->endClip();
 }
 
-void LayerPainter::restoreClip(GraphicsContext* context, const LayoutRect& paintDirtyRect, const ClipRect& clipRect)
+void LayerPainter::restoreClip(GraphicsContext* context, const LayoutRect& paintDirtyRect, const ClipRect& clipRect, PaintClipRecorder* paintClipRecorder = 0)
 {
     if (clipRect.rect() == paintDirtyRect && !clipRect.hasRadius())
         return;
-    context->restore();
+    if (paintClipRecorder)
+        paintClipRecorder->endClip();
+    else
+        context->restore();
 }
 
 void LayerPainter::updatePaintingInfoForFragments(LayerFragments& fragments, const LayerPaintingInfo& localPaintingInfo, PaintLayerFlags localPaintFlags,
     bool shouldPaintContent, const LayoutPoint* offsetFromRoot)
 {
     ASSERT(offsetFromRoot);
     for (size_t i = 0; i < fragments.size(); ++i) {
         LayerFragment& fragment = fragments.at(i);
         fragment.shouldPaintContent = shouldPaintContent;
         if (&m_renderLayer != localPaintingInfo.rootLayer || !(localPaintFlags & PaintLayerPaintingOverflowContents)) {
@@ skipping 74 matching lines @@
     // Only apply the sub-pixel accumulation if we don't paint into our own backing layer, otherwise the position
     // of the renderer already includes any sub-pixel offset.
     if (compositingState == PaintsIntoOwnBacking)
         return LayoutSize();
     return subPixelAccumulation;
 }
 
 void LayerPainter::paintOverflowControlsForFragments(const LayerFragments& layerFragments, GraphicsContext* context, const LayerPaintingInfo& localPaintingInfo, PaintLayerFlags paintFlags)
 {
     for (size_t i = 0; i < layerFragments.size(); ++i) {
+        PaintClipRecorder paintClipRecorder(&m_renderLayer, ClipDisplayItem::LayerOverflowControls);
+        PaintClipRecorder* paintClipRecorderPtr = 0;
+        if (RuntimeEnabledFeatures::slimmingPaintEnabled())
+            paintClipRecorderPtr = &paintClipRecorder;
+
         const LayerFragment& fragment = layerFragments.at(i);
-        clipToRect(localPaintingInfo, context, fragment.backgroundRect, paintFlags);
+
+        clipToRect(localPaintingInfo, context, fragment.backgroundRect, paintFlags, paintClipRecorderPtr);
         if (RenderLayerScrollableArea* scrollableArea = m_renderLayer.scrollableArea())
             scrollableArea->paintOverflowControls(context, roundedIntPoint(toPoint(fragment.layerBounds.location() - m_renderLayer.renderBoxLocation() + subPixelAccumulationIfNeeded(localPaintingInfo.subPixelAccumulation, m_renderLayer.compositingState()))), pixelSnappedIntRect(fragment.backgroundRect.rect()), true);
-        restoreClip(context, localPaintingInfo.paintDirtyRect, fragment.backgroundRect);
+        restoreClip(context, localPaintingInfo.paintDirtyRect, fragment.backgroundRect, paintClipRecorderPtr);
     }
 }
 
 static bool checkContainingBlockChainForPagination(RenderLayerModelObject* renderer, RenderBox* ancestorColumnsRenderer)
 {
     RenderView* view = renderer->view();
     RenderLayerModelObject* prevBlock = renderer;
     RenderBlock* containingBlock;
     for (containingBlock = renderer->containingBlock();
         containingBlock && containingBlock != view && containingBlock != ancestorColumnsRenderer;
@@ skipping 128 matching lines @@
         else
             currLogicalTopOffset -= blockDelta;
     }
 }
 
 void LayerPainter::paintBackgroundForFragments(const LayerFragments& layerFragments, GraphicsContext* context,
     const LayoutRect& transparencyPaintDirtyRect, bool haveTransparency, const LayerPaintingInfo& localPaintingInfo, PaintBehavior paintBehavior,
     RenderObject* paintingRootForRenderer, PaintLayerFlags paintFlags)
 {
     for (size_t i = 0; i < layerFragments.size(); ++i) {
+        PaintClipRecorder paintClipRecorder(&m_renderLayer, ClipDisplayItem::LayerBackground);
+        PaintClipRecorder* paintClipRecorderPtr = 0;
+        if (RuntimeEnabledFeatures::slimmingPaintEnabled())
+            paintClipRecorderPtr = &paintClipRecorder;
+
         const LayerFragment& fragment = layerFragments.at(i);
         if (!fragment.shouldPaintContent)
             continue;
 
         // Begin transparency layers lazily now that we know we have to paint something.
         if (haveTransparency || m_renderLayer.paintsWithBlendMode())
             beginTransparencyLayers(context, localPaintingInfo.rootLayer, transparencyPaintDirtyRect, localPaintingInfo.subPixelAccumulation, localPaintingInfo.paintBehavior);
 
         if (localPaintingInfo.clipToDirtyRect) {
             // Paint our background first, before painting any child layers.
             // Establish the clip used to paint our background.
-            clipToRect(localPaintingInfo, context, fragment.backgroundRect, paintFlags, DoNotIncludeSelfForBorderRadius); // Background painting will handle clipping to self.
+            clipToRect(localPaintingInfo, context, fragment.backgroundRect, paintFlags, paintClipRecorderPtr, DoNotIncludeSelfForBorderRadius); // Background painting will handle clipping to self.
         }
 
         // Paint the background.
         // FIXME: Eventually we will collect the region from the fragment itself instead of just from the paint info.
         PaintInfo paintInfo(context, pixelSnappedIntRect(fragment.backgroundRect.rect()), PaintPhaseBlockBackground, paintBehavior, paintingRootForRenderer, 0, localPaintingInfo.rootLayer->renderer());
         m_renderLayer.renderer()->paint(paintInfo, toPoint(fragment.layerBounds.location() - m_renderLayer.renderBoxLocation() + subPixelAccumulationIfNeeded(localPaintingInfo.subPixelAccumulation, m_renderLayer.compositingState())));
 
         if (localPaintingInfo.clipToDirtyRect)
-            restoreClip(context, localPaintingInfo.paintDirtyRect, fragment.backgroundRect);
+            restoreClip(context, localPaintingInfo.paintDirtyRect, fragment.backgroundRect, paintClipRecorderPtr);
     }
 }
 
 void LayerPainter::paintForegroundForFragments(const LayerFragments& layerFragments, GraphicsContext* context,
     const LayoutRect& transparencyPaintDirtyRect, bool haveTransparency, const LayerPaintingInfo& localPaintingInfo, PaintBehavior paintBehavior,
     RenderObject* paintingRootForRenderer, bool selectionOnly, PaintLayerFlags paintFlags)
 {
     // Begin transparency if we have something to paint.
     if (haveTransparency || m_renderLayer.paintsWithBlendMode()) {
         for (size_t i = 0; i < layerFragments.size(); ++i) {
             const LayerFragment& fragment = layerFragments.at(i);
             if (fragment.shouldPaintContent && !fragment.foregroundRect.isEmpty()) {
                 beginTransparencyLayers(context, localPaintingInfo.rootLayer, transparencyPaintDirtyRect, localPaintingInfo.subPixelAccumulation, localPaintingInfo.paintBehavior);
                 break;
             }
         }
     }
 
+    PaintClipRecorder paintClipRecorder(&m_renderLayer, ClipDisplayItem::LayerForeground);
+    PaintClipRecorder* paintClipRecorderPtr = 0;
+    if (RuntimeEnabledFeatures::slimmingPaintEnabled())
+        paintClipRecorderPtr = &paintClipRecorder;
+
     // Optimize clipping for the single fragment case.
     bool shouldClip = localPaintingInfo.clipToDirtyRect && layerFragments.size() == 1 && layerFragments[0].shouldPaintContent && !layerFragments[0].foregroundRect.isEmpty();
     if (shouldClip)
-        clipToRect(localPaintingInfo, context, layerFragments[0].foregroundRect, paintFlags);
+        clipToRect(localPaintingInfo, context, layerFragments[0].foregroundRect, paintFlags, paintClipRecorderPtr);
 
     // 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.
     paintForegroundForFragmentsWithPhase(selectionOnly ? PaintPhaseSelection : PaintPhaseChildBlockBackgrounds, layerFragments,
         context, localPaintingInfo, paintBehavior, paintingRootForRenderer, paintFlags);
 
     if (!selectionOnly) {
         paintForegroundForFragmentsWithPhase(PaintPhaseFloat, layerFragments, context, localPaintingInfo, paintBehavior, paintingRootForRenderer, paintFlags);
         paintForegroundForFragmentsWithPhase(PaintPhaseForeground, layerFragments, context, localPaintingInfo, paintBehavior, paintingRootForRenderer, paintFlags);
         paintForegroundForFragmentsWithPhase(PaintPhaseChildOutlines, layerFragments, context, localPaintingInfo, paintBehavior, paintingRootForRenderer, paintFlags);
     }
 
     if (shouldClip)
-        restoreClip(context, localPaintingInfo.paintDirtyRect, layerFragments[0].foregroundRect);
+        restoreClip(context, localPaintingInfo.paintDirtyRect, layerFragments[0].foregroundRect, paintClipRecorderPtr);
 }
 
 void LayerPainter::paintForegroundForFragmentsWithPhase(PaintPhase phase, const LayerFragments& layerFragments, GraphicsContext* context,
     const LayerPaintingInfo& localPaintingInfo, PaintBehavior paintBehavior, RenderObject* paintingRootForRenderer, PaintLayerFlags paintFlags)
 {
     bool shouldClip = localPaintingInfo.clipToDirtyRect && layerFragments.size() > 1;
 
     for (size_t i = 0; i < layerFragments.size(); ++i) {
         const LayerFragment& fragment = layerFragments.at(i);
         if (!fragment.shouldPaintContent || fragment.foregroundRect.isEmpty())
             continue;
 
+        // Note: this method only clips when there is more than one fragment.
+        ClipDisplayItem::ClipType clipType = (ClipDisplayItem::ClipType)0;
+        if (RuntimeEnabledFeatures::slimmingPaintEnabled()) {
+            switch (phase) {
+            case PaintPhaseFloat:
+                clipType = ClipDisplayItem::LayerFragmentFloat;
+                break;
+            case PaintPhaseForeground:
+                clipType = ClipDisplayItem::LayerFragmentForeground;
+                break;
+            case PaintPhaseChildOutlines:
+                clipType = ClipDisplayItem::LayerFragmentChildOutline;
+                break;
+            default:
+                ASSERT_NOT_REACHED();
+            }
+        }
+        PaintClipRecorder paintClipRecorder(&m_renderLayer, clipType);
+        PaintClipRecorder* paintClipRecorderPtr = 0;
+        if (RuntimeEnabledFeatures::slimmingPaintEnabled())
+            paintClipRecorderPtr = &paintClipRecorder;
+
         if (shouldClip)
-            clipToRect(localPaintingInfo, context, fragment.foregroundRect, paintFlags);
+            clipToRect(localPaintingInfo, context, fragment.foregroundRect, paintFlags, paintClipRecorderPtr);
 
         PaintInfo paintInfo(context, pixelSnappedIntRect(fragment.foregroundRect.rect()), phase, paintBehavior, paintingRootForRenderer, 0, localPaintingInfo.rootLayer->renderer());
         m_renderLayer.renderer()->paint(paintInfo, toPoint(fragment.layerBounds.location() - m_renderLayer.renderBoxLocation() + subPixelAccumulationIfNeeded(localPaintingInfo.subPixelAccumulation, m_renderLayer.compositingState())));
 
         if (shouldClip)
-            restoreClip(context, localPaintingInfo.paintDirtyRect, fragment.foregroundRect);
+            restoreClip(context, localPaintingInfo.paintDirtyRect, fragment.foregroundRect, paintClipRecorderPtr);
     }
 }
 
 void LayerPainter::paintOutlineForFragments(const LayerFragments& layerFragments, GraphicsContext* context, const LayerPaintingInfo& localPaintingInfo,
     PaintBehavior paintBehavior, RenderObject* paintingRootForRenderer, PaintLayerFlags paintFlags)
 {
     for (size_t i = 0; i < layerFragments.size(); ++i) {
         const LayerFragment& fragment = layerFragments.at(i);
         if (fragment.outlineRect.isEmpty())
             continue;
 
+        PaintClipRecorder paintClipRecorder(&m_renderLayer, ClipDisplayItem::LayerFragmentOutline);
+        PaintClipRecorder* paintClipRecorderPtr = 0;
+        if (RuntimeEnabledFeatures::slimmingPaintEnabled())
+            paintClipRecorderPtr = &paintClipRecorder;
+
         // Paint our own outline
         PaintInfo paintInfo(context, pixelSnappedIntRect(fragment.outlineRect.rect()), PaintPhaseSelfOutline, paintBehavior, paintingRootForRenderer, 0, localPaintingInfo.rootLayer->renderer());
-        clipToRect(localPaintingInfo, context, fragment.outlineRect, paintFlags, DoNotIncludeSelfForBorderRadius);
+        clipToRect(localPaintingInfo, context, fragment.outlineRect, paintFlags, paintClipRecorderPtr, DoNotIncludeSelfForBorderRadius);
         m_renderLayer.renderer()->paint(paintInfo, toPoint(fragment.layerBounds.location() - m_renderLayer.renderBoxLocation() + subPixelAccumulationIfNeeded(localPaintingInfo.subPixelAccumulation, m_renderLayer.compositingState())));
-        restoreClip(context, localPaintingInfo.paintDirtyRect, fragment.outlineRect);
+        restoreClip(context, localPaintingInfo.paintDirtyRect, fragment.outlineRect, paintClipRecorderPtr);
     }
 }
 
 void LayerPainter::paintMaskForFragments(const LayerFragments& layerFragments, GraphicsContext* context, const LayerPaintingInfo& localPaintingInfo,
     RenderObject* paintingRootForRenderer, PaintLayerFlags paintFlags)
 {
     for (size_t i = 0; i < layerFragments.size(); ++i) {
         const LayerFragment& fragment = layerFragments.at(i);
         if (!fragment.shouldPaintContent)
             continue;
 
+        PaintClipRecorder paintClipRecorder(&m_renderLayer, ClipDisplayItem::LayerFragmentMask);
+        PaintClipRecorder* paintClipRecorderPtr = 0;
+        if (RuntimeEnabledFeatures::slimmingPaintEnabled())
+            paintClipRecorderPtr = &paintClipRecorder;
+
         if (localPaintingInfo.clipToDirtyRect)
-            clipToRect(localPaintingInfo, context, fragment.backgroundRect, paintFlags, DoNotIncludeSelfForBorderRadius); // Mask painting will handle clipping to self.
+            clipToRect(localPaintingInfo, context, fragment.backgroundRect, paintFlags, paintClipRecorderPtr, DoNotIncludeSelfForBorderRadius); // Mask painting will handle clipping to self.
 
         // Paint the mask.
         // FIXME: Eventually we will collect the region from the fragment itself instead of just from the paint info.
         PaintInfo paintInfo(context, pixelSnappedIntRect(fragment.backgroundRect.rect()), PaintPhaseMask, PaintBehaviorNormal, paintingRootForRenderer, 0, localPaintingInfo.rootLayer->renderer());
         m_renderLayer.renderer()->paint(paintInfo, toPoint(fragment.layerBounds.location() - m_renderLayer.renderBoxLocation() + subPixelAccumulationIfNeeded(localPaintingInfo.subPixelAccumulation, m_renderLayer.compositingState())));
 
         if (localPaintingInfo.clipToDirtyRect)
-            restoreClip(context, localPaintingInfo.paintDirtyRect, fragment.backgroundRect);
+            restoreClip(context, localPaintingInfo.paintDirtyRect, fragment.backgroundRect, paintClipRecorderPtr);
     }
 }
 
 void LayerPainter::paintChildClippingMaskForFragments(const LayerFragments& layerFragments, GraphicsContext* context, const LayerPaintingInfo& localPaintingInfo,
     RenderObject* paintingRootForRenderer, PaintLayerFlags paintFlags)
 {
     for (size_t i = 0; i < layerFragments.size(); ++i) {
         const LayerFragment& fragment = layerFragments.at(i);
         if (!fragment.shouldPaintContent)
             continue;
 
+        PaintClipRecorder paintClipRecorder(&m_renderLayer, ClipDisplayItem::LayerFragmentClippingMask);
+        PaintClipRecorder* paintClipRecorderPtr = 0;
+        if (RuntimeEnabledFeatures::slimmingPaintEnabled())
+            paintClipRecorderPtr = &paintClipRecorder;
+
         if (localPaintingInfo.clipToDirtyRect)
-            clipToRect(localPaintingInfo, context, fragment.foregroundRect, paintFlags, IncludeSelfForBorderRadius); // Child clipping mask painting will handle clipping to self.
+            clipToRect(localPaintingInfo, context, fragment.foregroundRect, paintFlags, paintClipRecorderPtr, IncludeSelfForBorderRadius); // Child clipping mask painting will handle clipping to self.
 
         // Paint the the clipped mask.
         PaintInfo paintInfo(context, pixelSnappedIntRect(fragment.backgroundRect.rect()), PaintPhaseClippingMask, PaintBehaviorNormal, paintingRootForRenderer, 0, localPaintingInfo.rootLayer->renderer());
         m_renderLayer.renderer()->paint(paintInfo, toPoint(fragment.layerBounds.location() - m_renderLayer.renderBoxLocation() + subPixelAccumulationIfNeeded(localPaintingInfo.subPixelAccumulation, m_renderLayer.compositingState())));
 
         if (localPaintingInfo.clipToDirtyRect)
-            restoreClip(context, localPaintingInfo.paintDirtyRect, fragment.foregroundRect);
+            restoreClip(context, localPaintingInfo.paintDirtyRect, fragment.foregroundRect, paintClipRecorderPtr);
     }
 }
 
 void LayerPainter::paintOverlayScrollbars(GraphicsContext* context, const LayoutRect& damageRect, PaintBehavior paintBehavior, RenderObject* paintingRoot)
 {
     if (!m_renderLayer.containsDirtyOverlayScrollbars())
         return;
 
     LayerPaintingInfo paintingInfo(&m_renderLayer, enclosingIntRect(damageRect), paintBehavior, LayoutSize(), paintingRoot);
     paintLayer(context, paintingInfo, PaintLayerPaintingOverlayScrollbars);
@@ skipping 22 matching lines @@
             m_renderLayer.enclosingPaginationLayer()->convertToLayerCoords(paintingInfo.rootLayer, offsetOfPaginationLayerFromRoot);
 
             ClipRectsContext clipRectsContext(m_renderLayer.enclosingPaginationLayer(), (paintFlags & PaintLayerUncachedClipRects) ? UncachedClipRects : PaintingClipRects, IgnoreOverlayScrollbarSize);
             if (shouldRespectOverflowClip(paintFlags, m_renderLayer.renderer()) == IgnoreOverflowClip)
                 clipRectsContext.setIgnoreOverflowClip();
             LayoutRect parentClipRect = m_renderLayer.clipper().backgroundClipRect(clipRectsContext).rect();
             parentClipRect.moveBy(fragment.paginationOffset + offsetOfPaginationLayerFromRoot);
             clipRect.intersect(parentClipRect);
         }
 
-        LayerPainter(*m_renderLayer.parent()).clipToRect(paintingInfo, context, clipRect, paintFlags);
+        PaintClipRecorder paintClipRecorder(&m_renderLayer, ClipDisplayItem::LayerFragmentParent);
+        PaintClipRecorder* paintClipRecorderPtr = 0;
+        if (RuntimeEnabledFeatures::slimmingPaintEnabled())
+            paintClipRecorderPtr = &paintClipRecorder;
+
+        LayerPainter(*m_renderLayer.parent()).clipToRect(paintingInfo, context, clipRect, paintFlags, paintClipRecorderPtr);
         paintLayerByApplyingTransform(context, paintingInfo, paintFlags, fragment.paginationOffset);
-        LayerPainter(*m_renderLayer.parent()).restoreClip(context, paintingInfo.paintDirtyRect, clipRect);
+        LayerPainter(*m_renderLayer.parent()).restoreClip(context, paintingInfo.paintDirtyRect, clipRect, paintClipRecorderPtr);
     }
 }
 
 } // namespace blink