Margins that start at fragmentainer boundaries should be collapsed away.

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 797 matching lines @@
     // 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,
+      collapseMargins(child, layoutInfo, 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
@@ skipping 763 matching lines @@
     if (afterMargin > 0)
       childAfterPositive = afterMargin;
     else
       childAfterNegative = -afterMargin;
   }
 
   return LayoutBlockFlow::MarginValues(childBeforePositive, childBeforeNegative,
                                        childAfterPositive, childAfterNegative);
 }
 
+LayoutUnit LayoutBlockFlow::adjustedMarginBeforeForPagination(
+    const LayoutBox& child,
+    LayoutUnit logicalTopMarginEdge,
+    LayoutUnit logicalTopBorderEdge,
+    const BlockChildrenLayoutInfo& layoutInfo) const {
+  LayoutUnit effectiveMargin = logicalTopBorderEdge - logicalTopMarginEdge;
+  DCHECK(isPageLogicalHeightKnown());
+  if (effectiveMargin <= LayoutUnit())
+    return effectiveMargin;
+  // If margins would pull us past the top of the next fragmentainer, then we
+  // need to pull back and let the margins collapse into the fragmentainer
+  // boundary. If we're at a fragmentainer boundary, and there's no forced break
+  // involved, collapse the margin with the boundary we're at. Otherwise,
+  // preserve the margin at the top of the fragmentainer, but collapse it with
+  // the next fragmentainer boundary, since no margin should ever live in more
+  // than one fragmentainer.
+  PageBoundaryRule rule = AssociateWithLatterPage;
+  if (!child.needsForcedBreakBefore(layoutInfo.previousBreakAfterValue()) &&
+      offsetFromLogicalTopOfFirstPage() + logicalTopMarginEdge > LayoutUnit())
+    rule = AssociateWithFormerPage;
+  LayoutUnit remainingSpace =
+      pageRemainingLogicalHeightForOffset(logicalTopMarginEdge, rule);
+  return std::min(effectiveMargin, remainingSpace);
+}
+
 LayoutUnit LayoutBlockFlow::collapseMargins(LayoutBox& child,
-                                            MarginInfo& marginInfo,
+                                            BlockChildrenLayoutInfo& layoutInfo,
                                             bool childIsSelfCollapsing,
                                             bool childDiscardMarginBefore,
                                             bool childDiscardMarginAfter) {
+  MarginInfo& marginInfo = layoutInfo.marginInfo();
+
   // The child discards the before margin when the the after margin has discard
   // in the case of a self collapsing block.
   childDiscardMarginBefore = childDiscardMarginBefore ||
                              (childDiscardMarginAfter && childIsSelfCollapsing);
 
   // Get the four margin values for the child and cache them.
   const LayoutBlockFlow::MarginValues childMargins =
       marginValuesForChild(child);
 
   // Get our max pos and neg top margins.
@@ skipping 141 matching lines @@
       marginInfo.setPositiveMargin(childMargins.positiveMarginAfter());
       marginInfo.setNegativeMargin(childMargins.negativeMarginAfter());
     } else {
       marginInfo.clearMargin();
     }
 
     if (marginInfo.margin())
       marginInfo.setHasMarginAfterQuirk(hasMarginAfterQuirk(&child));
   }
 
-  // If margins would pull us past the top of the next page, then we need to
-  // pull back and pretend like the margins collapsed into the page edge.
-  LayoutState* layoutState = view()->layoutState();
-  if (layoutState->isPaginated() && isPageLogicalHeightKnown() &&
-      logicalTop > beforeCollapseLogicalTop) {
+  if (view()->layoutState()->isPaginated() && isPageLogicalHeightKnown()) {
     LayoutUnit oldLogicalTop = logicalTop;
-    logicalTop =
-        std::min(logicalTop, nextPageLogicalTop(beforeCollapseLogicalTop));
+    LayoutUnit margin = adjustedMarginBeforeForPagination(
+        child, beforeCollapseLogicalTop, logicalTop, layoutInfo);
+    logicalTop = beforeCollapseLogicalTop + margin;
     setLogicalHeight(logicalHeight() + (logicalTop - oldLogicalTop));
   }
 
   // If |child| has moved up into previous siblings it needs to avoid or clear
   // any floats they contain.
   LayoutUnit oldLogicalHeight = logicalHeight();
   setLogicalHeight(logicalTop);
   while (previousBlockFlow) {
     auto lowestFloat = previousBlockFlow->logicalTop() +
                        previousBlockFlow->lowestFloatLogicalBottom();
@@ skipping 270 matching lines @@
       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() &&
-      logicalTopEstimate > logicalHeight())
-    logicalTopEstimate =
-        std::min(logicalTopEstimate, nextPageLogicalTop(logicalHeight()));
+  if (layoutState->isPaginated() && isPageLogicalHeightKnown()) {
+    LayoutUnit margin = adjustedMarginBeforeForPagination(
+        child, logicalHeight(), logicalTopEstimate, layoutInfo);
+    logicalTopEstimate = logicalHeight() + margin;
+  }
 
   logicalTopEstimate += getClearDelta(&child, logicalTopEstimate);
 
   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
@@ skipping 2458 matching lines @@
   return LayoutBlock::invalidatePaintIfNeeded(paintInvalidationState);
 }
 
 void LayoutBlockFlow::invalidateDisplayItemClients(
     PaintInvalidationReason invalidationReason) const {
   BlockFlowPaintInvalidator(*this).invalidateDisplayItemClients(
       invalidationReason);
 }
 
 }  // namespace blink