ColumnBalancer: Don't leak the break-after value from the previous sibling to children.

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"
 
 namespace blink {
 
 ColumnBalancer::ColumnBalancer(const LayoutMultiColumnSet& columnSet, LayoutUnit logicalTopInFlowThread, LayoutUnit logicalBottomInFlowThread)
     : m_columnSet(columnSet)
     , m_logicalTopInFlowThread(logicalTopInFlowThread)
     , m_logicalBottomInFlowThread(logicalBottomInFlowThread)
-    , m_previousBreakAfterValue(BreakAuto)
 {
 }
 
 void ColumnBalancer::traverse()
 {
     traverseSubtree(*columnSet().flowThread());
     ASSERT(!flowThreadOffset());
 }
 
 void ColumnBalancer::traverseSubtree(const LayoutBox& box)
 {
     if (box.childrenInline() && box.isLayoutBlockFlow()) {
         // Look for breaks between lines.
         for (const RootInlineBox* line = toLayoutBlockFlow(box).firstRootBox(); line; line = line->nextRootBox()) {
             LayoutUnit lineTopInFlowThread = m_flowThreadOffset + line->lineTopWithLeading();
             if (lineTopInFlowThread < logicalTopInFlowThread())
                 continue;
             if (lineTopInFlowThread >= logicalBottomInFlowThread())
                 break;
             examineLine(*line);
         }
     }
 
     const LayoutFlowThread* flowThread = columnSet().flowThread();
     bool isHorizontalWritingMode = flowThread->isHorizontalWritingMode();
 
+    // 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 sibling.
+    EBreak previousBreakAfterValue = BreakAuto;
+
     // Look for breaks between and inside block-level children. Even if this is a block flow with
     // inline children, there may be interesting floats to examine here.
     for (const LayoutObject* child = box.slowFirstChild(); child; child = child->nextSibling()) {
         if (!child->isBox() || child->isInline())
             continue;
         const LayoutBox& childBox = toLayoutBox(*child);
         LayoutRect overflowRect = childBox.layoutOverflowRect();
         LayoutUnit childLogicalBottomWithOverflow = childBox.logicalTop() + (isHorizontalWritingMode ? overflowRect.maxY() : overflowRect.maxX());
         if (m_flowThreadOffset + childLogicalBottomWithOverflow <= logicalTopInFlowThread()) {
             // This child is fully above the flow thread portion we're examining.
             continue;
         }
         LayoutUnit childLogicalTopWithOverflow = childBox.logicalTop() + (isHorizontalWritingMode ? overflowRect.y() : overflowRect.x());
         if (m_flowThreadOffset + childLogicalTopWithOverflow >= logicalBottomInFlowThread()) {
             // This child is fully below the flow thread portion we're examining. We cannot just
             // stop here, though, thanks to negative margins. So keep looking.
             continue;
         }
         if (childBox.isOutOfFlowPositioned() || childBox.isColumnSpanAll())
             continue;
 
         // Tables are wicked. Both table rows and table cells are relative to their table section.
         LayoutUnit offsetForThisChild = childBox.isTableRow() ? LayoutUnit() : childBox.logicalTop();
         m_flowThreadOffset += offsetForThisChild;
 
-        examineBoxAfterEntering(childBox);
+        examineBoxAfterEntering(childBox, previousBreakAfterValue);
         // Unless the child is unsplittable, or if the child establishes an inner multicol
         // container, we descend into its subtree for further examination.
         if (childBox.getPaginationBreakability() != LayoutBox::ForbidBreaks
             && (!childBox.isLayoutBlockFlow() || !toLayoutBlockFlow(childBox).multiColumnFlowThread()))
             traverseSubtree(childBox);
-        m_previousBreakAfterValue = childBox.breakAfter();
+        previousBreakAfterValue = childBox.breakAfter();
         examineBoxBeforeLeaving(childBox);
 
         m_flowThreadOffset -= offsetForThisChild;
     }
 }
 
 InitialColumnHeightFinder::InitialColumnHeightFinder(const LayoutMultiColumnSet& columnSet, LayoutUnit logicalTopInFlowThread, LayoutUnit logicalBottomInFlowThread)
     : ColumnBalancer(columnSet, logicalTopInFlowThread, logicalBottomInFlowThread)
 {
     m_shortestStruts.resize(columnSet.usedColumnCount());
     for (auto& strut : m_shortestStruts)
         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
 {
     unsigned index = contentRunIndexWithTallestColumns();
     LayoutUnit startOffset = index > 0 ? m_contentRuns[index - 1].breakOffset() : logicalTopInFlowThread();
     return m_contentRuns[index].columnLogicalHeight(startOffset);
 }
 
-void InitialColumnHeightFinder::examineBoxAfterEntering(const LayoutBox& box)
+void InitialColumnHeightFinder::examineBoxAfterEntering(const LayoutBox& box, EBreak previousBreakAfterValue)
 {
     if (isLogicalTopWithinBounds(flowThreadOffset() - box.paginationStrut())) {
-        if (box.needsForcedBreakBefore(previousBreakAfterValue())) {
+        if (box.needsForcedBreakBefore(previousBreakAfterValue)) {
             addContentRun(flowThreadOffset());
         } else {
             ASSERT(isFirstAfterBreak(flowThreadOffset()) || !box.paginationStrut());
             if (isFirstAfterBreak(flowThreadOffset())) {
                 // This box is first after a soft break.
                 recordStrutBeforeOffset(flowThreadOffset(), box.paginationStrut());
             }
         }
     }
 
@@ skipping 117 matching lines @@
 
 MinimumSpaceShortageFinder::MinimumSpaceShortageFinder(const LayoutMultiColumnSet& columnSet, LayoutUnit logicalTopInFlowThread, LayoutUnit logicalBottomInFlowThread)
     : ColumnBalancer(columnSet, logicalTopInFlowThread, logicalBottomInFlowThread)
     , m_minimumSpaceShortage(LayoutUnit::max())
     , m_pendingStrut(LayoutUnit::min())
     , m_forcedBreaksCount(0)
 {
     traverse();
 }
 
-void MinimumSpaceShortageFinder::examineBoxAfterEntering(const LayoutBox& box)
+void MinimumSpaceShortageFinder::examineBoxAfterEntering(const LayoutBox& box, EBreak previousBreakAfterValue)
 {
     LayoutBox::PaginationBreakability breakability = box.getPaginationBreakability();
 
     // Look for breaks before the child box.
     if (isLogicalTopWithinBounds(flowThreadOffset() - box.paginationStrut())) {
-        if (box.needsForcedBreakBefore(previousBreakAfterValue())) {
+        if (box.needsForcedBreakBefore(previousBreakAfterValue)) {
             m_forcedBreaksCount++;
         } else {
             ASSERT(isFirstAfterBreak(flowThreadOffset()) || !box.paginationStrut());
             if (isFirstAfterBreak(flowThreadOffset())) {
                 // This box is first after a soft break.
                 LayoutUnit strut = box.paginationStrut();
                 // Figure out how much more space we would need to prevent it from being pushed to the next column.
                 recordSpaceShortage(box.logicalHeight() - strut);
                 if (breakability != LayoutBox::ForbidBreaks && m_pendingStrut == LayoutUnit::min()) {
                     // We now want to look for the first piece of unbreakable content (e.g. a line or a
@@ skipping 75 matching lines @@
     // of said overflow ends up in the next column. That counts as space shortage.
     const MultiColumnFragmentainerGroup& group = groupAtOffset(lineTopInFlowThread);
     LayoutUnit lineBottomWithOverflow = lineTopInFlowThread + line.lineBottom() - lineTop;
     if (group.columnLogicalTopForOffset(lineTopInFlowThread) != group.columnLogicalTopForOffset(lineBottomWithOverflow)) {
         LayoutUnit shortage = lineBottomWithOverflow - group.columnLogicalTopForOffset(lineBottomWithOverflow);
         recordSpaceShortage(shortage);
     }
 }
 
 } // namespace blink