[New Multicolumn] Make computeOffsetFromCompositedAncestor() flowthread-aware.

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 444 matching lines @@
     // 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);
         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);
+    rect.moveBy(-ancestorLayer->visualOffsetFromAncestor(paginationLayer));
 }
 
 bool RenderLayer::useRegionBasedColumns() const
 {
     return renderer()->document().regionBasedColumnsEnabled();
 }
 
 void RenderLayer::updatePaginationRecursive(bool needsPaginationUpdate)
 {
     m_isPaginated = false;
@@ skipping 968 matching lines @@
         currLayer = accumulateOffsetTowardsAncestor(currLayer, ancestorLayer, location);
 }
 
 void RenderLayer::convertToLayerCoords(const RenderLayer* ancestorLayer, LayoutRect& rect) const
 {
     LayoutPoint delta;
     convertToLayerCoords(ancestorLayer, delta);
     rect.moveBy(delta);
 }
 
+LayoutPoint RenderLayer::visualOffsetFromAncestor(const RenderLayer* ancestorLayer) const

[chrishtr, 2014/12/17 19:35:55]

Should we generalize convertToLayerCoords rather than adding a new method? Does
it do something conceptually different?

[mstensho (USE GERRIT), 2014/12/17 20:49:27]

There are quite a few cases where the (new) multicol implementation in
RenderLayer / LayerPainter expects (non-visual) flow thread coordinates (which
is what converToLayerCoords() gives us). It uses this together with (non-visual)
flow thread rectangles, to figure out the exact fragments to paint, and where to
clip. If we were to use visual coordinates and rectangles everywhere, it would
no longer be possible to reliably express a clip area (e.g. a layer with
overflow:hidden inside multicol) as a rectangle, since blocks that cross a
column boundary has two fragments: one at the bottom of one column and one at
the top of the next one. I think it would be very cumbersome to work with. It's
convenient to work on flow thread coordinates and rectangles as long as and as
much as we can. That's what the render objects do too. I don't think we want to
support non-rectangular render objects. You don't want the line layout code to
be aware of the visual whereabouts of each line box (if one line happens to end
up in the next column), for instance. That's why we have the flow thread, which
represents the multicol container as one single column strip, that can be sliced
and painted into columns during painting.

So I really think we need both.

+{
+    RenderLayer* paginationLayer = enclosingPaginationLayer();
+    LayoutPoint offset;
+    if (!paginationLayer || paginationLayer == this) {
+        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.
+        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()
 {
     updateSelfPaintingLayer();
 }
 
 void RenderLayer::updateReflectionInfo(const RenderStyle* oldStyle)
 {
     ASSERT(!oldStyle || !renderer()->style()->reflectionDataEquivalent(oldStyle));
     if (renderer()->hasReflection()) {
         if (!m_reflectionInfo)
@@ skipping 1408 matching lines @@
     }
 }
 
 void showLayerTree(const blink::RenderObject* renderer)
 {
     if (!renderer)
         return;
     showLayerTree(renderer->enclosingLayer());
 }
 #endif