Remove LayoutBlockFlow overflow invalidation

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 721 matching lines @@
     // Compute our overflow now.
     lineBox->computeOverflow(lineBox->lineTop(), lineBox->lineBottom(), textBoxDataMap);
 
     return lineBox;
 }
 
 static void deleteLineRange(LineLayoutState& layoutState, RootInlineBox* startLine, RootInlineBox* stopLine = 0)
 {
     RootInlineBox* boxToDelete = startLine;
     while (boxToDelete && boxToDelete != stopLine) {
-        layoutState.updatePaintInvalidationRangeFromBox(boxToDelete);
         // Note: deleteLineRange(firstRootBox()) is not identical to deleteLineBoxTree().
         // deleteLineBoxTree uses nextLineBox() instead of nextRootBox() when traversing.
         RootInlineBox* next = boxToDelete->nextRootBox();
         boxToDelete->deleteLine();
         boxToDelete = next;
     }
 }
 
 void LayoutBlockFlow::layoutRunsAndFloats(LineLayoutState& layoutState)
 {
     // We want to skip ahead to the first dirty line
     InlineBidiResolver resolver;
     RootInlineBox* startLine = determineStartPosition(layoutState, resolver);
 
     if (containsFloats())
         layoutState.setLastFloat(m_floatingObjects->set().last().get());
 
     // We also find the first clean line and extract these lines.  We will add them back
     // if we determine that we're able to synchronize after handling all our dirty lines.
     InlineIterator cleanLineStart;
     BidiStatus cleanLineBidiStatus;
     if (!layoutState.isFullLayout() && startLine)
         determineEndPosition(layoutState, startLine, cleanLineStart, cleanLineBidiStatus);
 
-    if (startLine) {
-        if (!layoutState.usesPaintInvalidationBounds())
-            layoutState.setPaintInvalidationRange(logicalHeight());
+    if (startLine)
         deleteLineRange(layoutState, startLine);
-    }
 
     layoutRunsAndFloatsInRange(layoutState, resolver, cleanLineStart, cleanLineBidiStatus);
     linkToEndLineIfNeeded(layoutState);
     markDirtyFloatsForPaintInvalidation(layoutState.floats());
 }
 
 // Before restarting the layout loop with a new logicalHeight, remove all floats that were added and reset the resolver.
 inline const InlineIterator& LayoutBlockFlow::restartLayoutRunsAndFloatsInRange(LayoutUnit oldLogicalHeight, LayoutUnit newLogicalHeight,  FloatingObject* lastFloatFromPreviousLine, InlineBidiResolver& resolver,  const InlineIterator& oldEnd)
 {
     removeFloatingObjectsBelow(lastFloatFromPreviousLine, oldLogicalHeight);
@@ skipping 119 matching lines @@
             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) {
                     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. 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();
@@ skipping 99 matching lines @@
         if (layoutState.endLineMatched()) {
             bool paginated = view()->layoutState() && view()->layoutState()->isPaginated();
             // 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) {
                     delta -= line->paginationStrut();
                     adjustLinePositionForPagination(*line, delta);
                 }
-                if (delta) {
-                    layoutState.updatePaintInvalidationRangeFromBox(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);
                         setLogicalHeight(logicalTopForChild(*box) - marginBeforeForChild(*box) + delta);
                         positionNewFloats();
                     }
                 }
             }
@@ skipping 475 matching lines @@
     const LayoutObject* objectToCheck = block;
     if (block->isAnonymousBlock()) {
         const LayoutObject* parent = block->parent();
         if (!parent || !parent->behavesLikeBlockContainer())
             return false;
         objectToCheck = parent;
     }
     return objectToCheck->hasOverflowClip() && objectToCheck->style()->getTextOverflow();
 }
 
-void LayoutBlockFlow::layoutInlineChildren(bool relayoutChildren, LayoutUnit& paintInvalidationLogicalTop, LayoutUnit& paintInvalidationLogicalBottom, LayoutUnit afterEdge)
+void LayoutBlockFlow::layoutInlineChildren(bool relayoutChildren, LayoutUnit afterEdge)
 {
     // Figure out if we should clear out our line boxes.
     // FIXME: Handle resize eventually!
     bool isFullLayout = !firstLineBox() || selfNeedsLayout() || relayoutChildren;
-    LineLayoutState layoutState(isFullLayout, paintInvalidationLogicalTop, paintInvalidationLogicalBottom);
+    LineLayoutState layoutState(isFullLayout);
 
     if (isFullLayout) {
         // Ensure the old line boxes will be erased.
         if (firstLineBox())
             setShouldDoFullPaintInvalidation();
         lineBoxes()->deleteLineBoxes();
     }
 
     // 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.
@@ skipping 89 matching lines @@
         for (curr = firstRootBox(); curr && !curr->isDirty(); curr = curr->nextRootBox()) {
             if (paginated) {
                 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;
                     }
-
-                    layoutState.updatePaintInvalidationRangeFromBox(curr, paginationDelta);
                     curr->moveInBlockDirection(paginationDelta);
                 }
             }
 
             // If the linebox breaks cleanly and with clearance then dirty from at least this point onwards so that we can clear the correct floats without difficulty.
             if (!firstLineBoxWithBreakAndClearance && lineBoxHasBRWithClearance(curr))
                 firstLineBoxWithBreakAndClearance = curr;
 
             if (layoutState.isFullLayout())
                 break;
@@ skipping 385 matching lines @@
     LayoutUnit totalLogicalWidth;
     LayoutUnit logicalLeft = logicalLeftOffsetForLine(logicalHeight(), DoNotIndentText);
     LayoutUnit availableLogicalWidth = logicalRightOffsetForLine(logicalHeight(), DoNotIndentText) - logicalLeft;
     updateLogicalWidthForAlignment(textAlign, 0, 0, logicalLeft, totalLogicalWidth, availableLogicalWidth, 0);
 
     if (!style()->isLeftToRightDirection())
         return logicalWidth() - logicalLeft;
     return logicalLeft;
 }
 
-void LayoutBlockFlow::invalidateDisplayItemClientsOfFirstLine()
+void LayoutBlockFlow::setShouldDoFullPaintInvalidationForFirstLine()
 {
     ASSERT(childrenInline());
     if (RootInlineBox* firstRootBox = this->firstRootBox())
-        firstRootBox->invalidateDisplayItemClientsRecursively();
+        firstRootBox->setShouldDoFullPaintInvalidationRecursively();
 }
 
 PaintInvalidationReason LayoutBlockFlow::invalidatePaintIfNeeded(const PaintInvalidationState& paintInvalidationState)
 {
     if (containsFloats())
         paintInvalidationState.paintingLayer().setNeedsPaintPhaseFloat();
 
     PaintInvalidationReason reason = LayoutBlock::invalidatePaintIfNeeded(paintInvalidationState);
     if (reason == PaintInvalidationNone)
         return reason;
     RootInlineBox* line = firstRootBox();
     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, reason);
     return reason;
 }
 
 } // namespace blink