[New Multicolumn] Render transformed layers into multiple fragments.

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 67 matching lines @@
 
     // PaintLayerAppliedTransform is used in RenderReplica, to avoid applying the transform twice.
     if (m_renderLayer.paintsWithTransform(paintingInfo.paintBehavior) && !(paintFlags & PaintLayerAppliedTransform)) {
         paintLayerWithTransform(context, paintingInfo, paintFlags);
         return;
     }
 
     paintLayerContentsAndReflection(context, paintingInfo, paintFlags);
 }
 
-void LayerPainter::paintLayerContentsAndReflection(GraphicsContext* context, const LayerPaintingInfo& paintingInfo, PaintLayerFlags paintFlags)
+void LayerPainter::paintLayerContentsAndReflection(GraphicsContext* context, const LayerPaintingInfo& paintingInfo, PaintLayerFlags paintFlags, FragmentPolicy fragmentPolicy)
 {
     ASSERT(m_renderLayer.isSelfPaintingLayer() || m_renderLayer.hasSelfPaintingLayerDescendant());
 
     PaintLayerFlags localPaintFlags = paintFlags & ~(PaintLayerAppliedTransform);
 
     // Paint the reflection first if we have one.
     if (m_renderLayer.reflectionInfo())
         m_renderLayer.reflectionInfo()->paint(context, paintingInfo, localPaintFlags | PaintLayerPaintingReflection);
 
     localPaintFlags |= PaintLayerPaintingCompositingAllPhases;
-    paintLayerContents(context, paintingInfo, localPaintFlags);
+    paintLayerContents(context, paintingInfo, localPaintFlags, fragmentPolicy);
 }
 
 class ClipPathHelper {
 public:
     ClipPathHelper(GraphicsContext* context, const RenderLayer& renderLayer, const LayerPaintingInfo& paintingInfo, LayoutRect& rootRelativeBounds, bool& rootRelativeBoundsComputed,
         const LayoutPoint& offsetFromRoot, PaintLayerFlags paintFlags)
         : m_resourceClipper(0), m_clipStateSaver(*context, false), m_renderLayer(renderLayer), m_context(context)
     {
         RenderStyle* style = renderLayer.renderer()->style();
 
@@ skipping 48 matching lines @@
             m_resourceClipper->postApplyStatefulResource(m_renderLayer.renderer(), m_context, m_clipperState);
     }
 private:
     RenderSVGResourceClipper* m_resourceClipper;
     GraphicsContextStateSaver m_clipStateSaver;
     RenderSVGResourceClipper::ClipperState m_clipperState;
     const RenderLayer& m_renderLayer;
     GraphicsContext* m_context;
 };
 
