Support multiple fragmentainer groups per ColumnBalancer run.

third_party/WebKit/Source/core/layout/MultiColumnFragmentainerGroup.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 "core/layout/MultiColumnFragmentainerGroup.h"
 
 #include "core/layout/ColumnBalancer.h"
 #include "core/layout/FragmentationContext.h"
 #include "core/layout/LayoutMultiColumnSet.h"
 
@@ skipping 57 matching lines @@
     // passes as well.
     if (isLastGroup() && m_columnSet.heightIsAuto()) {
         LayoutUnit newColumnHeight;
         if (!m_columnSet.isInitialHeightCalculated()) {
             // Initial balancing: Start with the lowest imaginable column height. Also calculate the
             // height of the tallest piece of unbreakable content. Columns should never get any
             // shorter than that (unless constrained by max-height). Propagate this to our
             // containing column set, in case there is an outer multicol container that also needs
             // to balance. After having calculated the initial column height, the multicol container
             // needs another layout pass with the column height that we just calculated.
-            InitialColumnHeightFinder initialHeightFinder(*this);
+            InitialColumnHeightFinder initialHeightFinder(columnSet(), logicalTopInFlowThread(), logicalBottomInFlowThread());
             LayoutUnit tallestUnbreakableLogicalHeight = initialHeightFinder.tallestUnbreakableLogicalHeight();
             m_columnSet.propagateTallestUnbreakableLogicalHeight(tallestUnbreakableLogicalHeight);
             newColumnHeight = std::max(initialHeightFinder.initialMinimalBalancedHeight(), tallestUnbreakableLogicalHeight);
         } else {
             // Rebalancing: After having laid out again, we'll need to rebalance if the height
             // wasn't enough and we're allowed to stretch it, and then re-lay out. There are further
             // details on the column balancing machinery in ColumnBalancer and its derivates.
             newColumnHeight = rebalanceColumnHeightIfNeeded();
         }
         setAndConstrainColumnHeight(newColumnHeight);
@@ skipping 240 matching lines @@
         return m_columnHeight;
     }
 
     if (m_columnHeight >= m_maxColumnHeight) {
         // We cannot stretch any further. We'll just have to live with the overflowing columns. This
         // typically happens if the max column height is less than the height of the tallest piece
         // of unbreakable content (e.g. lines).
         return m_columnHeight;
     }
 
-    MinimumSpaceShortageFinder shortageFinder(*this);
+    MinimumSpaceShortageFinder shortageFinder(columnSet(), logicalTopInFlowThread(), logicalBottomInFlowThread());
 
     if (shortageFinder.forcedBreaksCount() + 1 >= m_columnSet.usedColumnCount()) {
         // Too many forced breaks to allow any implicit breaks. Initial balancing should already
         // have set a good height. There's nothing more we should do.
         return m_columnHeight;
     }
 
     // If the initial guessed column height wasn't enough, stretch it now. Stretch by the lowest
     // amount of space.
     LayoutUnit minSpaceShortage = shortageFinder.minimumSpaceShortage();
@@ skipping 182 matching lines @@
     append(MultiColumnFragmentainerGroup(m_columnSet));
     return last();
 }
 
 void MultiColumnFragmentainerGroupList::deleteExtraGroups()
 {
     shrink(1);
 }
 
 } // namespace blink