LayoutBlockFlow: rename paginationStrut to paginationStrutPropagatedFromChild.

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 348 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());
-        setPaginationStrut(0);
+        setPaginationStrutPropagatedFromChild(LayoutUnit());
     }
 
     LayoutUnit beforeEdge = borderBefore() + paddingBefore();
     LayoutUnit afterEdge = borderAfter() + paddingAfter() + scrollbarLogicalHeight();
     LayoutUnit previousHeight = logicalHeight();
     setLogicalHeight(beforeEdge);
 
     m_paintInvalidationLogicalTop = 0;
     m_paintInvalidationLogicalBottom = 0;
     if (!firstChild() && !isAnonymousBlock())
@@ skipping 311 matching lines @@
     // 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 logicalTopBeforeUnsplittableAdjustment = newLogicalTop;
     LayoutUnit logicalTopAfterUnsplittableAdjustment = adjustForUnsplittableChild(child, newLogicalTop);
 
     LayoutUnit paginationStrut = 0;
     LayoutUnit unsplittableAdjustmentDelta = logicalTopAfterUnsplittableAdjustment - logicalTopBeforeUnsplittableAdjustment;
     LayoutUnit childLogicalHeight = child.logicalHeight();
     if (unsplittableAdjustmentDelta) {
         setPageBreak(newLogicalTop, childLogicalHeight - unsplittableAdjustmentDelta);
         paginationStrut = unsplittableAdjustmentDelta;
-    } else if (childBlockFlow && childBlockFlow->paginationStrut()) {
-        paginationStrut = childBlockFlow->paginationStrut();
+    } else if (childBlockFlow && childBlockFlow->paginationStrutPropagatedFromChild()) {
+        paginationStrut = childBlockFlow->paginationStrutPropagatedFromChild();
     }
 
     if (paginationStrut) {
         // 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 && logicalTop == newLogicalTop && 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.
-            setPaginationStrut(paginationStrut);
+            setPaginationStrutPropagatedFromChild(paginationStrut);
             if (childBlockFlow)
-                childBlockFlow->setPaginationStrut(0);
+                childBlockFlow->setPaginationStrutPropagatedFromChild(LayoutUnit());
         } else {
             newLogicalTop += paginationStrut;
         }
     }
 
     if (!unsplittableAdjustmentDelta) {
         if (LayoutUnit pageLogicalHeight = pageLogicalHeightForOffset(newLogicalTop)) {
             LayoutUnit remainingLogicalHeight = pageRemainingLogicalHeightForOffset(newLogicalTop, AssociateWithLatterPage);
             LayoutUnit spaceShortage = childLogicalHeight - remainingLogicalHeight;
             if (spaceShortage > 0) {
@@ skipping 97 matching lines @@
         setPageBreak(logicalOffset, lineHeight - remainingLogicalHeight);
         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.
-            setPaginationStrut(paginationStrut);
+            setPaginationStrutPropagatedFromChild(paginationStrut);
         } else {
             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 (lineBox != firstRootBox() || offsetFromLogicalTopOfFirstPage())
@@ skipping 671 matching lines @@
     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);
 
         // 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);
-
-        if (!child.selfNeedsLayout() && child.isLayoutBlockFlow())
-            logicalTopEstimate += toLayoutBlockFlow(&child)->paginationStrut();
     }
 
     return logicalTopEstimate;
 }
 
 void LayoutBlockFlow::adjustFloatingBlock(const MarginInfo& marginInfo)
 {
     // The float should be positioned taking into account the bottom margin
     // of the previous flow. We add that margin into the height, get the
     // float positioned properly, and then subtract the margin out of the
@@ skipping 868 matching lines @@
         bool isPaginated = layoutState->isPaginated();
         if (isPaginated && !childBox->needsLayout())
             childBox->markForPaginationRelayoutIfNeeded(layoutScope);
 
         childBox->layoutIfNeeded();
 
         if (isPaginated) {
             LayoutUnit newLogicalTop = floatLogicalLocation.y();
 
             LayoutBlockFlow* childBlockFlow = childBox->isLayoutBlockFlow() ? toLayoutBlockFlow(childBox) : 0;
-            if (childBlockFlow && childBlockFlow->paginationStrut()) {
+            if (childBlockFlow && childBlockFlow->paginationStrutPropagatedFromChild()) {
                 // Some content inside this float has determined that we need to move to the next
                 // page or column.
-                newLogicalTop += childBlockFlow->paginationStrut();
-                childBlockFlow->setPaginationStrut(LayoutUnit());
+                newLogicalTop += childBlockFlow->paginationStrutPropagatedFromChild();
             } else {
                 // Now that we know the final height, check if we are unsplittable, and if we don't
                 // fit at the current position, but would fit at the top of the next page or
                 // column, move there.
                 newLogicalTop = adjustForUnsplittableChild(*childBox, newLogicalTop);
             }
 
             if (newLogicalTop != floatLogicalLocation.y()) {
                 floatingObject.setPaginationStrut(newLogicalTop - floatLogicalLocation.y());
 
@@ skipping 475 matching lines @@
     // up the struts and handle them. We handle floats and regular in-flow children, and that's
     // all. We could handle this in other layout modes as well (and even for out-of-flow children),
     // but currently we don't.
     // TODO(mstensho): But we *should*.
     if (isOutOfFlowPositioned())
         return false;
     LayoutBlock* containingBlock = this->containingBlock();
     return containingBlock && containingBlock->isLayoutBlockFlow();
 }
 
-void LayoutBlockFlow::setPaginationStrut(LayoutUnit strut)
+void LayoutBlockFlow::setPaginationStrutPropagatedFromChild(LayoutUnit strut)
 {
     if (!m_rareData) {
         if (!strut)
             return;
         m_rareData = adoptPtr(new LayoutBlockFlowRareData(this));
     }
-    m_rareData->m_paginationStrut = strut;
+    m_rareData->m_paginationStrutPropagatedFromChild = strut;
 }
 
 void LayoutBlockFlow::positionSpannerDescendant(LayoutMultiColumnSpannerPlaceholder& child)
 {
     LayoutBox& spanner = *child.layoutObjectInFlowThread();
     // FIXME: |spanner| is a descendant, but never a direct child, so the names here are bad, if
     // nothing else.
     setLogicalTopForChild(spanner, child.logicalTop());
     determineLogicalLeftPositionForChild(spanner);
 }
@@ skipping 154 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