Split EBreak enum into EBreakBetween & EBreakInside

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

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 189 matching lines @@
 // Some features, such as floats, margin collapsing and fragmentation, require
 // some knowledge about things that happened when laying out previous block
 // child siblings. Only looking at the object currently being laid out isn't
 // always enough.
 class BlockChildrenLayoutInfo {
  public:
   BlockChildrenLayoutInfo(LayoutBlockFlow* blockFlow,
                           LayoutUnit beforeEdge,
                           LayoutUnit afterEdge)
       : m_marginInfo(blockFlow, beforeEdge, afterEdge),
-        m_previousBreakAfterValue(BreakAuto),
+        m_previousBreakAfterValue(EBreakBetween::kAuto),
         m_isAtFirstInFlowChild(true) {}
 
   // Store multicol layout state before first layout of a block child. The child
   // may contain a column spanner. If we need to re-lay out the block child
   // because our initial logical top estimate was wrong, we need to roll back to
   // how things were before laying out the child.
   void storeMultiColumnLayoutState(const LayoutFlowThread& flowThread) {
     m_multiColumnLayoutState = flowThread.multiColumnLayoutState();
   }
   void rollBackToInitialMultiColumnLayoutState(LayoutFlowThread& flowThread) {
     flowThread.restoreMultiColumnLayoutState(m_multiColumnLayoutState);
   }
 
   const MarginInfo& marginInfo() const { return m_marginInfo; }
   MarginInfo& marginInfo() { return m_marginInfo; }
   LayoutUnit& previousFloatLogicalBottom() {
     return m_previousFloatLogicalBottom;
   }
 
-  EBreak previousBreakAfterValue() const { return m_previousBreakAfterValue; }
-  void setPreviousBreakAfterValue(EBreak value) {
+  EBreakBetween previousBreakAfterValue() const {
+    return m_previousBreakAfterValue;
+  }
+  void setPreviousBreakAfterValue(EBreakBetween value) {
     m_previousBreakAfterValue = value;
   }
 
   bool isAtFirstInFlowChild() const { return m_isAtFirstInFlowChild; }
   void clearIsAtFirstInFlowChild() { m_isAtFirstInFlowChild = false; }
 
  private:
   MultiColumnLayoutState m_multiColumnLayoutState;
   MarginInfo m_marginInfo;
   LayoutUnit m_previousFloatLogicalBottom;
-  EBreak m_previousBreakAfterValue;
+  EBreakBetween m_previousBreakAfterValue;
   bool m_isAtFirstInFlowChild;
 };
 
 LayoutBlockFlow::LayoutBlockFlow(ContainerNode* node) : LayoutBlock(node) {
   static_assert(sizeof(MarginInfo) == sizeof(SameSizeAsMarginInfo),
                 "MarginInfo should stay small");
   setChildrenInline(true);
 }
 
 LayoutBlockFlow::~LayoutBlockFlow() {}
@@ skipping 494 matching lines @@
     // siblings), so steal its break value and join it with what we already have
     // here.
     setBreakBefore(
         joinFragmentainerBreakValues(breakBefore(), child.breakBefore()));
     return;
   }
 
   // Figure out if a forced break should be inserted in front of the child. If
   // we insert a forced break, the margins on this child may not collapse with
   // those preceding the break.
-  EBreak classABreakPointValue =
+  EBreakBetween classABreakPointValue =
       child.classABreakPointValue(layoutInfo.previousBreakAfterValue());
   if (isForcedFragmentainerBreakValue(classABreakPointValue)) {
     layoutInfo.marginInfo().clearMargin();
     LayoutUnit oldLogicalTop = logicalHeight();
     LayoutUnit newLogicalTop =
         applyForcedBreak(oldLogicalTop, classABreakPointValue);
     setLogicalHeight(newLogicalTop);
     LayoutUnit paginationStrut = newLogicalTop - oldLogicalTop;
     child.setPaginationStrut(paginationStrut);
   }
