Replace ASSERT with DCHECK in core/layout/ excluding subdirs

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 107 matching lines @@
  private:
   Vector<unsigned, 16> m_runsWithExpansions;
   unsigned m_totalOpportunities;
 };
 
 static inline InlineBox* createInlineBoxForLayoutObject(
     LineLayoutItem lineLayoutItem,
     bool isRootLineBox,
     bool isOnlyRun = false) {
   // Callers should handle text themselves.
-  ASSERT(!lineLayoutItem.isText());
+  DCHECK(!lineLayoutItem.isText());
 
   if (isRootLineBox)
     return LineLayoutBlockFlow(lineLayoutItem).createAndAppendRootInlineBox();
 
   if (lineLayoutItem.isBox())
     return LineLayoutBox(lineLayoutItem).createInlineBox();
 
   return LineLayoutInline(lineLayoutItem).createAndAppendInlineFlowBox();
 }
 
 static inline InlineTextBox* createInlineBoxForText(BidiRun& run,
                                                     bool isOnlyRun) {
-  ASSERT(run.m_lineLayoutItem.isText());
+  DCHECK(run.m_lineLayoutItem.isText());
   LineLayoutText text = LineLayoutText(run.m_lineLayoutItem);
   InlineTextBox* textBox =
       text.createInlineTextBox(run.m_start, run.m_stop - run.m_start);
   // We only treat a box as text for a <br> if we are on a line by ourself or in
   // strict mode (Note the use of strict mode.  In "almost strict" mode, we
   // don't treat the box for <br> as text.)
   if (text.isBR())
     textBox->setIsText(isOnlyRun || text.document().inNoQuirksMode());
   textBox->setDirOverride(
       run.dirOverride(text.style()->rtlOrdering() == EOrder::kVisual));
@@ skipping 113 matching lines @@
   if (pos >= length)
     return true;
 
   if (layoutText.is8Bit())
     return endsWithASCIISpaces(layoutText.characters8(), pos, length);
   return endsWithASCIISpaces(layoutText.characters16(), pos, length);
 }
 
 RootInlineBox* LayoutBlockFlow::constructLine(BidiRunList<BidiRun>& bidiRuns,
                                               const LineInfo& lineInfo) {
-  ASSERT(bidiRuns.firstRun());
+  DCHECK(bidiRuns.firstRun());
 
   bool rootHasSelectedChildren = false;
   InlineFlowBox* parentBox = nullptr;
   int runCount = bidiRuns.runCount() - lineInfo.runsFromLeadingWhitespace();
   for (BidiRun* r = bidiRuns.firstRun(); r; r = r->next()) {
     // Create a box for our object.
     bool isOnlyRun = (runCount == 1);
     if (runCount == 2 && !r->m_lineLayoutItem.isListMarker())
       isOnlyRun = (!style()->isLeftToRightDirection() ? bidiRuns.lastRun()
                                                       : bidiRuns.firstRun())
                       ->m_lineLayoutItem.isListMarker();
 
     if (lineInfo.isEmpty())
       continue;
 
     InlineBox* box;
     if (r->m_lineLayoutItem.isText())
       box = createInlineBoxForText(*r, isOnlyRun);
     else
       box =
           createInlineBoxForLayoutObject(r->m_lineLayoutItem, false, isOnlyRun);
     r->m_box = box;
 
-    ASSERT(box);
+    DCHECK(box);
     if (!box)
       continue;
 
     if (!rootHasSelectedChildren &&
         box->getLineLayoutItem().getSelectionState() != SelectionNone)
       rootHasSelectedChildren = true;
 
     // If we have no parent box yet, or if the run is not simply a sibling,
     // then we need to construct inline boxes as necessary to properly enclose
     // the run's inline box. Segments can only be siblings at the root level, as
@@ skipping 11 matching lines @@
     box->setBidiLevel(r->level());
 
     if (box->isInlineTextBox()) {
       if (AXObjectCache* cache = document().existingAXObjectCache())
         cache->inlineTextBoxesUpdated(r->m_lineLayoutItem);
     }
   }
 
   // We should have a root inline box.  It should be unconstructed and
   // be the last continuation of our line list.
-  ASSERT(lastLineBox() && !lastLineBox()->isConstructed());
+  DCHECK(lastLineBox());
+  DCHECK(!lastLineBox()->isConstructed());
 
   // Set the m_selectedChildren flag on the root inline box if one of the leaf
   // inline box from the bidi runs walk above has a selection state.
   if (rootHasSelectedChildren)
     lastLineBox()->root().setHasSelectedChildren(true);
 
   // Set bits on our inline flow boxes that indicate which sides should
   // paint borders/margins/padding.  This knowledge will ultimately be used when
   // we determine the horizontal positions and widths of all the inline boxes on
   // the line.
@@ skipping 303 matching lines @@
   }
 
   const SimpleFontData* fontData = font.primaryFont();
   DCHECK(fontData);
   glyphOverflow.setFromBounds(
       glyphBounds, fontData ? fontData->getFontMetrics().floatAscent() : 0,
       fontData ? fontData->getFontMetrics().floatDescent() : 0, measuredWidth);
 
   run->m_box->setLogicalWidth(LayoutUnit(measuredWidth) + hyphenWidth);
   if (!fallbackFonts.isEmpty()) {
-    ASSERT(run->m_box->isText());
+    DCHECK(run->m_box->isText());
     GlyphOverflowAndFallbackFontsMap::ValueType* it =
         textBoxDataMap
             .insert(toInlineTextBox(run->m_box),
                     std::make_pair(Vector<const SimpleFontData*>(),
                                    GlyphOverflow()))
             .storedValue;
-    ASSERT(it->value.first.isEmpty());
+    DCHECK(it->value.first.isEmpty());
     copyToVector(fallbackFonts, it->value.first);
     run->m_box->parent()->clearDescendantsHaveSameLineHeightAndBaseline();
   }
   if (!glyphOverflow.isApproximatelyZero()) {
-    ASSERT(run->m_box->isText());
+    DCHECK(run->m_box->isText());
     GlyphOverflowAndFallbackFontsMap::ValueType* it =
         textBoxDataMap
             .insert(toInlineTextBox(run->m_box),
                     std::make_pair(Vector<const SimpleFontData*>(),
                                    GlyphOverflow()))
             .storedValue;
     it->value.second = glyphOverflow;
     run->m_box->clearKnownToHaveNoOverflow();
   }
 }
