Calculate minimum column height after layout.

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"
 
 namespace blink {
 
 ColumnBalancer::ColumnBalancer(const MultiColumnFragmentainerGroup& group)
     : m_group(group)
 {
 }
 
 void ColumnBalancer::traverse()
 {
     traverseSubtree(*m_group.columnSet().flowThread());
     ASSERT(!flowThreadOffset());
 }
 
 void ColumnBalancer::traverseSubtree(const LayoutBox& box)
 {
     if (box.childrenInline() && box.isLayoutBlockFlow()) {
         // Look for breaks between lines.
-        for (const RootInlineBox* line = toLayoutBlockFlow(box).firstRootBox(); line; line = line->nextRootBox()) {
+        const LayoutBlockFlow& blockFlow = toLayoutBlockFlow(box);
+        for (const RootInlineBox* line = blockFlow.firstRootBox(); line; line = line->nextRootBox()) {
             LayoutUnit lineTopInFlowThread = m_flowThreadOffset + line->lineTopWithLeading();
             if (lineTopInFlowThread < group().logicalTopInFlowThread())
                 continue;
             if (lineTopInFlowThread >= group().logicalBottomInFlowThread())
                 break;
-            examineLine(*line);
+            examineLine(blockFlow, *line);
         }
     }
 
     const LayoutFlowThread* flowThread = group().columnSet().flowThread();
     bool isHorizontalWritingMode = flowThread->isHorizontalWritingMode();
 
     // Look for breaks between and inside block-level children. Even if this is a block flow with
     // inline children, there may be interesting floats to examine here.
     for (const LayoutObject* child = box.slowFirstChild(); child; child = child->nextSibling()) {
         if (!child->isBox() || child->isInline())
@@ skipping 40 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();
-    return m_contentRuns[index].columnLogicalHeight(startOffset);
+    LayoutUnit logicalHeightEstimate = m_contentRuns[index].columnLogicalHeight(startOffset);
+    return std::max(logicalHeightEstimate, m_minimumColumnLogicalHeight);
 }
 
 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) {

[leviw_travelin_and_unemployed, 2015/11/05 18:44:26]

This is new code?

[mstensho (USE GERRIT), 2015/11/05 19:15:56]

This used to be handled in LayoutBlockFlow::adjustForUnsplittableChild(), by
calling updateMinimumHeight().

+        LayoutUnit unsplittableLogicalHeight = box.logicalHeight();
+        if (box.isFloating())
+            unsplittableLogicalHeight += box.marginBefore() + box.marginAfter();
+        if (m_minimumColumnLogicalHeight < unsplittableLogicalHeight)
+            m_minimumColumnLogicalHeight = unsplittableLogicalHeight;
+    }
 }
 
 void InitialColumnHeightFinder::examineBoxBeforeLeaving(const LayoutBox& box)
 {
 }
 
-void InitialColumnHeightFinder::examineLine(const RootInlineBox& line)
+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 lineCount = std::max<unsigned>(style.hasAutoOrphans() ? 1 : style.orphans(), style.widows());

[leviw_travelin_and_unemployed, 2015/11/05 18:44:26]

minimumLineCount?

[mstensho (USE GERRIT), 2015/11/05 19:15:56]

Good idea. This code was just copied from LayoutBlockFlow.

[mstensho (USE GERRIT), 2015/11/05 22:17:10]

Done.

+    const RootInlineBox* firstLine = &lastLine;
+    for (unsigned i = 1; i < lineCount && firstLine->prevRootBox(); i++)
+        firstLine = firstLine->prevRootBox();
+    return lastLine.lineBottomWithLeading() - firstLine->lineTopWithLeading();
+}
+
+void InitialColumnHeightFinder::examineLine(const LayoutBlockFlow& containingBlock, const RootInlineBox& line)
 {
     LayoutUnit lineTop = line.lineTopWithLeading();
     LayoutUnit lineTopInFlowThread = flowThreadOffset() + lineTop;
+    LayoutUnit minimumLogialHeight = columnLogicalHeightRequirementForLine(containingBlock.styleRef(), line);
+    if (m_minimumColumnLogicalHeight < minimumLogialHeight)
+        m_minimumColumnLogicalHeight = 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 125 matching lines @@
         return;
 
     // The previous break was before a breakable block. Here's the first piece of unbreakable
     // content after / inside that block. We want to record the distance from the top of the column
     // to the bottom of this box as space shortage.
     LayoutUnit logicalOffsetFromCurrentColumn = flowThreadOffset() - group().columnLogicalTopForOffset(flowThreadOffset());
     recordSpaceShortage(logicalOffsetFromCurrentColumn + box.logicalHeight() - m_pendingStrut);
     m_pendingStrut = LayoutUnit::min();
 }
 
-void MinimumSpaceShortageFinder::examineLine(const RootInlineBox& line)
+void MinimumSpaceShortageFinder::examineLine(const LayoutBlockFlow& containingBlock, const RootInlineBox& line)
 {
     LayoutUnit lineTop = line.lineTopWithLeading();
     LayoutUnit lineTopInFlowThread = flowThreadOffset() + lineTop;
     LayoutUnit lineHeight = line.lineBottomWithLeading() - lineTop;
     if (m_pendingStrut != LayoutUnit::min()) {
         // The previous break was before a breakable block. Here's the first line after / inside
         // that block. We want to record the distance from the top of the column to the bottom of
         // this box as space shortage.
         LayoutUnit logicalOffsetFromCurrentColumn = lineTopInFlowThread - group().columnLogicalTopForOffset(lineTopInFlowThread);
         recordSpaceShortage(logicalOffsetFromCurrentColumn + lineHeight - m_pendingStrut);
         m_pendingStrut = LayoutUnit::min();
         return;
     }
     ASSERT(isFirstAfterBreak(lineTopInFlowThread) || !line.paginationStrut());
     if (isFirstAfterBreak(lineTopInFlowThread))
         recordSpaceShortage(lineHeight - line.paginationStrut());
 }
 
 } // namespace blink