@@ skipping 1343 matching lines @@
 
   estimateWithoutPagination = logicalTopEstimate;
 
   if (layoutState->isPaginated()) {
     if (!layoutInfo.isAtFirstInFlowChild()) {
       // Estimate the need for a forced break in front of this child. The final
       // break policy at this class A break point isn't known until we have laid
       // out the children of |child|. There may be forced break-before values
       // set on first-children inside that get propagated up to the child.
       // Just make an estimate with what we know so far.
-      EBreak breakValue =
+      EBreakBetween breakValue =
           child.classABreakPointValue(layoutInfo.previousBreakAfterValue());
       if (isForcedFragmentainerBreakValue(breakValue)) {
         logicalTopEstimate = applyForcedBreak(logicalHeight(), breakValue);
         // Disregard previous margins, since they will collapse with the
         // fragmentainer boundary, due to the forced break. Only apply margins
         // that have been specified on the child or its descendants.
         if (!discardMarginBefore)
           logicalTopEstimate += positiveMarginBefore - negativeMarginBefore;
 
         // Clearance may already have taken us past the beginning of the next
@@ skipping 200 matching lines @@
   if (!child.isWritingModeRoot())
     return childStyle.marginAfterCollapse() == MarginCollapseSeparate;
   if (child.isHorizontalWritingMode() == isHorizontalWritingMode())
     return childStyle.marginBeforeCollapse() == MarginCollapseSeparate;
 
   // FIXME: See |mustDiscardMarginBeforeForChild| above.
   return false;
 }
 
 LayoutUnit LayoutBlockFlow::applyForcedBreak(LayoutUnit logicalOffset,
-                                             EBreak breakValue) {
+                                             EBreakBetween breakValue) {
   if (!isForcedFragmentainerBreakValue(breakValue))
     return logicalOffset;
   // TODO(mstensho): honor breakValue. There are different types of forced
   // breaks. We currently just assume that we want to break to the top of the
   // next fragmentainer of the fragmentation context we're in. However, we may
   // want to find the next left or right page - even if we're inside a multicol
   // container when printing.
   LayoutUnit pageLogicalHeight = pageLogicalHeightForOffset(logicalOffset);
   if (!pageLogicalHeight)
     return logicalOffset;  // Page height is still unknown, so we cannot insert
                            // forced breaks.
   LayoutUnit remainingLogicalHeight = pageRemainingLogicalHeightForOffset(
       logicalOffset, AssociateWithLatterPage);
   if (remainingLogicalHeight == pageLogicalHeight)
     return logicalOffset;  // Don't break if we're already at the block start of
                            // a fragmentainer.
 
   // If this is the first forced break inside this object, store the
   // location. We need this information later if there's a break-inside:avoid
   // object further up. We need to know if there are any forced breaks inside
   // such objects, in order to determine whether we need to push it to the next
   // fragmentainer or not.
   if (!firstForcedBreakOffset())
     setFirstForcedBreakOffset(logicalOffset);
 
   return logicalOffset + remainingLogicalHeight;
 }
 
-void LayoutBlockFlow::setBreakBefore(EBreak breakValue) {
-  if (breakValue != BreakAuto && !isBreakBetweenControllable(breakValue))
-    breakValue = BreakAuto;
-  if (breakValue == BreakAuto && !m_rareData)
+void LayoutBlockFlow::setBreakBefore(EBreakBetween breakValue) {
+  if (breakValue != EBreakBetween::kAuto &&
+      !isBreakBetweenControllable(breakValue))
+    breakValue = EBreakBetween::kAuto;
+  if (breakValue == EBreakBetween::kAuto && !m_rareData)
     return;
-  ensureRareData().m_breakBefore = breakValue;
+  ensureRareData().m_breakBefore = static_cast<unsigned>(breakValue);
 }
 
-void LayoutBlockFlow::setBreakAfter(EBreak breakValue) {
-  if (breakValue != BreakAuto && !isBreakBetweenControllable(breakValue))
-    breakValue = BreakAuto;
-  if (breakValue == BreakAuto && !m_rareData)
+void LayoutBlockFlow::setBreakAfter(EBreakBetween breakValue) {
+  if (breakValue != EBreakBetween::kAuto &&
+      !isBreakBetweenControllable(breakValue))
+    breakValue = EBreakBetween::kAuto;
+  if (breakValue == EBreakBetween::kAuto && !m_rareData)
     return;
-  ensureRareData().m_breakAfter = breakValue;
+  ensureRareData().m_breakAfter = static_cast<unsigned>(breakValue);
 }
 
-EBreak LayoutBlockFlow::breakBefore() const {
-  return m_rareData ? static_cast<EBreak>(m_rareData->m_breakBefore)
-                    : BreakAuto;
+EBreakBetween LayoutBlockFlow::breakBefore() const {
+  return m_rareData ? static_cast<EBreakBetween>(m_rareData->m_breakBefore)
+                    : EBreakBetween::kAuto;
 }
 
-EBreak LayoutBlockFlow::breakAfter() const {
-  return m_rareData ? static_cast<EBreak>(m_rareData->m_breakAfter) : BreakAuto;
+EBreakBetween LayoutBlockFlow::breakAfter() const {
+  return m_rareData ? static_cast<EBreakBetween>(m_rareData->m_breakAfter)
+                    : EBreakBetween::kAuto;
 }
 
 void LayoutBlockFlow::addOverflowFromFloats() {
   if (!m_floatingObjects)
     return;
 
   const FloatingObjectSet& floatingObjectSet = m_floatingObjects->set();
   FloatingObjectSetIterator end = floatingObjectSet.end();
   for (FloatingObjectSetIterator it = floatingObjectSet.begin(); it != end;
        ++it) {
@@ skipping 2196 matching lines @@
   return LayoutBlock::invalidatePaintIfNeeded(paintInvalidationState);
 }
 
 void LayoutBlockFlow::invalidateDisplayItemClients(
     PaintInvalidationReason invalidationReason) const {
   BlockFlowPaintInvalidator(*this).invalidateDisplayItemClients(
       invalidationReason);
 }
 
 }  // namespace blink