Add PageBoundaryRule parameter to fragmentainerGroupAtFlowThreadOffset().

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

 /*
  * Copyright (C) 2012 Apple Inc.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 32 matching lines @@
 
 LayoutMultiColumnSet* LayoutMultiColumnSet::createAnonymous(LayoutFlowThread& flowThread, const ComputedStyle& parentStyle)
 {
     Document& document = flowThread.document();
     LayoutMultiColumnSet* layoutObject = new LayoutMultiColumnSet(&flowThread);
     layoutObject->setDocumentForAnonymous(&document);
     layoutObject->setStyle(ComputedStyle::createAnonymousStyleWithDisplay(parentStyle, BLOCK));
     return layoutObject;
 }
 
-unsigned LayoutMultiColumnSet::fragmentainerGroupIndexAtFlowThreadOffset(LayoutUnit flowThreadOffset) const
+unsigned LayoutMultiColumnSet::fragmentainerGroupIndexAtFlowThreadOffset(LayoutUnit flowThreadOffset, PageBoundaryRule rule) const
 {
     ASSERT(m_fragmentainerGroups.size() > 0);
     if (flowThreadOffset <= 0)
         return 0;
     // TODO(mstensho): Introduce an interval tree or similar to speed up this.
     for (unsigned index = 0; index < m_fragmentainerGroups.size(); index++) {
         const auto& row = m_fragmentainerGroups[index];
-        if (row.logicalTopInFlowThread() <= flowThreadOffset && row.logicalBottomInFlowThread() > flowThreadOffset)
+        if (rule == AssociateWithLatterPage) {
+            if (row.logicalTopInFlowThread() <= flowThreadOffset && row.logicalBottomInFlowThread() > flowThreadOffset)
+                return index;
+        } else if (row.logicalTopInFlowThread() < flowThreadOffset && row.logicalBottomInFlowThread() >= flowThreadOffset) {
             return index;
+        }
     }
     return m_fragmentainerGroups.size() - 1;
 }
 
 const MultiColumnFragmentainerGroup& LayoutMultiColumnSet::fragmentainerGroupAtVisualPoint(const LayoutPoint& visualPoint) const
 {
     ASSERT(m_fragmentainerGroups.size() > 0);
     LayoutUnit blockOffset = isHorizontalWritingMode() ? visualPoint.y() : visualPoint.x();
     for (unsigned index = 0; index < m_fragmentainerGroups.size(); index++) {
         const auto& row = m_fragmentainerGroups[index];
@@ skipping 24 matching lines @@
             // is out of bounds. So just use the bottom we have found so far.
             LayoutUnit enclosingContextBottom = lastRow.blockOffsetInEnclosingFragmentationContext() + lastRow.logicalHeight();
             LayoutUnit enclosingFragmentainerHeight = enclosingFragmentationContext->fragmentainerLogicalHeightAt(enclosingContextBottom);
             // Constrain against specified height / max-height.
             LayoutUnit currentMulticolHeight = logicalTopFromMulticolContentEdge() + lastRow.logicalTop() + lastRow.logicalHeight();
             LayoutUnit multicolHeightWithExtraRow = currentMulticolHeight + enclosingFragmentainerHeight;
             multicolHeightWithExtraRow = std::min(multicolHeightWithExtraRow, flowThread->maxColumnLogicalHeight());
             return std::max(LayoutUnit(1), multicolHeightWithExtraRow - currentMulticolHeight);
         }
     }
-    return fragmentainerGroupAtFlowThreadOffset(offsetInFlowThread).logicalHeight();
+    return fragmentainerGroupAtFlowThreadOffset(offsetInFlowThread, AssociateWithLatterPage).logicalHeight();
 }
 
 LayoutUnit LayoutMultiColumnSet::pageRemainingLogicalHeightForOffset(LayoutUnit offsetInFlowThread, PageBoundaryRule pageBoundaryRule) const
 {
-    const MultiColumnFragmentainerGroup& row = fragmentainerGroupAtFlowThreadOffset(offsetInFlowThread);
+    const MultiColumnFragmentainerGroup& row = fragmentainerGroupAtFlowThreadOffset(offsetInFlowThread, pageBoundaryRule);
     LayoutUnit pageLogicalHeight = row.logicalHeight();
     ASSERT(pageLogicalHeight); // It's not allowed to call this method if the height is unknown.
     LayoutUnit pageLogicalBottom = row.columnLogicalTopForOffset(offsetInFlowThread) + pageLogicalHeight;
     LayoutUnit remainingLogicalHeight = pageLogicalBottom - offsetInFlowThread;
 
     if (pageBoundaryRule == AssociateWithFormerPage) {
         // An offset exactly at a column boundary will act as being part of the former column in
         // question (i.e. no remaining space), rather than being part of the latter (i.e. one whole
         // column length of remaining space).
         remainingLogicalHeight = intMod(remainingLogicalHeight, pageLogicalHeight);
@@ skipping 161 matching lines @@
                 // If we're followed by a spanner, we need to balance.
                 return true;
             }
         }
     }
     return !flowThread->columnHeightAvailable();
 }
 
 LayoutSize LayoutMultiColumnSet::flowThreadTranslationAtOffset(LayoutUnit blockOffset, PageBoundaryRule rule, CoordinateSpaceConversion mode) const
 {
-    return fragmentainerGroupAtFlowThreadOffset(blockOffset).flowThreadTranslationAtOffset(blockOffset, rule, mode);
+    return fragmentainerGroupAtFlowThreadOffset(blockOffset, rule).flowThreadTranslationAtOffset(blockOffset, rule, mode);
 }
 
 LayoutPoint LayoutMultiColumnSet::visualPointToFlowThreadPoint(const LayoutPoint& visualPoint) const
 {
     const MultiColumnFragmentainerGroup& row = fragmentainerGroupAtVisualPoint(visualPoint);
     return row.visualPointToFlowThreadPoint(visualPoint - row.offsetFromColumnSet());
 }
 
 LayoutUnit LayoutMultiColumnSet::pageLogicalTopForOffset(LayoutUnit offset) const
 {
-    return fragmentainerGroupAtFlowThreadOffset(offset).columnLogicalTopForOffset(offset);
+    return fragmentainerGroupAtFlowThreadOffset(offset, AssociateWithLatterPage).columnLogicalTopForOffset(offset);
 }
 
 bool LayoutMultiColumnSet::recalculateColumnHeight()
 {
     if (m_oldLogicalTop != logicalTop() && multiColumnFlowThread()->enclosingFragmentationContext()) {
         // Preceding spanners or column sets have been moved or resized. This means that the
         // fragmentainer groups that we have inserted need to be re-inserted. Restart column
         // balancing.
         resetColumnHeight();
         return true;
@@ skipping 219 matching lines @@
     // Now add in column rule bounds, if present.
     Vector<LayoutRect> columnRuleBounds;
     if (computeColumnRuleBounds(LayoutPoint(), columnRuleBounds)) {
         for (auto& bound : columnRuleBounds)
             blockFlowBounds.unite(bound);
     }
     return blockFlowBounds;
 }
 
 } // namespace blink