Changeset 11727 in webkit for trunk/JavaScriptCore/kxmlcore/RefPtr.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/RefPtr.h (modified) (5 diffs)

trunk/JavaScriptCore/kxmlcore/RefPtr.h

@@ -26 +26 @@
 namespace KXMLCore {
 
-    template <class T> class PassRefPtr;
-    template <class T> class PassRefPtr_Ref;
+    template <typename T> class PassRefPtr;
+    template <typename T> class PassRefPtr_Ref;
 
-    template <class T> class RefPtr
+    template <typename T> class RefPtr
     {
     public:
@@ -35 +35 @@
         RefPtr(T *ptr) : m_ptr(ptr) { if (ptr) ptr->ref(); }
         RefPtr(const RefPtr& o) : m_ptr(o.m_ptr) { if (T *ptr = m_ptr) ptr->ref(); }
+        template <typename U> RefPtr(PassRefPtr<U>&);
+        template <typename U> RefPtr(PassRefPtr_Ref<U>);
 
         ~RefPtr() { if (T *ptr = m_ptr) ptr->deref(); }
         
-        template <class U> RefPtr(const RefPtr<U>& o) : m_ptr(o.get()) { if (T *ptr = m_ptr) ptr->ref(); }
+        template <typename U> RefPtr(const RefPtr<U>& o) : m_ptr(o.get()) { if (T *ptr = m_ptr) ptr->ref(); }
         
         T *get() const { return m_ptr; }
@@ -55 +57 @@
         RefPtr& operator=(PassRefPtr<T>&);
         RefPtr& operator=(PassRefPtr_Ref<T>);
+        template <typename U> RefPtr& operator=(const RefPtr<U>&);
+        template <typename U> RefPtr& operator=(PassRefPtr<U>&);
+        template <typename U> RefPtr& operator=(PassRefPtr_Ref<U>);
 
     private:
@@ -60 +65 @@
     };
     
-    template <class T> RefPtr<T>& RefPtr<T>::operator=(const RefPtr<T>& o) 
+    template <typename T> template <typename U> inline RefPtr<T>::RefPtr(PassRefPtr_Ref<U> ref)
+        : m_ptr(ref.m_ptr)
+    {
+    }
+    
+    template <typename T> template <typename U> inline RefPtr<T>::RefPtr(PassRefPtr<U>& o)
+        : m_ptr(o.release())
+    {
+    }
+
+    template <typename T> RefPtr<T>& RefPtr<T>::operator=(const RefPtr<T>& o)
     {
         T *optr = o.m_ptr;
         if (optr)
             optr->ref();
-        if (T *ptr = m_ptr)
-            ptr->deref();
+        if (m_ptr)
+            m_ptr->deref();
         m_ptr = optr;
         return *this;
     }
     
-    template <class T> inline RefPtr<T>& RefPtr<T>::operator=(T *optr)
+    template <typename T> template <typename U> RefPtr<T>& RefPtr<T>::operator=(const RefPtr<U>& o)
+    {
+        T *optr = o.m_ptr;
+        if (optr)
+            optr->ref();
+        if (m_ptr)
+            m_ptr->deref();
+        m_ptr = optr;
+        return *this;
+    }
+    
+    template <typename T> inline RefPtr<T>& RefPtr<T>::operator=(T* optr)
     {
         if (optr)
             optr->ref();
-        if (T *ptr = m_ptr)
-            ptr->deref();
+        if (m_ptr)
+            m_ptr->deref();
         m_ptr = optr;
         return *this;
     }
 
-    template <class T> inline RefPtr<T>& RefPtr<T>::operator=(PassRefPtr_Ref<T> ref)
+    template <typename T> template <typename U> inline RefPtr<T>& RefPtr<T>::operator=(PassRefPtr_Ref<U> ref)
     {
         if (m_ptr)
@@ -89 +115 @@
     }
     
-    template <class T> inline RefPtr<T>& RefPtr<T>::operator=(PassRefPtr<T>& o) 
+    template <typename T> inline RefPtr<T>& RefPtr<T>::operator=(PassRefPtr<T>& o)
     {
-        if (T *ptr = m_ptr)
-            ptr->deref();
+        if (m_ptr)
+            m_ptr->deref();
         m_ptr = o.release();
         return *this;
     }
 
-    template <class T> inline bool operator==(const RefPtr<T>& a, const RefPtr<T>& b) 
+    template <typename T> inline RefPtr<T>& RefPtr<T>::operator=(PassRefPtr_Ref<T> ref)
+    {
+        if (m_ptr)
+            m_ptr->deref();
+        m_ptr = ref.m_ptr;
+        return *this;
+    }
+    
+    template <typename T> template <typename U> inline RefPtr<T>& RefPtr<T>::operator=(PassRefPtr<U>& o)
+    {
+        if (m_ptr)
+            m_ptr->deref();
+        m_ptr = o.release();
+        return *this;
+    }
+
+    template <typename T, typename U> inline bool operator==(const RefPtr<T>& a, const RefPtr<U>& b)
     { 
         return a.get() == b.get(); 
     }
 
-    template <class T> inline bool operator==(const RefPtr<T>& a, const T *b) 
+    template <typename T, typename U> inline bool operator==(const RefPtr<T>& a, U* b)
     { 
         return a.get() == b; 
     }
     
-    template <class T> inline bool operator==(const T *a, const RefPtr<T>& b) 
+    template <typename T, typename U> inline bool operator==(T* a, const RefPtr<U>& b) 
     {
         return a == b.get(); 
     }
     
-    template <class T> inline bool operator!=(const RefPtr<T>& a, const RefPtr<T>& b) 
+    template <typename T, typename U> inline bool operator!=(const RefPtr<T>& a, const RefPtr<U>& b)
     { 
         return a.get() != b.get(); 
     }
 
-    template <class T> inline bool operator!=(const RefPtr<T>& a, const T *b)
+    template <typename T, typename U> inline bool operator!=(const RefPtr<T>& a, U* b)
     {
         return a.get() != b; 
     }
 
-    template <class T> inline bool operator!=(const T *a, const RefPtr<T>& b) 
+    template <typename T, typename U> inline bool operator!=(T* a, const RefPtr<U>& b)
     { 
         return a != b.get(); 
     }
     
-    template <class T, class U> inline RefPtr<T> static_pointer_cast(const RefPtr<U>& p) 
+    template <typename T, typename U> inline RefPtr<T> static_pointer_cast(const RefPtr<U>& p)
     { 
         return RefPtr<T>(static_cast<T *>(p.get())); 
     }
 
-    template <class T, class U> inline RefPtr<T> const_pointer_cast(const RefPtr<U>& p) 
+    template <typename T, typename U> inline RefPtr<T> const_pointer_cast(const RefPtr<U>& p)
     { 
         return RefPtr<T>(const_cast<T *>(p.get()));