Clip abspos descendants correctly in all columns (not just the first).

third_party/WebKit/Source/core/paint/PaintLayerClipper.cpp

 /*
  * Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc. All rights reserved.
  *
  * Portions are Copyright (C) 1998 Netscape Communications Corporation.
  *
  * Other contributors:
  *   Robert O'Callahan <roc+@cs.cmu.edu>
  *   David Baron <dbaron@fas.harvard.edu>
  *   Christian Biesinger <cbiesinger@web.de>
  *   Randall Jesup <rjesup@wgate.com>
@@ skipping 250 matching lines @@
         } else {
             parentLayer->clipper().calculateClipRects(context, clipRects);
         }
     } else {
         clipRects.reset(LayoutRect(LayoutRect::infiniteIntRect()));
     }
 
     adjustClipRectsForChildren(m_layoutObject, clipRects);
 
     if ((m_layoutObject.hasOverflowClip() && shouldRespectOverflowClip(context)) || m_layoutObject.hasClip()) {
-        // This offset cannot use convertToLayerCoords, because sometimes our rootLayer may be across
-        // some transformed layer boundary, for example, in the PaintLayerCompositor overlapMap, where
-        // clipRects are needed in view space.
-        applyClipRects(context, m_layoutObject, roundedLayoutPoint(m_layoutObject.localToContainerPoint(FloatPoint(), context.rootLayer->layoutObject())), clipRects);
+        PaintLayer* layer = m_layoutObject.layer();
+        LayoutPoint offset;
+        if (!layer->enclosingPaginationLayer()) {
+            // This offset cannot use convertToLayerCoords, because sometimes our rootLayer may be across
+            // some transformed layer boundary, for example, in the PaintLayerCompositor overlapMap, where
+            // clipRects are needed in view space.
+
+            // TODO(mstensho): Switch to always using convertToLayerCoords() (see code further

[chrishtr, 2015/11/19 23:31:41]

localToContainerPoint is actually incorrect here, it should be
localToContainerQuad :) see crbug.com/548184 if you are curious. But
localToContainerQuad makes even less sense for fragmentation, because the result
would have to be multiple quads.

Is the problem that you want to compute clip rects up to the boundary of the
flowthread->visual coordinates conversion? The rootLayer in your use case is the
pagination container, right?

[mstensho (USE GERRIT), 2015/11/20 10:37:15]

Makes sense.
Exactly.
The rootLayer could be anything (if there are no transforms, it will typically
be that of LayoutView). There's normally nothing special when it comes to
setting rootLayer for multicol, unless we have a transform inside a multicol
container.

Clip rects are calculated before we slice and translate the flow thread into
columns, which is why we don't want to be multicol-aware here.

See PaintLayer::collectFragments(). We call clipper().calculateRects(). Then we
intersect layerBoundingBoxInFlowThread with the background clip rectangle. Then
we pass this to enclosingFlowThread->collectLayerFragments(), which will slice
the flow thread into fragments.

[chrishtr, 2015/12/08 22:56:07]

The point I was getting at with asking what the rootLayer is, is this: it
doesn't really make sense to compute pass clip rects across pagination
boundaries. Instead, why not change the code to compute clip rects internally to
the pagination layer, and not cross its boundary? That way the clip rects have a
well-defined meaning.

Any clip rects which come in from outside the pagination container should I
think be dealt with post-fragmentation.

+            // below). Using localToContainerPoint() unfortunately seems necessary in some rare
+            // cases, but isn't it bad that we need to cross transformed layer boundaries here?
+            // localToContainerPoint() is multicol-aware (as well as being transforms-aware, which
+            // is the reason why it's called here in the first place, in favor of
+            // convertToLayerCoords()), in that it converts from flowthread coordinates to visual
+            // coordinates. That won't work, because clip rectangles are... well... rectangles, so
+            // they are calculated before everything is sliced and translated into columns (at
+            // which point each column will get its own slice of the clip rectangle).
+            offset = roundedLayoutPoint(m_layoutObject.localToContainerPoint(FloatPoint(), context.rootLayer->layoutObject()));
+        } else {
+            m_layoutObject.layer()->convertToLayerCoords(context.rootLayer, offset);
+        }
+        applyClipRects(context, m_layoutObject, offset, clipRects);
     }
 }
 
 static ClipRect backgroundClipRectForPosition(const ClipRects& parentRects, EPosition position)
 {
     if (position == FixedPosition)
         return parentRects.fixedClipRect();
 
     if (position == AbsolutePosition)
         return parentRects.posClipRect();
@@ skipping 38 matching lines @@
     if (context.respectOverflowClip == IgnoreOverflowClip)
         return false;
 
     if (layer->isRootLayer() && context.respectOverflowClipForViewport == IgnoreOverflowClip)
         return false;
 
     return true;
 }
 
 } // namespace blink