-void LayerPainter::paintLayerContents(GraphicsContext* context, const LayerPaintingInfo& paintingInfo, PaintLayerFlags paintFlags)
+void LayerPainter::paintLayerContents(GraphicsContext* context, const LayerPaintingInfo& paintingInfo, PaintLayerFlags paintFlags, FragmentPolicy fragmentPolicy)
 {
     ASSERT(m_renderLayer.isSelfPaintingLayer() || m_renderLayer.hasSelfPaintingLayerDescendant());
     ASSERT(!(paintFlags & PaintLayerAppliedTransform));
 
     bool isSelfPaintingLayer = m_renderLayer.isSelfPaintingLayer();
     bool isPaintingOverlayScrollbars = paintFlags & PaintLayerPaintingOverlayScrollbars;
     bool isPaintingScrollingContent = paintFlags & PaintLayerPaintingCompositingScrollingPhase;
     bool isPaintingCompositedForeground = paintFlags & PaintLayerPaintingCompositingForegroundPhase;
     bool isPaintingCompositedBackground = paintFlags & PaintLayerPaintingCompositingBackgroundPhase;
     bool isPaintingOverflowContents = paintFlags & PaintLayerPaintingOverflowContents;
@@ skipping 40 matching lines @@
 
         transparencyRecorder = adoptPtr(new TransparencyRecorder(context, m_renderLayer.renderer()->displayItemClient(),
             context->compositeOperation(), m_renderLayer.renderer()->style()->blendMode(), m_renderLayer.renderer()->opacity(), context->compositeOperation()));
     }
 
     LayerPaintingInfo localPaintingInfo(paintingInfo);
 
     LayerFragments layerFragments;
     if (shouldPaintContent || shouldPaintOutline || isPaintingOverlayScrollbars) {
         // Collect the fragments. This will compute the clip rectangles and paint offsets for each layer fragment.
-        m_renderLayer.collectFragments(layerFragments, localPaintingInfo.rootLayer, localPaintingInfo.paintDirtyRect,
-            (paintFlags & PaintLayerUncachedClipRects) ? UncachedClipRects : PaintingClipRects, IgnoreOverlayScrollbarSize,
-            shouldRespectOverflowClip(paintFlags, m_renderLayer.renderer()), &offsetFromRoot, localPaintingInfo.subPixelAccumulation);
+        ClipRectsCacheSlot cacheSlot = (paintFlags & PaintLayerUncachedClipRects) ? UncachedClipRects : PaintingClipRects;
+        ShouldRespectOverflowClip respectOverflowClip = shouldRespectOverflowClip(paintFlags, m_renderLayer.renderer());
+        if (fragmentPolicy == ForceSingleFragment)
+            m_renderLayer.appendSingleFragmentIgnoringPagination(layerFragments, localPaintingInfo.rootLayer, localPaintingInfo.paintDirtyRect, cacheSlot, IgnoreOverlayScrollbarSize, respectOverflowClip, &offsetFromRoot, localPaintingInfo.subPixelAccumulation);
+        else
+            m_renderLayer.collectFragments(layerFragments, localPaintingInfo.rootLayer, localPaintingInfo.paintDirtyRect, cacheSlot, IgnoreOverlayScrollbarSize, respectOverflowClip, &offsetFromRoot, localPaintingInfo.subPixelAccumulation);
         if (shouldPaintContent)
             shouldPaintContent = atLeastOneFragmentIntersectsDamageRect(layerFragments, localPaintingInfo, paintFlags, offsetFromRoot);
     }
 
     bool selectionOnly = localPaintingInfo.paintBehavior & PaintBehaviorSelectionOnly;
     // 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;
@@ skipping 126 matching lines @@
         if (parentLayer) {
             ClipRect clipRectForFragment(clipRect);
             clipRectForFragment.moveBy(fragment.paginationOffset);
             clipRectForFragment.intersect(fragment.backgroundRect);
             if (clipRectForFragment.isEmpty())
                 continue;
             if (needsToClip(paintingInfo, clipRectForFragment))
                 clipRecorder = adoptPtr(new LayerClipRecorder(parentLayer->renderer(), context, DisplayItem::ClipLayerParent, clipRectForFragment, &paintingInfo, fragment.paginationOffset, paintFlags));
         }
 
         paintFragmentByApplyingTransform(context, paintingInfo, paintFlags, fragment.paginationOffset);

[chrishtr, 2015/01/15 18:49:47]

It looks like a bunch of the complexity in this CL is in re-creating the
fragment under the hood from the partial data sent through this function. Isn't
there a cleaner way to pass the fragment you already have
at this point down through the relevant interfaces?

[mstensho (USE GERRIT), 2015/01/15 20:36:47]

Sorry, I'm not sure if I understand. This CL isn't about changing the behavior
in this part of the code (non-composited transforms) (although the CL is
certainly about NOT messing up things for this part of the code).

I'm only interested in being able to cancel out the single-fragment forcing,
which this code still needs. Single-fragment forcing cannot be used when
paintLayerContents() (and not paintLayer(), which gets bypassed) is called
directly from CompositedLayerMapping::doPaintTask(). That's what I'm fixing.

Or did you mean that we should change non-composited transforms (this code) to
set up only one transform (instead of one per fragment) for the entire layer, so
that it gets equally borked, compared to when compositing? Then we'd get the
problems pointed out in the commit message also when not compositing transforms
in multicol. Then again, none of the renderings (composited vs. non-composited)
are really correct. The transform's origin is wrong (although differently wrong)
in both cases. Column clipping works fine only when not compositing, though.

Correct rendering of transforms in multicol (or paged) is an unsolved mystery. I
hope it will be possible to get it right with slimming paint & co. The thing is
that if we decide that we need graphics layers for a transform inside multicol
(which is today's core/rendering/compositing/ stuff, which is going to be
removed, as far as I understand), I think we should ideally create a separate
layer for each column, so that they get separate transform origins, and get
clipped correctly against the column gaps. I think the code right here
(non-composited) is closer to that goal than what can be achieved with the
current compositing code involved. This makes me reluctant to break it.

Try this in Firefox; they get it right (Blink doesn't; not when composting and
not when not compositing):

