Type check when upcasting PassOwnPtr/PassOwnArrayPtr to avoid possible function call ambiguousness

Source/wtf/PassRefPtr.h

 /*
  *  Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010 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
  *  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_PassRefPtr_h
 #define WTF_PassRefPtr_h
 
 #include "wtf/Assertions.h"
 #include "wtf/NullPtr.h"
 #include "wtf/TypeTraits.h"
 
+#define EnsureRefPtrConvertibleArgDefn \

[Nico, 2013/08/29 19:58:47]

This is identical to EnsureOwnArrayPtrConvertibleArgDefn, right? Maybe some
define like this should be in TypeTraits instead?

+    typename EnableIf<IsPointerConvertible<U, T>::Value, bool>::Type
+#define EnsureRefPtrConvertibleArgDecl \
+    EnsureRefPtrConvertibleArgDefn = true
+
 namespace WTF {
 
     template<typename T> class RefPtr;
     template<typename T> class PassRefPtr;
     template<typename T> PassRefPtr<T> adoptRef(T*);
 
     inline void adopted(const void*) { }
 
     template<typename T> ALWAYS_INLINE void refIfNotNull(T* ptr)
     {
         if (LIKELY(ptr != 0))
             ptr->ref();
     }
 
     template<typename T> ALWAYS_INLINE void derefIfNotNull(T* ptr)
     {
         if (LIKELY(ptr != 0))
             ptr->deref();
     }
 
     template<typename T> class PassRefPtr {
     public:
         PassRefPtr() : m_ptr(0) { }
         PassRefPtr(T* ptr) : m_ptr(ptr) { refIfNotNull(ptr); }
         // It somewhat breaks the type system to allow transfer of ownership out of
         // a const PassRefPtr. However, it makes it much easier to work with PassRefPtr
         // temporaries, and we don't have a need to use real const PassRefPtrs anyway.
         PassRefPtr(const PassRefPtr& o) : m_ptr(o.leakRef()) { }
-        template<typename U> PassRefPtr(const PassRefPtr<U>& o, EnsurePtrConvertibleArgDecl(U, T)) : m_ptr(o.leakRef()) { }
+        template<typename U> PassRefPtr(const PassRefPtr<U>& o, EnsureRefPtrConvertibleArgDecl) : m_ptr(o.leakRef()) { }
 
         ALWAYS_INLINE ~PassRefPtr() { derefIfNotNull(m_ptr); }
 
-        template<typename U> PassRefPtr(const RefPtr<U>&, EnsurePtrConvertibleArgDecl(U, T));
+        template<typename U> PassRefPtr(const RefPtr<U>&, EnsureRefPtrConvertibleArgDecl);
 
         T* get() const { return m_ptr; }
 
         T* leakRef() const WARN_UNUSED_RETURN;
 
         T& operator*() const { return *m_ptr; }
         T* operator->() const { return m_ptr; }
 
         bool operator!() const { return !m_ptr; }
 
         // This conversion operator allows implicit conversion to bool but not to other integer types.
         typedef T* (PassRefPtr::*UnspecifiedBoolType);
         operator UnspecifiedBoolType() const { return m_ptr ? &PassRefPtr::m_ptr : 0; }
 
         PassRefPtr& operator=(const PassRefPtr&) { COMPILE_ASSERT(!sizeof(T*), PassRefPtr_should_never_be_assigned_to); return *this; }
 
         friend PassRefPtr adoptRef<T>(T*);
 
     private:
         // adopting constructor
         PassRefPtr(T* ptr, bool) : m_ptr(ptr) { }
 
         mutable T* m_ptr;
     };
 
-    template<typename T> template<typename U> inline PassRefPtr<T>::PassRefPtr(const RefPtr<U>& o, EnsurePtrConvertibleArgDefn(U, T))
+    template<typename T> template<typename U> inline PassRefPtr<T>::PassRefPtr(const RefPtr<U>& o, EnsureRefPtrConvertibleArgDefn)
         : m_ptr(o.get())
     {
         T* ptr = m_ptr;
         refIfNotNull(ptr);
     }
 
     template<typename T> inline T* PassRefPtr<T>::leakRef() const
     {
         T* ptr = m_ptr;
         m_ptr = 0;
@@ skipping 72 matching lines @@
     }
 
 } // namespace WTF
 
 using WTF::PassRefPtr;
 using WTF::adoptRef;
 using WTF::static_pointer_cast;
 using WTF::const_pointer_cast;
 
 #endif // WTF_PassRefPtr_h