Allow flow thread portion logical bottom to be above its logical top.

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 19 matching lines @@
 }
 
 LayoutUnit
 MultiColumnFragmentainerGroup::blockOffsetInEnclosingFragmentationContext()
     const {
   return logicalTop() + m_columnSet.logicalTopFromMulticolContentEdge() +
          m_columnSet.multiColumnFlowThread()
              ->blockOffsetInEnclosingFragmentationContext();
 }
 
+LayoutUnit MultiColumnFragmentainerGroup::logicalHeightInFlowThreadAt(
+    unsigned columnIndex) const {
+  if (!m_columnHeight)
+    return LayoutUnit();
+  LayoutUnit logicalTop = logicalTopInFlowThreadAt(columnIndex);
+  LayoutUnit logicalBottom = logicalTop + m_columnHeight;
+  if (logicalBottom > logicalBottomInFlowThread()) {
+    DCHECK_EQ(columnIndex + 1, actualColumnCount());
+    logicalBottom = logicalBottomInFlowThread();
+  }
+  return (logicalBottom - logicalTop).clampNegativeToZero();
+}
+
 void MultiColumnFragmentainerGroup::resetColumnHeight() {
   m_maxColumnHeight = calculateMaxColumnHeight();
 
   LayoutMultiColumnFlowThread* flowThread = m_columnSet.multiColumnFlowThread();
   if (m_columnSet.heightIsAuto()) {
     FragmentationContext* enclosingFragmentationContext =
         flowThread->enclosingFragmentationContext();
     if (enclosingFragmentationContext &&
         enclosingFragmentationContext->isFragmentainerLogicalHeightKnown()) {
       // Set an initial height, based on the fragmentainer height in the outer
@@ skipping 312 matching lines @@
          LayoutUnit::max());  // If this happens, we probably have a bug.
   if (minSpaceShortage == LayoutUnit::max())
     return m_columnHeight;  // So bail out rather than looping infinitely.
 
   return m_columnHeight + minSpaceShortage;
 }
 
 LayoutRect MultiColumnFragmentainerGroup::columnRectAt(
     unsigned columnIndex) const {
   LayoutUnit columnLogicalWidth = m_columnSet.pageLogicalWidth();
-  LayoutUnit columnLogicalHeight = m_columnHeight;
+  LayoutUnit columnLogicalHeight = logicalHeightInFlowThreadAt(columnIndex);
   LayoutUnit columnLogicalTop;
   LayoutUnit columnLogicalLeft;
   LayoutUnit columnGap = m_columnSet.columnGap();
-  LayoutUnit portionOutsideFlowThread =
-      logicalTopInFlowThread() + (columnIndex + 1) * columnLogicalHeight -
-      logicalBottomInFlowThread();
-  if (portionOutsideFlowThread > 0) {
-    // The last column may not be using all available space.
-    ASSERT(columnIndex + 1 == actualColumnCount());
-    columnLogicalHeight -= portionOutsideFlowThread;
-    ASSERT(columnLogicalHeight >= 0);
-  }
 
   if (m_columnSet.multiColumnFlowThread()->progressionIsInline()) {
     if (m_columnSet.style()->isLeftToRightDirection())
       columnLogicalLeft += columnIndex * (columnLogicalWidth + columnGap);
     else
       columnLogicalLeft += m_columnSet.contentLogicalWidth() -
                            columnLogicalWidth -
                            columnIndex * (columnLogicalWidth + columnGap);
   } else {
     columnLogicalTop += columnIndex * (m_columnHeight + columnGap);
   }
 
   LayoutRect columnRect(columnLogicalLeft, columnLogicalTop, columnLogicalWidth,
                         columnLogicalHeight);
   if (!m_columnSet.isHorizontalWritingMode())
     return columnRect.transposedRect();
   return columnRect;
 }
 
 LayoutRect MultiColumnFragmentainerGroup::flowThreadPortionRectAt(
     unsigned columnIndex) const {
   LayoutUnit logicalTop = logicalTopInFlowThreadAt(columnIndex);
-  LayoutUnit logicalBottom = logicalTop + m_columnHeight;
-  if (logicalBottom > logicalBottomInFlowThread()) {
-    // The last column may not be using all available space.
-    ASSERT(columnIndex + 1 == actualColumnCount());
-    logicalBottom = logicalBottomInFlowThread();
-    ASSERT(logicalBottom >= logicalTop);
-  }
-  LayoutUnit portionLogicalHeight = logicalBottom - logicalTop;
+  LayoutUnit portionLogicalHeight = logicalHeightInFlowThreadAt(columnIndex);
   if (m_columnSet.isHorizontalWritingMode())
     return LayoutRect(LayoutUnit(), logicalTop, m_columnSet.pageLogicalWidth(),
                       portionLogicalHeight);
   return LayoutRect(logicalTop, LayoutUnit(), portionLogicalHeight,
                     m_columnSet.pageLogicalWidth());
 }
 
 LayoutRect MultiColumnFragmentainerGroup::flowThreadPortionOverflowRectAt(
     unsigned columnIndex) const {
   // This function determines the portion of the flow thread that paints for the
@@ skipping 97 matching lines @@
 
 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,
                                     LayoutBox::AssociateWithLatterPage);
-  if (logicalBottomInFlowThread == logicalTopInFlowThread) {
+  if (logicalBottomInFlowThread <= logicalTopInFlowThread) {
     // Zero-height block range. There'll be one column in the interval. Set it
     // right away. This is important if we're at a column boundary, since
     // calling columnIndexAtOffset() with the end-exclusive bottom offset would
     // actually give us the *previous* column.
     lastColumn = firstColumn;
   } else {
     lastColumn = columnIndexAtOffset(logicalBottomInFlowThread,
                                      LayoutBox::AssociateWithFormerPage);
   }
 }
@@ skipping 46 matching lines @@
 MultiColumnFragmentainerGroupList::addExtraGroup() {
   append(MultiColumnFragmentainerGroup(m_columnSet));
   return last();
 }
 
 void MultiColumnFragmentainerGroupList::deleteExtraGroups() {
   shrink(1);
 }
 
 }  // namespace blink