Translate flow thread coords to the nearest enclosing coord space when appropriate.

third_party/WebKit/Source/core/layout/MultiColumnFragmentainerGroup.cpp

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/layout/MultiColumnFragmentainerGroup.h"
 
 #include "core/layout/ColumnBalancer.h"
 #include "core/layout/FragmentationContext.h"
 #include "core/layout/LayoutMultiColumnSet.h"
 
@@ skipping 80 matching lines @@
         // columns may have changed as well.
         setAndConstrainColumnHeight(m_columnHeight);
     }
 
     if (m_columnHeight == oldColumnHeight)
         return false; // No change. We're done.
 
     return true; // Need another pass.
 }
 
-LayoutSize MultiColumnFragmentainerGroup::flowThreadTranslationAtOffset(LayoutUnit offsetInFlowThread) const
+LayoutSize MultiColumnFragmentainerGroup::flowThreadTranslationAtOffset(LayoutUnit offsetInFlowThread, CoordinateSpaceConversion mode) const
 {
     LayoutMultiColumnFlowThread* flowThread = m_columnSet.multiColumnFlowThread();
     unsigned columnIndex = columnIndexAtOffset(offsetInFlowThread);
     LayoutRect portionRect(flowThreadPortionRectAt(columnIndex));
     flowThread->flipForWritingMode(portionRect);
     LayoutRect columnRect(columnRectAt(columnIndex));
     m_columnSet.flipForWritingMode(columnRect);
     LayoutSize translationRelativeToGroup = columnRect.location() - portionRect.location();
+    LayoutSize translationRelativeToFlowThread = translationRelativeToGroup + offsetFromColumnSet() + m_columnSet.topLeftLocationOffset() - flowThread->topLeftLocationOffset();
+    if (mode == CoordinateSpaceConversion::Containing)
+        return translationRelativeToFlowThread;
 
     LayoutSize enclosingTranslation;
     if (LayoutMultiColumnFlowThread* enclosingFlowThread = flowThread->enclosingFlowThread()) {
         const MultiColumnFragmentainerGroup& firstRow = flowThread->firstMultiColumnSet()->firstFragmentainerGroup();
         // Translation that would map points in the coordinate space of the outermost flow thread to
         // visual points in the first column in the first fragmentainer group (row) in our multicol
         // container.
-        LayoutSize enclosingTranslationOrigin = enclosingFlowThread->flowThreadTranslationAtOffset(firstRow.blockOffsetInEnclosingFragmentationContext());
+        LayoutSize enclosingTranslationOrigin = enclosingFlowThread->flowThreadTranslationAtOffset(firstRow.blockOffsetInEnclosingFragmentationContext(), mode);
 
         // Translation that would map points in the coordinate space of the outermost flow thread to
         // visual points in the first column in this fragmentainer group.
-        enclosingTranslation = enclosingFlowThread->flowThreadTranslationAtOffset(blockOffsetInEnclosingFragmentationContext());
+        enclosingTranslation = enclosingFlowThread->flowThreadTranslationAtOffset(blockOffsetInEnclosingFragmentationContext(), mode);
 
         // What we ultimately return from this method is a translation that maps points in the
         // coordinate space of our flow thread to a visual point in a certain column in this
         // fragmentainer group. We had to go all the way up to the outermost flow thread, since this
         // fragmentainer group may be in a different outer column than the first outer column that
         // this multicol container lives in. It's the visual distance between the first
         // fragmentainer group and this fragmentainer group that we need to add to the translation.
         enclosingTranslation -= enclosingTranslationOrigin;
     }
 
-    return enclosingTranslation + translationRelativeToGroup + offsetFromColumnSet() + m_columnSet.topLeftLocationOffset() - flowThread->topLeftLocationOffset();
+    return enclosingTranslation + translationRelativeToFlowThread;
 }
 
 LayoutUnit MultiColumnFragmentainerGroup::columnLogicalTopForOffset(LayoutUnit offsetInFlowThread) const
 {
     unsigned columnIndex = columnIndexAtOffset(offsetInFlowThread, AssumeNewColumns);
     return logicalTopInFlowThreadAt(columnIndex);
 }
 
 LayoutPoint MultiColumnFragmentainerGroup::visualPointToFlowThreadPoint(const LayoutPoint& visualPoint) const
 {
@@ skipping 34 matching lines @@
     if (boundingBoxLogicalBottom <= logicalTopInFlowThread() || boundingBoxLogicalTop >= logicalBottomInFlowThread())
         return LayoutRect(); // The bounding box doesn't intersect this fragmentainer group.
     unsigned startColumn;
     unsigned endColumn;
     columnIntervalForBlockRangeInFlowThread(boundingBoxLogicalTop, boundingBoxLogicalBottom, startColumn, endColumn);
 
     LayoutRect startColumnFlowThreadOverflowPortion = flowThreadPortionOverflowRectAt(startColumn);
     flowThread->flipForWritingMode(startColumnFlowThreadOverflowPortion);
     LayoutRect startColumnRect(boundingBoxInFlowThread);
     startColumnRect.intersect(startColumnFlowThreadOverflowPortion);
-    startColumnRect.move(flowThreadTranslationAtOffset(logicalTopInFlowThreadAt(startColumn)));
+    startColumnRect.move(flowThreadTranslationAtOffset(logicalTopInFlowThreadAt(startColumn), CoordinateSpaceConversion::Containing));
     if (startColumn == endColumn)
         return startColumnRect; // It all takes place in one column. We're done.
 
     LayoutRect endColumnFlowThreadOverflowPortion = flowThreadPortionOverflowRectAt(endColumn);
     flowThread->flipForWritingMode(endColumnFlowThreadOverflowPortion);
     LayoutRect endColumnRect(boundingBoxInFlowThread);
     endColumnRect.intersect(endColumnFlowThreadOverflowPortion);
-    endColumnRect.move(flowThreadTranslationAtOffset(logicalTopInFlowThreadAt(endColumn)));
+    endColumnRect.move(flowThreadTranslationAtOffset(logicalTopInFlowThreadAt(endColumn), CoordinateSpaceConversion::Containing));
     return unionRect(startColumnRect, endColumnRect);
 }
 
 void MultiColumnFragmentainerGroup::collectLayerFragments(PaintLayerFragments& fragments, const LayoutRect& layerBoundingBox, const LayoutRect& dirtyRect) const
 {
     // |layerBoundingBox| is in the flow thread coordinate space, relative to the top/left edge of
     // the flow thread, but note that it has been converted with respect to writing mode (so that
     // it's visual/physical in that sense).
     //
     // |dirtyRect| is visual, relative to the multicol container.
@@ skipping 38 matching lines @@
     if (startColumn < firstColumnInDirtyRect)
         startColumn = firstColumnInDirtyRect;
     if (endColumn > lastColumnInDirtyRect)
         endColumn = lastColumnInDirtyRect;
     ASSERT(endColumn >= startColumn);
 
     for (unsigned i = startColumn; i <= endColumn; i++) {
         PaintLayerFragment fragment;
 
         // Set the physical translation offset.
-        fragment.paginationOffset = toLayoutPoint(flowThreadTranslationAtOffset(logicalTopInFlowThreadAt(i)));
+        fragment.paginationOffset = toLayoutPoint(flowThreadTranslationAtOffset(logicalTopInFlowThreadAt(i), CoordinateSpaceConversion::Visual));
 
         // Set the overflow clip rect that corresponds to the column.
         fragment.paginationClip = flowThreadPortionOverflowRectAt(i);
         // Flip it into more a physical (PaintLayer-style) rectangle.
         flowThread->flipForWritingMode(fragment.paginationClip);
 
         fragments.append(fragment);
     }
 }
 
@@ skipping 267 matching lines @@
     append(MultiColumnFragmentainerGroup(m_columnSet));
     return last();
 }
 
 void MultiColumnFragmentainerGroupList::deleteExtraGroups()
 {
     shrink(1);
 }
 
 } // namespace blink