Need to consider the need for a soft break even when inserting a forced break.

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 659 matching lines @@
             child.markForPaginationRelayoutIfNeeded(layoutScope);
         }
     }
 
     if (!child.needsLayout())
         return false;
     child.layout();
     return true;
 }
 
-bool LayoutBlockFlow::insertForcedBreakBeforeChildIfNeeded(LayoutBox& child, BlockChildrenLayoutInfo& layoutInfo)
+void 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;
+        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 = 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.
@@ skipping 18 matching lines @@
 
     // 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);
+    if (paginated) {
+        // We will now insert the strut needed by any forced break. After this operation, we will
+        // have calculated the offset where we can apply margin collapsing and clearance. After
+        // having applied those things, we'll be at the position where we can honor requirements of
+        // unbreakable content, which may extend the strut further.
+        child.resetPaginationStrut();
+        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);
 
     // 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 (paginated) {
         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);
         }
 
+        // We have now applied forced breaks, margin collapsing and clearance, and we're at the
+        // position where we can honor requirements of unbreakable content.
         newLogicalTop = adjustBlockChildForPagination(newLogicalTop, child, layoutInfo, atBeforeSideOfBlock && logicalTopBeforeClear == newLogicalTop);
     }
 
     // Clearance, margin collapsing or pagination may have given us a new logical top, in which
     // case we may have to reposition and possibly relayout as well. If we determined during child
     // layout that we need to insert a break to honor widows, we also need to relayout.
     if (newLogicalTop != logicalTopEstimate
         || child.needsLayout()
         || (paginated && childLayoutBlockFlow && childLayoutBlockFlow->shouldBreakAtLineToAvoidWidow())) {
         positionAndLayoutOnceIfNeeded(child, newLogicalTop, layoutInfo);
@@ skipping 42 matching lines @@
     }
 
     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;
 
     // 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. 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;
 
     // 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, logicalTopAfterUnsplittable);
     LayoutUnit newLogicalTop = logicalTop;
-    if (LayoutUnit paginationStrut = logicalTopAfterPagination - logicalTop) {
+
+    // Forced breaks may already have caused a strut, and this needs to be added together with
+    // any strut detected here in this method.
+    LayoutUnit previousStrut = child.paginationStrut();
+
+    if (LayoutUnit paginationStrut = logicalTopAfterPagination - logicalTop + previousStrut) {
         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 && 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);
+            child.resetPaginationStrut();
             if (childBlockFlow)
                 childBlockFlow->setPaginationStrutPropagatedFromChild(LayoutUnit());
         } else {
             child.setPaginationStrut(paginationStrut);
-            newLogicalTop += paginationStrut;
+            // |previousStrut| was already baked into the logical top, so don't add it again.
+            newLogicalTop += paginationStrut - previousStrut;
         }
     }
 
     // Similar to how we apply clearance. Go ahead and boost height() to be the place where we're going to position the child.
     setLogicalHeight(logicalHeight() + (newLogicalTop - logicalTop));
 
     // Return the final adjusted logical top.
     return newLogicalTop;
 }
 
@@ skipping 2878 matching lines @@
 
     return LayoutBlock::invalidatePaintIfNeeded(paintInvalidationState);
 }
 
 void LayoutBlockFlow::invalidateDisplayItemClients(PaintInvalidationReason invalidationReason) const
 {
     BlockFlowPaintInvalidator(*this).invalidateDisplayItemClients(invalidationReason);
 }
 
 } // namespace blink