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

Source/core/layout/LayoutText.cpp

 /*
  * (C) 1999 Lars Knoll (knoll@kde.org)
  * (C) 2000 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007 Apple Inc. All rights reserved.
  * Copyright (C) 2006 Andrew Wellington (proton@wiretapped.net)
  * Copyright (C) 2006 Graham Dennis (graham.dennis@gmail.com)
  *
  * 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
@@ skipping 48 matching lines @@
     uint32_t bitfields : 16;
     float widths[4];
     String text;
     void* pointers[2];
 };
 
 static_assert(sizeof(LayoutText) == sizeof(SameSizeAsLayoutText), "LayoutText should stay small");
 
 class SecureTextTimer;
 typedef HashMap<LayoutText*, SecureTextTimer*> SecureTextTimerMap;
-static SecureTextTimerMap* gSecureTextTimers = 0;
+static SecureTextTimerMap* gSecureTextTimers = nullptr;
 
 class SecureTextTimer final : public TimerBase {
 public:
     SecureTextTimer(LayoutText* layoutText)
         : m_layoutText(layoutText)
         , m_lastTypedCharacterOffset(-1)
     {
     }
 
     void restartWithNewText(unsigned lastTypedCharacterOffset)
@@ skipping 60 matching lines @@
     : LayoutObject(!node || node->isDocumentNode() ? 0 : node)
     , m_hasTab(false)
     , m_linesDirty(false)
     , m_containsReversedText(false)
     , m_knownToHaveNoOverflowAndNoFallbackFonts(false)
     , m_minWidth(-1)
     , m_maxWidth(-1)
     , m_firstLineMinWidth(0)
     , m_lastLineLineMinWidth(0)
     , m_text(str)
-    , m_firstTextBox(0)
-    , m_lastTextBox(0)
+    , m_firstTextBox(nullptr)
+    , m_lastTextBox(nullptr)
 {
     ASSERT(m_text);
     // FIXME: Some clients of LayoutText (and subclasses) pass Document as node to create anonymous layoutObject.
     // They should be switched to passing null and using setDocumentForAnonymous.
     if (node && node->isDocumentNode())
         setDocumentForAnonymous(toDocument(node));
 
     m_canUseSimpleFontCodePath = computeCanUseSimpleFontCodePath();
     setIsText();
 
@@ skipping 70 matching lines @@
     removeAndDestroyTextBoxes();
     LayoutObject::willBeDestroyed();
 }
 
 void LayoutText::extractTextBox(InlineTextBox* box)
 {
     checkConsistency();
 
     m_lastTextBox = box->prevTextBox();
     if (box == m_firstTextBox)
-        m_firstTextBox = 0;
+        m_firstTextBox = nullptr;
     if (box->prevTextBox())
-        box->prevTextBox()->setNextTextBox(0);
-    box->setPreviousTextBox(0);
+        box->prevTextBox()->setNextTextBox(nullptr);
+    box->setPreviousTextBox(nullptr);
     for (InlineTextBox* curr = box; curr; curr = curr->nextTextBox())
         curr->setExtracted();
 
     checkConsistency();
 }
 
 void LayoutText::attachTextBox(InlineTextBox* box)
 {
     checkConsistency();
 
@@ skipping 30 matching lines @@
 }
 
 void LayoutText::deleteTextBoxes()
 {
     if (firstTextBox()) {
         InlineTextBox* next;
         for (InlineTextBox* curr = firstTextBox(); curr; curr = next) {
             next = curr->nextTextBox();
             curr->destroy();
         }
-        m_firstTextBox = m_lastTextBox = 0;
+        m_firstTextBox = m_lastTextBox = nullptr;
     }
 }
 
 PassRefPtr<StringImpl> LayoutText::originalText() const
 {
     Node* e = node();
     return (e && e->isTextNode()) ? toText(e)->dataImpl() : 0;
 }
 
 String LayoutText::plainText() const
@@ skipping 287 matching lines @@
 
 PositionWithAffinity LayoutText::positionForPoint(const LayoutPoint& point)
 {
     if (!firstTextBox() || textLength() == 0)
         return createPositionWithAffinity(0, DOWNSTREAM);
 
     LayoutUnit pointLineDirection = firstTextBox()->isHorizontal() ? point.x() : point.y();
     LayoutUnit pointBlockDirection = firstTextBox()->isHorizontal() ? point.y() : point.x();
     bool blocksAreFlipped = style()->isFlippedBlocksWritingMode();
 
-    InlineTextBox* lastBox = 0;
+    InlineTextBox* lastBox = nullptr;
     for (InlineTextBox* box = firstTextBox(); box; box = box->nextTextBox()) {
         if (box->isLineBreak() && !box->prevLeafChild() && box->nextLeafChild() && !box->nextLeafChild()->isLineBreak())
             box = box->nextTextBox();
 
         RootInlineBox& rootBox = box->root();
         LayoutUnit top = std::min(rootBox.selectionTop(), rootBox.lineTop());
         if (pointBlockDirection > top || (!blocksAreFlipped && pointBlockDirection == top)) {
             LayoutUnit bottom = rootBox.selectionBottom();
             if (rootBox.nextRootBox())
                 bottom = std::min(bottom, rootBox.nextRootBox()->lineTop());
@@ skipping 586 matching lines @@
 void LayoutText::setTextWithOffset(PassRefPtr<StringImpl> text, unsigned offset, unsigned len, bool force)
 {
     if (!force && equal(m_text.impl(), text.get()))
         return;
 
     unsigned oldLen = textLength();
     unsigned newLen = text->length();
     int delta = newLen - oldLen;
     unsigned end = len ? offset + len - 1 : offset;
 
-    RootInlineBox* firstRootBox = 0;
-    RootInlineBox* lastRootBox = 0;
+    RootInlineBox* firstRootBox = nullptr;
+    RootInlineBox* lastRootBox = nullptr;
 
     bool dirtiedLines = false;
 
     // Dirty all text boxes that include characters in between offset and offset+len.
     for (InlineTextBox* curr = firstTextBox(); curr; curr = curr->nextTextBox()) {
         // FIXME: This shouldn't rely on the end of a dirty line box. See https://bugs.webkit.org/show_bug.cgi?id=97264
         // Text run is entirely before the affected range.
         if (curr->end() < offset)
             continue;
 
@@ skipping 597 matching lines @@
     if (m_text.is8Bit())
         return true;
     return Character::characterRangeCodePath(characters16(), length()) == SimplePath;
 }
 
 #if ENABLE(ASSERT)
 
 void LayoutText::checkConsistency() const
 {
 #ifdef CHECK_CONSISTENCY
-    const InlineTextBox* prev = 0;
-    for (const InlineTextBox* child = m_firstTextBox; child != 0; child = child->nextTextBox()) {
+    const InlineTextBox* prev = nullptr;
+    for (const InlineTextBox* child = m_firstTextBox; child; child = child->nextTextBox()) {
         ASSERT(child->layoutObject() == this);
         ASSERT(child->prevTextBox() == prev);
         prev = child;
     }
     ASSERT(prev == m_lastTextBox);
 #endif
 }
 
 #endif
 
@@ skipping 16 matching lines @@
 }
 
 void LayoutText::invalidateDisplayItemClients(const LayoutBoxModelObject& paintInvalidationContainer) const
 {
     LayoutObject::invalidateDisplayItemClients(paintInvalidationContainer);
     for (InlineTextBox* box = firstTextBox(); box; box = box->nextTextBox())
         paintInvalidationContainer.invalidateDisplayItemClientOnBacking(*box);
 }
 
 } // namespace blink