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

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 20 matching lines @@
 namespace WTF {
 
     template<typename T> class PassRefPtr;
 
     template<typename T> class RefPtr {
         WTF_MAKE_FAST_ALLOCATED;
     public:
         ALWAYS_INLINE RefPtr() : m_ptr(0) { }
         ALWAYS_INLINE RefPtr(T* ptr) : m_ptr(ptr) { refIfNotNull(ptr); }
         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); }
+        template<typename U> RefPtr(const RefPtr<U>& o, EnsureRefPtrConvertibleArgDecl) : 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));
+        template<typename U> RefPtr(const PassRefPtr<U>&, EnsureRefPtrConvertibleArgDecl);
 
         // Hash table deleted values, which are only constructed and never copied or destroyed.
         RefPtr(HashTableDeletedValueType) : m_ptr(hashTableDeletedValue()) { }
         bool isHashTableDeletedValue() const { return m_ptr == hashTableDeletedValue(); }
 
         ALWAYS_INLINE ~RefPtr() { derefIfNotNull(m_ptr); }
 
         T* get() const { return m_ptr; }
 
         void clear();
@@ skipping 18 matching lines @@
         template<typename U> EnsurePtrConvertibleType(RefPtr<T>&, U, T) operator=(const PassRefPtr<U>&);
 
         void swap(RefPtr&);
 
         static T* hashTableDeletedValue() { return reinterpret_cast<T*>(-1); }
 
     private:
         T* m_ptr;
     };
 
-    template<typename T> template<typename U> inline RefPtr<T>::RefPtr(const PassRefPtr<U>& o, EnsurePtrConvertibleArgDefn(U, T))
+    template<typename T> template<typename U> inline RefPtr<T>::RefPtr(const PassRefPtr<U>& o, EnsureRefPtrConvertibleArgDefn)
         : m_ptr(o.leakRef())
     {
     }
 
     template<typename T> inline void RefPtr<T>::clear()
     {
         T* ptr = m_ptr;
         m_ptr = 0;
         derefIfNotNull(ptr);
     }
@@ skipping 88 matching lines @@
         return p.get();
     }
 
 } // namespace WTF
 
 using WTF::RefPtr;
 using WTF::static_pointer_cast;
 using WTF::const_pointer_cast;
 
 #endif // WTF_RefPtr_h