Only allow forced fragmentainer breaks at class A break points.

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
  * modify it under the terms of the GNU Library General Public
@@ skipping 1891 matching lines @@
 }
 
 EBreak LayoutBox::breakInside() const
 {
     EBreak breakValue = style()->breakInside();
     if (breakValue == BreakAuto || isBreakInsideControllable(breakValue))
         return breakValue;
     return BreakAuto;
 }
 
-bool LayoutBox::hasForcedBreakBefore() const
+// 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)
 {
-    return isForcedFragmentainerBreakValue(breakBefore());
+    // "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:
+        return 0;
+    case BreakAvoidColumn:
+        return 1;
+    case BreakAvoidPage:
+        return 2;
+    case BreakAvoid:
+        return 3;
+    case BreakColumn:
+        return 4;
+    case BreakPage:
+        return 5;
+    case BreakLeft:
+    case BreakRight:
+    case BreakRecto:
+    case BreakVerso:
+        return 6;
+    }
 }
 
-bool LayoutBox::hasForcedBreakAfter() const
+EBreak LayoutBox::joinFragmentainerBreakValues(EBreak firstValue, EBreak secondValue)
 {
-    return isForcedFragmentainerBreakValue(breakAfter());
+    if (fragmentainerBreakPrecedence(secondValue) >= fragmentainerBreakPrecedence(firstValue))
+        return secondValue;
+    return firstValue;
+}
+
+EBreak LayoutBox::classABreakPointValue(EBreak previousBreakAfterValue) const
+{
+    ASSERT(isBreakBetweenControllable(previousBreakAfterValue));
+    return joinFragmentainerBreakValues(previousBreakAfterValue, breakBefore());
+}
+
+bool LayoutBox::needsForcedBreakBefore(EBreak previousBreakAfterValue) const
+{
+    return isForcedFragmentainerBreakValue(classABreakPointValue(previousBreakAfterValue));
 }
 
 LayoutRect LayoutBox::localOverflowRectForPaintInvalidation() const
 {
     if (style()->visibility() != VISIBLE) {
         PaintLayer* layer = enclosingLayer();
         layer->updateDescendantDependentFlags();
         if (layer->subtreeIsInvisible())
             return LayoutRect();
     }
@@ skipping 2771 matching lines @@
 
 void LayoutBox::clearPercentHeightDescendants()
 {
     for (LayoutObject* curr = slowFirstChild(); curr; curr = curr->nextInPreOrder(this)) {
         if (curr->isBox())
             toLayoutBox(curr)->removeFromPercentHeightContainer();
     }
 }
 
 } // namespace blink