Changeset 11727 in webkit for trunk/JavaScriptCore/kxmlcore/PassRefPtr.h

Timestamp:

Dec 22, 2005, 8:48:08 AM (19 years ago)

Author:

darin

Message:

Reviewed by Maciej.

• fix ​http://bugzilla.opendarwin.org/show_bug.cgi?id=6191 RefPtr/PassRefPtr have a leak issue, operator== issues

• kxmlcore/PassRefPtr.h: (KXMLCore::PassRefPtr::PassRefPtr): Remove non-template constructor that takes RefPtr since the constructor template that takes RefPtr should be sufficient. Add a constructor template that takes PassRefPtr&. (KXMLCore::PassRefPtr::adopt): Use PassRefPtr_Ref to avoid setting pointer first to 0 and then to the pointer. (KXMLCore::PassRefPtr::operator=): Added template versions that take PassRefPtr& and RefPtr parameters. (KXMLCore::PassRefPtr::operator PassRefPtr<U>): Changed to fix leak -- old version would release and then ref. (KXMLCore::operator==): Make templates have two parameters so you can mix types. Also remove unneeded const in raw pointer versions. (KXMLCore::operator!=): Ditto.

• kxmlcore/RefPtr.h: (KXMLCore::RefPtr::RefPtr): Add constructor template that takes PassRefPtr. (KXMLCore::RefPtr::operator=): Add assignment operator templates that take RefPtr and PassRefPtr. (KXMLCore::operator==): Make templates have two parameters so you can mix types. Also remove unneeded const in raw pointer versions. (KXMLCore::operator!=): Ditto.

File:

• trunk/JavaScriptCore/kxmlcore/PassRefPtr.h (modified) (8 diffs)

trunk/JavaScriptCore/kxmlcore/PassRefPtr.h

@@ -44 +44 @@
         PassRefPtr() : m_ptr(0) {}
         PassRefPtr(T *ptr) : m_ptr(ptr) { if (ptr) ptr->ref(); }
-        PassRefPtr(const RefPtr<T>& o) : m_ptr(o.get()) { if (T *ptr = m_ptr) ptr->ref(); }
         PassRefPtr(PassRefPtr& o) : m_ptr(o.release()) {}
+        template <typename U> PassRefPtr(PassRefPtr<U>& o) : m_ptr(o.release()) { }
 
         ~PassRefPtr() { if (T *ptr = m_ptr) ptr->deref(); }
@@ -56 +56 @@
         T *release() { T *tmp = m_ptr; m_ptr = 0; return tmp; }
 
-        static PassRefPtr<T> adopt(T *ptr) 
-        { 
-            PassRefPtr result; 
-            result.m_ptr = ptr; 
-            return result; 
+        template <typename U> static PassRefPtr<T> adopt(U* ptr)
+        {
+            PassRefPtr result((PassRefPtr_Ref<T>(ptr)));
+            return result;
         }
         
@@ -72 +71 @@
         operator UnspecifiedBoolType() const { return m_ptr ? &PassRefPtr::get : 0; }
         
-        PassRefPtr& operator=(const RefPtr<T>&);
         PassRefPtr& operator=(T *);
         PassRefPtr& operator=(PassRefPtr&);
+        template <typename U> PassRefPtr& operator=(PassRefPtr<U>&);
+        template <typename U> PassRefPtr& operator=(const RefPtr<U>&);
 
         PassRefPtr(PassRefPtr_Ref<T> ref) : m_ptr(ref.m_ptr) { }
@@ -86 +86 @@
         }
 
-        template<typename U>
-        operator PassRefPtr_Ref<U>()
-        { 
-            return PassRefPtr_Ref<U>(release()); 
-        }
-
-        template<typename U>
-        operator PassRefPtr<U>()
-        { 
-            return PassRefPtr<U>(this->release()); 
-        }
+        template <typename U> operator PassRefPtr_Ref<U>() { return PassRefPtr_Ref<U>(release()); }
+        template <typename U> operator PassRefPtr<U>() { return PassRefPtr_Ref<U>(release()); }
         
     private:
@@ -102 +93 @@
     };
     
-    template <class T> inline PassRefPtr<T>& PassRefPtr<T>::operator=(const RefPtr<T>& o) 
+    template <typename T> template <typename U> inline PassRefPtr<T>& PassRefPtr<T>::operator=(const RefPtr<U>& o) 
     {
         T *optr = o.m_ptr;
@@ -113 +104 @@
     }
     
