Use nullptr_t for RefPtr, PassRefPtr and RawPtr.

Source/heap/Handle.h

 /*
  * Copyright (C) 2014 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 191 matching lines @@
 // handles can be stored in objects and they are not scoped.
 // Persistent handles must not be used to contain pointers
 // between objects that are in the managed heap. They are only
 // meant to point to managed heap objects from variables/members
 // outside the managed heap.
 //
 // A Persistent is always a GC root from the point of view of
 // the garbage collector.
 template<typename T, typename RootsAccessor /* = ThreadLocalPersistents<ThreadingTrait<T>::Affinity > */ >
 class Persistent : public PersistentBase<RootsAccessor, Persistent<T, RootsAccessor> > {
+    WTF_DISALLOW_CONSTRUCTION_FROM_ZERO(Persistent);
+    WTF_DISALLOW_ZERO_ASSIGNMENT(Persistent);
 public:
     Persistent() : m_raw(0) { }
+    Persistent(std::nullptr_t) : m_raw(0) { }
 
     Persistent(T* raw) : m_raw(raw) { }
 
     Persistent(const Persistent& other) : m_raw(other) { }
 
     template<typename U>
     Persistent(const Persistent<U, RootsAccessor>& other) : m_raw(other) { }
 
     template<typename U>
     Persistent(const Member<U>& other) : m_raw(other) { }
 
     template<typename U>
     Persistent(const RawPtr<U>& other) : m_raw(other.get()) { }
 
     template<typename U>
     Persistent& operator=(U* other)
     {
         m_raw = other;
         return *this;
     }
+
+    Persistent& operator=(std::nullptr_t)
+    {
+        m_raw = 0;
+        return *this;
+    }
+
     void clear() { m_raw = 0; }
 
     virtual ~Persistent()
     {
         m_raw = 0;
     }
 
     template<typename U>
     U* as() const
     {
@@ skipping 79 matching lines @@
 template<typename T, size_t inlineCapacity = 0>
 class PersistentHeapVector : public PersistentHeapCollectionBase<HeapVector<T, inlineCapacity> > { };
 
 // Members are used in classes to contain strong pointers to other oilpan heap
 // allocated objects.
 // All Member fields of a class must be traced in the class' trace method.
 // During the mark phase of the GC all live objects are marked as live and
 // all Member fields of a live object will be traced marked as live as well.
 template<typename T>
 class Member {
+    WTF_DISALLOW_CONSTRUCTION_FROM_ZERO(Member);
+    WTF_DISALLOW_ZERO_ASSIGNMENT(Member);
 public:
     Member() : m_raw(0) { }
+    Member(std::nullptr_t) : m_raw(0) { }
 
     Member(T* raw) : m_raw(raw) { }
 
     Member(WTF::HashTableDeletedValueType) : m_raw(reinterpret_cast<T*>(-1)) { }
 
     bool isHashTableDeletedValue() const { return m_raw == reinterpret_cast<T*>(-1); }
 
     template<typename U>
     Member(const Persistent<U>& other) : m_raw(other) { }
 
@@ skipping 44 matching lines @@
         return *this;
     }
 
     template<typename U>
     Member& operator=(RawPtr<U> other)
     {
         m_raw = other;
         return *this;
     }
 
+    Member& operator=(std::nullptr_t)
+    {
+        m_raw = 0;
+        return *this;
+    }
+
     void swap(Member<T>& other) { std::swap(m_raw, other.m_raw); }
 
     T* get() const { return m_raw; }
 
     void clear() { m_raw = 0; }
 
 protected:
     T* m_raw;
 
     template<bool x, bool y, bool z, typename U, typename V> friend struct CollectionBackingTraceTrait;
@@ skipping 20 matching lines @@
 };
 
 // WeakMember is similar to Member in that it is used to point to other oilpan
 // heap allocated objects.
 // However instead of creating a strong pointer to the object, the WeakMember creates
 // a weak pointer, which does not keep the pointee alive. Hence if all pointers to
 // to a heap allocated object are weak the object will be garbage collected. At the
 // time of GC the weak pointers will automatically be set to null.
 template<typename T>
 class WeakMember : public Member<T> {
+    WTF_DISALLOW_CONSTRUCTION_FROM_ZERO(WeakMember);
+    WTF_DISALLOW_ZERO_ASSIGNMENT(WeakMember);
 public:
     WeakMember() : Member<T>() { }
+    WeakMember(std::nullptr_t) : Member<T>(nullptr) { }
 
     WeakMember(T* raw) : Member<T>(raw) { }
 
     WeakMember(WTF::HashTableDeletedValueType x) : Member<T>(x) { }
 
     template<typename U>
     WeakMember(const Persistent<U>& other) : Member<T>(other) { }
 
     template<typename U>
     WeakMember(const Member<U>& other) : Member<T>(other) { }
@@ skipping 19 matching lines @@
         return *this;
     }
 
     template<typename U>
     WeakMember& operator=(const RawPtr<U>& other)
     {
         this->m_raw = other;
         return *this;
     }
 
+    WeakMember& operator=(std::nullptr_t)
+    {
+        this->m_raw = 0;
+        return *this;
+    }
+
 private:
     T** cell() const { return const_cast<T**>(&this->m_raw); }
 
     friend class Visitor;
 };
 
 // Comparison operators between (Weak)Members and Persistents
 template<typename T, typename U> inline bool operator==(const Member<T>& a, const Member<U>& b) { return a.get() == b.get(); }
 template<typename T, typename U> inline bool operator!=(const Member<T>& a, const Member<U>& b) { return a.get() != b.get(); }
 template<typename T, typename U> inline bool operator==(const Member<T>& a, const Persistent<U>& b) { return a.get() == b.get(); }
