Enable WTF::HashSet<OwnPtr<> >

Source/wtf/OwnPtr.h

 /*
  *  Copyright (C) 2006, 2007, 2008, 2009, 2010 Apple Inc. All rights reserved.
  *  Copyright (C) 2013 Intel Corporation. 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
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  *  Library General Public License for more details.
  *
  *  You should have received a copy of the GNU Library General Public License
  *  along with this library; see the file COPYING.LIB.  If not, write to
  *  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  *  Boston, MA 02110-1301, USA.
  *
  */
 
 #ifndef WTF_OwnPtr_h
 #define WTF_OwnPtr_h
 
+#include "wtf/HashTableDeletedValueType.h"
 #include "wtf/Noncopyable.h"
 #include "wtf/NullPtr.h"
 #include "wtf/OwnPtrCommon.h"
 #include <algorithm>
 
 namespace WTF {
 
     template<typename T> class PassOwnPtr;
 
     template<typename T> class OwnPtr {
 #if COMPILER_SUPPORTS(CXX_RVALUE_REFERENCES)
         // If rvalue references are not supported, the copy constructor is
         // public so OwnPtr cannot be marked noncopyable. See note below.
         WTF_MAKE_NONCOPYABLE(OwnPtr);
 #endif
         WTF_DISALLOW_CONSTRUCTION_FROM_ZERO(OwnPtr);
     public:
         typedef typename RemoveExtent<T>::Type ValueType;
         typedef ValueType* PtrType;
 
         OwnPtr() : m_ptr(0) { }
         OwnPtr(std::nullptr_t) : m_ptr(0) { }
 
         // See comment in PassOwnPtr.h for why this takes a const reference.
         OwnPtr(const PassOwnPtr<T>&);
         template<typename U> OwnPtr(const PassOwnPtr<U>&, EnsurePtrConvertibleArgDecl(U, T));
 
+        // Hash table deleted values, which are only constructed and never copied or destroyed.
+        OwnPtr(HashTableDeletedValueType) : m_ptr(hashTableDeletedValue()) { }
+        bool isHashTableDeletedValue() const { return m_ptr == hashTableDeletedValue(); }
+
 #if !COMPILER_SUPPORTS(CXX_RVALUE_REFERENCES)
         // This copy constructor is used implicitly by gcc when it generates
         // transients for assigning a PassOwnPtr<T> object to a stack-allocated
         // OwnPtr<T> object. It should never be called explicitly and gcc
         // should optimize away the constructor when generating code.
         OwnPtr(const OwnPtr&);
 #endif
 
         ~OwnPtr()
         {
@@ skipping 25 matching lines @@
 #if COMPILER_SUPPORTS(CXX_RVALUE_REFERENCES)
         OwnPtr(OwnPtr&&);
         template<typename U> OwnPtr(OwnPtr<U>&&);
 
         OwnPtr& operator=(OwnPtr&&);
         template<typename U> OwnPtr& operator=(OwnPtr<U>&&);
 #endif
 
         void swap(OwnPtr& o) { std::swap(m_ptr, o.m_ptr); }
 
+        static T* hashTableDeletedValue() { return reinterpret_cast<T*>(-1); }
+
     private:
 #if !COMPILER_SUPPORTS(CXX_RVALUE_REFERENCES)
         // If rvalue references are supported, noncopyable takes care of this.
         OwnPtr& operator=(const OwnPtr&);
 #endif
 
         // We should never have two OwnPtrs for the same underlying object (otherwise we'll get
         // double-destruction), so these equality operators should never be needed.
         template<typename U> bool operator==(const OwnPtr<U>&) const { COMPILE_ASSERT(!sizeof(U*), OwnPtrs_should_never_be_equal); return false; }
         template<typename U> bool operator!=(const OwnPtr<U>&) const { COMPILE_ASSERT(!sizeof(U*), OwnPtrs_should_never_be_equal); return false; }
@@ skipping 124 matching lines @@
     template<typename T> inline typename OwnPtr<T>::PtrType getPtr(const OwnPtr<T>& p)
     {
         return p.get();
     }
 
 } // namespace WTF
 
 using WTF::OwnPtr;
 
 #endif // WTF_OwnPtr_h