Only allow forced fragmentainer breaks at class A break points.

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 MultiColumnFragmentainerGroup& group)
     : m_group(group)
+    , m_previousBreakAfterValue(BreakAuto)
 {
 }
 
 void ColumnBalancer::traverse()
 {
     traverseSubtree(*m_group.columnSet().flowThread());
     ASSERT(!flowThreadOffset());
 }
 
 void ColumnBalancer::traverseSubtree(const LayoutBox& box)
@@ skipping 37 matching lines @@
         // 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);
         // 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();
         examineBoxBeforeLeaving(childBox);
 
         m_flowThreadOffset -= offsetForThisChild;
     }
 }
 
 InitialColumnHeightFinder::InitialColumnHeightFinder(const MultiColumnFragmentainerGroup& group)
     : ColumnBalancer(group)
 {
     m_shortestStruts.resize(group.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() : group().logicalTopInFlowThread();
     return m_contentRuns[index].columnLogicalHeight(startOffset);
 }
 
 void InitialColumnHeightFinder::examineBoxAfterEntering(const LayoutBox& box)
 {
     if (isLogicalTopWithinBounds(flowThreadOffset() - box.paginationStrut())) {
-        ASSERT(isFirstAfterBreak(flowThreadOffset()) || !box.paginationStrut());
-        if (box.hasForcedBreakBefore()) {
+        if (box.needsForcedBreakBefore(previousBreakAfterValue())) {
             addContentRun(flowThreadOffset());
         } else if (isFirstAfterBreak(flowThreadOffset())) {
             // This box is first after a soft break.
+            ASSERT(isFirstAfterBreak(flowThreadOffset()) || !box.paginationStrut());
             recordStrutBeforeOffset(flowThreadOffset(), box.paginationStrut());
         }
     }
 
-    if (box.hasForcedBreakAfter()) {
-        LayoutUnit logicalBottomInFlowThread = flowThreadOffset() + box.logicalHeight();
-        if (isLogicalBottomWithinBounds(logicalBottomInFlowThread))
-            addContentRun(logicalBottomInFlowThread);
-    }
-
     if (box.getPaginationBreakability() != LayoutBox::AllowAnyBreaks) {
         LayoutUnit unsplittableLogicalHeight = box.logicalHeight();
         if (box.isFloating())
             unsplittableLogicalHeight += box.marginBefore() + box.marginAfter();
         m_tallestUnbreakableLogicalHeight = std::max(m_tallestUnbreakableLogicalHeight, unsplittableLogicalHeight);
         return;
     }
     // Need to examine inner multicol containers to find their tallest unbreakable piece of content.
     if (!box.isLayoutBlockFlow())
         return;
@@ skipping 114 matching lines @@
 {
     traverse();
 }
 
 void MinimumSpaceShortageFinder::examineBoxAfterEntering(const LayoutBox& box)
 {
     LayoutBox::PaginationBreakability breakability = box.getPaginationBreakability();
 
     // Look for breaks before the child box.
     if (isLogicalTopWithinBounds(flowThreadOffset() - box.paginationStrut())) {
-        ASSERT(isFirstAfterBreak(flowThreadOffset()) || !box.paginationStrut());
-        if (box.hasForcedBreakBefore()) {
+        if (box.needsForcedBreakBefore(previousBreakAfterValue())) {
             m_forcedBreaksCount++;
         } else if (isFirstAfterBreak(flowThreadOffset())) {
             // This box is first after a soft break.
+            ASSERT(isFirstAfterBreak(flowThreadOffset()) || !box.paginationStrut());
             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
                 // block-displayed image) inside this block. That ought to be a good candidate for
                 // minimum space shortage; a much better one than reporting space shortage for the
                 // entire block (which we'll also do (further down), in case we couldn't find anything
                 // more suitable).
                 m_pendingStrut = strut;
             }
         }
     }
 
-    if (box.hasForcedBreakAfter() && isLogicalBottomWithinBounds(flowThreadOffset() + box.logicalHeight()))
-        m_forcedBreaksCount++;
-
     if (breakability != LayoutBox::ForbidBreaks) {
         // See if this breakable box crosses column boundaries.
         LayoutUnit bottomInFlowThread = flowThreadOffset() + box.logicalHeight();
         if (isFirstAfterBreak(flowThreadOffset())
             || group().columnLogicalTopForOffset(flowThreadOffset()) != group().columnLogicalTopForOffset(bottomInFlowThread)) {
             // If the child crosses a column boundary, record space shortage, in case nothing
             // inside it has already done so. The column balancer needs to know by how much it
             // has to stretch the columns to make more content fit. If no breaks are reported
             // (but do occur), the balancer will have no clue. Only measure the space after the
             // last column boundary, in case it crosses more than one.
@@ skipping 42 matching lines @@
         recordSpaceShortage(logicalOffsetFromCurrentColumn + lineHeight - m_pendingStrut);
         m_pendingStrut = LayoutUnit::min();
         return;
     }
     ASSERT(isFirstAfterBreak(lineTopInFlowThread) || !line.paginationStrut() || !isLogicalTopWithinBounds(lineTopInFlowThread - line.paginationStrut()));
     if (isFirstAfterBreak(lineTopInFlowThread))
         recordSpaceShortage(lineHeight - line.paginationStrut());
 }
 
 } // namespace blink