Make WebPrivatePtr capable of wrapping garbage collected objects.

public/platform/WebPrivateGarbageCollectedPtr.h

+/* Copyright (c) 2014 The Chromium Authors. All rihts reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef WebPrivateGarbageCollectedPtr_h
+#define WebPrivateGarbageCollectedPtr_h
+
+#include "WebCommon.h"
+
+#if INSIDE_BLINK
+#include "wtf/PassRefPtr.h"
+
+namespace WebCore {
+template<typename T> class Persistent;
+}
+
+namespace WTF {
+template<typename T> class RawPtr;
+}
+
+# if ENABLE(OILPAN)
+# define PassRefPtrWillBeRawPtr RawPtr
+# else
+# define PassRefPtrWillBeRawPtr PassRefPtr
+# endif
+#endif
+
+namespace blink {
+
+// A variant of WebPrivatePtr that holds a Blink object that's garbage
+// collected, without exposing the details of how (and with what
+// types.) If no support for having such objects (i.e., no Oilpan),
+// WebPrivateGarbageCollectedPtr is equal to WebPrivatePtr and the
+// object will be reference counted.
+//
+// See WebPrivatePtr.h comment for how to make use of
+// WebPrivateGarbageCollectedPtr; same pattern applies, but for one
+// detail. Instead of declaring & defining,
+//
+//    #if INSIDE_BLINK
+//        WebFoo(const WTF::PassRefPtr<WebCore::Foo>&);
+//    #endif
+//
+// provide
+//
+//    #if INSIDE_BLINK
+//        WebFoo(const WTF::PassRefPtrWillBeRawPtr<WebCore::Foo>&);
+//    #endif
+//
+// FIXME: oilpan: when transition types are no more, remove the
+// unseemly #if ENABLE(OILPAN) blocks.
+template <typename T>
+class WebPrivateGarbageCollectedPtr {
+public:
+    WebPrivateGarbageCollectedPtr() : m_ptr(0) { }
+    ~WebPrivateGarbageCollectedPtr()
+    {
+        // 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 WebPrivateGarbageCollectedPtr
+        // members.
+        BLINK_ASSERT(!m_ptr);
+    }
+
+    bool isNull() const { return !m_ptr; }
+
+#if INSIDE_BLINK
+    WebPrivateGarbageCollectedPtr(const WTF::PassRefPtrWillBeRawPtr<T>& p)
+    {
+# if ENABLE(OILPAN)
+        assign(p);
+# else
+        m_ptr = p.leakRef();
+# endif
+    }
+
+    void reset()
+    {
+# if ENABLE(OILPAN)
+        if (m_ptr) {
+            delete reinterpret_cast<WebCore::Persistent<T>*>(m_ptr);
+            m_ptr = 0;
+        }
+# else
+        assign(0);
+# endif
+    }
+
+    WebPrivateGarbageCollectedPtr<T>& operator=(const WebPrivateGarbageCollectedPtr<T>& other)
+    {
+# if ENABLE(OILPAN)
+        assign(other.get());
+# else
+        T* p = other.m_ptr;
+        if (p)
+            p->ref();
+        assign(p);
+# endif
+        return *this;
+    }
+
+    WebPrivateGarbageCollectedPtr<T>& operator=(WebPrivateGarbageCollectedPtr<T>& other)
+    {
+        assign(other.get());
+        return *this;
+    }
+
+    WebPrivateGarbageCollectedPtr<T>& operator=(const WTF::PassRefPtrWillBeRawPtr<T>& p)
+    {
+# if ENABLE(OILPAN)
+        assign(p);
+# else
+        assign(p.leakRef());
+# endif
+        return *this;
+    }
+
+    T* get() const
+    {
+# if ENABLE(OILPAN)
+        if (!m_ptr)
+            return 0;
+        return (reinterpret_cast<WebCore::Persistent<T>* >(m_ptr))->get();
+# else
+        return m_ptr;
+# endif
+    }
+
+    T* operator->() const
+    {
+        ASSERT(m_ptr);
+# if ENABLE(OILPAN)
+        return (reinterpret_cast<WebCore::Persistent<T>* >(m_ptr))->get();
+# else
+        return m_ptr;
+# endif
+    }
+#endif
+
+private:
+#if INSIDE_BLINK
+    void assign(T* p)
+    {
+# if ENABLE(OILPAN)
+        reset();
+        // Keep an opaque pointer object pointer to avoid exposing
+        // representation details. (Relatively speaking, it's
+        // acceptable to have this be as a T* rather than a
+        // generic void*.
+        m_ptr = reinterpret_cast<T*>(new WebCore::Persistent<T>(p));
+# else
+        // p is already ref'd for us by the caller
+        if (m_ptr)
+            m_ptr->deref();
+        m_ptr = p;
+# endif
+    }
+#else
+    // 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.
+    WebPrivateGarbageCollectedPtr<T>& operator=(const WebPrivateGarbageCollectedPtr<T>& other);
+#endif
+    // Disable the copy constructor; classes that contain a
+    // WebPrivateGarbageCollectedPtr should implement their copy
+    // constructor using assign().
+    WebPrivateGarbageCollectedPtr(const WebPrivateGarbageCollectedPtr<T>&);
+
+    T* m_ptr;

[zerny-chromium, 2014/02/17 11:45:08]

Could we simplify this code by changing T* to RawPtrWillBePersistent<T> ?

That would give use the same interface for accessing T and use the existing
infrastructure for selecting the interpretation.

[sof, 2014/02/17 11:55:34]

We cannot expose Persistent (or RawPtr) on this object. I think.

+};
+
+} // namespace blink
+
+#endif