Use nullptr_t for RefPtr, PassRefPtr and RawPtr.

Source/heap/HeapTest.cpp

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 780 matching lines @@
 
     void trace(Visitor* visitor)
     {
 #if ENABLE_OILPAN
         visitor->trace(m_backPointer);
 #endif
     }
 
     static int s_aliveCount;
 private:
-    PointsBack() : m_backPointer(0)
+    PointsBack() : m_backPointer(nullptr)
     {
         ++s_aliveCount;
     }
 
     RawPtrWillBeWeakMember<SuperClass> m_backPointer;
 };
 
 int PointsBack::s_aliveCount = 0;
 
 class SuperClass : public RefCountedWillBeGarbageCollectedFinalized<SuperClass> {
@@ skipping 999 matching lines @@
         weakSet->add(IntWrapper::create(0));
         weakSet->add(two);
         weakSet->add(keepNumbersAlive[0]);
         weakSet->add(keepNumbersAlive[1]);
         EXPECT_EQ(1u, weakStrong->size());
         EXPECT_EQ(1u, strongWeak->size());
         EXPECT_EQ(2u, weakWeak->size());
         EXPECT_EQ(4u, weakSet->size());
     }
 
-    keepNumbersAlive[0] = 0;
+    keepNumbersAlive[0] = nullptr;
 
     Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
 
     EXPECT_EQ(0u, weakStrong->size());
     EXPECT_EQ(0u, strongWeak->size());
     EXPECT_EQ(0u, weakWeak->size());
     EXPECT_EQ(2u, weakSet->size());
 }
 
 TEST(HeapTest, HeapWeakCollectionTypes)
@@ skipping 63 matching lines @@
             for (int i = 0; i < 128; i += 2) {
                 IntWrapper* wrapped = keepNumbersAlive[i];
                 IntWrapper* wrapped2 = keepNumbersAlive[i + 1];
                 EXPECT_EQ(wrapped2, weakStrong->get(wrapped));
                 EXPECT_EQ(wrapped, strongWeak->get(wrapped2));
                 EXPECT_EQ(wrapped2, weakWeak->get(wrapped));
                 EXPECT_TRUE(weakSet->contains(wrapped));
             }
 
             for (int i = 0; i < 128; i += 3)
-                keepNumbersAlive[i] = 0;
+                keepNumbersAlive[i] = nullptr;
 
             if (collectionNumber != weakStrongIndex)
                 weakStrong->clear();
             if (collectionNumber != strongWeakIndex)
                 strongWeak->clear();
             if (collectionNumber != weakWeakIndex)
                 weakWeak->clear();
             if (collectionNumber != weakSetIndex)
                 weakSet->clear();
 
@@ skipping 70 matching lines @@
                 WeakStrong::iterator it1 = weakStrong->begin();
                 StrongWeak::iterator it2 = strongWeak->begin();
                 WeakWeak::iterator it3 = weakWeak->begin();
                 WeakSet::iterator it4 = weakSet->begin();
                 MapIteratorCheck(it1, weakStrong->end(), (collectionNumber == weakStrongIndex ? count : 0) + added);
                 MapIteratorCheck(it2, strongWeak->end(), (collectionNumber == strongWeakIndex ? count : 0) + added);
                 MapIteratorCheck(it3, weakWeak->end(), (collectionNumber == weakWeakIndex ? count : 0) + added);
                 SetIteratorCheck(it4, weakSet->end(), (collectionNumber == weakSetIndex ? count : 0) + added);
             }
             for (unsigned i = 0; i < 128 + added; i++)
-                keepNumbersAlive[i] = 0;
+                keepNumbersAlive[i] = nullptr;
             Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
             EXPECT_EQ(added, weakStrong->size());
             EXPECT_EQ(added, strongWeak->size());
             EXPECT_EQ(added, weakWeak->size());
             EXPECT_EQ(added, weakSet->size());
         }
     }
 }
 
 TEST(HeapTest, RefCountedGarbageCollected)
@@ skipping 193 matching lines @@
 }
 
 TEST(HeapTest, VisitOffHeapCollections)
 {
     HeapStats initialHeapStats;
     clearOutOldGarbage(&initialHeapStats);
     IntWrapper::s_destructorCalls = 0;
     Persistent<OffHeapContainer> container = OffHeapContainer::create();
     Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
     EXPECT_EQ(0, IntWrapper::s_destructorCalls);
-    container = 0;
+    container = nullptr;
     Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
     EXPECT_EQ(7, IntWrapper::s_destructorCalls);
 }
 
 TEST(HeapTest, PersistentHeapCollectionTypes)
 {
     HeapStats initialHeapSize;
     IntWrapper::s_destructorCalls = 0;
 
     typedef HeapVector<Member<IntWrapper> > Vec;
@@ skipping 83 matching lines @@
 DEFINE_GC_INFO(RefCountedAndGarbageCollected2);
 DEFINE_GC_INFO(SimpleFinalizedObject);
 DEFINE_GC_INFO(SimpleObject);
 DEFINE_GC_INFO(SuperClass);
 DEFINE_GC_INFO(SubData);
 DEFINE_GC_INFO(TestTypedHeapClass);
 DEFINE_GC_INFO(TraceCounter);
 DEFINE_GC_INFO(TransitionRefCounted);
 
 } // namespace