@@ skipping 221 matching lines @@
 void LayoutBlockFlow::computeBlockDirectionPositionsForLine(
     RootInlineBox* lineBox,
     BidiRun* firstRun,
     GlyphOverflowAndFallbackFontsMap& textBoxDataMap,
     VerticalPositionCache& verticalPositionCache) {
   setLogicalHeight(lineBox->alignBoxesInBlockDirection(
       logicalHeight(), textBoxDataMap, verticalPositionCache));
 
   // Now make sure we place replaced layout objects correctly.
   for (BidiRun* r = firstRun; r; r = r->next()) {
-    ASSERT(r->m_box);
+    DCHECK(r->m_box);
     if (!r->m_box)
       continue;  // Skip runs with no line boxes.
 
     // Align positioned boxes with the top of the line box.  This is
     // a reasonable approximation of an appropriate y position.
     if (r->m_lineLayoutItem.isOutOfFlowPositioned())
       r->m_box->setLogicalTop(logicalHeight());
 
     // Position is used to properly position both replaced elements and
     // to update the static normal flow x/y of positioned elements.
     if (r->m_lineLayoutItem.isText())
       toLayoutText(r->m_lineLayoutItem.layoutObject())
           ->positionLineBox(r->m_box);
     else if (r->m_lineLayoutItem.isBox())
       toLayoutBox(r->m_lineLayoutItem.layoutObject())
           ->positionLineBox(r->m_box);
   }
 }
 
 void LayoutBlockFlow::appendFloatingObjectToLastLine(
     FloatingObject& floatingObject) {
-  ASSERT(!floatingObject.originatingLine());
+  DCHECK(!floatingObject.originatingLine());
   floatingObject.setOriginatingLine(lastRootBox());
   lastRootBox()->appendFloat(floatingObject.layoutObject());
 }
 
 // This function constructs line boxes for all of the text runs in the resolver
 // and computes their position.
 RootInlineBox* LayoutBlockFlow::createLineBoxesFromBidiRuns(
     unsigned bidiLevel,
     BidiRunList<BidiRun>& bidiRuns,
     const InlineIterator& end,
@@ skipping 27 matching lines @@
   // Now position our text runs vertically.
   computeBlockDirectionPositionsForLine(lineBox, bidiRuns.firstRun(),
                                         textBoxDataMap, verticalPositionCache);
 
   // SVG text layout code computes vertical & horizontal positions on its own.
   // Note that we still need to execute computeVerticalPositionsForLine() as
   // it calls InlineTextBox::positionLineBox(), which tracks whether the box
   // contains reversed text or not. If we wouldn't do that editing and thus
   // text selection in RTL boxes would not work as expected.
   if (isSVGRootInlineBox) {
-    ASSERT(isSVGText());
+    DCHECK(isSVGText());
     toSVGRootInlineBox(lineBox)->computePerCharacterLayoutInformation();
   }
 
   // Compute our overflow now.
   lineBox->computeOverflow(lineBox->lineTop(), lineBox->lineBottom(),
                            textBoxDataMap);
 
   return lineBox;
 }
 
