Split EBreak enum into EBreakBetween & EBreakInside

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 34 matching lines @@
       continue;
     if (lineTopInFlowThread >= logicalBottomInFlowThread())
       break;
     examineLine(*line);
   }
 }
 
 void ColumnBalancer::traverseChildren(const LayoutObject& object) {
   // 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;
+  EBreakBetween previousBreakAfterValue = EBreakBetween::kAuto;
 
   for (const LayoutObject* child = object.slowFirstChild(); child;
        child = child->nextSibling()) {
     if (!child->isBox()) {
       // Keep traversing inside inlines. There may be floats there.
       if (child->isLayoutInline())
         traverseChildren(*child);
       continue;
     }
 
@@ skipping 99 matching lines @@
   unsigned index = contentRunIndexWithTallestColumns();
   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) {
+    EBreakBetween 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()) &&
                m_lastBreakSeen != flowThreadOffset()) {
@@ skipping 168 matching lines @@
                      logicalBottomInFlowThread),
       m_minimumSpaceShortage(LayoutUnit::max()),
       m_pendingStrut(LayoutUnit::min()),
       m_forcedBreaksCount(0) {
   traverse();
 }
 
 void MinimumSpaceShortageFinder::examineBoxAfterEntering(
     const LayoutBox& box,
     LayoutUnit childLogicalHeight,
-    EBreak previousBreakAfterValue) {
+    EBreakBetween previousBreakAfterValue) {
   LayoutBox::PaginationBreakability breakability =
       box.getPaginationBreakability();
 
   // Look for breaks before the child box.
   if (isLogicalTopWithinBounds(flowThreadOffset() - box.paginationStrut())) {
     if (box.needsForcedBreakBefore(previousBreakAfterValue)) {
       m_forcedBreaksCount++;
     } else {
       if (isFirstAfterBreak(flowThreadOffset())) {
         // This box is first after a soft break.
@@ skipping 107 matching lines @@
   if (group.columnLogicalTopForOffset(lineTopInFlowThread) !=
       group.columnLogicalTopForOffset(lineBottomWithOverflow)) {
     LayoutUnit shortage =
         lineBottomWithOverflow -
         group.columnLogicalTopForOffset(lineBottomWithOverflow);
     recordSpaceShortage(shortage);
   }
 }
 
 }  // namespace blink