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

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/LayoutMultiColumnSet.h"
 
 namespace blink {
 
 // A column balancer traverses a portion of the subtree of a flow thread that belongs to one or
 // more fragmentainer groups within one column set, in order to collect certain data to be used for
@@ skipping 16 matching lines @@
     }
 
     LayoutUnit offsetFromColumnLogicalTop(LayoutUnit offsetInFlowThread) const
     {
         return offsetInFlowThread - groupAtOffset(offsetInFlowThread).columnLogicalTopForOffset(offsetInFlowThread);
     }
 
     // Flow thread offset for the layout object that we're currently examining.
     LayoutUnit flowThreadOffset() const { return m_flowThreadOffset; }
 
-    EBreak previousBreakAfterValue() const { return m_previousBreakAfterValue; }
-
     // Return true if the specified offset is at the top of a column, as long as it's not the first
     // column in the flow thread portion.
     bool isFirstAfterBreak(LayoutUnit flowThreadOffset) const
     {
         if (flowThreadOffset <= m_logicalTopInFlowThread) {
             // The first column is either not after any break at all, or after a break in a
             // previous fragmentainer group.
             return false;
         }
         return flowThreadOffset == groupAtOffset(flowThreadOffset).columnLogicalTopForOffset(flowThreadOffset);
     }
 
     bool isLogicalTopWithinBounds(LayoutUnit logicalTopInFlowThread) const
     {
         return logicalTopInFlowThread >= m_logicalTopInFlowThread
             && logicalTopInFlowThread < m_logicalBottomInFlowThread;
     }
 
     bool isLogicalBottomWithinBounds(LayoutUnit logicalBottomInFlowThread) const
     {
         return logicalBottomInFlowThread > m_logicalTopInFlowThread
             && logicalBottomInFlowThread <= m_logicalBottomInFlowThread;
     }
 
     // Examine and collect column balancing data from a layout box that has been found to intersect
     // with the flow thread portion we're examining. Does not recurse into
     // children. flowThreadOffset() will return the offset from |box| to the flow thread. Two hooks
     // are provided here. The first one is called right after entering and before traversing the
     // subtree of the box, and the second one right after having traversed the subtree.
-    virtual void examineBoxAfterEntering(const LayoutBox&) = 0;
+    virtual void examineBoxAfterEntering(const LayoutBox&, EBreak previousBreakAfterValue) = 0;
     virtual void examineBoxBeforeLeaving(const LayoutBox&) = 0;
 
     // Examine and collect column balancing data from a line that has been found to intersect with
     // the flow thread portion. Does not recurse into layout objects on that line.
     virtual void examineLine(const RootInlineBox&) = 0;
 
     // Examine and collect column balancing data for everything in the flow thread portion. Will
     // trigger calls to examineBoxAfterEntering(), examineBoxBeforeLeaving() and examineLine() for
     // interesting boxes and lines.
     void traverse();
 
 private:
     void traverseSubtree(const LayoutBox&);
 
     const LayoutMultiColumnSet& m_columnSet;
     const LayoutUnit m_logicalTopInFlowThread;
     const LayoutUnit m_logicalBottomInFlowThread;
 
     LayoutUnit m_flowThreadOffset;
-
-    // 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 object.
-    EBreak m_previousBreakAfterValue;
 };
 
 // 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:
     InitialColumnHeightFinder(const LayoutMultiColumnSet&, LayoutUnit logicalTopInFlowThread, LayoutUnit logicalBottomInFlowThread);
 
     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 examineBoxAfterEntering(const LayoutBox&, EBreak previousBreakAfterValue);
     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.
     LayoutUnit spaceUsedByStrutsAt(LayoutUnit offsetInFlowThread) const;
@@ skipping 64 matching lines @@
 // 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 LayoutMultiColumnSet&, LayoutUnit logicalTopInFlowThread, LayoutUnit logicalBottomInFlowThread);
 
     LayoutUnit minimumSpaceShortage() const { return m_minimumSpaceShortage; }
     unsigned forcedBreaksCount() const { return m_forcedBreaksCount; }
 
 private:
-    void examineBoxAfterEntering(const LayoutBox&);
+    void examineBoxAfterEntering(const LayoutBox&, EBreak previousBreakAfterValue);
     void examineBoxBeforeLeaving(const LayoutBox&);
     void examineLine(const RootInlineBox&);
 
     void recordSpaceShortage(LayoutUnit shortage)
     {
         // Only positive values are interesting (and allowed) here. Zero space shortage may
         // be reported when we're at the top of a column and the element has zero
         // height.
         if (shortage > 0)
             m_minimumSpaceShortage = std::min(m_minimumSpaceShortage, shortage);
     }
 
     // The smallest amout of space shortage that caused a column break.
     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