[New Multicolumn] Make layer bounding boxes visual and relative to "root".

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 397 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|.
+static void convertFromFlowThreadToVisualBoundingBoxInAncestor(const RenderLayer* layer, const RenderLayer* ancestorLayer, LayoutRect& rect)
+{
+    RenderLayer* paginationLayer = layer->enclosingPaginationLayer();
+    ASSERT(paginationLayer);
+    RenderFlowThread* flowThread = toRenderFlowThread(paginationLayer->renderer());
+    LayoutPoint offsetWithinPaginationLayer;
+    layer->convertToLayerCoords(paginationLayer, offsetWithinPaginationLayer);
+
+    // First make the flow thread rectangle relative to the flow thread, not to |layer|.

[Julien - ping for review, 2014/10/15 14:36:40]

It seems like this comment should encompass the 3 lines (starting at the
definition of offsetWithinPaginationLayer).

[mstensho (USE GERRIT), 2014/10/15 16:45:22]

Done.

+    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: nested fragmentation contexts (crbug.com/423076). For now just give up if there are

[Julien - ping for review, 2014/10/15 14:36:41]

Let's make the FIXME actionable:

// FIXME: Handle nested fragmentation contexts...

[mstensho (USE GERRIT), 2014/10/15 16:45:22]

Done.

+    // 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);
+        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.
+    LayoutPoint offsetFromPaginationLayerToAncestor;
+    ancestorLayer->convertToLayerCoords(paginationLayer, offsetFromPaginationLayerToAncestor);
+    offsetFromPaginationLayerToAncestor = flowThread->flowThreadPointToVisualPoint(offsetFromPaginationLayerToAncestor);
+    rect.moveBy(-offsetFromPaginationLayerToAncestor);
+}
+
 bool RenderLayer::useRegionBasedColumns() const
 {
     return renderer()->document().regionBasedColumnsEnabled();
 }
 
 void RenderLayer::updatePaginationRecursive(bool needsPaginationUpdate)
 {
     m_isPaginated = false;
     m_enclosingPaginationLayer = 0;
 
@@ skipping 1807 matching lines @@
         convertToLayerCoords(ancestorLayer, result);
     return result;
 }
 
 LayoutRect RenderLayer::fragmentsBoundingBox(const RenderLayer* ancestorLayer) const
 {
     if (!enclosingPaginationLayer())
         return physicalBoundingBox(ancestorLayer);
 
     LayoutRect result = flippedLogicalBoundingBox();
-
-    // 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.
-    LayoutPoint offsetWithinPaginationLayer;
-    convertToLayerCoords(enclosingPaginationLayer(), offsetWithinPaginationLayer);
-    result.moveBy(offsetWithinPaginationLayer);
-
-    RenderFlowThread* enclosingFlowThread = toRenderFlowThread(enclosingPaginationLayer()->renderer());
-    result = enclosingFlowThread->fragmentsBoundingBox(result);
-    enclosingPaginationLayer()->convertToLayerCoords(ancestorLayer, result);
+    convertFromFlowThreadToVisualBoundingBoxInAncestor(this, ancestorLayer, result);
     return result;
 }
 
 static void expandRectForReflectionAndStackingChildren(const RenderLayer* ancestorLayer, RenderLayer::CalculateBoundsOptions options, LayoutRect& result)
 {
     if (ancestorLayer->reflectionInfo() && !ancestorLayer->reflectionInfo()->reflectionLayer()->hasCompositedLayerMapping())
         result.unite(ancestorLayer->reflectionInfo()->reflectionLayer()->boundingBoxForCompositing(ancestorLayer));
 
     ASSERT(ancestorLayer->stackingNode()->isStackingContext() || !ancestorLayer->stackingNode()->hasPositiveZOrderList());
 
@@ skipping 42 matching lines @@
     // The root layer is always just the size of the document.
     if (isRootLayer())
         return m_renderer->view()->unscaledDocumentRect();
 
     // The layer created for the RenderFlowThread is just a helper for painting and hit-testing,
     // and should not contribute to the bounding box. The RenderMultiColumnSets will contribute
     // the correct size for the rendered content of the multicol container.
     if (useRegionBasedColumns() && renderer()->isRenderFlowThread())
         return LayoutRect();
 
-    const bool shouldIncludeTransform = paintsWithTransform(PaintBehaviorNormal) || (options == ApplyBoundsChickenEggHacks && transform());
+    LayoutRect result = clipper().localClipRect();
+    if (result == PaintInfo::infiniteRect()) {
+        LayoutPoint origin;
+        result = physicalBoundingBox(ancestorLayer, &origin);
 
-    LayoutRect localClipRect = clipper().localClipRect();
-    if (localClipRect != PaintInfo::infiniteRect()) {
-        if (shouldIncludeTransform)
-            localClipRect = transform()->mapRect(localClipRect);
+        const_cast<RenderLayer*>(this)->stackingNode()->updateLayerListsIfNeeded();
 
-        LayoutPoint delta;
-        convertToLayerCoords(ancestorLayer, delta);
-        localClipRect.moveBy(delta);
-        return localClipRect;
+        // Reflections are implemented with RenderLayers that hang off of the reflected layer. However,
+        // the reflection layer subtree does not include the subtree of the parent RenderLayer, so
+        // a recursive computation of stacking children yields no results. This breaks cases when there are stacking
+        // children of the parent, that need to be included in reflected composited bounds.
+        // Fix this by including composited bounds of stacking children of the reflected RenderLayer.
+        if (hasCompositedLayerMapping() && parent() && parent()->reflectionInfo() && parent()->reflectionInfo()->reflectionLayer() == this)
+            expandRectForReflectionAndStackingChildren(parent(), options, result);
+        else
+            expandRectForReflectionAndStackingChildren(this, options, result);
+
+        // FIXME: We can optimize the size of the composited layers, by not enlarging
+        // filtered areas with the outsets if we know that the filter is going to render in hardware.
+        // https://bugs.webkit.org/show_bug.cgi?id=81239
+        m_renderer->style()->filterOutsets().expandRect(result);
     }
 
-    LayoutPoint origin;
-    LayoutRect result = physicalBoundingBox(ancestorLayer, &origin);
-
-    const_cast<RenderLayer*>(this)->stackingNode()->updateLayerListsIfNeeded();
-
-    // Reflections are implemented with RenderLayers that hang off of the reflected layer. However,
-    // the reflection layer subtree does not include the subtree of the parent RenderLayer, so
-    // a recursive computation of stacking children yields no results. This breaks cases when there are stacking
-    // children of the parent, that need to be included in reflected composited bounds.
-    // Fix this by including composited bounds of stacking children of the reflected RenderLayer.
-    if (hasCompositedLayerMapping() && parent() && parent()->reflectionInfo() && parent()->reflectionInfo()->reflectionLayer() == this)
-        expandRectForReflectionAndStackingChildren(parent(), options, result);
-    else
-        expandRectForReflectionAndStackingChildren(this, options, result);
-
-    // FIXME: We can optimize the size of the composited layers, by not enlarging
-    // filtered areas with the outsets if we know that the filter is going to render in hardware.
-    // https://bugs.webkit.org/show_bug.cgi?id=81239
-    m_renderer->style()->filterOutsets().expandRect(result);
-
-    if (shouldIncludeTransform)
+    if (paintsWithTransform(PaintBehaviorNormal) || (options == ApplyBoundsChickenEggHacks && transform()))
         result = transform()->mapRect(result);
 
+    if (enclosingPaginationLayer()) {
+        convertFromFlowThreadToVisualBoundingBoxInAncestor(this, ancestorLayer, result);
+        return result;
+    }
     LayoutPoint delta;
     convertToLayerCoords(ancestorLayer, delta);
     result.moveBy(delta);
     return result;
 }
 
 CompositingState RenderLayer::compositingState() const
 {
     ASSERT(isAllowedToQueryCompositingState());
 
@@ skipping 484 matching lines @@
     }
 }
 
 void showLayerTree(const blink::RenderObject* renderer)
 {
     if (!renderer)
         return;
     showLayerTree(renderer->enclosingLayer());
 }
 #endif