-    template <class T> inline PassRefPtr<T>& PassRefPtr<T>::operator=(T *optr)
+    template <typename T> inline PassRefPtr<T>& PassRefPtr<T>::operator=(T* optr)
     {
         if (optr)
@@ -123 +114 @@
     }
 
-    template <class T> inline PassRefPtr<T>& PassRefPtr<T>::operator=(PassRefPtr<T>& ref)
+    template <typename T> inline PassRefPtr<T>& PassRefPtr<T>::operator=(PassRefPtr<T>& ref)
     {
         T *optr = ref.release();
@@ -132 +123 @@
     }
     
-    template <class T> inline bool operator==(const PassRefPtr<T>& a, const PassRefPtr<T>& b) 
+    template <typename T> template <typename U> inline PassRefPtr<T>& PassRefPtr<T>::operator=(PassRefPtr<U>& ref)
+    {
+        T *optr = ref.release();
+        if (T *ptr = m_ptr)
+            ptr->deref();
+        m_ptr = optr;
+        return *this;
+    }
+    
+    template <typename T, typename U> inline bool operator==(const PassRefPtr<T>& a, const PassRefPtr<U>& b) 
     { 
         return a.get() == b.get(); 
     }
 
-    template <class T> inline bool operator==(const PassRefPtr<T>& a, const RefPtr<T>& b) 
+    template <typename T, typename U> inline bool operator==(const PassRefPtr<T>& a, const RefPtr<U>& b) 
     { 
         return a.get() == b.get(); 
     }
 
-    template <class T> inline bool operator==(const RefPtr<T>& a, const PassRefPtr<T>& b) 
+    template <typename T, typename U> inline bool operator==(const RefPtr<T>& a, const PassRefPtr<U>& b) 
     { 
         return a.get() == b.get(); 
     }
 
-    template <class T> inline bool operator==(const PassRefPtr<T>& a, const T *b) 
+    template <typename T, typename U> inline bool operator==(const PassRefPtr<T>& a, U* b) 
     { 
         return a.get() == b; 
     }
     
-    template <class T> inline bool operator==(const T *a, const PassRefPtr<T>& b) 
+    template <typename T, typename U> inline bool operator==(T* a, const PassRefPtr<U>& b) 
     {
         return a == b.get(); 
     }
     
-    template <class T> inline bool operator!=(const PassRefPtr<T>& a, const PassRefPtr<T>& b) 
+    template <typename T, typename U> inline bool operator!=(const PassRefPtr<T>& a, const PassRefPtr<U>& b) 
     { 
         return a.get() != b.get(); 
     }
 
-    template <class T> inline bool operator!=(const PassRefPtr<T>& a, const RefPtr<T>& b) 
+    template <typename T, typename U> inline bool operator!=(const PassRefPtr<T>& a, const RefPtr<U>& b) 
     { 
         return a.get() != b.get(); 
     }
 
-    template <class T> inline bool operator!=(const RefPtr<T>& a, const PassRefPtr<T>& b) 
+    template <typename T, typename U> inline bool operator!=(const RefPtr<T>& a, const PassRefPtr<U>& b) 
     { 
         return a.get() != b.get(); 
     }
 
-    template <class T> inline bool operator!=(const PassRefPtr<T>& a, const T *b)
+    template <typename T, typename U> inline bool operator!=(const PassRefPtr<T>& a, U* b)
     {
         return a.get() != b; 
     }
 
-    template <class T> inline bool operator!=(const T *a, const PassRefPtr<T>& b) 
+    template <typename T, typename U> inline bool operator!=(T* a, const PassRefPtr<U>& b) 
     { 
         return a != b.get(); 
     }
     
-    template <class T, class U> inline PassRefPtr<T> static_pointer_cast(const PassRefPtr<U>& p) 
+    template <typename T, typename U> inline PassRefPtr<T> static_pointer_cast(const PassRefPtr<U>& p) 
     { 
         return PassRefPtr<T>::adopt(static_cast<T *>(p.release())); 
     }
 
-    template <class T, class U> inline PassRefPtr<T> const_pointer_cast(const PassRefPtr<U>& p) 
+    template <typename T, typename U> inline PassRefPtr<T> const_pointer_cast(const PassRefPtr<U>& p) 
     { 
         return PassRefPtr<T>::adopt(const_cast<T *>(p.release()));