Split EBreak enum into EBreakBetween & EBreakInside

third_party/WebKit/Source/core/layout/LayoutBox.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2005 Allan Sandfeld Jensen (kde@carewolf.com)
  *           (C) 2005, 2006 Samuel Weinig (sam.weinig@gmail.com)
  * Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010 Apple Inc.
  *               All rights reserved.
  * Copyright (C) 2013 Adobe Systems Incorporated. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
@@ skipping 2094 matching lines @@
     return;
   m_rareData->m_spannerPlaceholder = nullptr;
 }
 
 void LayoutBox::setPaginationStrut(LayoutUnit strut) {
   if (!strut && !m_rareData)
     return;
   ensureRareData().m_paginationStrut = strut;
 }
 
-bool LayoutBox::isBreakBetweenControllable(EBreak breakValue) const {
-  if (breakValue == BreakAuto)
+bool LayoutBox::isBreakBetweenControllable(EBreakBetween breakValue) const {
+  if (breakValue == EBreakBetween::kAuto)
     return true;
   // We currently only support non-auto break-before and break-after values on
   // in-flow block level elements, which is the minimum requirement according to
   // the spec.
   if (isInline() || isFloatingOrOutOfFlowPositioned())
     return false;
   const LayoutBlock* curr = containingBlock();
   if (!curr || !curr->isLayoutBlockFlow())
     return false;
   const LayoutView* layoutView = view();
   bool viewIsPaginated = layoutView->fragmentationContext();
   if (!viewIsPaginated && !flowThreadContainingBlock())
     return false;
   while (curr) {
-    if (curr == layoutView)
-      return viewIsPaginated && breakValue != BreakColumn &&
-             breakValue != BreakAvoidColumn;
+    if (curr == layoutView) {
+      return viewIsPaginated && breakValue != EBreakBetween::kColumn &&
+             breakValue != EBreakBetween::kAvoidColumn;
+    }
     if (curr->isLayoutFlowThread()) {
       if (breakValue ==
-          BreakAvoid)  // Valid in any kind of fragmentation context.
+          EBreakBetween::kAvoid)  // Valid in any kind of fragmentation context.
         return true;
-      bool isMulticolValue =
-          breakValue == BreakColumn || breakValue == BreakAvoidColumn;
+      bool isMulticolValue = breakValue == EBreakBetween::kColumn ||
+                             breakValue == EBreakBetween::kAvoidColumn;
       if (toLayoutFlowThread(curr)->isLayoutPagedFlowThread())
         return !isMulticolValue;
       if (isMulticolValue)
         return true;
       // If this is a flow thread for a multicol container, and we have a break
       // value for paged, we need to keep looking.
     }
     if (curr->isFloatingOrOutOfFlowPositioned())
       return false;
     curr = curr->containingBlock();
   }
   ASSERT_NOT_REACHED();
   return false;
 }
 
