Need to remove line pagination struts when no longer fragmented.

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 1058 matching lines @@
 }
 
 void LayoutBlockFlow::layoutRunsAndFloatsInRange(
     LineLayoutState& layoutState,
     InlineBidiResolver& resolver,
     const InlineIterator& cleanLineStart,
     const BidiStatus& cleanLineBidiStatus) {
   const ComputedStyle& styleToUse = styleRef();
   bool paginated =
       view()->layoutState() && view()->layoutState()->isPaginated();
+  bool recalculateStruts = layoutState.needsPaginationStrutRecalculation();
   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;
 
@@ skipping 94 matching lines @@
       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 (paginated) {
+        if (recalculateStruts) {
           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;
@@ skipping 28 matching lines @@
               }
             }
           }
         }
       }
     }
 
     if (!paginationStrutFromDeletedLine) {
       for (const auto& positionedObject : lineBreaker.positionedObjects()) {
         if (positionedObject.style()->isOriginalDisplayInlineType()) {
-          // Auto-positioend "inline" out-of-flow objects have already been
-          // positioned, but if we're paginated, we need to update their
-          // position now, since the line they "belong" to may have been pushed
-          // by a pagination strut.
-          if (paginated && lineBox)
+          // Auto-positioned "inline" out-of-flow objects have already been
+          // positioned, but if we're paginated, or just ceased to be so, we
+          // need to update their position now, since the line they "belong" to
+          // may have been pushed by a pagination strut, or pulled back because
+          // a pagination strut was removed.
+          if (recalculateStruts && lineBox)
             positionedObject.layer()->setStaticBlockPosition(
                 lineBox->lineTopWithLeading());
           continue;
         }
         setStaticPositions(LineLayoutBlockFlow(this), positionedObject,
                            DoNotIndentText);
       }
 
       if (!layoutState.lineInfo().isEmpty())
         layoutState.lineInfo().setFirstLine(false);
@@ skipping 82 matching lines @@
                                  lineBox->lineBottomWithLeading(), lineBox);
     }
   }
 
   clearDidBreakAtLineToAvoidWidow();
 }
 
 void LayoutBlockFlow::linkToEndLineIfNeeded(LineLayoutState& layoutState) {
   if (layoutState.endLine()) {
     if (layoutState.endLineMatched()) {
-      bool paginated =
-          view()->layoutState() && view()->layoutState()->isPaginated();
+      bool recalculateStruts = layoutState.needsPaginationStrutRecalculation();
       // Attach all the remaining lines, and then adjust their y-positions as
       // needed.
       LayoutUnit delta = logicalHeight() - layoutState.endLineLogicalTop();
       for (RootInlineBox* line = layoutState.endLine(); line;
            line = line->nextRootBox()) {
         line->attachLine();
-        if (paginated) {
+        if (recalculateStruts) {
           delta -= line->paginationStrut();
           adjustLinePositionForPagination(*line, delta);
         }
         if (delta)
           line->moveInBlockDirection(delta);
         if (Vector<LayoutBox*>* cleanLineFloats = line->floatsPtr()) {
           for (auto* box : *cleanLineFloats) {
             FloatingObject* floatingObject = insertFloatingObject(*box);
             ASSERT(!floatingObject->originatingLine());
             floatingObject->setOriginatingLine(line);
@@ skipping 521 matching lines @@
   // Figure out if we should clear out our line boxes.
   // FIXME: Handle resize eventually!
   bool isFullLayout = !firstLineBox() || selfNeedsLayout() || relayoutChildren;
   LineLayoutState layoutState(isFullLayout);
 
   if (isFullLayout) {
     // Ensure the old line boxes will be erased.
     if (firstLineBox())
       setShouldDoFullPaintInvalidation();
     lineBoxes()->deleteLineBoxes();
+  } else if (const LayoutState* boxState = view()->layoutState()) {
+    // We'll attempt to keep the line boxes that we have, but we may need to
+    // add, change or remove pagination struts in front of them.
+    if (boxState->isPaginated() || boxState->paginationStateChanged())
+      layoutState.setNeedsPaginationStrutRecalculation();
   }
 
   // Text truncation kicks in if overflow isn't visible and text-overflow isn't
   // 'clip'. If this is an anonymous block, we have to examine the parent.
   // FIXME: CSS3 says that descendants that are clipped must also know how to
   // truncate. This is insanely difficult to figure out in general (especially
   // in the middle of doing layout), so we only handle the simple case of an
   // anonymous block truncating when its parent is clipped.
   bool hasTextOverflow = shouldTruncateOverflowingText(this);
 
@@ skipping 89 matching lines @@
     LineLayoutState& layoutState,
     InlineBidiResolver& resolver) {
   RootInlineBox* curr = nullptr;
   RootInlineBox* last = nullptr;
   RootInlineBox* firstLineBoxWithBreakAndClearance = 0;
 
   // FIXME: This entire float-checking block needs to be broken into a new
   // function.
   if (!layoutState.isFullLayout()) {
     // Paginate all of the clean lines.
-    bool paginated =
-        view()->layoutState() && view()->layoutState()->isPaginated();
+    bool recalculateStruts = layoutState.needsPaginationStrutRecalculation();
     LayoutUnit paginationDelta;
     for (curr = firstRootBox(); curr && !curr->isDirty();
          curr = curr->nextRootBox()) {
-      if (paginated) {
+      if (recalculateStruts) {
         paginationDelta -= curr->paginationStrut();
         adjustLinePositionForPagination(*curr, paginationDelta);
         if (paginationDelta) {
           if (containsFloats() || !layoutState.floats().isEmpty()) {
             // FIXME: Do better eventually.  For now if we ever shift because of
             // pagination and floats are present just go to a full layout.
             layoutState.markForFullLayout();
             break;
           }
           curr->moveInBlockDirection(paginationDelta);
@@ skipping 152 matching lines @@
   layoutState.setEndLine(last);
 }
 
 bool LayoutBlockFlow::checkPaginationAndFloatsAtEndLine(
     LineLayoutState& layoutState) {
   if (!m_floatingObjects || !layoutState.endLine())
     return true;
 
   LayoutUnit lineDelta = logicalHeight() - layoutState.endLineLogicalTop();
 
-  bool paginated =
-      view()->layoutState() && view()->layoutState()->isPaginated();
-  if (paginated) {
+  if (layoutState.needsPaginationStrutRecalculation()) {
     // Check all lines from here to the end, and see if the hypothetical new
     // position for the lines will result
     // in a different available line width.
     for (RootInlineBox* lineBox = layoutState.endLine(); lineBox;
          lineBox = lineBox->nextRootBox()) {
       // This isn't the real move we're going to do, so don't update the line
       // box's pagination strut yet.
       LayoutUnit oldPaginationStrut = lineBox->paginationStrut();
       lineDelta -= oldPaginationStrut;
       adjustLinePositionForPagination(*lineBox, lineDelta);
@@ skipping 315 matching lines @@
 
 bool LayoutBlockFlow::paintedOutputOfObjectHasNoEffectRegardlessOfSize() const {
   // LayoutBlockFlow is in charge of paint invalidation of the first line.
   if (firstLineBox())
     return false;
 
   return LayoutBlock::paintedOutputOfObjectHasNoEffectRegardlessOfSize();
 }
 
 }  // namespace blink