[New Multicolumn] Minimal support for nested multicol in RenderLayer.

Source/core/rendering/RenderLayer.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 417 matching lines @@
         return false;
 
     // If the previous block is absolutely positioned, then we can't be paginated by the columns block.
     if (prevBlock->isOutOfFlowPositioned())
         return false;
 
     // Otherwise we are paginated by the columns block.
     return true;
 }
 
 // Convert a bounding box from flow thread coordinates, relative to |layer|, to visual coordinates, relative to |ancestorLayer|.

[chrishtr, 2015/01/07 01:06:08]

What's the difference between flow thread coordinates and visual coordinates
again? The "relative to.." clause seems to make them the same given the right
context?

[mstensho (USE GERRIT), 2015/01/07 09:41:47]

<div style="-webkit-columns:3; -webkit-column-rule:solid;
-webkit-column-gap:20px; line-height:20px; width:220px;">
    line1<br>
    line2<br>
    line3<br>
    line4<br>
    line5<br>
    <div id="elm">
        LINE6<br>
        LINE7<br>
    </div>
    line8<br>
    line9<br>
</div>

Column width will be 60px (220px minus two gaps (2 * 20px), then divided by the
number of columns (3)).

Column height will also be 60px (three lines - 3 * 20px).

It will be rendered like this, visually:

+---------------------------+
|line1   | line4   | LINE7  |
|line2   | line5   | line8  |
|line3   | LINE6   | line9  |
+---------------------------+

But the flow thread is laid out like an imaginary tall single column (i.e. with
a width of 60px), like this:

+-------+
|line1  |
|line2  |
|line3  |
|line4  |
|line5  |
|LINE6  |
|LINE7  |
|line8  |
|line9  |
+-------+

The bounding box of "elm" (the one with LINE6 and LINE7) in flow thread
coordinates, relatively to the multicol container, will be (0, 100px, 60px,
40px). A nice rectangle. But it gets more complicated when we want the visual
bounding box for this, because "elm" lives in two columns. There's one portion
at the bottom in the second column, at (80px, 40px, 60px, 20px) (in visual
coordinates, relatively to the multicol container), and one portion at the top
in the third column, at (160px, 0, 60px, 20px) (in visual coordinates,
relatively to the multicol container). The visual bounding box is the union of
these two portions - i.e. (80px, 0, 140px, 60px).

 static void convertFromFlowThreadToVisualBoundingBoxInAncestor(const RenderLayer* layer, const RenderLayer* ancestorLayer, LayoutRect& rect)

[chrishtr, 2015/01/07 01:06:08]

I still don't quite get why you have two functions here
(convertFromFlowThreadToVisualBoundingBoxInAncestor and
visualOffsetFromAncestor) that are doing such similar things.
It's also still kind of of hard to understand.

What you're doing here seems conceptually straightforward (hopefully I got it
right):
1. Convert from local coords of |layer| to enclosing pagination coords (i.e.
"visual coords")
2. Ditto for |ancestorLayer|
3. Walk up the pagination containment hierarchy from |layer| until you find the
one for |ancestorLayer|, adjusting coords as you go.
4. Subtract the value computed in step 2 from the output of step 3

Does something like the code below work?

// Converts |rect| from |layer|'s coords to the visual coords of |ancestor|.
convertFromFromLayerCoordsToVisualCoords(RenderLayer& layer, RenderLayer&
ancestorLayer, LayoutRect rect)
{
   RenderLayer* layerPaginationContainer = layer.enclosingPaginationLayer();
   ASSERT(layerPaginationContainer);
   RenderLayer* ancestorLayerPaginationContainer =
ancestorLayer.enclosingPaginationLayer();

   LayoutPoint offsetWithinPaginationLayer;
   layer->convertToLayerCoords(ancestorLayerPaginationContainer,
offsetWithinPaginationLayer);
   rect.moveBy(offsetWithinPaginationLayer);

  
rect.moveBy(-ancestorLayer->visualOffsetFromAncestor(ancestorLayerPaginationContainer));
}

}

[mstensho (USE GERRIT), 2015/01/07 09:41:47]

