A line that ends up naturally in the next column may need to propagate a strut.

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 719 matching lines @@
 
     paginatedContentWasLaidOut(newLogicalTop);
 
     // 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;
 }
 
-static inline bool shouldSetStrutOnBlock(const LayoutBlockFlow& block, const RootInlineBox& lineBox, LayoutUnit lineLogicalOffset, int lineIndex, LayoutUnit remainingLogicalHeight)
+static bool shouldSetStrutOnBlock(const LayoutBlockFlow& block, const RootInlineBox& lineBox, LayoutUnit lineLogicalOffset, int lineIndex, LayoutUnit remainingLogicalHeight)
 {
     bool wantsStrutOnBlock = false;
     if (!block.style()->hasAutoOrphans() && block.style()->orphans() >= lineIndex) {
         // Not enough orphans here. Push the entire block to the next column / page as an
         // attempt to better satisfy the orphans requirement.
         wantsStrutOnBlock = true;
     } else if (lineBox == block.firstRootBox() && lineLogicalOffset == block.borderAndPaddingBefore()) {
         // This is the first line in the block. We can take the whole block with us to the next page
         // or column, rather than keeping a content-less portion of it in the previous one. Only do
         // this if the line is flush with the content edge of the block, though. If it isn't, it
         // means that the line was pushed downwards by preceding floats that didn't fit beside the
         // line, and we don't want to move all that, since it has already been established that it
         // fits nicely where it is.
         LayoutUnit lineHeight = lineBox.lineBottomWithLeading() - lineBox.lineTopWithLeading();
         LayoutUnit totalLogicalHeight = lineHeight + std::max<LayoutUnit>(0, lineLogicalOffset);
         LayoutUnit pageLogicalHeightAtNewOffset = block.pageLogicalHeightForOffset(lineLogicalOffset + remainingLogicalHeight);
         // It's rather pointless to break before the block if the current line isn't going to
         // fit in the same column or page, so check that as well.
         if (totalLogicalHeight <= pageLogicalHeightAtNewOffset)
             wantsStrutOnBlock = true;
     }
     return wantsStrutOnBlock && block.allowsPaginationStrut();
 }
 
