Jump to the next outer column when an inner column is too short.

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 664 matching lines @@
 LayoutUnit LayoutBlockFlow::adjustBlockChildForPagination(LayoutUnit logicalTop, LayoutBox& child, bool atBeforeSideOfBlock)
 {
     LayoutBlockFlow* childBlockFlow = child.isLayoutBlockFlow() ? toLayoutBlockFlow(&child) : 0;
 
     // Calculate the pagination strut for this child. A strut may come from three sources:
     // 1. The first piece of content inside the child doesn't fit in the current page or column
     // 2. A forced break before the child
     // 3. The child itself is unsplittable and doesn't 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 the next page or column, or be zero.
+    // 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;
 
     // If the object has a page or column break value of "before", then we should shift to the top of the next page.
     LayoutUnit logicalTopAfterForcedBreak = applyBeforeBreak(child, logicalTop);
 
     // 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);
 
-    // Some sanity checks: No matter what the reason is for pushing the child to the next page or
-    // column, the amount should be the same.
-    ASSERT(!strutFromContent || logicalTopAfterForcedBreak == logicalTop || logicalTopAfterForcedBreak == logicalTopWithContentStrut);
-    ASSERT(!strutFromContent || logicalTopAfterUnsplittable == logicalTop || logicalTopAfterUnsplittable == logicalTopWithContentStrut);
-    ASSERT(logicalTopAfterUnsplittable == logicalTop || logicalTopAfterForcedBreak == logicalTop || logicalTopAfterUnsplittable == logicalTopAfterForcedBreak);
-
+    // 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, 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 + marginBeforeIfFloating();
             setPaginationStrutPropagatedFromChild(paginationStrut);
             if (childBlockFlow)
                 childBlockFlow->setPaginationStrutPropagatedFromChild(LayoutUnit());
         } else {
             child.setPaginationStrut(paginationStrut);
             newLogicalTop += paginationStrut;
         }
     }
 
     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 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 pageLogicalHeight)
 {
     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)
+        if (totalLogicalHeight <= pageLogicalHeight)
             wantsStrutOnBlock = true;
     }
     return wantsStrutOnBlock && block.allowsPaginationStrut();
 }
 
 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
     // line and all following lines.
     LayoutUnit logicalOffset = lineBox.lineTopWithLeading();
     LayoutUnit lineHeight = lineBox.lineBottomWithLeading() - logicalOffset;
     logicalOffset += delta;
     lineBox.setPaginationStrut(LayoutUnit());
     lineBox.setIsFirstAfterPageBreak(false);
     LayoutUnit pageLogicalHeight = pageLogicalHeightForOffset(logicalOffset);
     if (!pageLogicalHeight)
         return;
-    if (lineHeight > pageLogicalHeight) {
-        // Too tall to fit in one page / column. Give up. Don't push to the next page / column.
-        // TODO(mstensho): Get rid of this. This is just utter weirdness, but the other browsers
-        // also do something slightly similar, although in much more specific cases than we do here,
-        // and printing Google Docs depends on it.
-        return;
-    }
     LayoutUnit remainingLogicalHeight = pageRemainingLogicalHeightForOffset(logicalOffset, AssociateWithLatterPage);
