Handle exclusive end offsets when translating from flow thread coordinates.

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, CoordinateSpaceConversion mode) const
+LayoutSize MultiColumnFragmentainerGroup::flowThreadTranslationAtOffset(LayoutUnit offsetInFlowThread, LayoutBox::PageBoundaryRule rule, CoordinateSpaceConversion mode) const
 {
     LayoutMultiColumnFlowThread* flowThread = m_columnSet.multiColumnFlowThread();
-    unsigned columnIndex = columnIndexAtOffset(offsetInFlowThread);
+
+    // A column out of range doesn't have a flow thread portion, so we need to clamp to make sure
+    // that we stay within the actual columns. This means that content in the overflow area will be
+    // mapped to the last actual column, instead of being mapped to an imaginary column further
+    // ahead.
+    unsigned columnIndex = offsetInFlowThread >= logicalBottomInFlowThread() ? actualColumnCount() - 1 : columnIndexAtOffset(offsetInFlowThread, rule);

[eae, 2016/09/14 22:08:47]

Maybe add a DCHECK(actualColumnCount() > 0) before to ensure it doesn't
undeflow?

[mstensho (USE GERRIT), 2016/09/15 06:37:50]

There are already other actualColumnCount() - 1 expressions, so I see little
point in DCHECKing only here. Note that the actualColumnCount() implementation
has an assert on being 1 or greater, though.

Hmm, I'll document that actualColumnCount() returns 1 or greater instead of
adding a DCHECK here.

+
     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(), mode);
+        LayoutSize enclosingTranslationOrigin = enclosingFlowThread->flowThreadTranslationAtOffset(firstRow.blockOffsetInEnclosingFragmentationContext(), LayoutBox::AssociateWithLatterPage, 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(), mode);
+        enclosingTranslation = enclosingFlowThread->flowThreadTranslationAtOffset(blockOffsetInEnclosingFragmentationContext(), LayoutBox::AssociateWithLatterPage, 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 + translationRelativeToFlowThread;
 }
 
 LayoutUnit MultiColumnFragmentainerGroup::columnLogicalTopForOffset(LayoutUnit offsetInFlowThread) const
 {
-    unsigned columnIndex = columnIndexAtOffset(offsetInFlowThread, AssumeNewColumns);
+    unsigned columnIndex = columnIndexAtOffset(offsetInFlowThread, LayoutBox::AssociateWithLatterPage);
     return logicalTopInFlowThreadAt(columnIndex);
 }
 
 LayoutPoint MultiColumnFragmentainerGroup::visualPointToFlowThreadPoint(const LayoutPoint& visualPoint) const
 {
     unsigned columnIndex = columnIndexAtVisualPoint(visualPoint);
     LayoutRect columnRect = columnRectAt(columnIndex);
     LayoutPoint localPoint(visualPoint);
     localPoint.moveBy(-columnRect.location());
     // Before converting to a flow thread position, if the block direction coordinate is outside the
@@ skipping 29 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), CoordinateSpaceConversion::Containing));
+    startColumnRect.move(flowThreadTranslationAtOffset(logicalTopInFlowThreadAt(startColumn), LayoutBox::AssociateWithLatterPage, 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), CoordinateSpaceConversion::Containing));
+    endColumnRect.move(flowThreadTranslationAtOffset(logicalTopInFlowThreadAt(endColumn), LayoutBox::AssociateWithLatterPage, CoordinateSpaceConversion::Containing));
     return unionRect(startColumnRect, endColumnRect);
 }
 
 LayoutRect MultiColumnFragmentainerGroup::calculateOverflow() const
 {
     // Note that we just return the bounding rectangle of the column boxes here. We currently don't
     // examine overflow caused by the actual content that ends up in each column.
     LayoutRect overflowRect;
     if (unsigned columnCount = actualColumnCount()) {
         overflowRect = columnRectAt(0);
@@ skipping 169 matching lines @@
             overflowRect.shiftMaxXEdgeTo(portionRect.maxX() + columnGap - columnGap / 2);
     } else {
         if (!isLeftmostColumn)
             overflowRect.shiftYEdgeTo(portionRect.y() - columnGap / 2);
         if (!isRightmostColumn)
             overflowRect.shiftMaxYEdgeTo(portionRect.maxY() + columnGap - columnGap / 2);
     }
     return overflowRect;
 }
 
