Alternative approach to supporting ref counting and garbage collection

Source/wtf/Ptr.h

 /*
- * Copyright (C) 2009 Google Inc. All rights reserved.
+ * Copyright (C) 2014 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
  * copyright notice, this list of conditions and the following disclaimer
  * in the documentation and/or other materials provided with the
  * distribution.
  *     * Neither the name of Google Inc. nor the names of its
  * contributors may be used to endorse or promote products derived from
  * this software without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (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 WebData_h
-#define WebData_h
+#ifndef WTF_Ptr_h
+#define WTF_Ptr_h
 
-#include "WebCommon.h"
-#include "WebPrivatePtr.h"
+// Ptr is a simple wrapper for a raw pointer that provides the
+// interface (get, clear) of other pointer types such as RefPtr,
+// Persistent and Member. This is used for the Blink garbage
+// collection work in order to be able to write shared code that will
+// use reference counting or garbage collection based on a
+// compile-time flag.
 
-namespace WebCore { class SharedBuffer; }
+namespace WTF {
 
-namespace blink {
+template<typename T>
+class Ptr {
+public:
+#if ENABLE(OILPAN)
+    typedef Ptr<T> FromPassRefPtr;
+    typedef Ptr<T> FromRefPtr;
+    typedef Ptr<T> FromPassOwnPtr;
+#else
+    typedef PassRefPtr<T> FromPassRefPtr;
+    typedef RefPtr<T> FromRefPtr;
+    typedef PassOwnPtr<T> FromPassOwnPtr;
+#endif
 
-class WebDataPrivate;
+    Ptr(T* ptr) : m_ptr(ptr) { }
+    Ptr(std::nullptr_t) : m_ptr(0) { }
 
-// A container for raw bytes.  It is inexpensive to copy a WebData object.
-//
-// WARNING: It is not safe to pass a WebData across threads!!!
-//
-class BLINK_PLATFORM_EXPORT WebData {
-public:
-    ~WebData() { reset(); }
-
-    WebData() { }
-
-    WebData(const char* data, size_t size)
+    template<typename U>
+    Ptr(const Ptr<U>& other)
+        : m_ptr(other.get())
     {
-        assign(data, size);
     }
 
-    template <int N>
-    WebData(const char (&data)[N])
+    T* get() const { return m_ptr; }
+    void clear() { m_ptr = 0; }
+
+    Ptr& operator=(T* ptr)
     {
-        assign(data, N - 1);
-    }
-
-    WebData(const WebData& d) { assign(d); }
-
-    WebData& operator=(const WebData& d)
-    {
-        assign(d);
+        m_ptr = ptr;
         return *this;
     }
 
-    void reset();
-    void assign(const WebData&);
-    void assign(const char* data, size_t size);
-
-    size_t size() const;
-    const char* data() const;
-
-    bool isEmpty() const { return !size(); }
-    bool isNull() const { return m_private.isNull(); }
-
-#if INSIDE_BLINK
-    WebData(const PassRefPtr<WebCore::SharedBuffer>&);
-    WebData& operator=(const PassRefPtr<WebCore::SharedBuffer>&);
-    operator PassRefPtr<WebCore::SharedBuffer>() const;
-#else
-    template <class C>
-    WebData(const C& c)
+    Ptr& operator=(std::nullptr_t)
     {
-        assign(c.data(), c.size());
+        m_ptr = 0;
+        return *this;
     }
 
-    template <class C>
-    WebData& operator=(const C& c)
-    {
-        assign(c.data(), c.size());
-        return *this;
-    }
-#endif
+    operator T*() const { return m_ptr; }
+    T& operator*() const { return *m_ptr; }
+    T* operator->() const { return m_ptr; }
+    bool operator!() const { return !m_ptr; }
+
+    // This conversion operator allows implicit conversion to bool but
+    // not to other integer types.
+    typedef T* Ptr::*UnspecifiedBoolType;
+    operator UnspecifiedBoolType() const { return m_ptr ? &m_ptr : 0; }
 
 private:
-    WebPrivatePtr<WebCore::SharedBuffer> m_private;
+    T* m_ptr;
 };
 
-} // namespace blink
+} // namespace WTF
+
+using WTF::Ptr;
 
 #endif