InitialColumnHeightFinder needs to take all expected rows into account.

third_party/WebKit/Source/core/layout/ColumnBalancer.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/ColumnBalancer.h"
 
 #include "core/layout/LayoutMultiColumnFlowThread.h"
 #include "core/layout/LayoutMultiColumnSet.h"
 #include "core/layout/api/LineLayoutBlockFlow.h"
 
@@ skipping 125 matching lines @@
     strut = LayoutUnit::max();
   traverse();
   // We have now found each explicit / forced break, and their location. Now we
   // need to figure out how many additional implicit / soft breaks we need and
   // guess where they will occur, in order
   // to provide an initial column height.
   distributeImplicitBreaks();
 }
 
 LayoutUnit InitialColumnHeightFinder::initialMinimalBalancedHeight() const {
+  LayoutUnit rowLogicalTop;
+  if (m_contentRuns.size() > columnSet().usedColumnCount()) {
+    // We have not inserted additional fragmentainer groups yet (because we
+    // aren't able to calculate their constraints yet), but we already know for
+    // sure that there'll be more than one of them, due to the number of forced
+    // breaks in a nested multicol container. We will now attempt to take all
+    // the imaginary rows into account and calculate a minimal balanced logical
+    // height for everything.
+    unsigned stride = columnSet().usedColumnCount();
+    LayoutUnit rowStartOffset = logicalTopInFlowThread();
+    for (unsigned i = 0; i < firstContentRunIndexInLastRow(); i += stride) {
+      LayoutUnit rowEndOffset = m_contentRuns[i + stride - 1].breakOffset();
+      float rowHeight = float(rowEndOffset - rowStartOffset) / float(stride);
+      rowLogicalTop += LayoutUnit::fromFloatCeil(rowHeight);

[eae, 2016/11/10 23:37:12]

why ceil?

[mstensho (USE GERRIT), 2016/11/11 08:47:46]

That's what InitialColumnHeightFinder::ContentRun::columnLogicalHeight() does.
We want to make sure that the LayoutUnit value is at least as large as that of
the float.

+      rowStartOffset = rowEndOffset;
+    }
+  }
   unsigned index = contentRunIndexWithTallestColumns();
   LayoutUnit startOffset = index > 0 ? m_contentRuns[index - 1].breakOffset()
                                      : logicalTopInFlowThread();
-  return m_contentRuns[index].columnLogicalHeight(startOffset);
+  LayoutUnit height = m_contentRuns[index].columnLogicalHeight(startOffset);
+  return rowLogicalTop + std::max(height, m_tallestUnbreakableLogicalHeight);
 }
 
 void InitialColumnHeightFinder::examineBoxAfterEntering(
     const LayoutBox& box,
     LayoutUnit childLogicalHeight,
     EBreak previousBreakAfterValue) {
   if (isLogicalTopWithinBounds(flowThreadOffset() - box.paginationStrut())) {
     if (box.needsForcedBreakBefore(previousBreakAfterValue)) {
       addContentRun(flowThreadOffset());
     } else {
@@ skipping 88 matching lines @@
   return totalStrutSpace;
 }
 
 void InitialColumnHeightFinder::addContentRun(
     LayoutUnit endOffsetInFlowThread) {
   endOffsetInFlowThread -= spaceUsedByStrutsAt(endOffsetInFlowThread);
   if (!m_contentRuns.isEmpty() &&
       endOffsetInFlowThread <= m_contentRuns.last().breakOffset())
     return;
   // Append another item as long as we haven't exceeded used column count. What
-  // ends up in the overflow area shouldn't affect column balancing.
-  if (m_contentRuns.size() < columnSet().usedColumnCount())
-    m_contentRuns.append(ContentRun(endOffsetInFlowThread));
+  // ends up in the overflow area shouldn't affect column balancing. However, if
+  // we're in a nested fragmentation context, we may still need to record all
+  // runs, since there'll be no overflow area in the inline direction then, but
+  // rather additional rows of columns in multiple outer fragmentainers.
+  if (m_contentRuns.size() >= columnSet().usedColumnCount()) {
+    const auto* flowThread = columnSet().multiColumnFlowThread();
+    if (!flowThread->enclosingFragmentationContext() ||
+        columnSet().newFragmentainerGroupsAllowed())
+      return;
+  }
+  m_contentRuns.append(ContentRun(endOffsetInFlowThread));
 }
 
 unsigned InitialColumnHeightFinder::contentRunIndexWithTallestColumns() const {
   unsigned indexWithLargestHeight = 0;
   LayoutUnit largestHeight;
   LayoutUnit previousOffset = logicalTopInFlowThread();
   size_t runCount = m_contentRuns.size();
   ASSERT(runCount);
-  for (size_t i = 0; i < runCount; i++) {
+  for (size_t i = firstContentRunIndexInLastRow(); i < runCount; i++) {
     const ContentRun& run = m_contentRuns[i];
     LayoutUnit height = run.columnLogicalHeight(previousOffset);
     if (largestHeight < height) {
       largestHeight = height;
       indexWithLargestHeight = i;
     }
     previousOffset = run.breakOffset();
   }
   return indexWithLargestHeight;
 }
 
 void InitialColumnHeightFinder::distributeImplicitBreaks() {
   // Insert a final content run to encompass all content. This will include
   // overflow if we're at the end of the multicol container.
   addContentRun(logicalBottomInFlowThread());
   unsigned columnCount = m_contentRuns.size();
 
   // If there is room for more breaks (to reach the used value of column-count),
   // imagine that we insert implicit breaks at suitable locations. At any given
   // time, the content run with the currently tallest columns will get another
   // implicit break "inserted", which will increase its column count by one and
   // shrink its columns' height. Repeat until we have the desired total number
   // of breaks. The largest column height among the runs will then be the
   // initial column height for the balancer to use.
+  if (columnCount > columnSet().usedColumnCount()) {
+    // If we exceed used column-count (which we are allowed to do if we're at
+    // the initial balancing pass for a multicol that lives inside another
+    // to-be-balanced outer multicol container), we only care about content that
+    // could end up in the last row. We need to pad up the number of columns, so
+    // that all rows will contain as many columns as used column-count dictates.
+    columnCount %= columnSet().usedColumnCount();
+    // If there are just enough explicit breaks to fill all rows with the right
+    // amount of columns, we won't be needing any implicit breaks.
+    if (!columnCount)
+      return;
+  }
   while (columnCount < columnSet().usedColumnCount()) {
     unsigned index = contentRunIndexWithTallestColumns();
     m_contentRuns[index].assumeAnotherImplicitBreak();
     columnCount++;
   }
 }
 
 MinimumSpaceShortageFinder::MinimumSpaceShortageFinder(
     const LayoutMultiColumnSet& columnSet,
     LayoutUnit logicalTopInFlowThread,
@@ skipping 131 matching lines @@
   if (group.columnLogicalTopForOffset(lineTopInFlowThread) !=
       group.columnLogicalTopForOffset(lineBottomWithOverflow)) {
     LayoutUnit shortage =
         lineBottomWithOverflow -
         group.columnLogicalTopForOffset(lineBottomWithOverflow);
     recordSpaceShortage(shortage);
   }
 }
 
 }  // namespace blink