Improve strut handling in initial column balancing pass.

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 155 matching lines @@
   LayoutUnit startOffset = index > 0 ? m_contentRuns[index - 1].breakOffset()
                                      : logicalTopInFlowThread();
   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 (m_lastBreakSeen > flowThreadOffset()) {
+    // We have moved backwards. We're probably in a parallel flow, caused by
+    // floats, sibling table cells, etc.
+    m_lastBreakSeen = LayoutUnit();
+  }
   if (isLogicalTopWithinBounds(flowThreadOffset() - box.paginationStrut())) {
     if (box.needsForcedBreakBefore(previousBreakAfterValue)) {
       addContentRun(flowThreadOffset());
-    } else {
-      if (isFirstAfterBreak(flowThreadOffset())) {
-        // This box is first after a soft break.
-        recordStrutBeforeOffset(flowThreadOffset(), box.paginationStrut());
-      }
+    } else if (isFirstAfterBreak(flowThreadOffset()) &&
+               m_lastBreakSeen != flowThreadOffset()) {
+      // This box is first after a soft break.
+      m_lastBreakSeen = flowThreadOffset();
+      recordStrutBeforeOffset(flowThreadOffset(), box.paginationStrut());
     }
   }
 
   if (box.getPaginationBreakability() != LayoutBox::AllowAnyBreaks) {
     m_tallestUnbreakableLogicalHeight =
         std::max(m_tallestUnbreakableLogicalHeight, childLogicalHeight);
     return;
   }
   // Need to examine inner multicol containers to find their tallest unbreakable
   // piece of content.
@@ skipping 32 matching lines @@
 void InitialColumnHeightFinder::examineLine(const RootInlineBox& line) {
   LayoutUnit lineTop = line.lineTopWithLeading();
   LayoutUnit lineTopInFlowThread = flowThreadOffset() + lineTop;
   LayoutUnit minimumLogialHeight =
       columnLogicalHeightRequirementForLine(line.block().styleRef(), line);
   m_tallestUnbreakableLogicalHeight =
       std::max(m_tallestUnbreakableLogicalHeight, minimumLogialHeight);
   ASSERT(
       isFirstAfterBreak(lineTopInFlowThread) || !line.paginationStrut() ||
       !isLogicalTopWithinBounds(lineTopInFlowThread - line.paginationStrut()));
-  if (isFirstAfterBreak(lineTopInFlowThread))
+  if (isFirstAfterBreak(lineTopInFlowThread) &&
+      m_lastBreakSeen != lineTopInFlowThread) {
+    m_lastBreakSeen = lineTopInFlowThread;
     recordStrutBeforeOffset(lineTopInFlowThread, line.paginationStrut());
+  }
 }
 
 void InitialColumnHeightFinder::recordStrutBeforeOffset(
     LayoutUnit offsetInFlowThread,
     LayoutUnit strut) {
   unsigned columnCount = columnSet().usedColumnCount();
   ASSERT(m_shortestStruts.size() == columnCount);
   unsigned index = groupAtOffset(offsetInFlowThread)
                        .columnIndexAtOffset(offsetInFlowThread - strut,
-                                            LayoutBox::AssociateWithLatterPage);
+                                            LayoutBox::AssociateWithFormerPage);
   if (index >= columnCount)
     return;
   m_shortestStruts[index] = std::min(m_shortestStruts[index], strut);
 }
 
 LayoutUnit InitialColumnHeightFinder::spaceUsedByStrutsAt(
     LayoutUnit offsetInFlowThread) const {
   unsigned stopBeforeColumn =
       groupAtOffset(offsetInFlowThread)
           .columnIndexAtOffset(offsetInFlowThread,
@@ skipping 216 matching lines @@
   if (group.columnLogicalTopForOffset(lineTopInFlowThread) !=
       group.columnLogicalTopForOffset(lineBottomWithOverflow)) {
     LayoutUnit shortage =
         lineBottomWithOverflow -
         group.columnLogicalTopForOffset(lineBottomWithOverflow);
     recordSpaceShortage(shortage);
   }
 }
 
 }  // namespace blink