Add marginBeforeIfFloating() to LayoutBlockFlow.

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 698 matching lines @@
     LayoutUnit logicalTopAfterPagination = std::max(logicalTopWithContentStrut, std::max(logicalTopAfterForcedBreak, logicalTopAfterUnsplittable));
     LayoutUnit newLogicalTop = logicalTop;
     if (LayoutUnit paginationStrut = logicalTopAfterPagination - logicalTop) {
         ASSERT(paginationStrut > 0);
         // We are willing to propagate out to our parent block as long as we were at the top of the block prior
         // to collapsing our margins, and as long as we didn't clear or move as a result of other pagination.
         if (atBeforeSideOfBlock && logicalTopAfterForcedBreak == logicalTop && 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;
-            if (isFloating())
-                paginationStrut += marginBefore(); // Floats' margins do not collapse with page or column boundaries.
+            paginationStrut += logicalTop + marginBeforeIfFloating();
             setPaginationStrutPropagatedFromChild(paginationStrut);
             if (childBlockFlow)
                 childBlockFlow->setPaginationStrutPropagatedFromChild(LayoutUnit());
         } else {
             child.setPaginationStrut(paginationStrut);
             newLogicalTop += paginationStrut;
         }
     }
 
     paginatedContentWasLaidOut(newLogicalTop);
@@ skipping 23 matching lines @@
         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.
-    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.
-            setPaginationStrutPropagatedFromChild(calculateStrutForPropagation(*this, remainingLogicalHeight + logicalOffset));
+            LayoutUnit strut = remainingLogicalHeight + logicalOffset + marginBeforeIfFloating();
+            setPaginationStrutPropagatedFromChild(strut);
         } 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 on the block, so that everything
         // 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));
+        if (shouldSetStrutOnBlock(*this, lineBox, logicalOffset, lineIndex, remainingLogicalHeight)) {
+            LayoutUnit strut = logicalOffset + marginBeforeIfFloating();
+            setPaginationStrutPropagatedFromChild(strut);
+        }
     } 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.
+        LayoutUnit totalLogicalOffset = logicalOffset + marginBeforeIfFloating();
         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);
         }
     }
 
@@ skipping 2075 matching lines @@
         // fully pushed to the next outer fragmentainer, instead of taking up unusable space in the
         // previous one. But currently we have no mechanism in place to handle this.
         return false;
     }
     LayoutBlock* containingBlock = this->containingBlock();
     return containingBlock && containingBlock->isLayoutBlockFlow();
 }
 
 void LayoutBlockFlow::setPaginationStrutPropagatedFromChild(LayoutUnit strut)
 {
+    strut = std::max(strut, LayoutUnit());
     if (!m_rareData) {
         if (!strut)
             return;
         m_rareData = adoptPtr(new LayoutBlockFlowRareData(this));
     }
     m_rareData->m_paginationStrutPropagatedFromChild = strut;
 }
 
 void LayoutBlockFlow::positionSpannerDescendant(LayoutMultiColumnSpannerPlaceholder& child)
 {
@@ skipping 160 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