Make WebPrivatePtr capable of wrapping garbage collected objects.

public/platform/WebPrivateGarbageCollectedPtr.h

Index: public/platform/WebPrivateGarbageCollectedPtr.h
diff --git a/public/platform/WebPrivateGarbageCollectedPtr.h b/public/platform/WebPrivateGarbageCollectedPtr.h
new file mode 100644
index 0000000000000000000000000000000000000000..29496e7c81e727524b0c2fea08a9831dcd783102
--- /dev/null
+++ b/public/platform/WebPrivateGarbageCollectedPtr.h
@@ -0,0 +1,173 @@
+/* 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"
+#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
+//
+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 WTF::PassRefPtrWillBeRawPtr<T>& p)

[Mads Ager (chromium), 2014/02/17 15:18:40]

I think we have the transition types in the WebCore namespace? Are you compiling
with GCC or with clang? I'm surprised this works but maybe that is because of
the use of #define on GCC. I don't think this will work with clang. Maybe we
need to change the defines a bit so that they use explicit namespaces so that
you don't have to write WTF:: here but can just use PassRefPtrWillBeRawPtr which
will be an alias for WTF::PassRefPtr or WTF::RawPtr depending on how we compile.

Anyway, we should verify that this compiles with both clang and gcc.

+    {
+        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 WTF::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 WTF::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 WTF::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

[Mads Ager (chromium), 2014/02/17 15:18:40]

Too many occurrences of pointer? :)

+        // 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