@@ skipping 123 matching lines @@
     static const bool canMoveWithMemcpy = true;
 };
 
 template<typename T> struct HashTraits<WebCore::Member<T> > : SimpleClassHashTraits<WebCore::Member<T> > {
     static const bool needsDestruction = false;
     // FIXME: The distinction between PeekInType and PassInType is there for
     // the sake of the reference counting handles. When they are gone the two
     // types can be merged into PassInType.
     // FIXME: Implement proper const'ness for iterator types. Requires support
     // in the marking Visitor.
-    typedef T* PeekInType;
-    typedef T* PassInType;
+    typedef RawPtr<T> PeekInType;
+    typedef RawPtr<T> PassInType;
     typedef WebCore::Member<T>* IteratorGetType;
     typedef const WebCore::Member<T>* IteratorConstGetType;
     typedef T* IteratorReferenceType;
     typedef T* IteratorConstReferenceType;
     static IteratorConstGetType getToConstGetConversion(const WebCore::Member<T>* x) { return x->get(); }
     static IteratorReferenceType getToReferenceConversion(IteratorGetType x) { return x->get(); }
     static IteratorConstReferenceType getToReferenceConstConversion(IteratorConstGetType x) { return x->get(); }
     // FIXME: Similarly, there is no need for a distinction between PeekOutType
     // and PassOutType without reference counting.
     typedef T* PeekOutType;
     typedef T* PassOutType;
 
     template<typename U>
     static void store(const U& value, WebCore::Member<T>& storage) { storage = value; }
 
     static PeekOutType peek(const WebCore::Member<T>& value) { return value; }
     static PassOutType passOut(const WebCore::Member<T>& value) { return value; }
 };
 
 template<typename T> struct HashTraits<WebCore::WeakMember<T> > : SimpleClassHashTraits<WebCore::WeakMember<T> > {
     static const bool needsDestruction = false;
     // FIXME: The distinction between PeekInType and PassInType is there for
     // the sake of the reference counting handles. When they are gone the two
     // types can be merged into PassInType.
     // FIXME: Implement proper const'ness for iterator types. Requires support
     // in the marking Visitor.
-    typedef T* PeekInType;
-    typedef T* PassInType;
+    typedef RawPtr<T> PeekInType;
+    typedef RawPtr<T> PassInType;
     typedef WebCore::WeakMember<T>* IteratorGetType;
     typedef const WebCore::WeakMember<T>* IteratorConstGetType;
     typedef T* IteratorReferenceType;
     typedef T* IteratorConstReferenceType;
     static IteratorConstGetType getToConstGetConversion(const WebCore::WeakMember<T>* x) { return x->get(); }
     static IteratorReferenceType getToReferenceConversion(IteratorGetType x) { return x->get(); }
     static IteratorConstReferenceType getToReferenceConstConversion(IteratorConstGetType x) { return x->get(); }
     // FIXME: Similarly, there is no need for a distinction between PeekOutType
     // and PassOutType without reference counting.
     typedef T* PeekOutType;
@@ skipping 58 matching lines @@
 };
 
 template<typename T> inline T* getPtr(const WebCore::Member<T>& p)
 {
     return p.get();
 }
 
 } // namespace WTF
 
 #endif