-
     int lineIndex = lineCount(&lineBox);
     if (remainingLogicalHeight < lineHeight || (shouldBreakAtLineToAvoidWidow() && lineBreakToAvoidWidow() == lineIndex)) {
+        LayoutUnit paginationStrut = calculatePaginationStrutToFitContent(logicalOffset, remainingLogicalHeight, lineHeight);
+        LayoutUnit newLogicalOffset = logicalOffset + paginationStrut;
+        // The new offset may require us to insert a new row for columns (fragmentainer group).
+        // Give the multicol machinery an opportunity to do so (before checking the height of a
+        // column that wouldn't have existed yet otherwise).
+        paginatedContentWasLaidOut(newLogicalOffset);
+        // Moving to a different page or column may mean that its height is different.
+        pageLogicalHeight = pageLogicalHeightForOffset(newLogicalOffset);
+        if (lineHeight > pageLogicalHeight) {
+            // Too tall to fit in one page / column. Give up. Don't push to the next page / column.
+            // TODO(mstensho): Get rid of this. This is just utter weirdness, but the other browsers
+            // also do something slightly similar, although in much more specific cases than we do here,
+            // and printing Google Docs depends on it.
+            return;
+        }
+
         // We need to insert a break now, either because there's no room for the line in the
         // current column / page, or because we have determined that we need a break to satisfy
         // widow requirements.
         if (shouldBreakAtLineToAvoidWidow() && lineBreakToAvoidWidow() == lineIndex) {
             clearShouldBreakAtLineToAvoidWidow();
             setDidBreakAtLineToAvoidWidow();
         }
-        if (shouldSetStrutOnBlock(*this, lineBox, logicalOffset, lineIndex, remainingLogicalHeight)) {
+        if (shouldSetStrutOnBlock(*this, lineBox, logicalOffset, lineIndex, pageLogicalHeight)) {
             // 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 strut = remainingLogicalHeight + logicalOffset + marginBeforeIfFloating();
+            LayoutUnit strut = paginationStrut + logicalOffset + marginBeforeIfFloating();
             setPaginationStrutPropagatedFromChild(strut);
         } else {
-            logicalOffset += remainingLogicalHeight;
-            delta += remainingLogicalHeight;
-            lineBox.setPaginationStrut(remainingLogicalHeight);
+            delta += paginationStrut;
+            lineBox.setPaginationStrut(paginationStrut);
             lineBox.setIsFirstAfterPageBreak(true);
         }
-    } else if (remainingLogicalHeight == pageLogicalHeight) {
+        return;
+    }
+
+    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)) {
+        if (shouldSetStrutOnBlock(*this, lineBox, logicalOffset, lineIndex, pageLogicalHeight)) {
             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 + marginBeforeIfFloating();
         LayoutUnit strut = remainingLogicalHeight + totalLogicalOffset - pageLogicalHeight;
         if (strut > 0) {
@@ skipping 13 matching lines @@
     if (child.paginationBreakability() == AllowAnyBreaks)
         return logicalOffset;
     LayoutUnit childLogicalHeight = logicalHeightForChild(child);
     // Floats' margins do not collapse with page or column boundaries.
     if (child.isFloating())
         childLogicalHeight += marginBeforeForChild(child) + marginAfterForChild(child);
     LayoutUnit pageLogicalHeight = pageLogicalHeightForOffset(logicalOffset);
     if (!pageLogicalHeight)
         return logicalOffset;
     LayoutUnit remainingLogicalHeight = pageRemainingLogicalHeightForOffset(logicalOffset, AssociateWithLatterPage);
-    // Break if there's not enough space left for us, but only as long as we're not already at the
-    // top of a page. No point in leaving a page completely blank.
-    if (remainingLogicalHeight < childLogicalHeight && remainingLogicalHeight < pageLogicalHeight)
-        return logicalOffset + remainingLogicalHeight;
-    return logicalOffset;
+    if (remainingLogicalHeight >= childLogicalHeight)
+        return logicalOffset; // It fits fine where it is. No need to break.
+    LayoutUnit paginationStrut = calculatePaginationStrutToFitContent(logicalOffset, remainingLogicalHeight, childLogicalHeight);
+    if (paginationStrut == remainingLogicalHeight && remainingLogicalHeight == pageLogicalHeight) {
+        // Don't break if we were at the top of a page, and we failed to fit the content
+        // completely. No point in leaving a page completely blank.
+        return logicalOffset;
+    }
+    return logicalOffset + paginationStrut;
 }
 
 void LayoutBlockFlow::rebuildFloatsFromIntruding()
 {
     if (m_floatingObjects)
         m_floatingObjects->setHorizontalWritingMode(isHorizontalWritingMode());
 
     HashSet<LayoutBox*> oldIntrudingFloatSet;
     if (!childrenInline() && m_floatingObjects) {
         const FloatingObjectSet& floatingObjectSet = m_floatingObjects->set();
@@ skipping 2226 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