C++11: Replace 0 with nullptr where applicable in layout code.

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 85 matching lines @@
         parentBox = parentBox->parent();
     } while (parentBox);
     return false;
 }
 
 InlineFlowBox* LayoutBlockFlow::createLineBoxes(LayoutObject* obj, const LineInfo& lineInfo, InlineBox* childBox)
 {
     // See if we have an unconstructed line box for this object that is also
     // the last item on the line.
     unsigned lineDepth = 1;
-    InlineFlowBox* parentBox = 0;
-    InlineFlowBox* result = 0;
+    InlineFlowBox* parentBox = nullptr;
+    InlineFlowBox* result = nullptr;
     bool hasDefaultLineBoxContain = style()->lineBoxContain() == ComputedStyle::initialLineBoxContain();
     do {
         ASSERT_WITH_SECURITY_IMPLICATION(obj->isLayoutInline() || obj == this);
 
         LayoutInline* inlineFlow = (obj != this) ? toLayoutInline(obj) : 0;
 
         // Get the last box we made for this layout object.
         parentBox = inlineFlow ? inlineFlow->lastLineBox() : toLayoutBlock(obj)->lastLineBox();
 
         // If this box or its ancestor is constructed then it is from a previous line, and we need
@@ skipping 70 matching lines @@
     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());
 
     bool rootHasSelectedChildren = false;
-    InlineFlowBox* parentBox = 0;
+    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_object->isListMarker())
             isOnlyRun = (!style()->isLeftToRightDirection() ? bidiRuns.lastRun() : bidiRuns.firstRun())->m_object->isListMarker();
 
         if (lineInfo.isEmpty())
             continue;
 
@@ skipping 136 matching lines @@
     if (isLeftToRightDirection)
         logicalLeft += std::max((availableLogicalWidth - totalLogicalWidth) / 2, LayoutUnit());
     else
         logicalLeft += totalLogicalWidth > availableLogicalWidth ? (availableLogicalWidth - totalLogicalWidth) : (availableLogicalWidth - totalLogicalWidth) / 2 - trailingSpaceWidth;
 }
 
 void LayoutBlockFlow::setMarginsForRubyRun(BidiRun* run, LayoutRubyRun* layoutRubyRun, LayoutObject* previousObject, const LineInfo& lineInfo)
 {
     int startOverhang;
     int endOverhang;
-    LayoutObject* nextObject = 0;
+    LayoutObject* nextObject = nullptr;
     for (BidiRun* runWithNextObject = run->next(); runWithNextObject; runWithNextObject = runWithNextObject->next()) {
         if (!runWithNextObject->m_object->isOutOfFlowPositioned() && !runWithNextObject->m_box->isLineBreak()) {
             nextObject = runWithNextObject->m_object;
             break;
         }
     }
     layoutRubyRun->getOverhang(lineInfo.isFirstLine(), layoutRubyRun->style()->isLeftToRightDirection() ? previousObject : nextObject, layoutRubyRun->style()->isLeftToRightDirection() ? nextObject : previousObject, startOverhang, endOverhang);
     setMarginStartForChild(*layoutRubyRun, -startOverhang);
     setMarginEndForChild(*layoutRubyRun, -endOverhang);
 }
