Support multiple fragmentainer groups per ColumnBalancer run.

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"
+#include "core/layout/LayoutMultiColumnSet.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
-// abstract class that just walks the subtree and leaves it to subclasses to actualy collect data.
+// A column balancer traverses a portion of the subtree of a flow thread that belongs to one or
+// more fragmentainer groups within one column set, in order to collect certain data to be used for
+// column balancing. This is an abstract class that just walks the subtree and leaves it to
+// subclasses to actually collect data.
 class ColumnBalancer {
 protected:
-    ColumnBalancer(const MultiColumnFragmentainerGroup&);
+    ColumnBalancer(const LayoutMultiColumnSet&, LayoutUnit logicalTopInFlowThread, LayoutUnit logicalBottomInFlowThread);
 
-    const MultiColumnFragmentainerGroup& group() const { return m_group; }
+    const LayoutMultiColumnSet& columnSet() const { return m_columnSet; }
+
+    // The flow thread portion we're examining. It may be that of the entire column set, or just of
+    // a fragmentainer group.
+    const LayoutUnit logicalTopInFlowThread() const { return m_logicalTopInFlowThread; }
+    const LayoutUnit logicalBottomInFlowThread() const { return m_logicalBottomInFlowThread; }
+
+    const MultiColumnFragmentainerGroup& groupAtOffset(LayoutUnit offsetInFlowThread) const
+    {
+        return m_columnSet.fragmentainerGroupAtFlowThreadOffset(offsetInFlowThread);
+    }
+
+    LayoutUnit offsetFromColumnLogicalTop(LayoutUnit offsetInFlowThread) const
+    {
+        return offsetInFlowThread - groupAtOffset(offsetInFlowThread).columnLogicalTopForOffset(offsetInFlowThread);
+    }
 
     // Flow thread offset for the layout object that we're currently examining.
     LayoutUnit flowThreadOffset() const { return m_flowThreadOffset; }
 
     EBreak previousBreakAfterValue() const { return m_previousBreakAfterValue; }
 
     // Return true if the specified offset is at the top of a column, as long as it's not the first
-    // column in the fragmentainer group.
+    // column in the flow thread portion.
     bool isFirstAfterBreak(LayoutUnit flowThreadOffset) const
     {
-        if (flowThreadOffset != m_group.columnLogicalTopForOffset(flowThreadOffset))
-            return false; // Not at the top of a column.
-        // The first column in the fragmentainer group is either not after any break at all, or
-        // after a break that belongs to the previous fragmentainer group.
-        return flowThreadOffset > m_group.logicalTopInFlowThread();
+        if (flowThreadOffset <= m_logicalTopInFlowThread) {
+            // The first column is either not after any break at all, or after a break in a
+            // previous fragmentainer group.
+            return false;
+        }
+        return flowThreadOffset == groupAtOffset(flowThreadOffset).columnLogicalTopForOffset(flowThreadOffset);
     }
 
     bool isLogicalTopWithinBounds(LayoutUnit logicalTopInFlowThread) const
     {
-        return logicalTopInFlowThread >= m_group.logicalTopInFlowThread()
-            && logicalTopInFlowThread < m_group.logicalBottomInFlowThread();
+        return logicalTopInFlowThread >= m_logicalTopInFlowThread
+            && logicalTopInFlowThread < m_logicalBottomInFlowThread;
     }
 
     bool isLogicalBottomWithinBounds(LayoutUnit logicalBottomInFlowThread) const
     {
-        return logicalBottomInFlowThread > m_group.logicalTopInFlowThread()
-            && logicalBottomInFlowThread <= m_group.logicalBottomInFlowThread();
+        return logicalBottomInFlowThread > m_logicalTopInFlowThread
+            && logicalBottomInFlowThread <= m_logicalBottomInFlowThread;
     }
 
     // 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.
+    // with the flow thread portion we're examining. 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.
+    // the flow thread portion. 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
+    // Examine and collect column balancing data for everything in the flow thread portion. Will
     // trigger calls to examineBoxAfterEntering(), examineBoxBeforeLeaving() and examineLine() for
     // interesting boxes and lines.
     void traverse();
 
 private:
     void traverseSubtree(const LayoutBox&);
 
-    const MultiColumnFragmentainerGroup& m_group;
+    const LayoutMultiColumnSet& m_columnSet;
+    const LayoutUnit m_logicalTopInFlowThread;
+    const LayoutUnit m_logicalBottomInFlowThread;
+
     LayoutUnit m_flowThreadOffset;
 
     // The break-after value from the previous in-flow block-level object to be joined with the
     // break-before value of the next in-flow block-level object.
     EBreak m_previousBreakAfterValue;
 };
 
 // After an initial layout pass, we know the height of the contents of a flow thread. Based on
 // this, we can estimate an initial minimal column height. This class will collect the necessary
 // information from the layout objects to make this estimate. This estimate may be used to perform
 // another layout iteration. If we after such a layout iteration cannot fit the contents with the
 // given column height without creating overflowing columns, we will have to stretch the columns by
 // some amount and lay out again. We may need to do this several times (but typically not more
 // times than the number of columns that we have). The amount to stretch is provided by the sister
 // of this class, named MinimumSpaceShortageFinder.
 class InitialColumnHeightFinder final : public ColumnBalancer {
 public:
-    InitialColumnHeightFinder(const MultiColumnFragmentainerGroup&);
+    InitialColumnHeightFinder(const LayoutMultiColumnSet&, LayoutUnit logicalTopInFlowThread, LayoutUnit logicalBottomInFlowThread);
 
     LayoutUnit initialMinimalBalancedHeight() const;
 
     // Height of the tallest piece of unbreakable content. This is the minimum column logical height
     // required to avoid fragmentation where it shouldn't occur (inside unbreakable content, between
     // orphans and widows, etc.). This will be used as a hint to the column balancer to help set a
     // good initial column height.
     LayoutUnit tallestUnbreakableLogicalHeight() const { return m_tallestUnbreakableLogicalHeight; }
 
 private:
@@ skipping 70 matching lines @@
 
     LayoutUnit m_tallestUnbreakableLogicalHeight;
 };
 
 // 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&);
+    MinimumSpaceShortageFinder(const LayoutMultiColumnSet&, LayoutUnit logicalTopInFlowThread, LayoutUnit logicalBottomInFlowThread);
 
     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 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