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

Source/core/layout/CounterNode.cpp

 /*
  * Copyright (C) 2005 Allan Sandfeld Jensen (kde@carewolf.com)
  * Copyright (C) 2006, 2007 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,
@@ skipping 17 matching lines @@
 #include <stdio.h>
 #endif
 
 namespace blink {
 
 CounterNode::CounterNode(LayoutObject& o, bool hasResetType, int value)
     : m_hasResetType(hasResetType)
     , m_value(value)
     , m_countInParent(0)
     , m_owner(o)
-    , m_rootLayoutObject(0)
-    , m_parent(0)
-    , m_previousSibling(0)
-    , m_nextSibling(0)
-    , m_firstChild(0)
-    , m_lastChild(0)
+    , m_rootLayoutObject(nullptr)
+    , m_parent(nullptr)
+    , m_previousSibling(nullptr)
+    , m_nextSibling(nullptr)
+    , m_firstChild(nullptr)
+    , m_lastChild(nullptr)
 {
 }
 
 CounterNode::~CounterNode()
 {
     // Ideally this would be an assert and this would never be reached. In reality this happens a lot
     // so we need to handle these cases. The node is still connected to the tree so we need to detach it.
     if (m_parent || m_previousSibling || m_nextSibling || m_firstChild || m_lastChild) {
-        CounterNode* oldParent = 0;
-        CounterNode* oldPreviousSibling = 0;
+        CounterNode* oldParent = nullptr;
+        CounterNode* oldPreviousSibling = nullptr;
         // Instead of calling removeChild() we do this safely as the tree is likely broken if we get here.
         if (m_parent) {
             if (m_parent->m_firstChild == this)
                 m_parent->m_firstChild = m_nextSibling;
             if (m_parent->m_lastChild == this)
                 m_parent->m_lastChild = m_previousSibling;
             oldParent = m_parent;
-            m_parent = 0;
+            m_parent = nullptr;
         }
         if (m_previousSibling) {
             if (m_previousSibling->m_nextSibling == this)
                 m_previousSibling->m_nextSibling = m_nextSibling;
             oldPreviousSibling = m_previousSibling;
-            m_previousSibling = 0;
+            m_previousSibling = nullptr;
         }
         if (m_nextSibling) {
             if (m_nextSibling->m_previousSibling == this)
                 m_nextSibling->m_previousSibling = oldPreviousSibling;
-            m_nextSibling = 0;
+            m_nextSibling = nullptr;
         }
         if (m_firstChild) {
             // The node's children are reparented to the old parent.
             for (CounterNode* child = m_firstChild; child; ) {
                 CounterNode* nextChild = child->m_nextSibling;
-                CounterNode* nextSibling = 0;
+                CounterNode* nextSibling = nullptr;
                 child->m_parent = oldParent;
                 if (oldPreviousSibling) {
                     nextSibling = oldPreviousSibling->m_nextSibling;
                     child->m_previousSibling = oldPreviousSibling;
                     oldPreviousSibling->m_nextSibling = child;
                     child->m_nextSibling = nextSibling;
                     nextSibling->m_previousSibling = child;
                     oldPreviousSibling = child;
                 }
                 child = nextChild;
             }
         }
     }
     resetLayoutObjects();
 }
 
 PassRefPtr<CounterNode> CounterNode::create(LayoutObject& owner, bool hasResetType, int value)
 {
     return adoptRef(new CounterNode(owner, hasResetType, value));
 }
 
 CounterNode* CounterNode::nextInPreOrderAfterChildren(const CounterNode* stayWithin) const
 {
     if (this == stayWithin)
-        return 0;
+        return nullptr;
 
     const CounterNode* current = this;
     CounterNode* next = current->m_nextSibling;
     for (; !next; next = current->m_nextSibling) {
         current = current->m_parent;
         if (!current || current == stayWithin)
-            return 0;
+            return nullptr;
     }
     return next;
 }
 
 CounterNode* CounterNode::nextInPreOrder(const CounterNode* stayWithin) const
 {
     if (CounterNode* next = m_firstChild)
         return next;
 
     return nextInPreOrderAfterChildren(stayWithin);
 }
 
 CounterNode* CounterNode::lastDescendant() const
 {
     CounterNode* last = m_lastChild;
     if (!last)
-        return 0;
+        return nullptr;
 
     while (CounterNode* lastChild = last->m_lastChild)
         last = lastChild;
 
     return last;
 }
 
 CounterNode* CounterNode::previousInPreOrder() const
 {
     CounterNode* previous = m_previousSibling;
@@ skipping 46 matching lines @@
 void CounterNode::removeLayoutObject(LayoutCounter* value)
 {
     if (!value) {
         ASSERT_NOT_REACHED();
         return;
     }
     if (value->m_counterNode && value->m_counterNode != this) {
         ASSERT_NOT_REACHED();
         value->m_counterNode->removeLayoutObject(value);
     }
-    LayoutCounter* previous = 0;
+    LayoutCounter* previous = nullptr;
     for (LayoutCounter* iterator = m_rootLayoutObject; iterator; iterator = iterator->m_nextForSameCounter) {
         if (iterator == value) {
             if (previous)
                 previous->m_nextForSameCounter = value->m_nextForSameCounter;
             else
                 m_rootLayoutObject = value->m_nextForSameCounter;
-            value->m_nextForSameCounter = 0;
-            value->m_counterNode = 0;
+            value->m_nextForSameCounter = nullptr;
+            value->m_counterNode = nullptr;
             return;
         }
         previous = iterator;
     }
     ASSERT_NOT_REACHED();
 }
 
 void CounterNode::resetLayoutObjects()
 {
     while (m_rootLayoutObject)
@@ skipping 95 matching lines @@
             next->m_previousSibling = last;
         } else {
             m_lastChild = last;
         }
         for (next = first; ; next = next->m_nextSibling) {
             next->m_parent = this;
             if (last == next)
                 break;
         }
     }
-    newChild->m_firstChild = 0;
-    newChild->m_lastChild = 0;
+    newChild->m_firstChild = nullptr;
+    newChild->m_lastChild = nullptr;
     newChild->m_countInParent = newChild->computeCountInParent();
     newChild->resetLayoutObjects();
     first->recount();
 }
 
 void CounterNode::removeChild(CounterNode* oldChild)
 {
     ASSERT(oldChild);
     ASSERT(!oldChild->m_firstChild);
     ASSERT(!oldChild->m_lastChild);
 
     CounterNode* next = oldChild->m_nextSibling;
     CounterNode* previous = oldChild->m_previousSibling;
 
-    oldChild->m_nextSibling = 0;
-    oldChild->m_previousSibling = 0;
-    oldChild->m_parent = 0;
+    oldChild->m_nextSibling = nullptr;
+    oldChild->m_previousSibling = nullptr;
+    oldChild->m_parent = nullptr;
 
     if (previous) {
         previous->m_nextSibling = next;
     } else {
         ASSERT(m_firstChild == oldChild);
         m_firstChild = next;
     }
 
     if (next) {
         next->m_previousSibling = previous;
@@ skipping 34 matching lines @@
 
 void showCounterTree(const blink::CounterNode* counter)
 {
     if (counter)
         showTreeAndMark(counter);
     else
         fprintf(stderr, "Cannot showCounterTree for (nil).\n");
 }
 
 #endif