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

Source/core/layout/line/RootInlineBox.cpp

 /*
  * Copyright (C) 2003, 2006, 2008 Apple 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.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ skipping 27 matching lines @@
 
 struct SameSizeAsRootInlineBox : public InlineFlowBox {
     unsigned unsignedVariable;
     void* pointers[3];
     LayoutUnit layoutVariables[6];
 };
 
 static_assert(sizeof(RootInlineBox) == sizeof(SameSizeAsRootInlineBox), "RootInlineBox should stay small");
 
 typedef WTF::HashMap<const RootInlineBox*, EllipsisBox*> EllipsisBoxMap;
-static EllipsisBoxMap* gEllipsisBoxMap = 0;
+static EllipsisBoxMap* gEllipsisBoxMap = nullptr;
 
 RootInlineBox::RootInlineBox(LayoutBlockFlow& block)
     : InlineFlowBox(block)
     , m_lineBreakPos(0)
-    , m_lineBreakObj(0)
+    , m_lineBreakObj(nullptr)
     , m_lineTop(0)
     , m_lineBottom(0)
     , m_lineTopWithLeading(0)
     , m_lineBottomWithLeading(0)
     , m_selectionBottom(0)
     , m_paginationStrut(0)
 {
     setIsHorizontal(block.isHorizontalWritingMode());
 }
 
 
 void RootInlineBox::destroy()
 {
     detachEllipsisBox();
     InlineFlowBox::destroy();
 }
 
 void RootInlineBox::detachEllipsisBox()
 {
     if (hasEllipsisBox()) {
         EllipsisBox* box = gEllipsisBoxMap->take(this);
-        box->setParent(0);
+        box->setParent(nullptr);
         box->destroy();
         setHasEllipsisBox(false);
     }
 }
 
 LineBoxList* RootInlineBox::lineBoxes() const
 {
     return block().lineBoxes();
 }
 
@@ skipping 268 matching lines @@
     return state;
 }
 
 InlineBox* RootInlineBox::firstSelectedBox() const
 {
     for (InlineBox* box = firstLeafChild(); box; box = box->nextLeafChild()) {
         if (box->selectionState() != LayoutObject::SelectionNone)
             return box;
     }
 
-    return 0;
+    return nullptr;
 }
 
 InlineBox* RootInlineBox::lastSelectedBox() const
 {
     for (InlineBox* box = lastLeafChild(); box; box = box->prevLeafChild()) {
         if (box->selectionState() != LayoutObject::SelectionNone)
             return box;
     }
 
-    return 0;
+    return nullptr;
 }
 
 LayoutUnit RootInlineBox::selectionTop() const
 {
     LayoutUnit selectionTop = m_lineTop;
 
     if (m_hasAnnotationsBefore)
         selectionTop -= !layoutObject().style()->isFlippedLinesWritingMode() ? computeOverAnnotationAdjustment(m_lineTop) : computeUnderAnnotationAdjustment(m_lineTop);
 
     if (layoutObject().style()->isFlippedLinesWritingMode() || !prevRootBox())
@@ skipping 107 matching lines @@
         // Return it.
         return firstLeaf;
     }
 
     if (leftPosition >= lastLeaf->logicalRight() && !lastLeaf->layoutObject().isListMarker() && (!onlyEditableLeaves || isEditableLeaf(lastLeaf))) {
         // The leftPosition coordinate is greater or equal to right edge of the lastLeaf.
         // Return it.
         return lastLeaf;
     }
 
-    InlineBox* closestLeaf = 0;
+    InlineBox* closestLeaf = nullptr;
     for (InlineBox* leaf = firstLeaf; leaf; leaf = leaf->nextLeafChildIgnoringLineBreak()) {
         if (!leaf->layoutObject().isListMarker() && (!onlyEditableLeaves || isEditableLeaf(leaf))) {
             closestLeaf = leaf;
             if (leftPosition < leaf->logicalRight()) {
                 // The x coordinate is less than the right edge of the box.
                 // Return it.
                 return leaf;
             }
         }
     }
@@ skipping 19 matching lines @@
     m_lineBreakPos = breakPos;
     m_lineBreakBidiStatusEor = status.eor;
     m_lineBreakBidiStatusLastStrong = status.lastStrong;
     m_lineBreakBidiStatusLast = status.last;
     m_lineBreakContext = status.context;
 }
 
 EllipsisBox* RootInlineBox::ellipsisBox() const
 {
     if (!hasEllipsisBox())
-        return 0;
+        return nullptr;
     return gEllipsisBoxMap->get(this);
 }
 
 void RootInlineBox::removeLineBoxFromLayoutObject()
 {
     block().lineBoxes()->removeLineBox(this);
 }
 
 void RootInlineBox::extractLineBoxFromLayoutObject()
 {
@@ skipping 49 matching lines @@
             ascent = box->baselinePosition(baselineType());
             descent = box->lineHeight() - ascent;
 
             // Replaced elements always affect both the ascent and descent.
             affectsAscent = true;
             affectsDescent = true;
         }
         return;
     }
 
-    Vector<const SimpleFontData*>* usedFonts = 0;
-    GlyphOverflow* glyphOverflow = 0;
+    Vector<const SimpleFontData*>* usedFonts = nullptr;
+    GlyphOverflow* glyphOverflow = nullptr;
     if (box->isText()) {
         GlyphOverflowAndFallbackFontsMap::iterator it = textBoxDataMap.find(toInlineTextBox(box));
         usedFonts = it == textBoxDataMap.end() ? 0 : &it->value.first;
         glyphOverflow = it == textBoxDataMap.end() ? 0 : &it->value.second;
     }
 
     bool includeLeading = includeLeadingForBox(box);
     bool includeFont = includeFontForBox(box);
 
     bool setUsedFont = false;
@@ skipping 199 matching lines @@
 Node* RootInlineBox::getLogicalStartBoxWithNode(InlineBox*& startBox) const
 {
     Vector<InlineBox*> leafBoxesInLogicalOrder;
     collectLeafBoxesInLogicalOrder(leafBoxesInLogicalOrder);
     for (size_t i = 0; i < leafBoxesInLogicalOrder.size(); ++i) {
         if (leafBoxesInLogicalOrder[i]->layoutObject().nonPseudoNode()) {
             startBox = leafBoxesInLogicalOrder[i];
             return startBox->layoutObject().nonPseudoNode();
         }
     }
-    startBox = 0;
-    return 0;
+    startBox = nullptr;
+    return nullptr;
 }
 
 Node* RootInlineBox::getLogicalEndBoxWithNode(InlineBox*& endBox) const
 {
     Vector<InlineBox*> leafBoxesInLogicalOrder;
     collectLeafBoxesInLogicalOrder(leafBoxesInLogicalOrder);
     for (size_t i = leafBoxesInLogicalOrder.size(); i > 0; --i) {
         if (leafBoxesInLogicalOrder[i - 1]->layoutObject().nonPseudoNode()) {
             endBox = leafBoxesInLogicalOrder[i - 1];
             return endBox->layoutObject().nonPseudoNode();
         }
     }
-    endBox = 0;
-    return 0;
+    endBox = nullptr;
+    return nullptr;
 }
 
 const char* RootInlineBox::boxName() const
 {
     return "RootInlineBox";
 }
 
 } // namespace blink