-bool LayoutBox::isBreakInsideControllable(EBreak breakValue) const {
-  ASSERT(!isForcedFragmentainerBreakValue(breakValue));
-  if (breakValue == BreakAuto)

[amoylan, 2017/02/07 04:35:02]

This ASSERT is not required now that we have split out the smaller EBreakInside.

[mstensho (USE GERRIT), 2017/02/07 10:21:34]

Acknowledged. Good stuff!

+bool LayoutBox::isBreakInsideControllable(EBreakInside breakValue) const {
+  if (breakValue == EBreakInside::kAuto)
     return true;
   // First check multicol.
   const LayoutFlowThread* flowThread = flowThreadContainingBlock();
   // 'avoid-column' is only valid in a multicol context.
-  if (breakValue == BreakAvoidColumn)
+  if (breakValue == EBreakInside::kAvoidColumn)
     return flowThread && !flowThread->isLayoutPagedFlowThread();
   // 'avoid' is valid in any kind of fragmentation context.
-  if (breakValue == BreakAvoid && flowThread)
+  if (breakValue == EBreakInside::kAvoid && flowThread)
     return true;
-  ASSERT(breakValue == BreakAvoidPage || breakValue == BreakAvoid);
+  DCHECK(breakValue == EBreakInside::kAvoidPage ||
+         breakValue == EBreakInside::kAvoid);
   if (view()->fragmentationContext())
     return true;  // The view is paginated, probably because we're printing.
   if (!flowThread)
     return false;  // We're not inside any pagination context
   // We're inside a flow thread. We need to be contained by a flow thread for
   // paged overflow in order for pagination values to be valid, though.
   for (const LayoutBlock* ancestor = flowThread; ancestor;
        ancestor = ancestor->containingBlock()) {
     if (ancestor->isLayoutFlowThread() &&
         toLayoutFlowThread(ancestor)->isLayoutPagedFlowThread())
       return true;
   }
   return false;
 }
 
-EBreak LayoutBox::breakAfter() const {
-  EBreak breakValue = style()->breakAfter();
-  if (breakValue == BreakAuto || isBreakBetweenControllable(breakValue))
+EBreakBetween LayoutBox::breakAfter() const {
+  EBreakBetween breakValue = style()->breakAfter();
+  if (breakValue == EBreakBetween::kAuto ||
+      isBreakBetweenControllable(breakValue))
     return breakValue;
-  return BreakAuto;
+  return EBreakBetween::kAuto;
 }
 
-EBreak LayoutBox::breakBefore() const {
-  EBreak breakValue = style()->breakBefore();
-  if (breakValue == BreakAuto || isBreakBetweenControllable(breakValue))
+EBreakBetween LayoutBox::breakBefore() const {
+  EBreakBetween breakValue = style()->breakBefore();
+  if (breakValue == EBreakBetween::kAuto ||
+      isBreakBetweenControllable(breakValue))
     return breakValue;
-  return BreakAuto;
+  return EBreakBetween::kAuto;
 }
 
-EBreak LayoutBox::breakInside() const {
-  EBreak breakValue = style()->breakInside();
-  if (breakValue == BreakAuto || isBreakInsideControllable(breakValue))
+EBreakInside LayoutBox::breakInside() const {
+  EBreakInside breakValue = style()->breakInside();
+  if (breakValue == EBreakInside::kAuto ||
+      isBreakInsideControllable(breakValue))
     return breakValue;
-  return BreakAuto;
+  return EBreakInside::kAuto;
 }
 
 // At a class A break point [1], the break value with the highest precedence
 // wins. If the two values have the same precedence (e.g. "left" and "right"),
 // the value specified on a latter object wins.
 //
 // [1] https://drafts.csswg.org/css-break/#possible-breaks
-static inline int fragmentainerBreakPrecedence(EBreak breakValue) {
+static inline int fragmentainerBreakPrecedence(EBreakBetween breakValue) {
   // "auto" has the lowest priority.
   // "avoid*" values win over "auto".
   // "avoid-page" wins over "avoid-column".
   // "avoid" wins over "avoid-page".
   // Forced break values win over "avoid".
   // Any forced page break value wins over "column" forced break.
   // More specific break values (left, right, recto, verso) wins over generic
   // "page" values.
 
   switch (breakValue) {
     default:
       ASSERT_NOT_REACHED();
     // fall-through
-    case BreakAuto:
+    case EBreakBetween::kAuto:
       return 0;
-    case BreakAvoidColumn:
+    case EBreakBetween::kAvoidColumn:
       return 1;
-    case BreakAvoidPage:
+    case EBreakBetween::kAvoidPage:
       return 2;
-    case BreakAvoid:
+    case EBreakBetween::kAvoid:
       return 3;
-    case BreakColumn:
+    case EBreakBetween::kColumn:
       return 4;
-    case BreakPage:
+    case EBreakBetween::kPage:
       return 5;
-    case BreakLeft:
-    case BreakRight:
-    case BreakRecto:
-    case BreakVerso:
+    case EBreakBetween::kLeft:
+    case EBreakBetween::kRight:
+    case EBreakBetween::kRecto:
+    case EBreakBetween::kVerso:
       return 6;
   }
 }
 
-EBreak LayoutBox::joinFragmentainerBreakValues(EBreak firstValue,
-                                               EBreak secondValue) {
+EBreakBetween LayoutBox::joinFragmentainerBreakValues(
+    EBreakBetween firstValue,
+    EBreakBetween secondValue) {
   if (fragmentainerBreakPrecedence(secondValue) >=
       fragmentainerBreakPrecedence(firstValue))
     return secondValue;
   return firstValue;
 }
 
-EBreak LayoutBox::classABreakPointValue(EBreak previousBreakAfterValue) const {
+EBreakBetween LayoutBox::classABreakPointValue(
+    EBreakBetween previousBreakAfterValue) const {
   // First assert that we're at a class A break point.
   ASSERT(isBreakBetweenControllable(previousBreakAfterValue));
 
   return joinFragmentainerBreakValues(previousBreakAfterValue, breakBefore());
 }
 
-bool LayoutBox::needsForcedBreakBefore(EBreak previousBreakAfterValue) const {
+bool LayoutBox::needsForcedBreakBefore(
+    EBreakBetween previousBreakAfterValue) const {
   // Forced break values are only honored when specified on in-flow objects, but
   // floats and out-of-flow positioned objects may be affected by a break-after
   // value of the previous in-flow object, even though we're not at a class A
   // break point.
-  EBreak breakValue = isFloatingOrOutOfFlowPositioned()
-                          ? previousBreakAfterValue
-                          : classABreakPointValue(previousBreakAfterValue);
+  EBreakBetween breakValue =
+      isFloatingOrOutOfFlowPositioned()
+          ? previousBreakAfterValue
+          : classABreakPointValue(previousBreakAfterValue);
   return isForcedFragmentainerBreakValue(breakValue);
 }
 
 bool LayoutBox::paintedOutputOfObjectHasNoEffectRegardlessOfSize() const {
   if (hasNonCompositedScrollbars() || getSelectionState() != SelectionNone ||
       hasBoxDecorationBackground() || styleRef().hasBoxDecorations() ||
       styleRef().hasVisualOverflowingEffect())
     return false;
 
   // If the box has clip or mask, we need issue paint invalidation to cover
@@ skipping 2753 matching lines @@
 }
 
 LayoutBox::PaginationBreakability LayoutBox::getPaginationBreakability() const {
   // TODO(mstensho): It is wrong to check isAtomicInlineLevel() as we
   // actually look for replaced elements.
   if (isAtomicInlineLevel() || hasUnsplittableScrollingOverflow() ||
       (parent() && isWritingModeRoot()) ||
       (isOutOfFlowPositioned() && style()->position() == FixedPosition))
     return ForbidBreaks;
 
-  EBreak breakValue = breakInside();
-  if (breakValue == BreakAvoid || breakValue == BreakAvoidPage ||
-      breakValue == BreakAvoidColumn)
+  EBreakInside breakValue = breakInside();
+  if (breakValue == EBreakInside::kAvoid ||
+      breakValue == EBreakInside::kAvoidPage ||
+      breakValue == EBreakInside::kAvoidColumn)
     return AvoidBreaks;
   return AllowAnyBreaks;
 }
 
 LayoutUnit LayoutBox::lineHeight(bool /*firstLine*/,
                                  LineDirectionMode direction,
                                  LinePositionMode /*linePositionMode*/) const {
   if (isAtomicInlineLevel())
     return direction == HorizontalLine ? marginHeight() + size().height()
                                        : marginWidth() + size().width();
@@ skipping 645 matching lines @@
     block->adjustChildDebugRect(rect);
 
   return rect;
 }
 
 bool LayoutBox::shouldClipOverflow() const {
   return hasOverflowClip() || styleRef().containsPaint() || hasControlClip();
 }
 
 }  // namespace blink