[New Multicolumn] Correct paint rectangle calculation for compositing.

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 796 matching lines @@
         if (positionedParent->renderer()->hasOverflowClip()) {
             LayoutSize offset = positionedParent->renderBox()->scrolledContentOffset();
             localPoint -= offset;
         }
 
         if (positionedParent->renderer()->isRelPositioned() && positionedParent->renderer()->isRenderInline()) {
             LayoutSize offset = toRenderInline(positionedParent->renderer())->offsetForInFlowPositionedInline(*toRenderBox(renderer()));
             localPoint += offset;
         }
     } else if (parent()) {
-        // FIXME: This code is very wrong. The compositing system doesn't
-        // understand columns and we're hacking around that fact by faking
-        // the position of the RenderLayers when we think we'll end up being
-        // composited. Hopefully we'll be able to unwind this hack when we
-        // implement multi-column using regions.
+        // FIXME: This code is very wrong, but luckily only needed in the old/current multicol
+        // implementation. The compositing system doesn't understand columns and we're hacking
+        // around that fact by faking the position of the RenderLayers when we think we'll end up
+        // being composited.
         if (hasStyleDeterminedDirectCompositingReasons()) {
             // FIXME: Composited layers ignore pagination, so about the best we can do is make sure they're offset into the appropriate column.
             // They won't split across columns properly.
             if (!parent()->renderer()->hasColumns() && parent()->renderer()->isDocumentElement() && renderer()->view()->hasColumns())
                 localPoint += renderer()->view()->columnOffset(localPoint);
-            else
-                localPoint += parent()->renderer()->columnOffset(localPoint);

[andersr, 2014/10/07 15:51:21]

Composited RenderLayers now render at flow-thread coordinates, ignoring the
multicolness completely.

If that's somehow intended for new-multicol, then we should at least avoid
breaking old-multicol (further).

[mstensho (USE GERRIT), 2014/10/07 16:35:59]

Done.

         }
 
         if (parent()->renderer()->hasOverflowClip()) {
             IntSize scrollOffset = parent()->renderBox()->scrolledContentOffset();
             localPoint -= scrollOffset;
         }
     }
 
     localPoint.move(offsetForInFlowPosition());
 
@@ skipping 643 matching lines @@
     ClipRect backgroundRectInFlowThread;
     ClipRect foregroundRectInFlowThread;
     ClipRect outlineRectInFlowThread;
     clipper().calculateRects(paginationClipRectsContext, PaintInfo::infiniteRect(), 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());
 
-    // Shift the dirty rect into flow thread coordinates.
+    // Make the dirty rect relative to the fragmentation context (multicol container, etc.).
+    RenderFlowThread* enclosingFlowThread = toRenderFlowThread(enclosingPaginationLayer()->renderer());
     LayoutPoint offsetOfPaginationLayerFromRoot;
-    enclosingPaginationLayer()->convertToLayerCoords(rootLayer, 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);
+    } else {
+        enclosingPaginationLayer()->convertToLayerCoords(rootLayer, offsetOfPaginationLayerFromRoot);
+    }
     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.
-    RenderFlowThread* enclosingFlowThread = toRenderFlowThread(enclosingPaginationLayer()->renderer());
     enclosingFlowThread->collectLayerFragments(fragments, layerBoundingBoxInFlowThread, dirtyRectInFlowThread);
 
     if (fragments.isEmpty())
         return;
 
     // Get the parent clip rects of the pagination layer, since we need to intersect with that when painting column contents.
     ClipRect ancestorClipRect = dirtyRect;
     if (enclosingPaginationLayer()->parent()) {
         ClipRectsContext clipRectsContext(rootLayer, clipRectsCacheSlot, inOverlayScrollbarSizeRelevancy);
         if (respectOverflowClip == IgnoreOverflowClip)
@@ skipping 1340 matching lines @@
     }
 }
 
 void showLayerTree(const blink::RenderObject* renderer)
 {
     if (!renderer)
         return;
     showLayerTree(renderer->enclosingLayer());
 }
 #endif