@@ skipping 55 matching lines @@
     LineLayoutState& layoutState,
     const InlineIterator& cleanLineStart,
     const InlineBidiResolver& resolver,
     const BidiStatus& cleanLineBidiStatus) {
   const FloatingObjectSet& floatingObjectSet = m_floatingObjects->set();
   FloatingObjectSetIterator it = floatingObjectSet.begin();
   FloatingObjectSetIterator end = floatingObjectSet.end();
   if (layoutState.lastFloat()) {
     FloatingObjectSetIterator lastFloatIterator =
         floatingObjectSet.find(layoutState.lastFloat());
-    ASSERT(lastFloatIterator != end);
+    DCHECK(lastFloatIterator != end);
     ++lastFloatIterator;
     it = lastFloatIterator;
   }
   for (; it != end; ++it) {
     FloatingObject& floatingObject = *it->get();
     // If we've reached the start of clean lines any remaining floating children
     // belong to them.
     if (cleanLineStart.getLineLayoutItem().isEqual(
             floatingObject.layoutObject()) &&
         layoutState.endLine()) {
       layoutState.setEndLineMatched(layoutState.endLineMatched() ||
                                     matchedEndLine(layoutState, resolver,
                                                    cleanLineStart,
                                                    cleanLineBidiStatus));
       if (layoutState.endLineMatched()) {
         layoutState.setLastFloat(&floatingObject);
         return;
       }
     }
     appendFloatingObjectToLastLine(floatingObject);
-    ASSERT(floatingObject.layoutObject() ==
-           layoutState.floats()[layoutState.floatIndex()].object);
+    DCHECK_EQ(floatingObject.layoutObject(),
+              layoutState.floats()[layoutState.floatIndex()].object);
     // If a float's geometry has changed, give up on syncing with clean lines.
     if (layoutState.floats()[layoutState.floatIndex()].rect !=
         floatingObject.frameRect()) {
       // Delete all the remaining lines.
       deleteLineRange(layoutState, layoutState.endLine());
       layoutState.setEndLine(nullptr);
     }
     layoutState.setFloatIndex(layoutState.floatIndex() + 1);
   }
   layoutState.setLastFloat(
@@ skipping 20 matching lines @@
   LayoutUnit paginationStrutFromDeletedLine;
 
   LineBreaker lineBreaker(LineLayoutBlockFlow(this));
 
   // We avoid inline capacity to save the stack space.
   WordMeasurements wordMeasurements;
   wordMeasurements.reserveInitialCapacity(64);
 
   while (!endOfLine.atEnd()) {
     // The runs from the previous line should have been cleaned up.
-    ASSERT(!resolver.runs().runCount());
+    DCHECK(!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),
@@ skipping 20 matching lines @@
       // FIXME: We shouldn't be creating any runs in nextLineBreak to begin
       // with! Once BidiRunList is separated from BidiResolver this will not be
       // needed.
       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());
+    DCHECK(endOfLine != resolver.position());
     RootInlineBox* lineBox = nullptr;
 
     // This is a short-cut for empty lines.
     if (layoutState.lineInfo().isEmpty()) {
-      ASSERT(!paginationStrutFromDeletedLine);
+      DCHECK(!paginationStrutFromDeletedLine);
       if (lastRootBox())
         lastRootBox()->setLineBreakInfo(endOfLine.getLineLayoutItem(),
                                         endOfLine.offset(), resolver.status());
       resolver.runs().deleteRuns();
     } else {
       VisualDirectionOverride override =
           (styleToUse.rtlOrdering() == EOrder::kVisual
                ? (styleToUse.direction() == TextDirection::kLtr
                       ? VisualLeftToRightOverride
                       : VisualRightToLeftOverride)
@@ skipping 14 matching lines @@
       layoutState.lineInfo().setTextAlign(textAlign);
       resolver.setNeedsTrailingSpace(
           textAlignmentNeedsTrailingSpace(textAlign, styleToUse));
 
       // 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);
+      DCHECK(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();
       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);
+      DCHECK(lineBox || !paginationStrutFromDeletedLine);
 
       if (lineBox) {
         lineBox->setLineBreakInfo(endOfLine.getLineLayoutItem(),
                                   endOfLine.offset(), resolver.status());
         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.
@@ skipping 13 matching lines @@
                       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);
+                DCHECK(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());
+                DCHECK(lineBox->isFirstAfterPageBreak());
                 lineBox->deleteLine();
                 endOfLine = restartLayoutRunsAndFloatsInRange(
                     oldLogicalHeight, oldLogicalHeight + adjustment,
                     lastFloatFromPreviousLine, resolver, previousEndofLine);
               } else {
                 setLogicalHeight(lineBox->lineBottomWithLeading());
               }
             }
           }
         }
