When balancing columns, we must check inner multicols for unbreakable content.

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 44 matching lines @@
 // 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:
-    static LayoutUnit initialMinimalBalancedHeight(const MultiColumnFragmentainerGroup& group)
-    {
-        return InitialColumnHeightFinder(group).initialMinimalBalancedHeight();
-    }
-
-private:
     InitialColumnHeightFinder(const MultiColumnFragmentainerGroup&);
 
     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:
     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.
@@ skipping 47 matching lines @@
     // 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;
+    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&);
 
@@ 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