[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 418 matching lines @@
 
     // 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|.
+// See http://www.chromium.org/developers/design-documents/multi-column-layout for more info on these coordinate types.
 static void convertFromFlowThreadToVisualBoundingBoxInAncestor(const RenderLayer* layer, const RenderLayer* ancestorLayer, LayoutRect& rect)
 {
     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)
+        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