Don't lose the pagination strut when a line is re-created.

third_party/WebKit/Source/core/layout/LayoutBlockFlowLine.cpp

 /*
  * Copyright (C) 2000 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2003, 2004, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All right reserved.
  * Copyright (C) 2010 Google Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
@@ skipping 815 matching lines @@
     InlineBidiResolver& resolver, const InlineIterator& cleanLineStart,
     const BidiStatus& cleanLineBidiStatus)
 {
     const ComputedStyle& styleToUse = styleRef();
     bool paginated = view()->layoutState() && view()->layoutState()->isPaginated();
     LineMidpointState& lineMidpointState = resolver.midpointState();
     InlineIterator endOfLine = resolver.position();
     LayoutTextInfo layoutTextInfo;
     VerticalPositionCache verticalPositionCache;
 
+    // Pagination may require us to delete and re-create a line due to floats. When this happens,
+    // we need to store the pagination strut in the meantime.
+    LayoutUnit paginationStrutFromDeletedLine;
+
     LineBreaker lineBreaker(LineLayoutBlockFlow(this));
 
     while (!endOfLine.atEnd()) {
-        bool logicalWidthIsAvailable = false;
-
         // The runs from the previous line should have been cleaned up.
         ASSERT(!resolver.runs().runCount());
 
         // FIXME: Is this check necessary before the first iteration or can it be moved to the end?
         if (layoutState.endLine()) {
             layoutState.setEndLineMatched(layoutState.endLineMatched() || matchedEndLine(layoutState, resolver, cleanLineStart, cleanLineBidiStatus));
             if (layoutState.endLineMatched()) {
                 resolver.setPosition(InlineIterator(resolver.position().root(), 0, 0), 0);
                 break;
             }
@@ skipping 17 matching lines @@
             resolver.runs().deleteRuns();
             resolver.markCurrentRunEmpty(); // FIXME: This can probably be replaced by an ASSERT (or just removed).
             resolver.setPosition(InlineIterator(resolver.position().root(), 0, 0), 0);
             break;
         }
 
         ASSERT(endOfLine != resolver.position());
 
         // This is a short-cut for empty lines.
         if (layoutState.lineInfo().isEmpty()) {
+            ASSERT(!paginationStrutFromDeletedLine);
             if (lastRootBox())
                 lastRootBox()->setLineBreakInfo(endOfLine.getLineLayoutItem(), endOfLine.offset(), resolver.status());
             resolver.runs().deleteRuns();
         } else {
             VisualDirectionOverride override = (styleToUse.rtlOrdering() == VisualOrder ? (styleToUse.direction() == LTR ? VisualLeftToRightOverride : VisualRightToLeftOverride) : NoVisualOverride);
             if (isNewUBAParagraph && styleToUse.unicodeBidi() == Plaintext && !resolver.context()->parent()) {
                 TextDirection direction = determinePlaintextDirectionality(resolver.position().root(), resolver.position().getLineLayoutItem(), resolver.position().offset());
                 resolver.setStatus(BidiStatus(direction, isOverride(styleToUse.unicodeBidi())));
             }
             // FIXME: This ownership is reversed. We should own the BidiRunList and pass it to createBidiRunsForLine.
             BidiRunList<BidiRun>& bidiRuns = resolver.runs();
             constructBidiRunsForLine(resolver, bidiRuns, endOfLine, override, layoutState.lineInfo().previousLineBrokeCleanly(), isNewUBAParagraph);
             ASSERT(resolver.position() == endOfLine);
 
             BidiRun* trailingSpaceRun = resolver.trailingSpaceRun();
 
             if (bidiRuns.runCount() && lineBreaker.lineWasHyphenated())
                 bidiRuns.logicallyLastRun()->m_hasHyphen = true;
 
             // Now that the runs have been ordered, we create the line boxes.
             // At the same time we figure out where border/padding/margin should be applied for
             // inline flow boxes.
 
             LayoutUnit oldLogicalHeight = logicalHeight();
             RootInlineBox* lineBox = createLineBoxesFromBidiRuns(resolver.status().context->level(), bidiRuns, endOfLine, layoutState.lineInfo(), verticalPositionCache, trailingSpaceRun, wordMeasurements);
 
             bidiRuns.deleteRuns();
             resolver.markCurrentRunEmpty(); // FIXME: This can probably be replaced by an ASSERT (or just removed).
 
+            // If we decided to re-create the line due to pagination, we better have a new line now.
+            ASSERT(lineBox || !paginationStrutFromDeletedLine);
+
             if (lineBox) {
                 lineBox->setLineBreakInfo(endOfLine.getLineLayoutItem(), endOfLine.offset(), resolver.status());
                 if (layoutState.usesPaintInvalidationBounds())
                     layoutState.updatePaintInvalidationRangeFromBox(lineBox);
 
                 if (paginated) {
-                    LayoutUnit adjustment;
-                    adjustLinePositionForPagination(*lineBox, adjustment);
-                    if (adjustment) {
-                        LayoutUnit oldLineWidth = availableLogicalWidthForLine(oldLogicalHeight, layoutState.lineInfo().isFirstLine() ? IndentText : DoNotIndentText);
-                        lineBox->moveInBlockDirection(adjustment);
-                        if (layoutState.usesPaintInvalidationBounds())
-                            layoutState.updatePaintInvalidationRangeFromBox(lineBox);
+                    if (paginationStrutFromDeletedLine) {
+                        // This is a line that got re-created because it got pushed to the next fragmentainer, and there
+                        // were floats in the vicinity that affected the available width. Restore the pagination info
+                        // for this line.
+                        lineBox->setIsFirstAfterPageBreak(true);
+                        lineBox->setPaginationStrut(paginationStrutFromDeletedLine);
+                        paginationStrutFromDeletedLine = LayoutUnit();
+                    } else {
+                        LayoutUnit adjustment;
+                        adjustLinePositionForPagination(*lineBox, adjustment);
+                        if (adjustment) {
+                            LayoutUnit oldLineWidth = availableLogicalWidthForLine(oldLogicalHeight, layoutState.lineInfo().isFirstLine() ? IndentText : DoNotIndentText);
+                            lineBox->moveInBlockDirection(adjustment);
+                            if (layoutState.usesPaintInvalidationBounds())
+                                layoutState.updatePaintInvalidationRangeFromBox(lineBox);
 
-                        if (availableLogicalWidthForLine(oldLogicalHeight + adjustment, layoutState.lineInfo().isFirstLine() ? IndentText: DoNotIndentText) != oldLineWidth) {
-                            // We have to delete this line, remove all floats that got added, and let line layout re-run.
-                            lineBox->deleteLine();
-                            endOfLine = restartLayoutRunsAndFloatsInRange(oldLogicalHeight, oldLogicalHeight + adjustment, lastFloatFromPreviousLine, resolver, previousEndofLine);
-                            logicalWidthIsAvailable = true;
-                        } else {
-                            setLogicalHeight(lineBox->lineBottomWithLeading());
+                            if (availableLogicalWidthForLine(oldLogicalHeight + adjustment, layoutState.lineInfo().isFirstLine() ? IndentText: DoNotIndentText) != oldLineWidth) {
+                                // We have to delete this line, remove all floats that got added, and let line layout
+                                // re-run. We had just calculated the pagination strut for this line, and we need to
+                                // stow it away, so that we can re-apply it when the new line has been created.
+                                paginationStrutFromDeletedLine = lineBox->paginationStrut();
+                                ASSERT(paginationStrutFromDeletedLine);
+                                // We're also going to assume that we're right after a page break when re-creating this
+                                // line, so it better be so.
+                                ASSERT(lineBox->isFirstAfterPageBreak());
+                                lineBox->deleteLine();
+                                endOfLine = restartLayoutRunsAndFloatsInRange(oldLogicalHeight, oldLogicalHeight + adjustment, lastFloatFromPreviousLine, resolver, previousEndofLine);
+                            } else {
+                                setLogicalHeight(lineBox->lineBottomWithLeading());
+                            }
                         }
                     }
                 }
             }
         }
 
-        if (!logicalWidthIsAvailable) {
+        if (!paginationStrutFromDeletedLine) {
             for (size_t i = 0; i < lineBreaker.positionedObjects().size(); ++i)
                 setStaticPositions(LineLayoutBlockFlow(this), LineLayoutBox(lineBreaker.positionedObjects()[i]), DoNotIndentText);
 
             if (!layoutState.lineInfo().isEmpty())
                 layoutState.lineInfo().setFirstLine(false);
             clearFloats(lineBreaker.clear());
 
             if (m_floatingObjects && lastRootBox()) {
                 InlineBidiResolver endOfLineResolver;
                 endOfLineResolver.setPosition(endOfLine, numberOfIsolateAncestors(endOfLine));
@@ skipping 1112 matching lines @@
     if (!line || !line->isFirstLineStyle())
         return reason;
     // It's the RootInlineBox that paints the ::first-line background. Note that since it may be
     // expensive to figure out if the first line is affected by any ::first-line selectors at all,
     // we just invalidate it unconditionally, since that's typically cheaper.
     invalidateDisplayItemClient(*line);
     return reason;
 }
 
 } // namespace blink