[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 421 matching lines @@
         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|.
 static void convertFromFlowThreadToVisualBoundingBoxInAncestor(const RenderLayer* layer, const RenderLayer* ancestorLayer, LayoutRect& rect)
 {
     RenderLayer* paginationLayer = layer->enclosingPaginationLayer();
-    ASSERT(paginationLayer);
+    if (paginationLayer == layer) {
+        // If |layer| is the flow thread, we want to convert and translate the rectangle with
+        // respect to the ancestor flow thread (pagination layer), if any. This typically happens
+        // when this function is called recursively.
+        if (ancestorLayer == paginationLayer)
+            return; // But if we've got to the layer where we should stop, do so.
+        paginationLayer = layer->parent()->enclosingPaginationLayer();
+    }
+    if (!paginationLayer) {
+        layer->convertToLayerCoords(ancestorLayer, rect);
+        return;
+    }
     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) {

[chrishtr, 2014/12/19 19:42:27]

Why do you need the recursion both here and in visualOffsetFromAncestor?

[mstensho (USE GERRIT), 2015/01/06 21:35:10]

Ideally, we should break the rectangle into a bounding box for the columns
involved, for each relevant fragmentation context.

If you have this:

<div style="-webkit-columns:2;">
    outer<br>
    outer<br>
    <div style="-webkit-columns:2;">
        inner1<br>
        inner2<br>
        inner3<br>
        inner4<br>
    </div>
    outer
    outer
</div>

... which should give something like this in a correct multicol implementation
(not yet in Blink, though):

+--------------------------------------+
| outer             | inner3  | inner4 |
| outer             | outer            |
| inner1  | inner2  | outer            |
+--------------------------------------+

... you need to break the bounding box of the inner flow thread twice to get the
correct visual rectangle. First you need to break it for the inner multicol, so
you get something that can hold this:

inner1  | inner2
inner3  | inner4

Then you need to break it again for the outer multicol, so you get this:

                  | inner3  | inner4
                  |
inner1  | inner2  |

However, Blink still doesn't handle situations where an inner multicol lives in
multiple outer columns (like in this example), so, you have a good point, I'd
better use visualOffsetFromAncestor() instead here, to correctly reflect the
broken rendering that we actually get:

+--------------------------------------+
| outer             |                  |
| outer             | outer            |
| inner1  | inner3  | outer            |
+-inner2  | inner4  -------------------+

Done.

+        // If we're inside a nested fragmentation context, for each ancestor fragmentation context
+        // we have to examine, we need to do another flow-thread-to-visual translation of both the
+        // offset and the bounding box. If this is the outermost or only fragmentation context, on
+        // the other hand, we just translate the rectangle to make it relative to |ancestorLayer|.
+        convertFromFlowThreadToVisualBoundingBoxInAncestor(paginationLayer, ancestorLayer, rect);
         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)
+        return offset;
     RenderLayer* paginationLayer = enclosingPaginationLayer();
-    LayoutPoint offset;
-    if (!paginationLayer || paginationLayer == this) {
+    if (paginationLayer == this)
+        paginationLayer = parent()->enclosingPaginationLayer();
+    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