<div style="margin:10em auto; width:30em; -webkit-columns:2; columns:2;
-moz-columns:2; line-height:2em; height:4em; column-fill:auto;
-moz-column-fill:auto; background:yellow;">
    first column<br>
    <div style="transform:rotate(45deg);">
        first column<br>
        second column<br>
    </div>
    second column<br>
</div>

All I really want to achieve with this CL is to not unconditionally lose all
transformed content in all columns but the initial one, which is part of fixing
issue 359877 as well as possible. But if you think the gain is too little to
bother with the extra code complexity, maybe I should just drop this CL?

     }
 }
 
 void LayerPainter::paintFragmentByApplyingTransform(GraphicsContext* context, const LayerPaintingInfo& paintingInfo, PaintLayerFlags paintFlags, const LayoutPoint& fragmentTranslation)
 {
     // This involves subtracting out the position of the layer in our current coordinate space, but preserving
     // the accumulated error for sub-pixel layout.
     LayoutPoint delta;
     m_renderLayer.convertToLayerCoords(paintingInfo.rootLayer, delta);
     delta.moveBy(fragmentTranslation);
     TransformationMatrix transform(m_renderLayer.renderableTransform(paintingInfo.paintBehavior));
     IntPoint roundedDelta = roundedIntPoint(delta);
     transform.translateRight(roundedDelta.x(), roundedDelta.y());
     LayoutSize adjustedSubPixelAccumulation = paintingInfo.subPixelAccumulation + (delta - roundedDelta);
 
     TransformRecorder transformRecorder(*context, m_renderLayer.renderer()->displayItemClient(), transform.toAffineTransform());
 
     // Now do a paint with the root layer shifted to be us.
     LayerPaintingInfo transformedPaintingInfo(&m_renderLayer, enclosingIntRect(transform.inverse().mapRect(paintingInfo.paintDirtyRect)), paintingInfo.paintBehavior,
         adjustedSubPixelAccumulation, paintingInfo.paintingRoot);
-    paintLayerContentsAndReflection(context, transformedPaintingInfo, paintFlags);
+    paintLayerContentsAndReflection(context, transformedPaintingInfo, paintFlags, ForceSingleFragment);

[chrishtr, 2015/01/15 23:33:45]

What I mean is that this call stack appears to be present:

paintLayerWithTransform
  -> paintFragmentByApplyingTransform
    -> paintLayerContentsAndReflection
      -> paintLayerContents

paintLayerContents then either collects fragments or collects one fragment based
on the fragment forcing enum parameter.
But paintLayerWithTransform already collected the fragments and is iterating
over them. Why shouldn't the code just pass down the fragment and avoid
recomputing it?

[mstensho (USE GERRIT), 2015/02/03 13:55:01]

paintLayerWithTransform() collects fragment(s) for the pagination layer (the
flow thread), to set up column clipping and column translation (and to figure
out which columns we need to visit). paintLayerContents(), on the other hand,
collects fragment(s) for the layer itself (to set up clipping established by the
layer itself (overflow:hidden, for instance).

I really believe this needs to be done in separate steps. Column clipping needs
to be set before transforming (because the transform is somewhere *inside* the
column contents, and the columns shouldn't be affected by the transform), and
layer clipping is set after transforming the layer.

We could certainly calculate the layer fragment in
paintFragmentByApplyingTransform() and pass it down to paintLayerContents(),
instead of saying ForceSingleFragment and deal with it when we get there, but I
really don't think that would be cleaner. That would mean yet another place
where we "collect" fragments.

 }
 
 void LayerPainter::paintChildren(unsigned childrenToVisit, GraphicsContext* context, const LayerPaintingInfo& paintingInfo, PaintLayerFlags paintFlags)
 {
     if (!m_renderLayer.hasSelfPaintingLayerDescendant())
         return;
 
 #if ENABLE(ASSERT)
     LayerListMutationDetector mutationChecker(m_renderLayer.stackingNode());
 #endif
@@ skipping 311 matching lines @@
     if (!m_renderLayer.containsDirtyOverlayScrollbars())
         return;
 
     LayerPaintingInfo paintingInfo(&m_renderLayer, enclosingIntRect(damageRect), paintBehavior, LayoutSize(), paintingRoot);
     paintLayer(context, paintingInfo, PaintLayerPaintingOverlayScrollbars);
 
     m_renderLayer.setContainsDirtyOverlayScrollbars(false);
 }
 
 } // namespace blink