Only allow forced fragmentainer breaks at class A break points.

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 144 matching lines @@
     bool lastChildIsSelfCollapsingBlockWithClearance() const { return m_lastChildIsSelfCollapsingBlockWithClearance; }
 };
 
 // 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_isAtFirstInFlowChild(true) { }
 
     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) { m_previousBreakAfterValue = value; }
+
     bool isAtFirstInFlowChild() const { return m_isAtFirstInFlowChild; }
     void clearIsAtFirstInFlowChild() { m_isAtFirstInFlowChild = false; }
 
 private:
     MarginInfo m_marginInfo;
     LayoutUnit m_previousFloatLogicalBottom;
+    EBreak m_previousBreakAfterValue;
     bool m_isAtFirstInFlowChild;
 };
 
 LayoutBlockFlow::LayoutBlockFlow(ContainerNode* node)
     : LayoutBlock(node)
 {
     static_assert(sizeof(MarginInfo) == sizeof(SameSizeAsMarginInfo), "MarginInfo should stay small");
     setChildrenInline(true);
 }
 
@@ skipping 182 matching lines @@
     // and subtract it from the maximal negative margin from both A and B to get the
     // true collapsed margin. This algorithm is recursive, so when we finish layout()
     // our block knows its current maximal positive/negative values.
     //
     // Start out by setting our margin values to our current margins. Table cells have
     // no margins, so we don't fill in the values for table cells.
     if (!isTableCell()) {
         initMaxMarginValues();
         setHasMarginBeforeQuirk(style()->hasMarginBeforeQuirk());
         setHasMarginAfterQuirk(style()->hasMarginAfterQuirk());
+    }
+
+    if (state.isPaginated()) {
         setPaginationStrutPropagatedFromChild(LayoutUnit());
+
+        // Start with any applicable computed break-after and break-before values for this
+        // object. During child layout, breakBefore will be joined with the breakBefore value of
+        // the first in-flow child, and breakAfter will be joined with the breakAfter value of the
+        // last in-flow child. This is done in order to honor the requirement that a class A break
+        // point [1] may only exists *between* in-flow siblings (i.e. not before the first child
+        // and not after the last child).
+        //
+        // [1] https://drafts.csswg.org/css-break/#possible-breaks
+        setBreakBefore(LayoutBlock::breakBefore());
+        setBreakAfter(LayoutBlock::breakAfter());
     }
 
     LayoutUnit beforeEdge = borderBefore() + paddingBefore();
     LayoutUnit afterEdge = borderAfter() + paddingAfter() + scrollbarLogicalHeight();
     LayoutUnit previousHeight = logicalHeight();
     setLogicalHeight(beforeEdge);
 
     m_paintInvalidationLogicalTop = LayoutUnit();
     m_paintInvalidationLogicalBottom = LayoutUnit();
     if (!firstChild() && !isAnonymousBlock())
@@ skipping 183 matching lines @@
             child.markForPaginationRelayoutIfNeeded(layoutScope);
         }
     }
 
     if (!child.needsLayout())
         return false;
     child.layout();
     return true;
 }
 
