Generate scroll/clip display item hierarchy for SPv2

Source/core/paint/DeprecatedPaintLayerPainter.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/DeprecatedPaintLayerPainter.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/CompositingRecorder.h"
 #include "core/paint/DeprecatedPaintLayer.h"
 #include "core/paint/FilterPainter.h"
 #include "core/paint/LayerClipRecorder.h"
+#include "core/paint/LayerDescendantClipRecorder.h"
 #include "core/paint/LayerFixedPositionRecorder.h"
 #include "core/paint/PaintInfo.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 "core/paint/TransformRecorder.h"
 #include "platform/graphics/GraphicsLayer.h"
 #include "platform/graphics/paint/ClipPathRecorder.h"
 #include "platform/graphics/paint/ClipRecorder.h"
 #include "platform/graphics/paint/CompositingDisplayItem.h"
+#include "platform/graphics/paint/FixedPositionContainerDisplayItem.h"
 #include "platform/graphics/paint/SubsequenceRecorder.h"
 #include "platform/graphics/paint/Transform3DDisplayItem.h"
 #include "wtf/Optional.h"
 
 namespace blink {
 
 static inline bool shouldSuppressPaintingLayer(DeprecatedPaintLayer* 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
@@ skipping 45 matching lines @@
     if (!m_paintLayer.layoutObject()->opacity() && !m_paintLayer.layoutObject()->hasBackdropFilter())
         return;
 
     if (!needsRepaint && SubsequenceRecorder::useCachedSubsequenceIfPossible(*context, m_paintLayer))
         return;
     SubsequenceRecorder subsequenceRecorder(*context, m_paintLayer);
 
     if (m_paintLayer.paintsWithTransparency(paintingInfo.globalPaintFlags()))
         paintFlags |= PaintLayerHaveTransparency;
 
-    LayerFixedPositionRecorder fixedPositionRecorder(*context, *m_paintLayer.layoutObject());

[pdr., 2015/09/08 04:23:53]

Can you pull this refactoring of LayerFixedPositionRecorder into its own change
(the removal of m_isFixedPosition and m_isFixedPositionContainer, the change
here, and the spv1-specific refactoring in LayerFixedPositionRecorder)? The
basic idea seems to be sound and separable.

[trchen, 2015/09/15 04:48:40]

Done.

-
     // PaintLayerAppliedTransform is used in LayoutReplica, to avoid applying the transform twice.
     if (m_paintLayer.paintsWithTransform(paintingInfo.globalPaintFlags()) && !(paintFlags & PaintLayerAppliedTransform)) {
         paintLayerWithTransform(context, paintingInfo, paintFlags);
         return;
     }
 
     paintLayerContentsAndReflection(context, paintingInfo, paintFlags);
 }
 
 void DeprecatedPaintLayerPainter::paintLayerContentsAndReflection(GraphicsContext* context, const DeprecatedPaintLayerPaintingInfo& paintingInfo, PaintLayerFlags paintFlags, FragmentPolicy fragmentPolicy)
 {
     ASSERT(m_paintLayer.isSelfPaintingLayer() || m_paintLayer.hasSelfPaintingLayerDescendant());
 
     PaintLayerFlags localPaintFlags = paintFlags & ~(PaintLayerAppliedTransform);
 
     // Paint the reflection first if we have one.
     if (m_paintLayer.reflectionInfo()) {
         ScopeRecorder scopeRecorder(*context);
         m_paintLayer.reflectionInfo()->paint(context, paintingInfo, localPaintFlags | PaintLayerPaintingReflection);
     }
 
     localPaintFlags |= PaintLayerPaintingCompositingAllPhases;
     paintLayerContents(context, paintingInfo, localPaintFlags, fragmentPolicy);
 }
 
 class ClipPathHelper {
 public:
-    ClipPathHelper(GraphicsContext* context, const DeprecatedPaintLayer& paintLayer, const DeprecatedPaintLayerPaintingInfo& paintingInfo, LayoutRect& rootRelativeBounds, bool& rootRelativeBoundsComputed,
+    ClipPathHelper(GraphicsContext* context, const DeprecatedPaintLayer& paintLayer, const LayoutRect& interestRect, LayoutRect& rootRelativeBounds, bool& rootRelativeBoundsComputed,

[pdr., 2015/09/08 04:23:53]

Chris just landed a patch that uses DPLPI's ancestorHasClipPathClipping but I
like the refactoring towards an interest rect here. Maybe we should switch this
back to DPLI but plan on renaming DPLPI.paintDirtyRect to DPLPI.interestRect in
a future patch?

[trchen, 2015/09/15 04:48:40]

Done.

         const LayoutPoint& offsetFromRoot, PaintLayerFlags paintFlags)
         : m_resourceClipper(0), m_paintLayer(paintLayer), m_context(context)
     {
         const ComputedStyle& style = paintLayer.layoutObject()->styleRef();
 
         // Clip-path, like border radius, must not be applied to the contents of a composited-scrolling container.
         // It must, however, still be applied to the mask layer, so that the compositor can properly mask the
         // scrolling contents and scrollbars.
         if (!paintLayer.layoutObject()->hasClipPath() || (paintLayer.needsCompositedScrolling() && !(paintFlags & PaintLayerPaintingChildClippingMaskPhase)))
             return;
@@ skipping 16 matching lines @@
             // FIXME: It doesn't work with forward or external SVG references (https://bugs.webkit.org/show_bug.cgi?id=90405)
             Element* element = document.getElementById(referenceClipPathOperation->fragment());
             if (isSVGClipPathElement(element) && element->layoutObject()) {
                 if (!rootRelativeBoundsComputed) {
                     rootRelativeBounds = paintLayer.physicalBoundingBoxIncludingReflectionAndStackingChildren(offsetFromRoot);
                     rootRelativeBoundsComputed = true;
                 }
 
                 m_resourceClipper = toLayoutSVGResourceClipper(toLayoutSVGResourceContainer(element->layoutObject()));
                 if (!SVGClipPainter(*m_resourceClipper).prepareEffect(*paintLayer.layoutObject(), FloatRect(rootRelativeBounds),
-                    FloatRect(paintingInfo.paintDirtyRect), context, m_clipperState)) {
+                    FloatRect(interestRect), context, m_clipperState)) {
                     // No need to post-apply the clipper if this failed.
                     m_resourceClipper = 0;
                 }
             }
         }
     }
 
     ~ClipPathHelper()
     {
         if (m_resourceClipper)
@@ skipping 28 matching lines @@
         && ((isPaintingScrollingContent && isPaintingCompositedBackground)
         || (!isPaintingScrollingContent && isPaintingCompositedForeground));
     bool shouldPaintContent = m_paintLayer.hasVisibleContent() && isSelfPaintingLayer && !isPaintingOverlayScrollbars;
 
     if (paintFlags & PaintLayerPaintingRootBackgroundOnly && !m_paintLayer.layoutObject()->isLayoutView() && !m_paintLayer.layoutObject()->isDocumentElement())
         return;
 
     // Ensure our lists are up-to-date.
     m_paintLayer.stackingNode()->updateLayerListsIfNeeded();
 
-    LayoutPoint offsetFromRoot;
-    m_paintLayer.convertToLayerCoords(paintingInfo.rootLayer, offsetFromRoot);
-
-    if (m_paintLayer.compositingState() == PaintsIntoOwnBacking)

[pdr., 2015/09/08 04:23:53]

The offsetFromRoot refactoring looks correct, but I'm less sure about removing
the PaintsIntoOwnBacking check here. How does this not affect SPV1 (here, and
the PaintsIntoOwnBacking changes below)? Can this be pulled into a separate
patch (before or after this change)?

[trchen, 2015/09/15 04:48:40]

Done. I think paintingInfo.subPixelAccumulation will be set by the caller in
every code path. Anyway it is not a necessity here.

-        offsetFromRoot.move(m_paintLayer.subpixelAccumulation());
+    LayoutPoint offsetFromRoot = toLayoutPoint(paintingInfo.subPixelAccumulation);
+    if (RuntimeEnabledFeatures::slimmingPaintV2Enabled())
+        m_paintLayer.convertToLayerCoords(paintingInfo.rootLayer, offsetFromRoot, DeprecatedPaintLayer::ExcludeScroll);
     else
-        offsetFromRoot.move(paintingInfo.subPixelAccumulation);
+        m_paintLayer.convertToLayerCoords(paintingInfo.rootLayer, offsetFromRoot);
 
     LayoutRect rootRelativeBounds;
     bool rootRelativeBoundsComputed = false;
 
+    if (RuntimeEnabledFeatures::slimmingPaintV2Enabled() && !context->displayItemList()->displayItemConstructionIsDisabled()) {
+        if (paintingInfo.rootLayer == &m_paintLayer) {
+            // A counter scroll needs to be applied in non-rootLayerScrolls mode,
+            // because we are supposed to paint in absolute space.
+            // (i.e. Impl-side scrolling would be impossible.)
+            // With rootLayerScrolls enabled, we are in the viewport space instead.
+            AffineTransform counterScroll;
+            if (m_paintLayer.layoutObject()->isLayoutView()) {
+                Settings* settings = m_paintLayer.layoutObject()->document().settings();
+                if (settings && settings->rootLayerScrolls()) {
+                    IntSize scrollOffset = static_cast<LayoutView*>(m_paintLayer.layoutObject())->frameView()->scrollOffset();
+                    counterScroll.translate(scrollOffset.width(), scrollOffset.height());
+                }
+            }
+            TransformRecorder frameScrollWorkaround(*context, *m_paintLayer.layoutObject(), counterScroll);
+
+            context->displayItemList()->createAndAppend<FixedPositionContainerDisplayItem>(*m_paintLayer.layoutObject());
+        }
+    }
+
     // These helpers output clip and compositing operations using a RAII pattern. Stack-allocated-varibles are destructed in the reverse order of construction,
     // so they are nested properly.
-    ClipPathHelper clipPathHelper(context, m_paintLayer, paintingInfo, rootRelativeBounds, rootRelativeBoundsComputed, offsetFromRoot, paintFlags);
+    ClipPathHelper clipPathHelper(context, m_paintLayer, paintingInfo.paintDirtyRect, rootRelativeBounds, rootRelativeBoundsComputed, offsetFromRoot, paintFlags);
 
     Optional<CompositingRecorder> compositingRecorder;
     // Blending operations must be performed only with the nearest ancestor stacking context.
     // Note that there is no need to composite if we're painting the root.
     // FIXME: this should be unified further into DeprecatedPaintLayer::paintsWithTransparency().
     bool shouldCompositeForBlendMode = (!m_paintLayer.layoutObject()->isDocumentElement() || m_paintLayer.layoutObject()->isSVGRoot()) && m_paintLayer.stackingNode()->isStackingContext() && m_paintLayer.hasNonIsolatedDescendantWithBlendMode();
     if (shouldCompositeForBlendMode || m_paintLayer.paintsWithTransparency(paintingInfo.globalPaintFlags())) {
         FloatRect compositingBounds = FloatRect(m_paintLayer.paintingExtent(paintingInfo.rootLayer, paintingInfo.paintDirtyRect, paintingInfo.globalPaintFlags()));
         compositingRecorder.emplace(*context, *m_paintLayer.layoutObject(),
             WebCoreCompositeToSkiaComposite(CompositeSourceOver, m_paintLayer.layoutObject()->style()->blendMode()),
             m_paintLayer.layoutObject()->opacity(), &compositingBounds);
     }
 
-    DeprecatedPaintLayerPaintingInfo localPaintingInfo(paintingInfo);
-    if (m_paintLayer.compositingState() == PaintsIntoOwnBacking)
-        localPaintingInfo.subPixelAccumulation = m_paintLayer.subpixelAccumulation();
-
     DeprecatedPaintLayerFragments layerFragments;
     if (shouldPaintContent || shouldPaintOutline || isPaintingOverlayScrollbars) {
         // Collect the fragments. This will compute the clip rectangles and paint offsets for each layer fragment.
         ClipRectsCacheSlot cacheSlot = (paintFlags & PaintLayerUncachedClipRects) ? UncachedClipRects : PaintingClipRects;
         ShouldRespectOverflowClip respectOverflowClip = shouldRespectOverflowClip(paintFlags, m_paintLayer.layoutObject());
-        if (fragmentPolicy == ForceSingleFragment)
-            m_paintLayer.appendSingleFragmentIgnoringPagination(layerFragments, localPaintingInfo.rootLayer, localPaintingInfo.paintDirtyRect, cacheSlot, IgnoreOverlayScrollbarSize, respectOverflowClip, &offsetFromRoot, localPaintingInfo.subPixelAccumulation);
-        else
-            m_paintLayer.collectFragments(layerFragments, localPaintingInfo.rootLayer, localPaintingInfo.paintDirtyRect, cacheSlot, IgnoreOverlayScrollbarSize, respectOverflowClip, &offsetFromRoot, localPaintingInfo.subPixelAccumulation);
+        if (RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
+            // TODO(trchen): Need to handle layer fragmentation.
+            DeprecatedPaintLayerFragment fragment;
+            fragment.layerBounds = LayoutRect(offsetFromRoot, LayoutSize(m_paintLayer.size()));
+            fragment.backgroundRect = LayoutRect::infiniteRect();
+            fragment.foregroundRect = LayoutRect::infiniteRect();
+            fragment.outlineRect = LayoutRect::infiniteRect();
+            layerFragments.append(fragment);
+        } else if (fragmentPolicy == ForceSingleFragment) {
+            m_paintLayer.appendSingleFragmentIgnoringPagination(layerFragments, paintingInfo.rootLayer, paintingInfo.paintDirtyRect, cacheSlot, IgnoreOverlayScrollbarSize, respectOverflowClip, &offsetFromRoot, paintingInfo.subPixelAccumulation);
+        } else {
+            m_paintLayer.collectFragments(layerFragments, paintingInfo.rootLayer, paintingInfo.paintDirtyRect, cacheSlot, IgnoreOverlayScrollbarSize, respectOverflowClip, &offsetFromRoot, paintingInfo.subPixelAccumulation);
+        }
+
         if (shouldPaintContent)
-            shouldPaintContent = atLeastOneFragmentIntersectsDamageRect(layerFragments, localPaintingInfo, paintFlags, offsetFromRoot);
+            shouldPaintContent = atLeastOneFragmentIntersectsDamageRect(layerFragments, paintingInfo, paintFlags, offsetFromRoot);
     }
 
-    bool selectionOnly = localPaintingInfo.globalPaintFlags() & GlobalPaintSelectionOnly;
+    bool selectionOnly = paintingInfo.globalPaintFlags() & GlobalPaintSelectionOnly;
     // If this layer's layoutObject is a child of the paintingRoot, we paint unconditionally, which
     // is done by passing a nil paintingRoot down to our layoutObject (as if no paintingRoot was ever set).
     // Else, our layout 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 layoutObjects.
     LayoutObject* paintingRootForLayoutObject = 0;
-    if (localPaintingInfo.paintingRoot && !m_paintLayer.layoutObject()->isDescendantOf(localPaintingInfo.paintingRoot))
-        paintingRootForLayoutObject = localPaintingInfo.paintingRoot;
+    if (paintingInfo.paintingRoot && !m_paintLayer.layoutObject()->isDescendantOf(paintingInfo.paintingRoot))
+        paintingRootForLayoutObject = paintingInfo.paintingRoot;
 
     { // Begin block for the lifetime of any filter.
+        // FilterPainter may mutate paintingInfo.
+        DeprecatedPaintLayerPaintingInfo localPaintingInfo(paintingInfo);
+        localPaintingInfo.clipToDirtyRect = true;

[pdr., 2015/09/08 04:23:53]

This violate's the comment above clipToDirtyRect because it can cause us to clip
twice with spv1:
https://code.google.com/p/chromium/codesearch#chromium/src/third_party/WebKit...

Should we even respect clipToDirtyRect with spv2?

[trchen, 2015/09/15 04:48:40]

IMO clipToDirtyRect is not inherited and shouldn't belong to DPLPI anyway.

Normally we apply clip per-fragment, but skip clipping if a filter clip is
applied so the edge won't be doubly clipped with anti-alias. I feel this hack
should be removed and we should always apply per-fragment clip.

Yea the changes around localPaintingInfo in this CL are totally no-op. Just to
make sure it doesn't serve any purpose other than carrying clipToDirtyRect. I
can revert it and upload a separate CL to remove it at all.

         FilterPainter filterPainter(m_paintLayer, context, offsetFromRoot, layerFragments.isEmpty() ? ClipRect() : layerFragments[0].backgroundRect, localPaintingInfo, paintFlags,
             rootRelativeBounds, rootRelativeBoundsComputed);
 
         bool shouldPaintBackground = isPaintingCompositedBackground && shouldPaintContent && !selectionOnly;
         bool shouldPaintNegZOrderList = (isPaintingScrollingContent && isPaintingOverflowContents) || (!isPaintingScrollingContent && isPaintingCompositedBackground);
         bool shouldPaintOwnContents = isPaintingCompositedForeground && shouldPaintContent;
         bool shouldPaintNormalFlowAndPosZOrderLists = isPaintingCompositedForeground;
         bool shouldPaintOverlayScrollbars = isPaintingOverlayScrollbars;
 
         if (shouldPaintBackground) {
-            paintBackgroundForFragments(layerFragments, context, paintingInfo.paintDirtyRect,
+            paintBackgroundForFragments(layerFragments, context, localPaintingInfo.paintDirtyRect,
                 localPaintingInfo, paintingRootForLayoutObject, paintFlags);
         }
 
         if (shouldPaintNegZOrderList)
-            paintChildren(NegativeZOrderChildren, context, paintingInfo, paintFlags);
+            paintChildren(NegativeZOrderChildren, context, localPaintingInfo, paintFlags);
 
         if (shouldPaintOwnContents) {
-            paintForegroundForFragments(layerFragments, context, paintingInfo.paintDirtyRect,
+            paintForegroundForFragments(layerFragments, context, localPaintingInfo.paintDirtyRect,
                 localPaintingInfo, paintingRootForLayoutObject, selectionOnly, paintFlags);
         }
 
         if (shouldPaintOutline)
             paintOutlineForFragments(layerFragments, context, localPaintingInfo, paintingRootForLayoutObject, paintFlags);
 
         if (shouldPaintNormalFlowAndPosZOrderLists)
-            paintChildren(NormalFlowChildren | PositiveZOrderChildren, context, paintingInfo, paintFlags);
+            paintChildren(NormalFlowChildren | PositiveZOrderChildren, context, localPaintingInfo, paintFlags);
 
         if (shouldPaintOverlayScrollbars)
             paintOverflowControlsForFragments(layerFragments, context, localPaintingInfo, paintFlags);
     } // FilterPainter block
 
     bool shouldPaintMask = (paintFlags & PaintLayerPaintingCompositingMaskPhase) && shouldPaintContent && m_paintLayer.layoutObject()->hasMask() && !selectionOnly;
     bool shouldPaintClippingMask = (paintFlags & PaintLayerPaintingChildClippingMaskPhase) && shouldPaintContent && !selectionOnly;
 
     if (shouldPaintMask)
-        paintMaskForFragments(layerFragments, context, localPaintingInfo, paintingRootForLayoutObject, paintFlags);
+        paintMaskForFragments(layerFragments, context, paintingInfo, paintingRootForLayoutObject, paintFlags);
     if (shouldPaintClippingMask) {
         // Paint the border radius mask for the fragments.
-        paintChildClippingMaskForFragments(layerFragments, context, localPaintingInfo, paintingRootForLayoutObject, paintFlags);
+        paintChildClippingMaskForFragments(layerFragments, context, paintingInfo, paintingRootForLayoutObject, paintFlags);
     }
 }
 
 bool DeprecatedPaintLayerPainter::needsToClip(const DeprecatedPaintLayerPaintingInfo& localPaintingInfo, const ClipRect& clipRect)
 {
+    // With SPv2 a layer clips its descendants so a layer never clips itself.
+    if (RuntimeEnabledFeatures::slimmingPaintV2Enabled())
+        return false;
     return clipRect.rect() != localPaintingInfo.paintDirtyRect || clipRect.hasRadius();
 }
 
 bool DeprecatedPaintLayerPainter::atLeastOneFragmentIntersectsDamageRect(DeprecatedPaintLayerFragments& fragments, const DeprecatedPaintLayerPaintingInfo& localPaintingInfo, PaintLayerFlags localPaintFlags, const LayoutPoint& offsetFromRoot)
 {
     if (m_paintLayer.enclosingPaginationLayer())
         return true; // The fragments created have already been found to intersect with the damage rect.
 
     if (&m_paintLayer == localPaintingInfo.rootLayer && (localPaintFlags & PaintLayerPaintingOverflowContents))
         return true;
@@ skipping 96 matching lines @@
 
 void DeprecatedPaintLayerPainter::paintChildren(unsigned childrenToVisit, GraphicsContext* context, const DeprecatedPaintLayerPaintingInfo& paintingInfo, PaintLayerFlags paintFlags)
 {
     if (!m_paintLayer.hasSelfPaintingLayerDescendant())
         return;
 
 #if ENABLE(ASSERT)
     LayerListMutationDetector mutationChecker(m_paintLayer.stackingNode());
 #endif
 
+    if (RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
+        paintChildrenWithFullScrollClipChain(childrenToVisit, context, paintingInfo, paintFlags);
+        return;
+    }
+
     IntSize scrollOffsetAccumulation = paintingInfo.scrollOffsetAccumulation;
     if (m_paintLayer.layoutObject()->hasOverflowClip())
         scrollOffsetAccumulation += m_paintLayer.layoutBox()->scrolledContentOffset();
 
     DeprecatedPaintLayerStackingNodeIterator iterator(*m_paintLayer.stackingNode(), childrenToVisit);
     while (DeprecatedPaintLayerStackingNode* child = iterator.next()) {
         DeprecatedPaintLayerPainter childPainter(*child->layer());
         // If this Layer should paint into its own backing or a grouped backing, that will be done via CompositedDeprecatedPaintLayerMapping::paintContents()
         // and CompositedDeprecatedPaintLayerMapping::doPaintTask().
         if (!childPainter.shouldPaintLayerInSoftwareMode(paintingInfo.globalPaintFlags(), paintFlags))
             continue;
 
         DeprecatedPaintLayerPaintingInfo childPaintingInfo = paintingInfo;
         childPaintingInfo.scrollOffsetAccumulation = scrollOffsetAccumulation;
         // Rare case: accumulate scroll offset of non-stacking-context ancestors up to m_paintLayer.
         for (DeprecatedPaintLayer* parentLayer = child->layer()->parent(); parentLayer != &m_paintLayer; parentLayer = parentLayer->parent()) {
             if (parentLayer->layoutObject()->hasOverflowClip())
                 childPaintingInfo.scrollOffsetAccumulation += parentLayer->layoutBox()->scrolledContentOffset();
         }
 
         childPainter.paintLayer(context, childPaintingInfo, paintFlags);
     }
 }
 
+static void recursivelyScrollAndPaintChildLayer(Vector<DeprecatedPaintLayer*>& clippingAncestors, DeprecatedPaintLayer& child, GraphicsContext& context, const DeprecatedPaintLayerPaintingInfo& paintingInfo, PaintLayerFlags paintFlags)
+{
+    ASSERT(RuntimeEnabledFeatures::slimmingPaintV2Enabled());
+    if (clippingAncestors.isEmpty()) {
+        DeprecatedPaintLayerPainter(child).paintLayer(&context, paintingInfo, paintFlags);
+        return;
+    }
+    DeprecatedPaintLayer* layer = clippingAncestors.last();
+    clippingAncestors.removeLast();
+
+    ASSERT(layer->layoutObject()->hasOverflowClip() && layer->layoutObject()->isBox());
+    LayoutPoint paintOffset = toLayoutPoint(paintingInfo.subPixelAccumulation);
+    // TODO(trchen): Hey this is slow. We should be able to calculate this on traversal.

[pdr., 2015/09/08 04:23:53]

Would it be difficult to go ahead and compute all of this data and store it on
DeprecatedPaintLayerPaintingInfo as we walk down?

[trchen, 2015/09/15 04:48:40]

Done.

+    layer->convertToLayerCoords(paintingInfo.rootLayer, paintOffset, DeprecatedPaintLayer::ExcludeScroll);
+    LayerDescendantClipRecorder clipRecorder(context, *layer->layoutBox(), paintOffset);
+
+    IntSize scrollOffset = layer->layoutBox()->scrolledContentOffset();
+    Optional<ScrollRecorder> scrollRecorder;
+    if (layer->scrollsOverflow() || !scrollOffset.isZero())
+        scrollRecorder.emplace(context, *layer->layoutObject(), PaintPhaseBlockBackground, scrollOffset);
+    recursivelyScrollAndPaintChildLayer(clippingAncestors, child, context, paintingInfo, paintFlags);
+}
+
+// TODO(trchen): Measure performance of this and implement display item de-duping if needed.
+// For the pessimistic case this function will generate O(n^2) of clip/scroll pairs, for example:
+// <div style="overflow:scroll;"> * repeat 100 times
+// <div style="position:relative;"></div> * repeat 100 times
+// We will need to generate 100 clip/scroll pairs for each of the in-flow positioned children.
+void DeprecatedPaintLayerPainter::paintChildrenWithFullScrollClipChain(unsigned childrenToVisit, GraphicsContext* context, const DeprecatedPaintLayerPaintingInfo& paintingInfo, PaintLayerFlags paintFlags)
+{
+    ASSERT(RuntimeEnabledFeatures::slimmingPaintV2Enabled());
+
+    DeprecatedPaintLayerStackingNodeIterator iterator(*m_paintLayer.stackingNode(), childrenToVisit);
+    while (DeprecatedPaintLayerStackingNode* childNode = iterator.next()) {
+        DeprecatedPaintLayer* child = childNode->layer();
+        EPosition childPosition = child->layoutObject()->style()->position();
+        if (childPosition == FixedPosition) {
+            ASSERT(paintingInfo.rootLayer == child->enclosingPositionedAncestor());
+            // TODO(trchen): Handle the insanity with reflection + fixed position.
+            LayerFixedPositionRecorder fixedPositionRecorder(*context, *child->layoutObject(), *paintingInfo.rootLayer->layoutObject());
+            DeprecatedPaintLayerPainter(*child).paintLayer(context, paintingInfo, paintFlags);
+            continue;
+        }
+
+        Vector<DeprecatedPaintLayer*> clippingAncestors;
+        DeprecatedPaintLayer* currentLayer = child;

[pdr., 2015/09/08 04:23:53]

Can you break this out into computeClippingLayersBetween(child, m_paintLayer)  
(or something like this).

[trchen, 2015/09/15 04:48:40]

Done.

+        while (currentLayer && currentLayer != &m_paintLayer) {
+            EPosition position = currentLayer->layoutObject()->style()->position();
+            ASSERT(position != FixedPosition);
+
+            DeprecatedPaintLayer* container = nullptr;
+            if (position == AbsolutePosition) {
+                bool ranPastThisLayer;
+                container = currentLayer->enclosingPositionedAncestor(&m_paintLayer, &ranPastThisLayer);
+                if (ranPastThisLayer)
+                    break;
+            } else {
+                container = currentLayer->parent();
+            }
+            if (!container)
+                break;
+
+            if (container->layoutObject()->hasOverflowClip())
+                clippingAncestors.append(container);
+
+            currentLayer = container;
+        }
+
+        recursivelyScrollAndPaintChildLayer(clippingAncestors, *child, *context, paintingInfo, paintFlags);
+    }
+}
+
 // FIXME: inline this.
 static bool paintForFixedRootBackground(const DeprecatedPaintLayer* layer, PaintLayerFlags paintFlags)
 {
     return layer->layoutObject()->isDocumentElement() && (paintFlags & PaintLayerPaintingRootBackgroundOnly);
 }
 
 bool DeprecatedPaintLayerPainter::shouldPaintLayerInSoftwareMode(const GlobalPaintFlags globalPaintFlags, PaintLayerFlags paintFlags)
 {
     DisableCompositingQueryAsserts disabler;
 
@@ skipping 17 matching lines @@
             clipRecorder.emplace(*context, *m_paintLayer.layoutObject(), DisplayItem::ClipLayerOverflowControls, fragment.backgroundRect, &localPaintingInfo, fragment.paginationOffset, paintFlags);
         if (DeprecatedPaintLayerScrollableArea* scrollableArea = m_paintLayer.scrollableArea())
             ScrollableAreaPainter(*scrollableArea).paintOverflowControls(context, roundedIntPoint(toPoint(fragment.layerBounds.location() - m_paintLayer.layoutBoxLocation())), pixelSnappedIntRect(fragment.backgroundRect.rect()), true);
     }
 }
 
 void DeprecatedPaintLayerPainter::paintFragmentWithPhase(PaintPhase phase, const DeprecatedPaintLayerFragment& fragment, GraphicsContext* context, const ClipRect& clipRect, const DeprecatedPaintLayerPaintingInfo& paintingInfo, LayoutObject* paintingRootForLayoutObject, PaintLayerFlags paintFlags, ClipState clipState)
 {
     ASSERT(m_paintLayer.isSelfPaintingLayer());
 
+    if (RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
+        PaintInfo paintInfo(context, enclosingIntRect(paintingInfo.paintDirtyRect), phase, paintingInfo.globalPaintFlags(), paintFlags, paintingRootForLayoutObject, paintingInfo.rootLayer->layoutObject());
+        LayoutPoint paintOffset = toPoint(fragment.layerBounds.location() - m_paintLayer.layoutBoxLocation());
+        m_paintLayer.layoutObject()->paint(paintInfo, paintOffset);
+        return;
+    }
+
     Optional<LayerClipRecorder> clipRecorder;
     if (clipState != HasClipped && paintingInfo.clipToDirtyRect && needsToClip(paintingInfo, clipRect)) {
         DisplayItem::Type clipType = DisplayItem::paintPhaseToClipLayerFragmentType(phase);
         LayerClipRecorder::BorderRadiusClippingRule clippingRule;
         switch (phase) {
         case PaintPhaseBlockBackground: // Background painting will handle clipping to self.
         case PaintPhaseSelfOutline:
         case PaintPhaseMask: // Mask painting will handle clipping to self.
             clippingRule = LayerClipRecorder::DoNotIncludeSelfForBorderRadius;
             break;
@@ skipping 115 matching lines @@
     if (!m_paintLayer.containsDirtyOverlayScrollbars())
         return;
 
     DeprecatedPaintLayerPaintingInfo paintingInfo(&m_paintLayer, LayoutRect(enclosingIntRect(damageRect)), paintFlags, LayoutSize(), paintingRoot);
     paintLayer(context, paintingInfo, PaintLayerPaintingOverlayScrollbars);
 
     m_paintLayer.setContainsDirtyOverlayScrollbars(false);
 }
 
 } // namespace blink