Add template aliases to support both reference counting and garbage collection for a transition per…

Source/wtf/Ptr.h

 /*
  * 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
@@ skipping 10 matching lines @@
  * 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 MessageLoopInterruptor_h
-#define MessageLoopInterruptor_h
+#ifndef WTF_Ptr_h
+#define WTF_Ptr_h
 
-#include "heap/ThreadState.h"
-#include "public/platform/WebThread.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 {
+namespace WTF {
 
-class MessageLoopInterruptor : public ThreadState::Interruptor {
+template<typename T>
+class Ptr {
 public:
-    explicit MessageLoopInterruptor(blink::WebThread* thread) : m_thread(thread) { }
+    Ptr(T* ptr) : m_ptr(ptr) { }
+    Ptr(std::nullptr_t) : m_ptr(0) { }
 
-    virtual void requestInterrupt() OVERRIDE
+    template<typename U>
+    Ptr(const Ptr<U>& other)
+        : m_ptr(other.get())
     {
-        // GCTask has an empty run() method. Its only purpose is to guarantee
-        // that MessageLoop will have a task to process which will result
-        // in PendingGCRunner::didProcessTask being executed.
-        m_thread->postTask(new GCTask);
     }
 
-    virtual void clearInterrupt() OVERRIDE { }
+    T* get() const { return m_ptr; }
+    void clear() { m_ptr = 0; }
+
+    Ptr& operator=(T* ptr)
+    {
+        m_ptr = ptr;
+        return *this;
+    }
+
+    Ptr& operator=(std::nullptr_t)
+    {
+        m_ptr = 0;
+        return *this;
+    }
+
+    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:
-    class GCTask : public blink::WebThread::Task {
-    public:
-        virtual ~GCTask() { }
-
-        virtual void run() OVERRIDE
-        {
-            // Don't do anything here because we don't know if this is
-            // a nested event loop or not. PendingGCRunner::didProcessTask
-            // will enter correct safepoint for us.
-            // We are not calling onInterrupted() because that always
-            // conservatively enters safepoint with pointers on stack.
-        }
-    };
-
-    blink::WebThread* m_thread;
+    T* m_ptr;
 };
 
-}
+} // namespace WTF
+
+using WTF::Ptr;
 
 #endif