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 "heap/Handle.h"
+#include "wtf/PassRefPtr.h"
+
+// FIXME: oilpan: If the WebCore-qualified PassRefPtrWillBeRawPtr

[sof, 2014/02/17 15:19:10]

Addressing some clang compilation breakage..referring to transition types from
outside of the WebCore namespace is a bit of a pain, as the names may refer to
(#defined) names that live in WTF. How about having such a "namespace
translation" block in Handle.h instead (next to the transition type #defines)?

(See also https://codereview.chromium.org/164713002/ , where this issue also
surfaced.)

[Mads Ager (chromium), 2014/02/17 15:23:35]

How about having the define expand to a fully qualified type with the namespace
always. I think that should remove the need for this at the use-site? I might be
missing something though?

[sof, 2014/02/17 15:27:40]

I don't see how that would work with template aliases; e.g., in
https://codereview.chromium.org/164713002/, RefPtrWillBeMember<> is not in the
blink namespace, so the name at the point of use will have to be qualified.

+// used below map to CPP #defines, move the type names it can expand
+// to into the WebCore namespace. When Oilpan is always enabled, this
+// block can be removed.
+namespace WebCore {
+using WTF::RawPtr;
+using WTF::PassRefPtr;
+}
+#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 WebCore::PassRefPtrWillBeRawPtr<WebCore::Foo>&);
+//    #endif
+//
+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
+#if ENABLE(OILPAN)
+    WebPrivateGarbageCollectedPtr(const WebCore::PassRefPtrWillBeRawPtr<T>& p)
+    {
+        assign(p);
+    }
+
+    void reset()
+    {
+        if (m_ptr) {
+            delete reinterpret_cast<WebCore::Persistent<T>*>(m_ptr);
+            m_ptr = 0;
+        }
+    }
+
+    WebPrivateGarbageCollectedPtr<T>& operator=(const WebPrivateGarbageCollectedPtr<T>& other)
+    {
+        assign(other.get());
+        return *this;
+    }
+
+    WebPrivateGarbageCollectedPtr<T>& operator=(const WebCore::PassRefPtrWillBeRawPtr<T>& p)
+    {
+        assign(p);
+        return *this;
+    }
+
+    T* get() const
+    {
+        if (!m_ptr)
+            return 0;
+        return (reinterpret_cast<WebCore::Persistent<T>* >(m_ptr))->get();
+    }
+
+    T* operator->() const
+    {
+        ASSERT(m_ptr);
+        return (reinterpret_cast<WebCore::Persistent<T>* >(m_ptr))->get();
+    }
+#else
+    WebPrivateGarbageCollectedPtr(const WebCore::PassRefPtrWillBeRawPtr<T>& p)
+    {
+        m_ptr = p.leakRef();
+    }
+
+    void reset()
+    {
+        assign(0);
+    }
+
+    WebPrivateGarbageCollectedPtr<T>& operator=(const WebPrivateGarbageCollectedPtr<T>& other)
+    {
+        T* p = other.m_ptr;
+        if (p)
+            p->ref();
+        assign(p);
+        return *this;
+    }
+
+    WebPrivateGarbageCollectedPtr<T>& operator=(const WebCore::PassRefPtrWillBeRawPtr<T>& p)
+    {
+        assign(p.leakRef());
+        return *this;
+    }
+
+    T* get() const
+    {
+        return m_ptr;
+    }
+
+    T* operator->() const
+    {
+        ASSERT(m_ptr);
+        return m_ptr;
+    }
+#endif
+#endif
+
+private:
+#if INSIDE_BLINK
+#if ENABLE(OILPAN)
+    void assign(T* p)
+    {
+        if (!p) {
+            reset();
+            return;
+        }
+        // Keep an opaque pointer object pointer to avoid exposing
+        // representation details.
+        if (!m_ptr)
+            m_ptr = reinterpret_cast<T*>(new WebCore::Persistent<T>(p));
+        else
+            *reinterpret_cast<WebCore::Persistent<T>*>(m_ptr) = p;
+    }
+#else
+    void assign(T* p)
+    {
+        // 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;
+};
+
+} // namespace blink
+
+#endif