Get rid of LayerPainter::paintTransformedLayerIntoFragments().

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/paint/FilterPainter.h"
@@ skipping 52 matching lines @@
 
     // If this layer is totally invisible then there is nothing to paint.
     if (!m_renderLayer.renderer()->opacity())
         return;
 
     if (m_renderLayer.paintsWithTransparency(paintingInfo.paintBehavior))
         paintFlags |= PaintLayerHaveTransparency;
 
     // PaintLayerAppliedTransform is used in RenderReplica, to avoid applying the transform twice.
     if (m_renderLayer.paintsWithTransform(paintingInfo.paintBehavior) && !(paintFlags & PaintLayerAppliedTransform)) {
+        // FIXME: move everything into paintLayerByApplyingTransform().
         TransformationMatrix layerTransform = m_renderLayer.renderableTransform(paintingInfo.paintBehavior);
         // If the transform can't be inverted, then don't paint anything.
         if (!layerTransform.isInvertible())
             return;
 
-        if (m_renderLayer.enclosingPaginationLayer()) {
-            // FIXME: unify this one-off path with the code below.
-            paintTransformedLayerIntoFragments(context, paintingInfo, paintFlags);
-            return;
-        }
+        // If this is the "root" layer, clipping wrt. the ancestry has already been set up, which
+        // means that we can skip some unnecessary work (and even potentially incorrect work at
+        // that, if the ancestry has additional transforms).
+        RenderLayer* parentLayer = &m_renderLayer == paintingInfo.rootLayer ? 0 : m_renderLayer.parent();
 
-        // Make sure the parent's clip rects have been calculated.
-        ClipRect clipRect = paintingInfo.paintDirtyRect;
-
-        OwnPtr<ClipRecorder> clipRecorder;
-        if (m_renderLayer.parent()) {
+        ClipRect clipRect(LayoutRect::infiniteRect());
+        if (parentLayer) {
+            // Calculate the clip rectangle that the ancestors establish.
             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);
-
-            if (needsToClip(paintingInfo, clipRect)) {
-                clipRecorder = adoptPtr(new ClipRecorder(m_renderLayer.parent()->renderer(), context, DisplayItem::ClipLayerParent, clipRect));
-                if (clipRect.hasRadius())
-                    applyRoundedRectClips(*m_renderLayer.parent(), paintingInfo, context, LayoutPoint(), paintFlags, *clipRecorder);
-            }
         }
 
-        paintLayerByApplyingTransform(context, paintingInfo, paintFlags);
+        RenderLayer* paginationLayer = m_renderLayer.enclosingPaginationLayer();
+        LayerFragments fragments;

[chrishtr, 2014/11/17 23:27:49]

Factor all this code into a new method
paintFragmentsForLayerByApplyingTransform, this method is getting too big.

[mstensho (USE GERRIT), 2014/11/18 08:43:58]

What I was going to do next (see the first FIXME) was to move everything into
paintLayerByApplyingTransform(). But having two methods would probably be even
cleaner.

Done, but I went for different names. I renamed old
paintLayerByApplyingTransform() to paintFragmentByApplyingTransform(), and moved
everything else to a new method simply named paintLayerWithTransform(). Also
renamed the parameter translationOffset to fragmentTranslation and removed the
default value.

Let me know what you think.

+        if (paginationLayer) {
+            ClipRectsCacheSlot cacheSlot = (paintFlags & PaintLayerUncachedClipRects) ? UncachedClipRects : PaintingClipRects;
+            ShouldRespectOverflowClip respectOverflowClip = shouldRespectOverflowClip(paintFlags, m_renderLayer.renderer());
+            // Calculate the transformed bounding box in the current coordinate space, to figure out
+            // which fragmentainers (e.g. columns) we need to visit.
+            LayoutRect transformedExtent = RenderLayer::transparencyClipBox(&m_renderLayer, paginationLayer, RenderLayer::PaintingTransparencyClipBox, RenderLayer::RootOfTransparencyClipBox, paintingInfo.subPixelAccumulation, paintingInfo.paintBehavior);
+            paginationLayer->collectFragments(fragments, paintingInfo.rootLayer, paintingInfo.paintDirtyRect, cacheSlot, IgnoreOverlayScrollbarSize, respectOverflowClip, 0, paintingInfo.subPixelAccumulation, &transformedExtent);
+        } 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.
+            fragments.append(LayerFragment());
+        }
 
