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

third_party/WebKit/Source/core/layout/ColumnBalancer.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/ColumnBalancer.h"
 
 #include "core/layout/LayoutMultiColumnSet.h"
 
@@ skipping 74 matching lines @@
     // We have now found each explicit / forced break, and their location. Now we need to figure out
     // how many additional implicit / soft breaks we need and guess where they will occur, in order
     // to provide an initial column height.
     distributeImplicitBreaks();
 }
 
 LayoutUnit InitialColumnHeightFinder::initialMinimalBalancedHeight() const
 {
     unsigned index = contentRunIndexWithTallestColumns();
     LayoutUnit startOffset = index > 0 ? m_contentRuns[index - 1].breakOffset() : group().logicalTopInFlowThread();
-    LayoutUnit logicalHeightEstimate = m_contentRuns[index].columnLogicalHeight(startOffset);
-    return std::max(logicalHeightEstimate, m_minimumColumnLogicalHeight);
+    return m_contentRuns[index].columnLogicalHeight(startOffset);
 }
 
 void InitialColumnHeightFinder::examineBoxAfterEntering(const LayoutBox& box)
 {
     ASSERT(isFirstAfterBreak(flowThreadOffset()) || !box.paginationStrut());
     if (box.hasForcedBreakBefore()) {
         addContentRun(flowThreadOffset());
     } else if (isFirstAfterBreak(flowThreadOffset())) {
         // This box is first after a soft break.
         recordStrutBeforeOffset(flowThreadOffset(), box.paginationStrut());
     }
 
     if (box.hasForcedBreakAfter())
         addContentRun(flowThreadOffset() + box.logicalHeight());
 
     if (box.paginationBreakability() != LayoutBox::AllowAnyBreaks) {
         LayoutUnit unsplittableLogicalHeight = box.logicalHeight();
         if (box.isFloating())
             unsplittableLogicalHeight += box.marginBefore() + box.marginAfter();
-        if (m_minimumColumnLogicalHeight < unsplittableLogicalHeight)
-            m_minimumColumnLogicalHeight = unsplittableLogicalHeight;
+        if (m_tallestUnbreakableLogicalHeight < unsplittableLogicalHeight)

[leviw_travelin_and_unemployed, 2015/11/20 22:26:31]

I like max(). Clearly, max(countFolksWhoLikeMax(folksWhoArentLeviwOnThisCL()),
0) == 0;

[mstensho (USE GERRIT), 2015/11/23 09:06:31]

Done.

+            m_tallestUnbreakableLogicalHeight = unsplittableLogicalHeight;
+    } else if (box.isLayoutBlockFlow()) {
+        if (LayoutMultiColumnFlowThread* innerFlowThread = toLayoutBlockFlow(box).multiColumnFlowThread()) {
+            LayoutUnit offsetInInnerFlowThread = flowThreadOffset() - innerFlowThread->blockOffsetInEnclosingFlowThread();
+            LayoutUnit innerUnbreakableHeight = innerFlowThread->tallestUnbreakableLogicalHeight(offsetInInnerFlowThread);
+            if (m_tallestUnbreakableLogicalHeight < innerUnbreakableHeight)
+                m_tallestUnbreakableLogicalHeight = innerUnbreakableHeight;
+        }
     }
 }
 
 void InitialColumnHeightFinder::examineBoxBeforeLeaving(const LayoutBox& box)
 {
 }
 
 static inline LayoutUnit columnLogicalHeightRequirementForLine(const ComputedStyle& style, const RootInlineBox& lastLine)
 {
     // We may require a certain minimum number of lines per page in order to satisfy
     // orphans and widows, and that may affect the minimum page height.
     unsigned minimumLineCount = std::max<unsigned>(style.hasAutoOrphans() ? 1 : style.orphans(), style.widows());
     const RootInlineBox* firstLine = &lastLine;
     for (unsigned i = 1; i < minimumLineCount && firstLine->prevRootBox(); i++)
         firstLine = firstLine->prevRootBox();
     return lastLine.lineBottomWithLeading() - firstLine->lineTopWithLeading();
 }
 
 void InitialColumnHeightFinder::examineLine(const RootInlineBox& line)
 {
     LayoutUnit lineTop = line.lineTopWithLeading();
     LayoutUnit lineTopInFlowThread = flowThreadOffset() + lineTop;
     LayoutUnit minimumLogialHeight = columnLogicalHeightRequirementForLine(line.block().styleRef(), line);
-    if (m_minimumColumnLogicalHeight < minimumLogialHeight)
-        m_minimumColumnLogicalHeight = minimumLogialHeight;
+    if (m_tallestUnbreakableLogicalHeight < minimumLogialHeight)
+        m_tallestUnbreakableLogicalHeight = minimumLogialHeight;
     ASSERT(isFirstAfterBreak(lineTopInFlowThread) || !line.paginationStrut());
     if (isFirstAfterBreak(lineTopInFlowThread))
         recordStrutBeforeOffset(lineTopInFlowThread, line.paginationStrut());
 }
 
 void InitialColumnHeightFinder::recordStrutBeforeOffset(LayoutUnit offsetInFlowThread, LayoutUnit strut)
 {
     const LayoutMultiColumnSet& columnSet = group().columnSet();
     ASSERT(columnSet.usedColumnCount() >= 1);
     unsigned columnCount = columnSet.usedColumnCount();
@@ skipping 145 matching lines @@
         recordSpaceShortage(logicalOffsetFromCurrentColumn + lineHeight - m_pendingStrut);
         m_pendingStrut = LayoutUnit::min();
         return;
     }
     ASSERT(isFirstAfterBreak(lineTopInFlowThread) || !line.paginationStrut());
     if (isFirstAfterBreak(lineTopInFlowThread))
         recordSpaceShortage(lineHeight - line.paginationStrut());
 }
 
 } // namespace blink