Use nullptr_t for RefPtr, PassRefPtr and RawPtr.

Source/core/svg/properties/SVGListProperty.h

 /*
  * Copyright (C) Research In Motion Limited 2010. 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 46 matching lines @@
         // See SVGPropertyTearOff::detachWrapper() for an explanation about what's happening here.
         ASSERT(wrappers);
         unsigned size = wrappers->size();
         for (unsigned i = 0; i < size; ++i) {
             if (ListItemTearOff* item = wrappers->at(i).get())
                 item->detachWrapper();
         }
 
         // Reinitialize the wrapper cache to be equal to the new values size, after the XML DOM changed the list.
         if (newListSize)
-            wrappers->fill(0, newListSize);
+            wrappers->fill(nullptr, newListSize);
         else
             wrappers->clear();
     }
 
     void detachListWrappers(unsigned newListSize)
     {
         detachListWrappersAndResize(m_wrappers, newListSize);
     }
 
     void setValuesAndWrappers(PropertyType* values, ListWrapperCache* wrappers, bool shouldOwnValues)
@@ skipping 51 matching lines @@
         m_values->append(newItem);
 
         commitChange();
         return newItem;
     }
 
     PassListItemTearOff initializeValuesAndWrappers(PassListItemTearOff passNewItem, ExceptionState& exceptionState)
     {
         ASSERT(m_wrappers);
         if (!canAlterList(exceptionState))
-            return 0;
+            return nullptr;
 
         // Not specified, but FF/Opera do it this way, and it's just sane.
         if (!passNewItem) {
             exceptionState.throwTypeError("The PassListItemType provided is invalid.");
-            return 0;
+            return nullptr;
         }
 
         RefPtr<ListItemTearOff> newItem = passNewItem;
         ASSERT(m_values->size() == m_wrappers->size());
 
         // Spec: If the inserted item is already in a list, it is removed from its previous list before it is inserted into this list.
         processIncomingListItemWrapper(newItem, 0);
 
         // Spec: Clears all existing current items from the list and re-initializes the list to hold the single item specified by the parameter.
         detachListWrappers(0);
@@ skipping 23 matching lines @@
             return ListItemType();
 
         // Spec: Returns the specified item from the list. The returned item is the item itself and not a copy.
         return m_values->at(index);
     }
 
     PassListItemTearOff getItemValuesAndWrappers(AnimatedListPropertyTearOff* animatedList, unsigned index, ExceptionState& exceptionState)
     {
         ASSERT(m_wrappers);
         if (!canGetItem(index, exceptionState))
-            return 0;
+            return nullptr;
 
         // Spec: Returns the specified item from the list. The returned item is the item itself and not a copy.
         // Any changes made to the item are immediately reflected in the list.
         ASSERT(m_values->size() == m_wrappers->size());
         RefPtr<ListItemTearOff> wrapper = m_wrappers->at(index);
         if (!wrapper) {
             // Create new wrapper, which is allowed to directly modify the item in the list, w/o copying and cache the wrapper in our map.
             // It is also associated with our animated property, so it can notify the SVG Element which holds the SVGAnimated*List
             // that it has been modified (and thus can call svgAttributeChanged(associatedAttributeName)).
             wrapper = ListItemTearOff::create(animatedList, UndefinedRole, m_values->at(index));
@@ skipping 24 matching lines @@
         m_values->insert(index, newItem);
 
         commitChange();
         return newItem;
     }
 
     PassListItemTearOff insertItemBeforeValuesAndWrappers(PassListItemTearOff passNewItem, unsigned index, ExceptionState& exceptionState)
     {
         ASSERT(m_wrappers);
         if (!canAlterList(exceptionState))
-            return 0;
+            return nullptr;
 
         // Not specified, but FF/Opera do it this way, and it's just sane.
         if (!passNewItem) {
             exceptionState.throwTypeError("The PassListItemType provided is invalid.");
-            return 0;
+            return nullptr;
         }
 
         // Spec: If the index is greater than or equal to numberOfItems, then the new item is appended to the end of the list.
         if (index > m_values->size())
              index = m_values->size();
 
         RefPtr<ListItemTearOff> newItem = passNewItem;
         ASSERT(m_values->size() == m_wrappers->size());
 
         // Spec: If newItem is already in a list, it is removed from its previous list before it is inserted into this list.
@@ skipping 47 matching lines @@
         m_values->at(index) = newItem;
 
         commitChange();
         return newItem;
     }
 
     PassListItemTearOff replaceItemValuesAndWrappers(PassListItemTearOff passNewItem, unsigned index, ExceptionState& exceptionState)
     {
         ASSERT(m_wrappers);
         if (!canReplaceItem(index, exceptionState))
-            return 0;
+            return nullptr;
 
         // Not specified, but FF/Opera do it this way, and it's just sane.
         if (!passNewItem) {
             exceptionState.throwTypeError("The PassListItemType provided is invalid.");
-            return 0;
+            return nullptr;
         }
 
         ASSERT(m_values->size() == m_wrappers->size());
         RefPtr<ListItemTearOff> newItem = passNewItem;
 
         // Spec: If newItem is already in a list, it is removed from its previous list before it is inserted into this list.
         // Spec: If the item is already in this list, note that the index of the item to replace is before the removal of the item.
         if (!processIncomingListItemWrapper(newItem, &index))
             return newItem.release();
 
         if (m_values->isEmpty()) {
             ASSERT(m_wrappers->isEmpty());
             // 'passNewItem' already lived in our list, we removed it, and now we're empty, which means there's nothing to replace.
             exceptionState.throwDOMException(IndexSizeError, "The new item lived in this list, and has been removed.");
-            return 0;
+            return nullptr;
         }
 
         // Detach the existing wrapper.
         RefPtr<ListItemTearOff> oldItem = m_wrappers->at(index);
         if (oldItem)
             oldItem->detachWrapper();
 
         // Update the value and the wrapper at the desired position 'index'.
         m_values->at(index) = newItem->propertyReference();
         m_wrappers->at(index) = newItem;
@@ skipping 25 matching lines @@
         m_values->remove(index);
 
         commitChange();
         return oldItem;
     }
 
     PassListItemTearOff removeItemValuesAndWrappers(AnimatedListPropertyTearOff* animatedList, unsigned index, ExceptionState& exceptionState)
     {
         ASSERT(m_wrappers);
         if (!canRemoveItem(index, exceptionState))
-            return 0;
+            return nullptr;
 
         ASSERT(m_values->size() == m_wrappers->size());
 
         // Detach the existing wrapper.
         RefPtr<ListItemTearOff> oldItem = m_wrappers->at(index);
         if (!oldItem)
             oldItem = ListItemTearOff::create(animatedList, UndefinedRole, m_values->at(index));
 
         oldItem->detachWrapper();
         m_wrappers->remove(index);
@@ skipping 16 matching lines @@
         m_values->append(newItem);
 
         commitChange(ListModificationAppend);
         return newItem;
     }
 
     PassListItemTearOff appendItemValuesAndWrappers(PassListItemTearOff passNewItem, ExceptionState& exceptionState)
     {
         ASSERT(m_wrappers);
         if (!canAlterList(exceptionState))
-            return 0;
+            return nullptr;
 
         // Not specified, but FF/Opera do it this way, and it's just sane.
         if (!passNewItem) {
             exceptionState.throwTypeError("The PassListItemType provided is invalid.");
-            return 0;
+            return nullptr;
         }
 
         RefPtr<ListItemTearOff> newItem = passNewItem;
         ASSERT(m_values->size() == m_wrappers->size());
 
         // Spec: If newItem is already in a list, it is removed from its previous list before it is inserted into this list.
         processIncomingListItemWrapper(newItem, 0);
 
         // Append the value and wrapper at the end of the list.
         m_values->append(newItem->propertyReference());
@@ skipping 41 matching lines @@
 
     SVGPropertyRole m_role;
     bool m_ownsValues;
     PropertyType* m_values;
     ListWrapperCache* m_wrappers;
 };
 
 }
 
 #endif // SVGListProperty_h