Calculate minimum column height after layout.

third_party/WebKit/Source/core/layout/ColumnBalancer.h

 // 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"
 
 namespace blink {
 
 // A column balancer traverses the portion of the subtree of a flow thread that belongs to a given
 // fragmentainer group, in order to collect certain data to be used for column balancing. This is an
@@ skipping 20 matching lines @@
     // Examine and collect column balancing data from a layout box that has been found to intersect
     // with this fragmentainer group. Does not recurse into children. flowThreadOffset() will
     // return the offset from |box| to the flow thread. Two hooks are provided here. The first one
     // is called right after entering and before traversing the subtree of the box, and the second
     // one right after having traversed the subtree.
     virtual void examineBoxAfterEntering(const LayoutBox&) = 0;
     virtual void examineBoxBeforeLeaving(const LayoutBox&) = 0;
 
     // Examine and collect column balancing data from a line that has been found to intersect with
     // this fragmentainer group. Does not recurse into layout objects on that line.
-    virtual void examineLine(const RootInlineBox&) = 0;
+    virtual void examineLine(const LayoutBlockFlow& containingBlock, const RootInlineBox&) = 0;
 
     // Examine and collect column balancing data for everything in the fragmentainer group. Will
     // trigger calls to examineBoxAfterEntering(), examineBoxBeforeLeaving() and examineLine() for
     // interesting boxes and lines.
     void traverse();
 
 private:
     void traverseSubtree(const LayoutBox&);
 
     const MultiColumnFragmentainerGroup& m_group;
@@ skipping 15 matching lines @@
         return InitialColumnHeightFinder(group).initialMinimalBalancedHeight();
     }
 
 private:
     InitialColumnHeightFinder(const MultiColumnFragmentainerGroup&);
 
     LayoutUnit initialMinimalBalancedHeight() const;
 
     void examineBoxAfterEntering(const LayoutBox&);
     void examineBoxBeforeLeaving(const LayoutBox&);
-    void examineLine(const RootInlineBox&);
+    void examineLine(const LayoutBlockFlow& containingBlock, const RootInlineBox&);

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

Since we're only looking at RootInlineBoxes, the containing block is always
accessible via the block() method on RootInlineBlock in O(1) time. Splitting the
object off seems more error prone to me.

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

I was unsure, with the ongoing efforts to untangle line layout from LayoutObject
in mind. But if I'm not introducing any unwanted coupling by doing it, I'll do
it. :)

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

Done.

 
     // Record that there's a pagination strut that ends at the specified |offsetInFlowThread|, which
     // is an offset exactly at the top of some column.
     void recordStrutBeforeOffset(LayoutUnit offsetInFlowThread, LayoutUnit strut);
 
     // Return the accumulated space used by struts at all column boundaries preceding the specified
     // flowthread offset.
     LayoutUnit spaceUsedByStrutsAt(LayoutUnit offsetInFlowThread) const;
 
     // Add a content run, specified by its end position. A content run is appended at every
@@ skipping 43 matching lines @@
     // so on). There may be several objects that cross the same column boundary, and we're only
     // interested in the shortest one. For example, when having a float beside regular in-flow
     // content, we end up with two parallel fragmentation flows [1]. The shortest strut found at a
     // column boundary is the amount of space that we wasted at said column boundary, and it needs
     // to be deducted when estimating the initial balanced column height, or we risk making the
     // column row too tall. An entry set to LayoutUnit::max() means that we didn't detect any object
     // crossing that boundary.
     //
     // [1] http://www.w3.org/TR/css3-break/#parallel-flows
     Vector<LayoutUnit, 32> m_shortestStruts;
+
+    LayoutUnit m_minimumColumnLogicalHeight;
 };
 
 // If we have previously used InitialColumnHeightFinder to estimate an initial column height, and
 // that didn't result in tall enough columns, we need subsequent layout passes where we increase
 // the column height by the minimum space shortage at column breaks. This class finds the minimum
 // space shortage after having laid out with the current column height.
 class MinimumSpaceShortageFinder final : public ColumnBalancer {
 public:
     MinimumSpaceShortageFinder(const MultiColumnFragmentainerGroup&);
 
     LayoutUnit minimumSpaceShortage() const { return m_minimumSpaceShortage; }
     unsigned forcedBreaksCount() const { return m_forcedBreaksCount; }
 
 private:
     void examineBoxAfterEntering(const LayoutBox&);
     void examineBoxBeforeLeaving(const LayoutBox&);
-    void examineLine(const RootInlineBox&);
+    void examineLine(const LayoutBlockFlow& containingBlock, const RootInlineBox&);
 
     void recordSpaceShortage(LayoutUnit shortage)
     {
         // Only positive values are interesting (and allowed) here. Zero space shortage may
         // be reported when we're at the top of a column and the element has zero
         // height.
         if (shortage > 0)
             m_minimumSpaceShortage = std::min(m_minimumSpaceShortage, shortage);
     }
 
     // The smallest amout of space shortage that caused a column break.
     LayoutUnit m_minimumSpaceShortage;
 
     // Set when breaking before a block, and we're looking for the first unbreakable descendant, in
     // order to report correct space shortage for that one.
     LayoutUnit m_pendingStrut;
 
     unsigned m_forcedBreaksCount;
 };
 
 } // namespace blink