+        for (const auto& fragment: fragments) {
+            ClipRect clipRectForFragment(clipRect);
+            if (paginationLayer) {
+                clipRectForFragment.moveBy(fragment.paginationOffset);
+                clipRectForFragment.intersect(fragment.backgroundRect);
+                if (clipRectForFragment.isEmpty())
+                    continue;
+            }
+            OwnPtr<ClipRecorder> clipRecorder;
+            if (parentLayer && needsToClip(paintingInfo, clipRectForFragment)) {
+                clipRecorder = adoptPtr(new ClipRecorder(parentLayer->renderer(), context, DisplayItem::ClipLayerParent, clipRectForFragment));
+                if (clipRectForFragment.hasRadius())
+                    applyRoundedRectClips(*parentLayer, paintingInfo, context, fragment.paginationOffset, paintFlags, *clipRecorder);
+            }
+
+            paintLayerByApplyingTransform(context, paintingInfo, paintFlags, fragment.paginationOffset);
+        }
         return;
     }
 
     paintLayerContentsAndReflection(context, paintingInfo, paintFlags);
 }
 
 class TransparencyLayerHelper {
 public:
     TransparencyLayerHelper(GraphicsContext* context, RenderLayer& renderLayer, const RenderLayer* rootLayer, const LayoutRect& paintDirtyRect, const LayoutSize& subPixelAccumulation, PaintBehavior paintBehavior)
         : m_transparencyLayerInProgress(false)
@@ skipping 649 matching lines @@
 {
     if (!m_renderLayer.containsDirtyOverlayScrollbars())
         return;
 
     LayerPaintingInfo paintingInfo(&m_renderLayer, enclosingIntRect(damageRect), paintBehavior, LayoutSize(), paintingRoot);
     paintLayer(context, paintingInfo, PaintLayerPaintingOverlayScrollbars);
 
     m_renderLayer.setContainsDirtyOverlayScrollbars(false);
 }
 
-void LayerPainter::paintTransformedLayerIntoFragments(GraphicsContext* context, const LayerPaintingInfo& paintingInfo, PaintLayerFlags paintFlags)
-{
-    LayerFragments enclosingPaginationFragments;
-    LayoutPoint offsetOfPaginationLayerFromRoot;
-    LayoutRect transformedExtent = RenderLayer::transparencyClipBox(&m_renderLayer, m_renderLayer.enclosingPaginationLayer(), RenderLayer::PaintingTransparencyClipBox, RenderLayer::RootOfTransparencyClipBox, paintingInfo.subPixelAccumulation, paintingInfo.paintBehavior);
-    m_renderLayer.enclosingPaginationLayer()->collectFragments(enclosingPaginationFragments, paintingInfo.rootLayer, paintingInfo.paintDirtyRect,
-        (paintFlags & PaintLayerUncachedClipRects) ? UncachedClipRects : PaintingClipRects, IgnoreOverlayScrollbarSize,
-        shouldRespectOverflowClip(paintFlags, m_renderLayer.renderer()), &offsetOfPaginationLayerFromRoot, paintingInfo.subPixelAccumulation, &transformedExtent);
-
-    for (size_t i = 0; i < enclosingPaginationFragments.size(); ++i) {
-        const LayerFragment& fragment = enclosingPaginationFragments.at(i);
-
-        // Apply the page/column clip for this fragment, as well as any clips established by layers in between us and
-        // the enclosing pagination layer.
-        LayoutRect clipRect = fragment.backgroundRect.rect();
-
-        // Now compute the clips within a given fragment
-        if (m_renderLayer.parent() != m_renderLayer.enclosingPaginationLayer()) {
-            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);
-        }
-
-        OwnPtr<ClipRecorder> clipRecorder;
-        if (needsToClip(paintingInfo, clipRect))
-            clipRecorder = adoptPtr(new ClipRecorder(m_renderLayer.renderer(), context, DisplayItem::ClipLayerFragmentParent, clipRect));
-
-        paintLayerByApplyingTransform(context, paintingInfo, paintFlags, fragment.paginationOffset);
-    }
-}
-
 } // namespace blink