+bool LayoutBlockFlow::insertForcedBreakBeforeChildIfNeeded(LayoutBox& child, BlockChildrenLayoutInfo& layoutInfo)
+{
+    if (layoutInfo.isAtFirstInFlowChild()) {
+        // There's no class A break point before the first child (only *between* siblings), so
+        // steal its break value and join it with what we already have here.
+        setBreakBefore(joinFragmentainerBreakValues(breakBefore(), child.breakBefore()));
+        return false;
+    }
+
+    // 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 = 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);
+        return true;
+    }
+    return false;
+}
+
 void LayoutBlockFlow::layoutBlockChild(LayoutBox& child, BlockChildrenLayoutInfo& layoutInfo)
 {
     MarginInfo& marginInfo = layoutInfo.marginInfo();
     LayoutBlockFlow* childLayoutBlockFlow = child.isLayoutBlockFlow() ? toLayoutBlockFlow(&child) : nullptr;
     LayoutUnit oldPosMarginBefore = maxPositiveMarginBefore();
     LayoutUnit oldNegMarginBefore = maxNegativeMarginBefore();
 
     // The child is a normal flow object. Compute the margins we will use for collapsing now.
     child.computeAndSetBlockDirectionMargins(this);
 
     // Try to guess our correct logical top position. In most cases this guess will
     // be correct. Only if we're wrong (when we compute the real logical top position)
     // will we have to potentially relayout.
     LayoutUnit estimateWithoutPagination;
-    LayoutUnit logicalTopEstimate = estimateLogicalTopPosition(child, marginInfo, estimateWithoutPagination);
+    LayoutUnit logicalTopEstimate = estimateLogicalTopPosition(child, layoutInfo, estimateWithoutPagination);
 
     // Cache our old rect so that we can dirty the proper paint invalidation rects if the child moves.
     LayoutRect oldRect = child.frameRect();
 
     // Use the estimated block position and lay out the child if needed. After child layout, when
     // we have enough information to perform proper margin collapsing, float clearing and
     // pagination, we may have to reposition and lay out again if the estimate was wrong.
     bool childNeededLayout = positionAndLayoutOnceIfNeeded(child, logicalTopEstimate, layoutInfo);
 
     // Cache if we are at the top of the block right now.
     bool atBeforeSideOfBlock = marginInfo.atBeforeSideOfBlock();
     bool childIsSelfCollapsing = child.isSelfCollapsingBlock();
     bool childDiscardMarginBefore = mustDiscardMarginBeforeForChild(child);
     bool childDiscardMarginAfter = mustDiscardMarginAfterForChild(child);
+    bool paginated = view()->layoutState()->isPaginated();
+
+    // If there should be a forced break before the child, we need to insert it before attempting
+    // to collapse margins or apply clearance.
+    bool forcedBreakWasInserted = paginated && insertForcedBreakBeforeChildIfNeeded(child, layoutInfo);
 
     // Now determine the correct ypos based off examination of collapsing margin
     // values.
     LayoutUnit logicalTopBeforeClear = collapseMargins(child, marginInfo, childIsSelfCollapsing, childDiscardMarginBefore, childDiscardMarginAfter);
 
     // Now check for clear.
     bool childDiscardMargin = childDiscardMarginBefore || childDiscardMarginAfter;
     LayoutUnit newLogicalTop = clearFloatsIfNeeded(child, marginInfo, oldPosMarginBefore, oldNegMarginBefore, logicalTopBeforeClear, childIsSelfCollapsing, childDiscardMargin);
 
-    // Now check for pagination.
-    bool paginated = view()->layoutState()->isPaginated();
-    if (paginated) {
+    // If there's a forced break in front of this child, its final position has already been
+    // determined. Otherwise, see if there are other reasons for breaking before it
+    // (break-inside:avoid, or not enough space for the first piece of child content to fit in the
+    // current fragmentainer), and adjust the position accordingly.
+    if (paginated && !forcedBreakWasInserted) {
         if (estimateWithoutPagination != newLogicalTop) {
             // We got a new position due to clearance or margin collapsing. Before we attempt to
             // paginate (which may result in the position changing again), let's try again at the
             // new position (since a new position may result in a new logical height).
             positionAndLayoutOnceIfNeeded(child, newLogicalTop, layoutInfo);
         }
 
         newLogicalTop = adjustBlockChildForPagination(newLogicalTop, child, layoutInfo, atBeforeSideOfBlock && logicalTopBeforeClear == newLogicalTop);
     }
 
@@ skipping 34 matching lines @@
     if (childLayoutBlockFlow)
         addOverhangingFloats(childLayoutBlockFlow, !childNeededLayout);
 
     // If the child moved, we have to invalidate its paint as well as any floating/positioned
     // descendants. An exception is if we need a layout. In this case, we know we're going to
     // invalidate our paint (and the child) anyway.
     if (!selfNeedsLayout() && (childOffset.width() || childOffset.height()))
         child.invalidatePaintForOverhangingFloats(true);
 
     if (paginated) {
-        // Check for an after page/column break.
-        LayoutUnit newHeight = applyAfterBreak(child, logicalHeight(), marginInfo);
-        if (newHeight != size().height())
-            setLogicalHeight(newHeight);
+        // Keep track of the break-after value of the child, so that it can be joined with the
+        // break-before value of the next in-flow object at the next class A break point.
+        layoutInfo.setPreviousBreakAfterValue(child.breakAfter());
     }
 
     if (child.isLayoutMultiColumnSpannerPlaceholder()) {
         // The actual column-span:all element is positioned by this placeholder child.
         positionSpannerDescendant(toLayoutMultiColumnSpannerPlaceholder(child));
     }
 }
 
 LayoutUnit LayoutBlockFlow::adjustBlockChildForPagination(LayoutUnit logicalTop, LayoutBox& child, BlockChildrenLayoutInfo& layoutInfo, bool atBeforeSideOfBlock)
 {
+    // Forced breaks trumps unforced ones, and if we have a forced break, we shouldn't even be here.
+    ASSERT(layoutInfo.isAtFirstInFlowChild() || !isForcedFragmentainerBreakValue(child.classABreakPointValue(layoutInfo.previousBreakAfterValue())));
+
     LayoutBlockFlow* childBlockFlow = child.isLayoutBlockFlow() ? toLayoutBlockFlow(&child) : 0;
 
-    // Calculate the pagination strut for this child. A strut may come from three sources:
+    // See if we need a soft (unforced) break in front of this child, and set the pagination strut
+    // in that case. An unforced break may come from two sources:
     // 1. The first piece of content inside the child doesn't fit in the current page or column
-    // 2. A forced break before the child
-    // 3. The child itself is unsplittable and doesn't fit in the current page or column.
+    // 2. The child itself has breaking restrictions (break-inside:avoid, replaced content, etc.)
+    // and doesn't fully fit in the current page or column.
     //
     // No matter which source, if we need to insert a strut, it should always take us to the exact
     // top of a page or column further ahead, or be zero.
 
     // We're now going to calculate the child's final pagination strut. We may end up propagating
     // it to its containing block (|this|), so reset it first.
     child.resetPaginationStrut();
 
     // The first piece of content inside the child may have set a strut during layout. Currently,
     // only block flows support strut propagation, but this may (and should) change in the future.
     // See crbug.com/539873
     LayoutUnit strutFromContent = childBlockFlow ? childBlockFlow->paginationStrutPropagatedFromChild() : LayoutUnit();
     LayoutUnit logicalTopWithContentStrut = logicalTop + strutFromContent;
 
-    // If the object has a page or column break value of "before", then we should shift to the top of the next page.
-    LayoutUnit logicalTopAfterForcedBreak = applyBeforeBreak(child, logicalTop);
-
     // For replaced elements and scrolled elements, we want to shift them to the next page if they don't fit on the current one.
     LayoutUnit logicalTopAfterUnsplittable = adjustForUnsplittableChild(child, logicalTop);
 
     // Pick the largest offset. Tall unsplittable content may take us to a page or column further
     // ahead than the next one.
-    LayoutUnit logicalTopAfterPagination = std::max(logicalTopWithContentStrut, std::max(logicalTopAfterForcedBreak, logicalTopAfterUnsplittable));
+    LayoutUnit logicalTopAfterPagination = std::max(logicalTopWithContentStrut, logicalTopAfterUnsplittable);
     LayoutUnit newLogicalTop = logicalTop;
     if (LayoutUnit paginationStrut = logicalTopAfterPagination - logicalTop) {
         ASSERT(paginationStrut > 0);
         // If we're not at the first in-flow child, there's a class A break point before the child. If we *are* at the
         // first in-flow child, but the child isn't flush with the content edge of its container, due to e.g. clearance,
         // there's a class C break point before the child. Otherwise we should propagate the strut to our parent block,
         // and attempt to break there instead. See https://drafts.csswg.org/css-break/#possible-breaks
-        if (layoutInfo.isAtFirstInFlowChild() && atBeforeSideOfBlock && logicalTopAfterForcedBreak == logicalTop && allowsPaginationStrut()) {
+        if (layoutInfo.isAtFirstInFlowChild() && atBeforeSideOfBlock && allowsPaginationStrut()) {
             // FIXME: Should really check if we're exceeding the page height before propagating the strut, but we don't
             // have all the information to do so (the strut only has the remaining amount to push). Gecko gets this wrong too
             // and pushes to the next page anyway, so not too concerned about it.
             paginationStrut += logicalTop + marginBeforeIfFloating();
             setPaginationStrutPropagatedFromChild(paginationStrut);
             if (childBlockFlow)
                 childBlockFlow->setPaginationStrutPropagatedFromChild(LayoutUnit());
         } else {
             child.setPaginationStrut(paginationStrut);
             newLogicalTop += paginationStrut;
@@ skipping 303 matching lines @@
 
         child->setMayNeedPaintInvalidation();
 
         if (childToExclude == child)
             continue; // Skip this child, since it will be positioned by the specialized subclass (fieldsets and ruby runs).
 
         updateBlockChildDirtyBitsBeforeLayout(relayoutChildren, *child);
 
         if (child->isOutOfFlowPositioned()) {
             child->containingBlock()->insertPositionedObject(child);
-            adjustPositionedBlock(*child, marginInfo);
+            adjustPositionedBlock(*child, layoutInfo);
             continue;
         }
         if (child->isFloating()) {
             insertFloatingObject(*child);
             adjustFloatingBlock(marginInfo);
             continue;
         }
         if (child->isColumnSpanAll()) {
             // This is not the containing block of the spanner. The spanner's placeholder will lay
             // it out in due course. For now we just need to consult our flow thread, so that the
@@ skipping 261 matching lines @@
         // into the margin area of the self-collapsing block then the float it clears is now intruding into |child|. Layout again so that we can look for
         // floats in the parent that overhang |child|'s new logical top.
         bool logicalTopIntrudesIntoFloat = logicalTop < beforeCollapseLogicalTop;
         if (logicalTopIntrudesIntoFloat && containsFloats() && !child.avoidsFloats() && lowestFloatLogicalBottom() > logicalTop)
             child.setNeedsLayoutAndFullPaintInvalidation(LayoutInvalidationReason::AncestorMarginCollapsing);
     }
 
     return logicalTop;
 }
 
-void LayoutBlockFlow::adjustPositionedBlock(LayoutBox& child, const MarginInfo& marginInfo)
+void LayoutBlockFlow::adjustPositionedBlock(LayoutBox& child, const BlockChildrenLayoutInfo& layoutInfo)
 {
     LayoutUnit logicalTop = logicalHeight();
+
+    // Forced breaks are only specified on in-flow objects, but auto-positioned out-of-flow objects
+    // may be affected by a break-after value of the previous in-flow object.
+    if (view()->layoutState()->isPaginated())
+        logicalTop = applyForcedBreak(logicalTop, layoutInfo.previousBreakAfterValue());
+
     updateStaticInlinePositionForChild(child, logicalTop);
 
+    const MarginInfo& marginInfo = layoutInfo.marginInfo();
     if (!marginInfo.canCollapseWithMarginBefore()) {
         // Positioned blocks don't collapse margins, so add the margin provided by
         // the container now. The child's own margin is added later when calculating its logical top.
         LayoutUnit collapsedBeforePos = marginInfo.positiveMargin();
         LayoutUnit collapsedBeforeNeg = marginInfo.negativeMargin();
         logicalTop += collapsedBeforePos - collapsedBeforeNeg;
     }
 
     PaintLayer* childLayer = child.layer();
     if (childLayer->staticBlockPosition() != logicalTop)
@@ skipping 137 matching lines @@
     // If we have a 'clear' value but also have a margin we may not actually require clearance to move past any floats.
     // If that's the case we want to be sure we estimate the correct position including margins after any floats rather
     // than use 'clearance' later which could give us the wrong position.
     if (grandchildBox->style()->clear() != ClearNone && childBlockFlow->marginBeforeForChild(*grandchildBox) == 0)
         return;
 
     // Collapse the margin of the grandchild box with our own to produce an estimate.
     childBlockFlow->marginBeforeEstimateForChild(*grandchildBox, positiveMarginBefore, negativeMarginBefore, discardMarginBefore);
 }
 
-LayoutUnit LayoutBlockFlow::estimateLogicalTopPosition(LayoutBox& child, const MarginInfo& marginInfo, LayoutUnit& estimateWithoutPagination)
+LayoutUnit LayoutBlockFlow::estimateLogicalTopPosition(LayoutBox& child, const BlockChildrenLayoutInfo& layoutInfo, LayoutUnit& estimateWithoutPagination)
 {
+    const MarginInfo& marginInfo = layoutInfo.marginInfo();
     // FIXME: We need to eliminate the estimation of vertical position, because when it's wrong we sometimes trigger a pathological
     // relayout if there are intruding floats.
     LayoutUnit logicalTopEstimate = logicalHeight();
+    LayoutUnit positiveMarginBefore;
+    LayoutUnit negativeMarginBefore;
+    bool discardMarginBefore = false;
     if (!marginInfo.canCollapseWithMarginBefore()) {
-        LayoutUnit positiveMarginBefore;
-        LayoutUnit negativeMarginBefore;
-        bool discardMarginBefore = false;
         if (child.selfNeedsLayout()) {
             // Try to do a basic estimation of how the collapse is going to go.
             marginBeforeEstimateForChild(child, positiveMarginBefore, negativeMarginBefore, discardMarginBefore);
         } else {
             // Use the cached collapsed margin values from a previous layout. Most of the time they
             // will be right.
             LayoutBlockFlow::MarginValues marginValues = marginValuesForChild(child);
             positiveMarginBefore = std::max(positiveMarginBefore, marginValues.positiveMarginBefore());
             negativeMarginBefore = std::max(negativeMarginBefore, marginValues.negativeMarginBefore());
             discardMarginBefore = mustDiscardMarginBeforeForChild(child);
         }
 
         // Collapse the result with our current margins.
         if (!discardMarginBefore)
             logicalTopEstimate += std::max(marginInfo.positiveMargin(), positiveMarginBefore) - std::max(marginInfo.negativeMargin(), negativeMarginBefore);
     }
 
     // Adjust logicalTopEstimate down to the next page if the margins are so large that we don't fit on the current
     // page.
     LayoutState* layoutState = view()->layoutState();
     if (layoutState->isPaginated() && isPageLogicalHeightKnown(logicalHeight()) && logicalTopEstimate > logicalHeight())
         logicalTopEstimate = std::min(logicalTopEstimate, nextPageLogicalTop(logicalHeight(), AssociateWithLatterPage));
 
     logicalTopEstimate += getClearDelta(&child, logicalTopEstimate);
 
     estimateWithoutPagination = logicalTopEstimate;
 
     if (layoutState->isPaginated()) {
-        // If the object has a page or column break value of "before", then we should shift to the top of the next page.
-        logicalTopEstimate = applyBeforeBreak(child, logicalTopEstimate);
+        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 = 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
+                // fragmentainer.
+                return std::max(estimateWithoutPagination, logicalTopEstimate);
+            }
+        }
 
         // For replaced elements and scrolled elements, we want to shift them to the next page if they don't fit on the current one.
         logicalTopEstimate = adjustForUnsplittableChild(child, logicalTopEstimate);
     }
 
     return logicalTopEstimate;
 }
 
 void LayoutBlockFlow::adjustFloatingBlock(const MarginInfo& marginInfo)
 {
@@ skipping 38 matching lines @@
 
     // Now add in our bottom border/padding.
     setLogicalHeight(logicalHeight() + afterSide);
 
     // Negative margins can cause our height to shrink below our minimal height (border/padding).
     // If this happens, ensure that the computed height is increased to the minimal height.
     setLogicalHeight(std::max(logicalHeight(), beforeSide + afterSide));
 
     // Update our bottom collapsed margin info.
     setCollapsedBottomMargin(marginInfo);
+
+    // There's no class A break point right after the last child, only *between* siblings. So
+    // propagate the break-after value, and keep looking for a class A break point (at the next
+    // in-flow block-level object), where we'll join this break-after value with the break-before
+    // value there.
+    if (view()->layoutState()->isPaginated() && lastChild)
+        setBreakAfter(joinFragmentainerBreakValues(breakAfter(), lastChild->breakAfter()));
 }
 
 void LayoutBlockFlow::setMustDiscardMarginBefore(bool value)
 {
     if (style()->marginBeforeCollapse() == MarginCollapseDiscard) {
         ASSERT(value);
         return;
     }
 
     if (!m_rareData && !value)
@@ skipping 97 matching lines @@
     const ComputedStyle& childStyle = child.styleRef();
     if (!child.isWritingModeRoot())
         return childStyle.marginAfterCollapse() == MarginCollapseSeparate;
     if (child.isHorizontalWritingMode() == isHorizontalWritingMode())
         return childStyle.marginBeforeCollapse() == MarginCollapseSeparate;
 
     // FIXME: See |mustDiscardMarginBeforeForChild| above.
     return false;
 }
 
-LayoutUnit LayoutBlockFlow::applyBeforeBreak(LayoutBox& child, LayoutUnit logicalOffset)
+LayoutUnit LayoutBlockFlow::applyForcedBreak(LayoutUnit logicalOffset, EBreak breakValue)
 {
-    if (child.hasForcedBreakBefore())
+    // 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.
+    if (isForcedFragmentainerBreakValue(breakValue))
         return nextPageLogicalTop(logicalOffset, AssociateWithFormerPage);
     return logicalOffset;
 }
 
-LayoutUnit LayoutBlockFlow::applyAfterBreak(LayoutBox& child, LayoutUnit logicalOffset, MarginInfo& marginInfo)
+void LayoutBlockFlow::setBreakBefore(EBreak breakValue)
 {
-    if (child.hasForcedBreakAfter()) {
-        // So our margin doesn't participate in the next collapsing steps.
-        marginInfo.clearMargin();
+    if (breakValue != BreakAuto && !isBreakBetweenControllable(breakValue))
+        breakValue = BreakAuto;
+    if (breakValue == BreakAuto && !m_rareData)
+        return;
+    ensureRareData().m_breakBefore = breakValue;
+}
 
-        return nextPageLogicalTop(logicalOffset, AssociateWithFormerPage);
-    }
-    return logicalOffset;
+void LayoutBlockFlow::setBreakAfter(EBreak breakValue)
+{
+    if (breakValue != BreakAuto && !isBreakBetweenControllable(breakValue))
+        breakValue = BreakAuto;
+    if (breakValue == BreakAuto && !m_rareData)
+        return;
+    ensureRareData().m_breakAfter = breakValue;
+}
+
+EBreak LayoutBlockFlow::breakBefore() const
+{
+    return m_rareData ? static_cast<EBreak>(m_rareData->m_breakBefore) : BreakAuto;
+}
+
+EBreak LayoutBlockFlow::breakAfter() const
+{
+    return m_rareData ? static_cast<EBreak>(m_rareData->m_breakAfter) : BreakAuto;
 }
 
 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 668 matching lines @@
 
         // FIXME Investigate if this can be removed. crbug.com/370006
         childBox->setMayNeedPaintInvalidation();
 
         LayoutUnit childLogicalLeftMargin = style()->isLeftToRightDirection() ? marginStartForChild(*childBox) : marginEndForChild(*childBox);
         if (childBox->style()->clear() & ClearLeft)
             logicalTop = std::max(lowestFloatLogicalBottom(FloatingObject::FloatLeft), logicalTop);
         if (childBox->style()->clear() & ClearRight)
             logicalTop = std::max(lowestFloatLogicalBottom(FloatingObject::FloatRight), logicalTop);
 
+        bool isPaginated = view()->layoutState()->isPaginated();
+        if (isPaginated && !childrenInline()) {
+            // Forced breaks are inserted at class A break points. Floats may be affected by a
+            // break-after value on the previous in-flow sibling.
+            if (LayoutBox* previousInFlowBox = childBox->previousInFlowSiblingBox())
+                logicalTop = applyForcedBreak(logicalTop, previousInFlowBox->breakAfter());
+        }
+
         LayoutPoint floatLogicalLocation = computeLogicalLocationForFloat(floatingObject, logicalTop);
 
         setLogicalLeftForFloat(floatingObject, floatLogicalLocation.x());
 
         setLogicalLeftForChild(*childBox, floatLogicalLocation.x() + childLogicalLeftMargin);
         setLogicalTopForChild(*childBox, floatLogicalLocation.y() + marginBeforeForChild(*childBox));
 
         SubtreeLayoutScope layoutScope(*childBox);
-        LayoutState* layoutState = view()->layoutState();
-        bool isPaginated = layoutState->isPaginated();
         if (isPaginated && !childBox->needsLayout())
             childBox->markForPaginationRelayoutIfNeeded(layoutScope);
 
         childBox->layoutIfNeeded();
 
         if (isPaginated) {
             LayoutBlockFlow* childBlockFlow = childBox->isLayoutBlockFlow() ? toLayoutBlockFlow(childBox) : nullptr;
             // The first piece of content inside the child may have set a strut during layout.
             LayoutUnit strut = childBlockFlow ? childBlockFlow->paginationStrutPropagatedFromChild() : LayoutUnit();
             if (!strut) {
@@ skipping 489 matching lines @@
     // FIXME: Glyph overflow will get lost in this case, but not really a big deal.
     GlyphOverflowAndFallbackFontsMap textBoxDataMap;
     for (ListHashSet<RootInlineBox*>::const_iterator it = lineBoxes.begin(); it != lineBoxes.end(); ++it) {
         RootInlineBox* box = *it;
         box->computeOverflow(box->lineTop(), box->lineBottom(), textBoxDataMap);
     }
     return childrenOverflowChanged;
 }
 
 } // namespace blink