Alternative approach to supporting ref counting and garbage collection

Source/heap/Heap.h

 /*
  * Copyright (C) 2013 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 19 matching lines @@
 
 #ifndef Heap_h
 #define Heap_h
 
 #include "heap/HeapExport.h"
 #include "heap/ThreadState.h"
 #include "heap/Visitor.h"
 
 #include "wtf/Assertions.h"
 #include "wtf/OwnPtr.h"
+#include "wtf/RefCounted.h"
 
 #include <stdint.h>
 
 namespace WebCore {
 
 // ASAN integration defintions
 #if COMPILER(CLANG)
 #define USE_ASAN (__has_feature(address_sanitizer) || defined(__SANITIZE_ADDRESS__))
 #else
 #define USE_ASAN 0
@@ skipping 827 matching lines @@
 private:
     void enter() const
     {
         if (m_active)
             ThreadStateFor<Affinity>::state()->enterNoAllocationScope();
     }
 
     bool m_active;
 };
 
+#if !ENABLE(OILPAN)
+template<typename T>
+class Dummy {
+public:
+    Dummy() { }
+    ~Dummy() { }
+};
+#endif
+
 // Base class for objects allocated in the Blink garbage-collected
 // heap.
 //
 // Defines a 'new' operator that allocates the memory in the
 // heap. 'delete' should not be called on objects that inherit from
 // GarbageCollected.
 //
 // Instances of GarbageCollected will *NOT* get finalized. Their
 // destructor will not be called. Therefore, only classes that have
 // trivial destructors with no semantic meaning (including all their
 // subclasses) should inherit from GarbageCollected. If there are
 // non-trival destructors in a given class or any of its subclasses,
 // GarbageCollectedFinalized should be used which guarantees that the
 // destructor is called on an instance when the garbage collector
 // determines that it is no longer reachable.
 template<typename T>
 class GarbageCollected {
     WTF_MAKE_NONCOPYABLE(GarbageCollected);
 
     // For now direct allocation of arrays on the heap is not allowed.
     void* operator new[](size_t size);
     void operator delete[](void* p);
 public:
+#if ENABLE(OILPAN)
+    typedef GarbageCollected<T> FromRefCounted;
+#else
+    typedef RefCounted<T> FromRefCounted;
+#endif
+
     void* operator new(size_t size)
     {
         return Heap::allocate<T>(size);
     }
 
     void operator delete(void* p)
     {
         ASSERT_NOT_REACHED();
     }
 
@@ skipping 12 matching lines @@
 // heap. 'delete' should not be called on objects that inherit from
 // GarbageCollected.
 //
 // Instances of GarbageCollectedFinalized will have their destructor
 // called when the garbage collector determines that the object is no
 // longer reachable.
 template<typename T>
 class GarbageCollectedFinalized : public GarbageCollected<T> {
     WTF_MAKE_NONCOPYABLE(GarbageCollectedFinalized);
 
+public:
+#if ENABLE(OILPAN)
+    typedef GarbageCollectedFinalized<T> FromRefCounted;
+    typedef GarbageCollectedFinalized<T> FromNoBase;
+#else
+    typedef RefCounted<T> FromRefCounted;
+    typedef Dummy<T> FromNoBase;
+#endif
+
 protected:
     // Finalize is called when the object is freed from the heap. By
     // default finalization means calling the destructor on the
     // object. Finalize can be overridden to support calling the
     // destructor of a subclass. This is useful for objects without
     // vtables that require explicit dispatching.
     void finalize()
     {
         static_cast<T*>(this)->~T();
     }
@@ skipping 679 matching lines @@
 // to export. This forces it to export all the methods from ThreadHeap.
 template<> void ThreadHeap<FinalizedHeapObjectHeader>::addPageToHeap(const GCInfo*);
 template<> void ThreadHeap<HeapObjectHeader>::addPageToHeap(const GCInfo*);
 extern template class HEAP_EXPORT ThreadHeap<FinalizedHeapObjectHeader>;
 extern template class HEAP_EXPORT ThreadHeap<HeapObjectHeader>;
 #endif
 
 }
 
 #endif // Heap_h