@@ skipping 29 matching lines @@
         appendFloatsToLastLine(layoutState, cleanLineStart, endOfLineResolver,
                                cleanLineBidiStatus);
       }
     }
 
     lineMidpointState.reset();
     resolver.setPosition(endOfLine, numberOfIsolateAncestors(endOfLine));
   }
 
   // The resolver runs should have been cleared, otherwise they're leaking.
-  ASSERT(!resolver.runs().runCount());
+  DCHECK(!resolver.runs().runCount());
 
   // In case we already adjusted the line positions during this layout to avoid
   // widows then we need to ignore the possibility of having a new widows
   // situation. Otherwise, we risk leaving empty containers which is against the
   // block fragmentation principles.
   if (paginated && style()->widows() > 1 && !didBreakAtLineToAvoidWidow()) {
     // Check the line boxes to make sure we didn't create unacceptable widows.
     // However, we'll prioritize orphans - so nothing we do here should create
     // a new orphan.
 
@@ skipping 70 matching lines @@
         line->attachLine();
         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());
+            DCHECK(!floatingObject->originatingLine());
             floatingObject->setOriginatingLine(line);
             LayoutUnit logicalTop =
                 logicalTopForChild(*box) - marginBeforeForChild(*box) + delta;
             placeNewFloats(logicalTop);
           }
         }
       }
       setLogicalHeight(lastRootBox()->lineBottomWithLeading());
     } else {
       // Delete all the remaining lines.
@@ skipping 668 matching lines @@
     // If we encountered a new float and have inline children, mark ourself to
     // force us to issue paint invalidations.
     if (layoutState.hasInlineChild() && !selfNeedsLayout()) {
       setNeedsLayoutAndFullPaintInvalidation(
           LayoutInvalidationReason::FloatDescendantChanged, MarkOnlyThis);
       setShouldDoFullPaintInvalidation();
     }
 
     deleteLineBoxTree();
     curr = nullptr;
-    ASSERT(!firstLineBox() && !lastLineBox());
+    DCHECK(!firstLineBox());
+    DCHECK(!lastLineBox());
   } else {
     if (firstLineBoxWithBreakAndClearance)
       curr = firstLineBoxWithBreakAndClearance;
     if (curr) {
       // We have a dirty line.
       if (RootInlineBox* prevRootBox = curr->prevRootBox()) {
         // We have a previous line.
         if (!prevRootBox->endsWithBreak() || !prevRootBox->lineBreakObj() ||
             (prevRootBox->lineBreakObj().isText() &&
              prevRootBox->lineBreakPos() >=
@@ skipping 16 matching lines @@
   }
 
   unsigned numCleanFloats = 0;
   if (!layoutState.floats().isEmpty()) {
     // Restore floats from clean lines.
     RootInlineBox* line = firstRootBox();
     while (line != curr) {
       if (Vector<LayoutBox*>* cleanLineFloats = line->floatsPtr()) {
         for (auto* box : *cleanLineFloats) {
           FloatingObject* floatingObject = insertFloatingObject(*box);
-          ASSERT(!floatingObject->originatingLine());
+          DCHECK(!floatingObject->originatingLine());
           floatingObject->setOriginatingLine(line);
           LayoutUnit logicalTop =
               logicalTopForChild(*box) - marginBeforeForChild(*box);
           placeNewFloats(logicalTop);
-          ASSERT(layoutState.floats()[numCleanFloats].object == box);
+          DCHECK_EQ(layoutState.floats()[numCleanFloats].object, box);
           numCleanFloats++;
         }
       }
       line = line->nextRootBox();
     }
   }
   layoutState.setFloatIndex(numCleanFloats);
 
   layoutState.lineInfo().setFirstLine(!last);
   layoutState.lineInfo().setPreviousLineBrokeCleanly(!last ||
@@ skipping 32 matching lines @@
                            ? curr->lastLeafChild()
                            : curr->firstLeafChild();
   return lastBox && lastBox->getLineLayoutItem().isBR() &&
          lastBox->getLineLayoutItem().style()->clear() != EClear::kNone;
 }
 
 void LayoutBlockFlow::determineEndPosition(LineLayoutState& layoutState,
                                            RootInlineBox* startLine,
                                            InlineIterator& cleanLineStart,
                                            BidiStatus& cleanLineBidiStatus) {
-  ASSERT(!layoutState.endLine());
+  DCHECK(!layoutState.endLine());
   RootInlineBox* last = nullptr;
   for (RootInlineBox* curr = startLine->nextRootBox(); curr;
        curr = curr->nextRootBox()) {
     if (!curr->isDirty() && lineBoxHasBRWithClearance(curr))
       return;
 
     if (curr->isDirty())
       last = nullptr;
     else if (!last)
       last = curr;
@@ skipping 104 matching lines @@
       return matched;
     }
   }
 
   return false;
 }
 
 bool LayoutBlockFlow::generatesLineBoxesForInlineChild(LayoutObject* inlineObj)
 
 {
-  ASSERT(inlineObj->parent() == this);
+  DCHECK_EQ(inlineObj->parent(), this);
 
   InlineIterator it(LineLayoutBlockFlow(this), LineLayoutItem(inlineObj), 0);
   // FIXME: We should pass correct value for WhitespacePosition.
   while (!it.atEnd() && !requiresLineBox(it))
     it.increment();
 
   return !it.atEnd();
 }
 
 void LayoutBlockFlow::addOverflowFromInlineChildren() {
@@ skipping 88 matching lines @@
                          *firstLineStyle(), ellipsisDirection));
   } else {
     selectedEllipsisStr = fullstopCharacterStr;
     firstLineEllipsisWidth = firstLineFont.width(
         constructTextRun(firstLineFont, fullStopString, fullStopStringLength,
                          *firstLineStyle(), ellipsisDirection));
   }
   ellipsisWidth = (font == firstLineFont) ? firstLineEllipsisWidth : 0;
 
   if (!ellipsisWidth) {
-    ASSERT(font.primaryFont());
+    DCHECK(font.primaryFont());
     if (font.primaryFont()->glyphForCharacter(horizontalEllipsisCharacter)) {
       ellipsisWidth =
           font.width(constructTextRun(font, &horizontalEllipsisCharacter, 1,
                                       styleRef(), ellipsisDirection));
     } else {
       selectedEllipsisStr = fullstopCharacterStr;
       ellipsisWidth = font.width(
           constructTextRun(font, fullStopString, fullStopStringLength,
                            styleRef(), ellipsisDirection));
     }
@@ skipping 177 matching lines @@
       logicalRightOffsetForLine(logicalHeight(), DoNotIndentText) - logicalLeft;
   updateLogicalWidthForAlignment(textAlign, 0, 0, logicalLeft,
                                  totalLogicalWidth, availableLogicalWidth, 0);
 
   if (!style()->isLeftToRightDirection())
     return logicalWidth() - logicalLeft;
   return logicalLeft;
 }
 
 void LayoutBlockFlow::setShouldDoFullPaintInvalidationForFirstLine() {
-  ASSERT(childrenInline());
+  DCHECK(childrenInline());
   if (RootInlineBox* firstRootBox = this->firstRootBox())
     firstRootBox->setShouldDoFullPaintInvalidationRecursively();
 }
 
 bool LayoutBlockFlow::paintedOutputOfObjectHasNoEffectRegardlessOfSize() const {
   // LayoutBlockFlow is in charge of paint invalidation of the first line.
   if (firstLineBox())
     return false;
 
   return LayoutBlock::paintedOutputOfObjectHasNoEffectRegardlessOfSize();
 }
 
 }  // namespace blink