When balancing columns, we must check inner multicols for unbreakable content.

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 "config.h"
 
 #include "core/layout/MultiColumnFragmentainerGroup.h"
 
 #include "core/layout/ColumnBalancer.h"
 #include "core/layout/LayoutMultiColumnSet.h"
@@ skipping 50 matching lines @@
 bool MultiColumnFragmentainerGroup::recalculateColumnHeight(BalancedColumnHeightCalculation calculationMode)
 {
     LayoutUnit oldColumnHeight = m_columnHeight;
 
     m_maxColumnHeight = calculateMaxColumnHeight();
 
     // Only the last row may have auto height, and thus be balanced. There are no good reasons to
     // balance the preceding rows, and that could potentially lead to an insane number of layout
     // passes as well.
     if (isLastGroup() && m_columnSet.heightIsAuto()) {
-        LayoutUnit newColumnHeight = calculateColumnHeight(calculationMode);
+        LayoutUnit newColumnHeight;
+        if (calculationMode == GuessFromFlowThreadPortion) {
+            // Initial balancing: Start with the lowest imaginable column height. Also calculate the
+            // height of the tallest piece of unbreakable content. Columns should never get any
+            // shorter than that (unless constrained by max-height). Propagate this to our
+            // containing column set, in case there is an outer multicol container that also needs
+            // to balance. After having calculated the initial column height, the multicol container
+            // needs another layout pass with the column height that we just calculated.
+            InitialColumnHeightFinder initialHeightFinder(*this);
+            LayoutUnit tallestUnbreakableLogicalHeight = initialHeightFinder.tallestUnbreakableLogicalHeight();
+            m_columnSet.propagateTallestUnbreakableLogicalHeight(tallestUnbreakableLogicalHeight);
+            newColumnHeight = std::max(initialHeightFinder.initialMinimalBalancedHeight(), tallestUnbreakableLogicalHeight);
+        } else {
+            // Rebalancing: After having laid out again, we'll need to rebalance if the height
+            // wasn't enough and we're allowed to stretch it, and then re-lay out. There are further
+            // details on the column balancing machinery in ColumnBalancer and its derivates.
+            newColumnHeight = rebalanceColumnHeightIfNeeded();
+        }
         setAndConstrainColumnHeight(newColumnHeight);
-        // After having calculated an initial column height, the multicol container typically needs at
-        // least one more layout pass with a new column height, but if a height was specified, we only
-        // need to do this if we think that we need less space than specified. Conversely, if we
-        // determined that the columns need to be as tall as the specified height of the container, we
-        // have already laid it out correctly, and there's no need for another pass.
     } else {
         // The position of the column set may have changed, in which case height available for
         // 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.
@@ skipping 236 matching lines @@
     return maxHeight;
 }
 
 void MultiColumnFragmentainerGroup::setAndConstrainColumnHeight(LayoutUnit newHeight)
 {
     m_columnHeight = newHeight;
     if (m_columnHeight > m_maxColumnHeight)
         m_columnHeight = m_maxColumnHeight;
 }
 
-LayoutUnit MultiColumnFragmentainerGroup::calculateColumnHeight(BalancedColumnHeightCalculation calculationMode) const
+LayoutUnit MultiColumnFragmentainerGroup::rebalanceColumnHeightIfNeeded() const
 {
-    if (calculationMode == GuessFromFlowThreadPortion) {
-        // Initial balancing. Start with the lowest imaginable column height. We use the tallest
-        // content run (after having "inserted" implicit breaks), and find its start offset (by
-        // looking at the previous run's end offset, or, if there's no previous run, the set's start
-        // offset in the flow thread).
-        return InitialColumnHeightFinder::initialMinimalBalancedHeight(*this);
-    }
-
     if (actualColumnCount() <= m_columnSet.usedColumnCount()) {
         // With the current column height, the content fits without creating overflowing columns. We're done.
         return m_columnHeight;
     }
 
     if (m_columnHeight >= m_maxColumnHeight) {
         // We cannot stretch any further. We'll just have to live with the overflowing columns. This
         // typically happens if the max column height is less than the height of the tallest piece
         // of unbreakable content (e.g. lines).
         return m_columnHeight;
@@ skipping 195 matching lines @@
     append(MultiColumnFragmentainerGroup(m_columnSet));
     return last();
 }
 
 void MultiColumnFragmentainerGroupList::deleteExtraGroups()
 {
     shrink(1);
 }
 
 } // namespace blink