I may have been able to explain why this is necessary in the previous comment.
:) A flow thread rectangle needs to be sliced into multiple columns in order to
become visual. This is not necessary when you just need the offset (a point). If
it's just a point, you just need to locate the correct column and adjust
accordingly.
Yes. RenderFlowTread::fragmentsBoundingBox() expects flow thread ("imaginary
tall single column") coordinates, relatively to the flow thread.
Not quite. If |ancestorLayer| happens to be within the same pagination context
as |layer|, you need to know |ancestorLayer|'s _visual_ whereabouts in the
pagination context.
Yes, this is what you do when |ancestorLayer| isn't inside the same pagination
context as |layer| ...
... and this is what you do when |ancestorLayer| IS inside the same pagination
context as |layer|.
No. The clue here is to call RenderFlowThread::fragmentsBoundingBox() to slice
the flow thread bounding box into multiple columns.

 {
     RenderLayer* paginationLayer = layer->enclosingPaginationLayer();
     ASSERT(paginationLayer);
     RenderFlowThread* flowThread = toRenderFlowThread(paginationLayer->renderer());
 
     // First make the flow thread rectangle relative to the flow thread, not to |layer|.
     LayoutPoint offsetWithinPaginationLayer;
     layer->convertToLayerCoords(paginationLayer, offsetWithinPaginationLayer);
     rect.moveBy(offsetWithinPaginationLayer);
 
     // Then make the rectangle visual, relative to the fragmentation context. Split our box up into
     // the actual fragment boxes that render in the columns/pages and unite those together to get
     // our true bounding box.
     rect = flowThread->fragmentsBoundingBox(rect);
 
     // Finally, make the visual rectangle relative to |ancestorLayer|.
-    // FIXME: Handle nested fragmentation contexts (crbug.com/423076). For now just give up if there
-    // are different pagination layers involved.
-    if (!ancestorLayer->enclosingPaginationLayer() || ancestorLayer->enclosingPaginationLayer() != paginationLayer) {
-        // The easy case. The ancestor layer is not within the pagination layer.
-        paginationLayer->convertToLayerCoords(ancestorLayer, rect);
+    if (ancestorLayer->enclosingPaginationLayer() != paginationLayer) {
+        rect.moveBy(paginationLayer->visualOffsetFromAncestor(ancestorLayer));
         return;
     }
-    // The ancestor layer is also inside the pagination layer, so we need to subtract the visual
-    // distance from the ancestor layer to the pagination layer.
+    // The ancestor layer is inside the same pagination layer as |layer|, so we need to subtract
+    // the visual distance from the ancestor layer to the pagination layer.
     rect.moveBy(-ancestorLayer->visualOffsetFromAncestor(paginationLayer));
 }
 
 bool RenderLayer::useRegionBasedColumns() const
 {
     return renderer()->document().regionBasedColumnsEnabled();
 }
 
 void RenderLayer::updatePaginationRecursive(bool needsPaginationUpdate)
 {
@@ skipping 971 matching lines @@
 
 void RenderLayer::convertToLayerCoords(const RenderLayer* ancestorLayer, LayoutRect& rect) const
 {
     LayoutPoint delta;
     convertToLayerCoords(ancestorLayer, delta);
     rect.moveBy(delta);
 }
 
 LayoutPoint RenderLayer::visualOffsetFromAncestor(const RenderLayer* ancestorLayer) const
 {
+    LayoutPoint offset;
+    if (ancestorLayer == this)

[chrishtr, 2015/01/07 01:06:08]

Why is this special case needed?

[mstensho (USE GERRIT), 2015/01/07 09:41:47]

In case someone tries to find a layer's offset relative to itself.

Similar stuff in RenderLayer::convertToLayerCoords(). Asserting instead would
cause a lot of failures. Here, for example:

#0  0x0000000002e3a532 in blink::RenderLayer::visualOffsetFromAncestor
(this=0x1330d80103d0, ancestorLayer=0x1330d80103d0) at
../../third_party/WebKit/Source/core/rendering/RenderLayer.cpp:1454
#1  0x0000000002e3f226 in
blink::convertFromFlowThreadToVisualBoundingBoxInAncestor (layer=0x1330d80103d0,
ancestorLayer=0x1330d80103d0, rect=...) at
../../third_party/WebKit/Source/core/rendering/RenderLayer.cpp:462
#2  0x0000000002e396e8 in blink::RenderLayer::fragmentsBoundingBox
(this=0x1330d80103d0, ancestorLayer=0x1330d80103d0) at
../../third_party/WebKit/Source/core/rendering/RenderLayer.cpp:2324
#3  0x0000000002e3f2a2 in
blink::RenderLayer::boundingBoxForCompositingOverlapTest (this=0x1330d80103d0)
at ../../third_party/WebKit/Source/core/rendering/RenderLayer.cpp:2330
#4  0x0000000002f60608 in blink::CompositingInputsUpdater::updateRecursive
(this=0x7fffdc21fb98, layer=0x1330d80103d0,
updateType=blink::CompositingInputsUpdater::ForceUpdate, info=...) at
../../third_party/WebKit/Source/core/rendering/compositing/CompositingInputsUpdater.cpp:112

boundingBoxForCompositingOverlapTest() calls fragmentsBoundingBox(this) (i.e. it
wants the bounding box relatively to itself), and
convertFromFlowThreadToVisualBoundingBoxInAncestor() doesn't bother to check if
|layer| and |ancestorLayer| are the same (and I don't think it should need to,
either).

+        return offset;
     RenderLayer* paginationLayer = enclosingPaginationLayer();
-    LayoutPoint offset;
-    if (!paginationLayer || paginationLayer == this) {
+    if (paginationLayer == this)
+        paginationLayer = parent()->enclosingPaginationLayer();

[chrishtr, 2015/01/07 01:06:08]

Only two levels of nesting are supported?

[mstensho (USE GERRIT), 2015/01/07 09:41:47]

No, this method is called recursively. :)

+    if (!paginationLayer) {
         convertToLayerCoords(ancestorLayer, offset);
         return offset;
     }
 
     RenderFlowThread* flowThread = toRenderFlowThread(paginationLayer->renderer());
     convertToLayerCoords(paginationLayer, offset);
     offset = flowThread->flowThreadPointToVisualPoint(offset);
     if (ancestorLayer == paginationLayer)
         return offset;
 
-    // FIXME: Handle nested fragmentation contexts (crbug.com/423076). For now just give up if there
-    // are different pagination layers involved.
-    if (!ancestorLayer->enclosingPaginationLayer() || ancestorLayer->enclosingPaginationLayer() != paginationLayer) {
-        // The easy case. The ancestor layer is not within the pagination layer.
+    if (ancestorLayer->enclosingPaginationLayer() != paginationLayer) {
         offset.moveBy(paginationLayer->visualOffsetFromAncestor(ancestorLayer));
     } else {
         // The ancestor layer is also inside the pagination layer, so we need to subtract the visual
         // distance from the ancestor layer to the pagination layer.
         offset.moveBy(-ancestorLayer->visualOffsetFromAncestor(paginationLayer));
     }
     return offset;
 }
 
 void RenderLayer::didUpdateNeedsCompositedScrolling()
@@ skipping 65 matching lines @@
     ClipRect outlineRectInFlowThread;
     clipper().calculateRects(paginationClipRectsContext, LayoutRect::infiniteIntRect(), layerBoundsInFlowThread, backgroundRectInFlowThread, foregroundRectInFlowThread,
         outlineRectInFlowThread, &offsetWithinPaginatedLayer);
 
     // Take our bounding box within the flow thread and clip it.
     LayoutRect layerBoundingBoxInFlowThread = layerBoundingBox ? *layerBoundingBox : physicalBoundingBox(enclosingPaginationLayer(), &offsetWithinPaginatedLayer);
     layerBoundingBoxInFlowThread.intersect(backgroundRectInFlowThread.rect());
 
     // Make the dirty rect relative to the fragmentation context (multicol container, etc.).
     RenderFlowThread* enclosingFlowThread = toRenderFlowThread(enclosingPaginationLayer()->renderer());
-    LayoutPoint offsetOfPaginationLayerFromRoot;
-    // FIXME: more work needed if there are nested pagination layers.
-    if (rootLayer != enclosingPaginationLayer() && rootLayer->enclosingPaginationLayer() == enclosingPaginationLayer()) {
-        // The root layer is inside the fragmentation context. So we need to look inside it and find
-        // the visual offset from the fragmentation context.
-        LayoutPoint flowThreadOffset;
-        rootLayer->convertToLayerCoords(enclosingPaginationLayer(), flowThreadOffset);
-        offsetOfPaginationLayerFromRoot = -enclosingFlowThread->flowThreadPointToVisualPoint(flowThreadOffset);
+    LayoutPoint offsetOfPaginationLayerFromRoot; // Visual offset from the root layer to the nearest fragmentation context.
+    if (rootLayer->enclosingPaginationLayer() == enclosingPaginationLayer()) {
+        // The root layer is in the same fragmentation context as this layer, so we need to look
+        // inside it and subtract the offset between the fragmentation context and the root layer.
+        offsetOfPaginationLayerFromRoot = -rootLayer->visualOffsetFromAncestor(enclosingPaginationLayer());
     } else {
-        enclosingPaginationLayer()->convertToLayerCoords(rootLayer, offsetOfPaginationLayerFromRoot);
+        offsetOfPaginationLayerFromRoot = enclosingPaginationLayer()->visualOffsetFromAncestor(rootLayer);
     }
     LayoutRect dirtyRectInFlowThread(dirtyRect);
     dirtyRectInFlowThread.moveBy(-offsetOfPaginationLayerFromRoot);
 
     // Tell the flow thread to collect the fragments. We pass enough information to create a minimal number of fragments based off the pages/columns
     // that intersect the actual dirtyRect as well as the pages/columns that intersect our layer's bounding box.
     enclosingFlowThread->collectLayerFragments(fragments, layerBoundingBoxInFlowThread, dirtyRectInFlowThread);
 
     if (fragments.isEmpty())
         return;
@@ skipping 1322 matching lines @@
     }
 }
 
 void showLayerTree(const blink::RenderObject* renderer)
 {
     if (!renderer)
         return;
     showLayerTree(renderer->enclosingLayer());
 }
 #endif