-unsigned MultiColumnFragmentainerGroup::columnIndexAtOffset(LayoutUnit offsetInFlowThread, ColumnIndexCalculationMode mode) const
+unsigned MultiColumnFragmentainerGroup::columnIndexAtOffset(LayoutUnit offsetInFlowThread, LayoutBox::PageBoundaryRule pageBoundaryRule) const
 {
     // Handle the offset being out of range.
     if (offsetInFlowThread < m_logicalTopInFlowThread)
         return 0;
-    // If we're laying out right now, we cannot constrain against some logical bottom, since it
-    // isn't known yet. Otherwise, just return the last column if we're past the logical bottom.
-    if (mode == ClampToExistingColumns) {
-        if (offsetInFlowThread >= m_logicalBottomInFlowThread)
-            return actualColumnCount() - 1;
+
+    if (!m_columnHeight)
+        return 0;
+    unsigned columnIndex = ((offsetInFlowThread - m_logicalTopInFlowThread) / m_columnHeight).floor();
+    if (pageBoundaryRule == LayoutBox::AssociateWithFormerPage
+        && columnIndex > 0 && logicalTopInFlowThreadAt(columnIndex) == offsetInFlowThread) {
+        // We are exactly at a column boundary, and we've been told to associate offsets at column
+        // boundaries with the former column, not the latter.
+        columnIndex--;
     }
-
-    if (m_columnHeight)
-        return ((offsetInFlowThread - m_logicalTopInFlowThread) / m_columnHeight).floor();
-    return 0;
+    return columnIndex;
 }
 
 unsigned MultiColumnFragmentainerGroup::columnIndexAtVisualPoint(const LayoutPoint& visualPoint) const
 {
     bool isColumnProgressionInline = m_columnSet.multiColumnFlowThread()->progressionIsInline();
     bool isHorizontalWritingMode = m_columnSet.isHorizontalWritingMode();
     LayoutUnit columnLengthInColumnProgressionDirection = isColumnProgressionInline ? m_columnSet.pageLogicalWidth() : logicalHeight();
     LayoutUnit offsetInColumnProgressionDirection = isHorizontalWritingMode == isColumnProgressionInline ? visualPoint.x() : visualPoint.y();
     if (!m_columnSet.style()->isLeftToRightDirection() && isColumnProgressionInline)
         offsetInColumnProgressionDirection = m_columnSet.logicalWidth() - offsetInColumnProgressionDirection;
     LayoutUnit columnGap = m_columnSet.columnGap();
     if (columnLengthInColumnProgressionDirection + columnGap <= 0)
         return 0;
     // Column boundaries are in the middle of the column gap.
     int index = ((offsetInColumnProgressionDirection + columnGap / 2) / (columnLengthInColumnProgressionDirection + columnGap)).toInt();
     if (index < 0)
         return 0;
     return std::min(unsigned(index), actualColumnCount() - 1);
 }
 
 void MultiColumnFragmentainerGroup::columnIntervalForBlockRangeInFlowThread(LayoutUnit logicalTopInFlowThread, LayoutUnit logicalBottomInFlowThread, unsigned& firstColumn, unsigned& lastColumn) const
 {
+    logicalTopInFlowThread = std::max(logicalTopInFlowThread, this->logicalTopInFlowThread());
+    logicalBottomInFlowThread = std::min(logicalBottomInFlowThread, this->logicalBottomInFlowThread());
     ASSERT(logicalTopInFlowThread <= logicalBottomInFlowThread);
-    firstColumn = columnIndexAtOffset(logicalTopInFlowThread);
-    lastColumn = columnIndexAtOffset(logicalBottomInFlowThread);
-    // logicalBottomInFlowThread is an exclusive endpoint, so some additional adjustments may be necessary.
-    if (lastColumn > firstColumn && logicalTopInFlowThreadAt(lastColumn) == logicalBottomInFlowThread)
-        lastColumn--;
+    firstColumn = columnIndexAtOffset(logicalTopInFlowThread, LayoutBox::AssociateWithLatterPage);
+    lastColumn = columnIndexAtOffset(logicalBottomInFlowThread, LayoutBox::AssociateWithFormerPage);
 }
 
 void MultiColumnFragmentainerGroup::columnIntervalForVisualRect(const LayoutRect& rect, unsigned& firstColumn, unsigned& lastColumn) const
 {
     bool isColumnProgressionInline = m_columnSet.multiColumnFlowThread()->progressionIsInline();
     bool isFlippedColumnProgression = !m_columnSet.style()->isLeftToRightDirection() && isColumnProgressionInline;
     if (m_columnSet.isHorizontalWritingMode() == isColumnProgressionInline) {
         if (isFlippedColumnProgression) {
             firstColumn = columnIndexAtVisualPoint(rect.maxXMinYCorner());
             lastColumn = columnIndexAtVisualPoint(rect.minXMinYCorner());
@@ skipping 33 matching lines @@
     append(MultiColumnFragmentainerGroup(m_columnSet));
     return last();
 }
 
 void MultiColumnFragmentainerGroupList::deleteExtraGroups()
 {
     shrink(1);
 }
 
 } // namespace blink