Use nullptr_t for RefPtr, PassRefPtr and RawPtr.

Source/wtf/RefPtr.h

 /*
  *  Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2013 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,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ skipping 15 matching lines @@
 #include <algorithm>
 #include "wtf/HashTableDeletedValueType.h"
 #include "wtf/PassRefPtr.h"
 #include "wtf/RawPtr.h"
 
 namespace WTF {
 
     template<typename T> class PassRefPtr;
 
     template<typename T> class RefPtr {
+        WTF_DISALLOW_CONSTRUCTION_FROM_ZERO(RefPtr);
+        WTF_DISALLOW_ZERO_ASSIGNMENT(RefPtr);
     public:
         ALWAYS_INLINE RefPtr() : m_ptr(0) { }
+        ALWAYS_INLINE RefPtr(std::nullptr_t) : m_ptr(0) { }
         ALWAYS_INLINE RefPtr(T* ptr) : m_ptr(ptr) { refIfNotNull(ptr); }
         template<typename U> RefPtr(const RawPtr<U>& ptr, EnsurePtrConvertibleArgDecl(U, T)) : m_ptr(ptr.get()) { refIfNotNull(m_ptr); }
         ALWAYS_INLINE explicit RefPtr(T& ref) : m_ptr(&ref) { m_ptr->ref(); }
         ALWAYS_INLINE RefPtr(const RefPtr& o) : m_ptr(o.m_ptr) { refIfNotNull(m_ptr); }
         template<typename U> RefPtr(const RefPtr<U>& o, EnsurePtrConvertibleArgDecl(U, T)) : m_ptr(o.get()) { refIfNotNull(m_ptr); }
 
         // See comments in PassRefPtr.h for an explanation of why this takes a const reference.
         template<typename U> RefPtr(const PassRefPtr<U>&, EnsurePtrConvertibleArgDecl(U, T));
 
         // Hash table deleted values, which are only constructed and never copied or destroyed.
@@ skipping 12 matching lines @@
 
         bool operator!() const { return !m_ptr; }
 
         // This conversion operator allows implicit conversion to bool but not to other integer types.
         typedef T* (RefPtr::*UnspecifiedBoolType);
         operator UnspecifiedBoolType() const { return m_ptr ? &RefPtr::m_ptr : 0; }
 
         RefPtr& operator=(const RefPtr&);
         RefPtr& operator=(T*);
         RefPtr& operator=(const PassRefPtr<T>&);
-#if !COMPILER_SUPPORTS(CXX_NULLPTR)
         RefPtr& operator=(std::nullptr_t) { clear(); return *this; }
-#endif
+
         template<typename U> RefPtr<T>& operator=(const RefPtr<U>&);
         template<typename U> RefPtr<T>& operator=(const PassRefPtr<U>&);
         template<typename U> RefPtr<T>& operator=(const RawPtr<U>&);
 
         void swap(RefPtr&);
 
         static T* hashTableDeletedValue() { return reinterpret_cast<T*>(-1); }
 
     private:
         T* m_ptr;
@@ skipping 102 matching lines @@
     {
         return p.get();
     }
 
 } // namespace WTF
 
 using WTF::RefPtr;
 using WTF::static_pointer_cast;
 
 #endif // WTF_RefPtr_h