Make WebPrivatePtr capable of wrapping garbage collected objects.

public/platform/WebPrivatePtr.h

 /*
  * Copyright (C) 2010 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 16 matching lines @@
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef WebPrivatePtr_h
 #define WebPrivatePtr_h
 
 #include "WebCommon.h"
 
 #if INSIDE_BLINK
+#include "heap/Handle.h"
 #include "wtf/PassRefPtr.h"
 #endif
 
 namespace blink {
 
+#if INSIDE_BLINK
+template<typename T, bool IsGarbageCollected>
+class PtrStorageImpl;
+
+template<typename T>
+class PtrStorageImpl<T, false> {
+public:
+    typedef PassRefPtr<T> BlinkPtrType;
+
+    void assign(const BlinkPtrType& val)
+    {
+        release();
+        m_ptr = val.leakRef();
+    }
+
+    void assign(const PtrStorageImpl& other)
+    {
+        release();
+        T* val = other.get();
+        if (val)
+            val->ref();
+        m_ptr = val;
+    }
+
+    T* get() const { return m_ptr; }
+
+    void release()
+    {
+        if (m_ptr)
+            m_ptr->deref();
+        m_ptr = 0;
+    }
+
+private:
+    T* m_ptr;
+};
+
+template<typename T>
+class PtrStorageImpl<T, true> {
+    typedef WebCore::Persistent<T> HandleType;
+public:
+    typedef RawPtr<T> BlinkPtrType;
+
+    void assign(const BlinkPtrType& val)
+    {
+        if (!val) {
+            release();
+            return;
+        }
+
+        if (!m_handle)
+            m_handle = new HandleType();
+
+        (*m_handle) = val;
+    }
+
+    void assign(const PtrStorageImpl& other) { assign(other.get()); }
+
+    T* get() const { return m_handle ? m_handle->get() : 0; }
+
+    void release()
+    {
+        delete m_handle;
+        m_handle = 0;
+    }
+
+private:
+    HandleType* m_handle;
+};
+
+template<typename T>
+class PtrStorage : public PtrStorageImpl<T, WTF::IsSubclassOfTemplate<T, WebCore::GarbageCollected>::value> {
+public:
+    static PtrStorage& fromSlot(void** slot)
+    {
+        COMPILE_ASSERT(sizeof(PtrStorage) == sizeof(void*), PtrStorage_must_be_pointer_size);
+        return *reinterpret_cast<PtrStorage*>(slot);
+    }
+
+    static const PtrStorage& fromSlot(void* const* slot)
+    {
+        COMPILE_ASSERT(sizeof(PtrStorage) == sizeof(void*), PtrStorage_must_be_pointer_size);
+        return *reinterpret_cast<const PtrStorage*>(slot);
+    }
+
+private:
+    PtrStorage();
+    PtrStorage(const PtrStorage&);
+};
+#endif
+
 // This class is an implementation detail of the Blink API. It exists to help
 // simplify the implementation of Blink interfaces that merely wrap a reference
 // counted WebCore class.
 //
 // A typical implementation of a class which uses WebPrivatePtr might look like
 // this:
 //    class WebFoo {
 //    public:
 //        BLINK_EXPORT ~WebFoo();
 //        WebFoo() { }
@@ skipping 19 matching lines @@
 //        WebPrivatePtr<WebCore::Foo> m_private;
 //    };
 //
 //    // WebFoo.cpp
 //    WebFoo::~WebFoo() { m_private.reset(); }
 //    void WebFoo::assign(const WebFoo& other) { ... }
 //
 template <typename T>
 class WebPrivatePtr {
 public:
-    WebPrivatePtr() : m_ptr(0) { }
+    WebPrivatePtr() : m_storage(0) { }
     ~WebPrivatePtr()
     {
         // We don't destruct the object pointed by m_ptr here because we don't
         // want to expose destructors of core classes to embedders. We should
         // call reset() manually in destructors of classes with WebPrivatePtr
         // members.
-        BLINK_ASSERT(!m_ptr);
+        BLINK_ASSERT(!m_storage);
     }
 
-    bool isNull() const { return !m_ptr; }
+    bool isNull() const { return !m_storage; }
 
 #if INSIDE_BLINK
-    WebPrivatePtr(const PassRefPtr<T>& prp)
-        : m_ptr(prp.leakRef())
+    template<typename U>
+    WebPrivatePtr(const U& ptr) // Can't use PtrStorage<T>::BlinkPtrType because it will cause early instantiation.
+        : m_storage(0)
     {
+        storage().assign(ptr);
     }
 
-    void reset()
-    {
-        assign(0);
-    }
+    void reset() { storage().release(); }
 
     WebPrivatePtr<T>& operator=(const WebPrivatePtr<T>& other)
     {
-        T* p = other.m_ptr;
-        if (p)
-            p->ref();
-        assign(p);
+        storage().assign(other.storage());
         return *this;
     }
 
-    WebPrivatePtr<T>& operator=(const PassRefPtr<T>& prp)
+    template<typename U>
+    WebPrivatePtr<T>& operator=(const U& ptr) // Can't use PtrStorage<T>::BlinkPtrType because it will cause early instantiation.
     {
-        assign(prp.leakRef());
+        storage().assign(ptr);
         return *this;
     }
 
-    T* get() const
-    {
-        return m_ptr;
-    }
+    T* get() const { return storage().get(); }
 
     T* operator->() const
     {
-        ASSERT(m_ptr);
-        return m_ptr;
+        ASSERT(m_storage);
+        return get();
     }
 #endif
 
 private:
 #if INSIDE_BLINK
-    void assign(T* p)
-    {
-        // p is already ref'd for us by the caller
-        if (m_ptr)
-            m_ptr->deref();
-        m_ptr = p;
-    }
-#else
+    PtrStorage<T>& storage() { return PtrStorage<T>::fromSlot(&m_storage); }
+    const PtrStorage<T>& storage() const { return PtrStorage<T>::fromSlot(&m_storage); }
+#endif
+
+#if !INSIDE_BLINK
     // Disable the assignment operator; we define it above for when
     // INSIDE_BLINK is set, but we need to make sure that it is not
     // used outside there; the compiler-provided version won't handle reference
     // counting properly.
     WebPrivatePtr<T>& operator=(const WebPrivatePtr<T>& other);
 #endif
     // Disable the copy constructor; classes that contain a WebPrivatePtr
     // should implement their copy constructor using assign().
     WebPrivatePtr(const WebPrivatePtr<T>&);
 
-    T* m_ptr;
+    void* m_storage;
 };
 
 } // namespace blink
 
 #endif