@@ skipping 214 matching lines @@
 
 BidiRun* LayoutBlockFlow::computeInlineDirectionPositionsForSegment(RootInlineBox* lineBox, const LineInfo& lineInfo, ETextAlign textAlign, LayoutUnit& logicalLeft,
     LayoutUnit& availableLogicalWidth, BidiRun* firstRun, BidiRun* trailingSpaceRun, GlyphOverflowAndFallbackFontsMap& textBoxDataMap, VerticalPositionCache& verticalPositionCache,
     WordMeasurements& wordMeasurements)
 {
     bool needsWordSpacing = true;
     LayoutUnit totalLogicalWidth = lineBox->getFlowSpacingLogicalWidth();
     unsigned expansionOpportunityCount = 0;
     bool isAfterExpansion = true;
     Vector<unsigned, 16> expansionOpportunities;
-    LayoutObject* previousObject = 0;
+    LayoutObject* previousObject = nullptr;
     TextJustify textJustify = style()->textJustify();
 
     BidiRun* r = firstRun;
     for (; r; r = r->next()) {
         if (!r->m_box || r->m_object->isOutOfFlowPositioned() || r->m_box->isLineBreak()) {
             continue; // Positioned objects are only participating to figure out their
                 // correct static x position.  They have no effect on the width.
                 // Similarly, line break boxes have no effect on the width.
         }
         if (r->m_object->isText()) {
@@ skipping 74 matching lines @@
 {
     ASSERT(!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, LineInfo& lineInfo, VerticalPositionCache& verticalPositionCache, BidiRun* trailingSpaceRun, WordMeasurements& wordMeasurements)
 {
     if (!bidiRuns.runCount())
-        return 0;
+        return nullptr;
 
     // FIXME: Why is this only done when we had runs?
     lineInfo.setLastLine(!end.object());
 
     RootInlineBox* lineBox = constructLine(bidiRuns, lineInfo);
     if (!lineBox)
-        return 0;
+        return nullptr;
 
     lineBox->setBidiLevel(bidiLevel);
     lineBox->setEndsWithBreak(lineInfo.previousLineBrokeCleanly());
 
     bool isSVGRootInlineBox = lineBox->isSVGRootInlineBox();
 
     GlyphOverflowAndFallbackFontsMap textBoxDataMap;
 
     // Now we position all of our text runs horizontally.
     if (!isSVGRootInlineBox)
@@ skipping 371 matching lines @@
         : parent(p), current(p), endOfInline(end)
     {
 
     }
 
     LayoutObject* next();
 };
 
 LayoutObject* InlineMinMaxIterator::next()
 {
-    LayoutObject* result = 0;
+    LayoutObject* result = nullptr;
     bool oldEndOfInline = endOfInline;
     endOfInline = false;
     while (current || current == parent) {
         if (!oldEndOfInline && (current == parent || (!current->isFloating() && !current->isReplaced() && !current->isOutOfFlowPositioned())))
             result = current->slowFirstChild();
 
         if (!result) {
             // We hit the end of our inline. (It was empty, e.g., <span></span>.)
             if (!oldEndOfInline && current->isLayoutInline()) {
                 result = current;
@@ skipping 14 matching lines @@
             }
         }
 
         if (!result)
             break;
 
         if (!result->isOutOfFlowPositioned() && (result->isText() || result->isFloating() || result->isReplaced() || result->isLayoutInline()))
             break;
 
         current = result;
-        result = 0;
+        result = nullptr;
     }
 
     // Update our position.
     current = result;
     return current;
 }
 
 static LayoutUnit getBPMWidth(LayoutUnit childValue, Length cssUnit)
 {
     if (cssUnit.type() != Auto)
@@ skipping 61 matching lines @@
     LayoutUnit inlineMax;
     LayoutUnit inlineMin;
 
     const ComputedStyle& styleToUse = styleRef();
     LayoutBlock* containingBlock = this->containingBlock();
     LayoutUnit cw = containingBlock ? containingBlock->contentLogicalWidth() : LayoutUnit();
 
     // If we are at the start of a line, we want to ignore all white-space.
     // Also strip spaces if we previously had text that ended in a trailing space.
     bool stripFrontSpaces = true;
-    LayoutObject* trailingSpaceChild = 0;
+    LayoutObject* trailingSpaceChild = nullptr;
 
     // Firefox and Opera will allow a table cell to grow to fit an image inside it under
     // very specific cirucumstances (in order to match common WinIE layouts).
     // Not supporting the quirk has caused us to mis-layout some real sites. (See Bugzilla 10517.)
     bool allowImagesToBreak = !document().inQuirksMode() || !isTableCell() || !styleToUse.logicalWidth().isIntrinsicOrAuto();
 
     bool autoWrap, oldAutoWrap;
     autoWrap = oldAutoWrap = styleToUse.autoWrap();
 
     InlineMinMaxIterator childIterator(this);
 
     // Only gets added to the max preffered width once.
     bool addedTextIndent = false;
     // Signals the text indent was more negative than the min preferred width
     bool hasRemainingNegativeTextIndent = false;
 
     LayoutUnit textIndent = minimumValueForLength(styleToUse.textIndent(), cw);
-    LayoutObject* prevFloat = 0;
+    LayoutObject* prevFloat = nullptr;
     bool isPrevChildInlineFlow = false;
     bool shouldBreakLineAfterText = false;
     while (LayoutObject* child = childIterator.next()) {
         autoWrap = child->isReplaced() ? child->parent()->style()->autoWrap() :
             child->style()->autoWrap();
 
         if (!child->isBR()) {
             // Step One: determine whether or not we need to go ahead and
             // terminate our current line. Each discrete chunk can become
             // the new min-width, if it is the widest chunk seen so far, and
@@ skipping 128 matching lines @@
 
                 if (autoWrap && canBreakReplacedElement && isPrevChildInlineFlow) {
                     minLogicalWidth = std::max(minLogicalWidth, inlineMin);
                     inlineMin = LayoutUnit();
                 }
 
                 // We are no longer stripping whitespace at the start of
                 // a line.
                 if (!child->isFloating()) {
                     stripFrontSpaces = false;
-                    trailingSpaceChild = 0;
+                    trailingSpaceChild = nullptr;
                 }
             } else if (child->isText()) {
                 // Case (3). Text.
                 LayoutText* t = toLayoutText(child);
 
                 if (t->isWordBreak()) {
                     minLogicalWidth = std::max(minLogicalWidth, inlineMin);
                     inlineMin = LayoutUnit();
                     continue;
                 }
@@ skipping 17 matching lines @@
                     if (autoWrap && (hasBreakableStart || hasBreakableEnd)) {
                         minLogicalWidth = std::max(minLogicalWidth, inlineMin);
                         inlineMin = LayoutUnit();
                     }
                     continue;
                 }
 
                 if (stripFrontSpaces)
                     trailingSpaceChild = child;
                 else
-                    trailingSpaceChild = 0;
+                    trailingSpaceChild = nullptr;
 
                 // Add in text-indent. This is added in only once.
                 LayoutUnit ti;
                 if (!addedTextIndent || hasRemainingNegativeTextIndent) {
                     ti = textIndent;
                     childMin += ti;
                     firstLineMinWidth += ti;
 
                     // It the text indent negative and larger than the child minimum, we re-use the remainder
                     // in future minimum calculations, but using the negative value again on the maximum
@@ skipping 49 matching lines @@
             }
 
             // Ignore spaces after a list marker.
             if (child->isListMarker())
                 stripFrontSpaces = true;
         } else {
             minLogicalWidth = std::max(minLogicalWidth, inlineMin);
             maxLogicalWidth = std::max(maxLogicalWidth, inlineMax);
             inlineMin = inlineMax = LayoutUnit();
             stripFrontSpaces = true;
-            trailingSpaceChild = 0;
+            trailingSpaceChild = nullptr;
             addedTextIndent = true;
         }
 
         if (!child->isText() && child->isLayoutInline())
             isPrevChildInlineFlow = true;
         else
             isPrevChildInlineFlow = false;
 
         oldAutoWrap = autoWrap;
     }
@@ skipping 136 matching lines @@
             markLinesDirtyInBlockRange(line->lineBottomWithLeading(), floatTop + floatHeight, line);
             floats[floatIndex].rect.setSize(newSize);
             dirtiedByFloat = true;
         }
         floatIndex++;
     }
 }
 
 RootInlineBox* LayoutBlockFlow::determineStartPosition(LineLayoutState& layoutState, InlineBidiResolver& resolver)
 {
-    RootInlineBox* curr = 0;
-    RootInlineBox* last = 0;
+    RootInlineBox* curr = nullptr;
+    RootInlineBox* last = nullptr;
 
     // FIXME: This entire float-checking block needs to be broken into a new function.
     bool dirtiedByFloat = false;
     if (!layoutState.isFullLayout()) {
         // Paginate all of the clean lines.
         bool paginated = view()->layoutState() && view()->layoutState()->isPaginated();
         LayoutUnit paginationDelta = 0;
         size_t floatIndex = 0;
         for (curr = firstRootBox(); curr && !curr->isDirty(); curr = curr->nextRootBox()) {
             if (paginated) {
@@ skipping 26 matching lines @@
     }
 
     if (layoutState.isFullLayout()) {
         // 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 = 0;
+        curr = nullptr;
         ASSERT(!firstLineBox() && !lastLineBox());
     } else {
         if (curr) {
             // We have a dirty line.
             if (RootInlineBox* prevRootBox = curr->prevRootBox()) {
                 // We have a previous line.
                 if (!dirtiedByFloat && (!prevRootBox->endsWithBreak() || !prevRootBox->lineBreakObj() || (prevRootBox->lineBreakObj()->isText() && prevRootBox->lineBreakPos() >= toLayoutText(prevRootBox->lineBreakObj())->textLength()))) {
                     // The previous line didn't break cleanly or broke at a newline
                     // that has been deleted, so treat it as dirty too.
                     curr = prevRootBox;
@@ skipping 49 matching lines @@
         InlineIterator iter = InlineIterator(this, bidiFirstSkippingEmptyInlines(this, resolver.runs(), &resolver), 0);
         resolver.setPosition(iter, numberOfIsolateAncestors(iter));
     }
     return curr;
 }
 
 void LayoutBlockFlow::determineEndPosition(LineLayoutState& layoutState, RootInlineBox* startLine, InlineIterator& cleanLineStart, BidiStatus& cleanLineBidiStatus)
 {
     ASSERT(!layoutState.endLine());
     size_t floatIndex = layoutState.floatIndex();
-    RootInlineBox* last = 0;
+    RootInlineBox* last = nullptr;
     for (RootInlineBox* curr = startLine->nextRootBox(); curr; curr = curr->nextRootBox()) {
         if (!curr->isDirty()) {
             bool encounteredNewFloat = false;
             bool dirtiedByFloat = false;
             checkFloatsInCleanLine(curr, layoutState.floats(), floatIndex, encounteredNewFloat, dirtiedByFloat);
             if (encounteredNewFloat)
                 return;
         }
         if (curr->isDirty())
-            last = 0;
+            last = nullptr;
         else if (!last)
             last = curr;
     }
 
     if (!last)
         return;
 
     // At this point, |last| is the first line in a run of clean lines that ends with the last line
     // in the block.
 
@@ skipping 256 matching lines @@
     LayoutUnit logicalLeft = logicalLeftOffsetForLine(logicalHeight(), false);
     LayoutUnit availableLogicalWidth = logicalRightOffsetForLine(logicalHeight(), false) - logicalLeft;
     updateLogicalWidthForAlignment(textAlign, 0, 0, logicalLeft, totalLogicalWidth, availableLogicalWidth, 0);
 
     if (!style()->isLeftToRightDirection())
         return logicalWidth() - logicalLeft;
     return logicalLeft;
 }
 
 }