Introduce LayoutBox::paginationBreakability().

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 "config.h"
 
 #include "core/layout/ColumnBalancer.h"
 
 #include "core/layout/LayoutMultiColumnSet.h"
 
@@ skipping 48 matching lines @@
         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);
         // Unless the child is unsplittable, or if the child establishes an inner multicol
         // container, we descend into its subtree for further examination.
-        if (!childBox.isUnsplittableForPagination()
+        if (childBox.paginationBreakability() != LayoutBox::ForbidBreaks
             && (!childBox.isLayoutBlockFlow() || !toLayoutBlockFlow(childBox).multiColumnFlowThread()))
             traverseSubtree(childBox);
         examineBoxBeforeLeaving(childBox);
 
         m_flowThreadOffset -= offsetForThisChild;
     }
 }
 
 InitialColumnHeightFinder::InitialColumnHeightFinder(const MultiColumnFragmentainerGroup& group)
     : ColumnBalancer(group)
@@ skipping 129 matching lines @@
 void MinimumSpaceShortageFinder::examineBoxAfterEntering(const LayoutBox& box)
 {
     if (box.hasForcedBreakBefore())
         m_forcedBreaksCount++;
     if (box.hasForcedBreakAfter())
         m_forcedBreaksCount++;
 
     // Look for breaks before the child box.
     bool isFirstAfterBreak = this->isFirstAfterBreak(flowThreadOffset());
     ASSERT(isFirstAfterBreak || !box.paginationStrut());
+    LayoutBox::PaginationBreakability breakability = box.paginationBreakability();
     if (isFirstAfterBreak && !box.hasForcedBreakBefore()) {
         // This box is first after a soft break.
         LayoutUnit strut = box.paginationStrut();
-        if (box.isUnsplittableForPagination()) {
+        if (breakability == LayoutBox::ForbidBreaks) {
             // Since we cannot break inside the box, just figure out how much more space we would
             // need to prevent it from being pushed to the next column.
             recordSpaceShortage(box.logicalHeight() - strut);
         } else if (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.isUnsplittableForPagination()) {
+    if (breakability != LayoutBox::ForbidBreaks) {
         // See if this breakable box crosses column boundaries.
         LayoutUnit bottomInFlowThread = flowThreadOffset() + box.logicalHeight();
         if (isFirstAfterBreak || 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.
             LayoutUnit spaceUsedInLastColumn = bottomInFlowThread - group().columnLogicalTopForOffset(bottomInFlowThread);
             recordSpaceShortage(spaceUsedInLastColumn);
         }
     }
 }
 
 void MinimumSpaceShortageFinder::examineBoxBeforeLeaving(const LayoutBox& box)
 {
-    if (m_pendingStrut == LayoutUnit::min() || !box.isUnsplittableForPagination())
+    if (m_pendingStrut == LayoutUnit::min() || box.paginationBreakability() != LayoutBox::ForbidBreaks)
         return;
 
     // The previous break was before a breakable block. Here's the first piece of unbreakable
     // content after / inside that block. We want to record the distance from the top of the column
     // to the bottom of this box as space shortage.
     LayoutUnit logicalOffsetFromCurrentColumn = flowThreadOffset() - group().columnLogicalTopForOffset(flowThreadOffset());
     recordSpaceShortage(logicalOffsetFromCurrentColumn + box.logicalHeight() - m_pendingStrut);
     m_pendingStrut = LayoutUnit::min();
 }
 
@@ skipping 10 matching lines @@
         recordSpaceShortage(logicalOffsetFromCurrentColumn + lineHeight - m_pendingStrut);
         m_pendingStrut = LayoutUnit::min();
         return;
     }
     ASSERT(isFirstAfterBreak(lineTopInFlowThread) || !line.paginationStrut());
     if (isFirstAfterBreak(lineTopInFlowThread))
         recordSpaceShortage(lineHeight - line.paginationStrut());
 }
 
 } // namespace blink