Deduct pagination struts when calculating initial column height.

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 18 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

[leviw_travelin_and_unemployed, 2015/10/30 20:10:50]

Maybe also mention here that we record strut information as well?

[mstensho (USE GERRIT), 2015/11/02 09:12:28]

I decided against that. That's just mighty fine column balancing data, if you
ask me. :)

This is a pure virtual method, and I'd rather try to be generic and not list
everything that overrides might end up doing.

     // this fragmentainer group. Does not recurse into layout objects on that line.
     virtual void examineLine(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&);
@@ skipping 19 matching lines @@
 
 private:
     InitialColumnHeightFinder(const MultiColumnFragmentainerGroup&);
 
     LayoutUnit initialMinimalBalancedHeight() const;
 
     void examineBoxAfterEntering(const LayoutBox&);
     void examineBoxBeforeLeaving(const LayoutBox&);
     void examineLine(const RootInlineBox&);
 
+    // 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
     // forced/explicit break and at the end of the column set. The content runs are used to
     // determine where implicit/soft breaks will occur, in order to calculate an initial column
     // height.
     void addContentRun(LayoutUnit endOffsetInFlowThread);
 
     // Return the index of the content run with the currently tallest columns, taking all implicit
     // breaks assumed so far into account.
     unsigned contentRunIndexWithTallestColumns() const;
 
@@ skipping 21 matching lines @@
 
         // Return the column height that this content run would require, considering the implicit
         // breaks assumed so far.
         LayoutUnit columnLogicalHeight(LayoutUnit startOffset) const { return ceilf((m_breakOffset - startOffset).toFloat() / float(m_assumedImplicitBreaks + 1)); }
 
     private:
         LayoutUnit m_breakOffset; // Flow thread offset where this run ends.
         unsigned m_assumedImplicitBreaks; // Number of implicit breaks in this run assumed so far.
     };
     Vector<ContentRun, 32> m_contentRuns;
+
+    // Shortest strut found at each column boundary (index 0 being the boundary between the first
+    // and the second column, index 1 being the one between the second and the third boundary, and
+    // 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_struts;

[leviw_travelin_and_unemployed, 2015/10/30 20:10:50]

m_shortestStruts maybe? (I do love the comment, though!)

[mstensho (USE GERRIT), 2015/11/02 09:12:28]

Done.

 };
 
 // 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&);
 
@@ skipping 18 matching lines @@
     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