+static LayoutUnit calculateStrutForPropagation(const LayoutBlockFlow& blockFlow, LayoutUnit lineLogicalOffset)
+{
+    LayoutUnit paginationStrut = std::max<LayoutUnit>(LayoutUnit(), lineLogicalOffset);
+    if (blockFlow.isFloating())
+        paginationStrut += blockFlow.marginBefore(); // Floats' margins do not collapse with page or column boundaries.

[leviw_travelin_and_unemployed, 2015/11/19 20:47:01]

CS
S!

[mstensho (USE GERRIT), 2015/11/20 09:49:34]

+----+
|CSS |
|IS  |
|AWESФME
+----+

+    return paginationStrut;
+}
+
 void LayoutBlockFlow::adjustLinePositionForPagination(RootInlineBox& lineBox, LayoutUnit& delta)
 {
     // TODO(mstensho): Pay attention to line overflow. It should be painted in the same column as
     // the rest of the line, possibly overflowing the column. We currently only allow overflow above
     // the first column. We clip at all other column boundaries, and that's how it has to be for
     // now. The paint we have to do when a column has overflow has to be special. We need to exclude
     // content that paints in a previous column (and content that paints in the following column).
     //
     // FIXME: Another problem with simply moving lines is that the available line width may change (because of floats).
     // Technically if the location we move the line to has a different line width than our old position, then we need to dirty the
@@ skipping 23 matching lines @@
         if (shouldBreakAtLineToAvoidWidow() && lineBreakToAvoidWidow() == lineIndex) {
             clearShouldBreakAtLineToAvoidWidow();
             setDidBreakAtLineToAvoidWidow();
         }
         if (shouldSetStrutOnBlock(*this, lineBox, logicalOffset, lineIndex, remainingLogicalHeight)) {
             // Note that when setting the strut on a block, it may be propagated to parent blocks
             // later on, if a block's logical top is flush with that of its parent. We don't want
             // content-less portions (struts) at the beginning of a block before a break, if it can
             // be avoided. After all, that's the reason for setting struts on blocks and not lines
             // in the first place.
-            LayoutUnit paginationStrut = remainingLogicalHeight + std::max<LayoutUnit>(0, logicalOffset);
-            if (isFloating())
-                paginationStrut += marginBefore(); // Floats' margins do not collapse with page or column boundaries.
-            setPaginationStrutPropagatedFromChild(paginationStrut);
+            setPaginationStrutPropagatedFromChild(calculateStrutForPropagation(*this, remainingLogicalHeight + logicalOffset));
         } else {
             logicalOffset += remainingLogicalHeight;
             delta += remainingLogicalHeight;
             lineBox.setPaginationStrut(remainingLogicalHeight);
             lineBox.setIsFirstAfterPageBreak(true);
         }
     } else if (remainingLogicalHeight == pageLogicalHeight) {
         // We're at the very top of a page or column.
         if (lineBox != firstRootBox())
             lineBox.setIsFirstAfterPageBreak(true);
+        // If this is the first line in the block, and the block has a top border, padding, or (in
+        // case it's a float) margin, we may want to set a strut to the block, so that everything

[leviw_travelin_and_unemployed, 2015/11/19 20:47:01]

I think you want "set a strut _on_ the block"

[mstensho (USE GERRIT), 2015/11/20 09:49:34]

Yeah, let's do that.

That was me wanting to write "may want to propagate a strut to the block". But
"set" is better in this case.

+        // ends up in the next column or page. Setting a strut on the block is also important when
+        // it comes to satisfying orphan requirements.
+        if (shouldSetStrutOnBlock(*this, lineBox, logicalOffset, lineIndex, remainingLogicalHeight))
+            setPaginationStrutPropagatedFromChild(calculateStrutForPropagation(*this, logicalOffset));
+    } else if (lineBox == firstRootBox() && allowsPaginationStrut()) {
+        // This is the first line in the block. The block may still start in the previous column or
+        // page, and if that's the case, attempt to pull it over to where this line is, so that we
+        // don't split the top border, padding, or (in case it's a float) margin.
+        LayoutUnit totalLogicalOffset = logicalOffset;
+        if (isFloating())
+            totalLogicalOffset += marginBefore(); // Floats' margins do not collapse with page or column boundaries.

[leviw_travelin_and_unemployed, 2015/11/19 20:47:01]

A nit, but maybe it makes sense to have a small inline method
"marginBeforeIfFloating" that has the comment and you re-use (since you've
duplicated it)

[mstensho (USE GERRIT), 2015/11/20 09:49:34]

Yeah, this has been bothering me. I too have been wanting to add a method for
this for some time, but I was afraid it would be considered too esoteric, and
that it was better to keep this mess locally. But since you're the second person
to suggest this to me (myself being the first one), I'll add a
marginBeforeIfFloating() method in an upcoming CL.

+        LayoutUnit strut = remainingLogicalHeight + totalLogicalOffset - pageLogicalHeight;
+        if (strut > 0) {
+            // The block starts in a previous column or page. Set a strut on the block if there's
+            // room for the top border, padding and (if it's a float) margin and the line in one
+            // column or page.
+            if (totalLogicalOffset + lineHeight <= pageLogicalHeight)
+                setPaginationStrutPropagatedFromChild(strut);
+        }
     }
 
     paginatedContentWasLaidOut(logicalOffset);
 }
 
 LayoutUnit LayoutBlockFlow::adjustForUnsplittableChild(LayoutBox& child, LayoutUnit logicalOffset) const
 {
     if (child.paginationBreakability() == AllowAnyBreaks)
         return logicalOffset;
     LayoutUnit childLogicalHeight = logicalHeightForChild(child);
@@ skipping 2229 matching lines @@
     FrameView* frameView = document().view();
     LayoutUnit top = (style()->position() == FixedPosition) ? 0 : frameView->scrollOffset().height();
     int visibleHeight = frameView->visibleContentRect(IncludeScrollbars).height();
     if (size().height() < visibleHeight)
         top += (visibleHeight - size().height()) / 2;
     setY(top);
     dialog->setCentered(top);
 }
 
 } // namespace blink