Oilpan: Make the Node hierarchy RefCountedGarbageCollected instead of TreeShared.

Source/platform/heap/Handle.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 504 matching lines @@
     bool isHashTableDeletedValue() const { return m_raw == reinterpret_cast<T*>(-1); }
 
     template<typename U>
     Member(const Persistent<U>& other) : m_raw(other) { }
 
     Member(const Member& other) : m_raw(other) { }
 
     template<typename U>
     Member(const Member<U>& other) : m_raw(other) { }
 
+    // FIXME: Oilpan: Get rid of these ASAP; this is only here to make
+    // Node hierarchy transition easier.
+    template<typename U>
+    Member(const PassRefPtr<U>& other) : m_raw(other.get()) { }
+
+    template<typename U>
+    Member(const RefPtr<U>& other) : m_raw(other.get()) { }
+
     T* release()
     {
         T* result = m_raw;
         m_raw = 0;
         return result;
     }
 
     template<typename U>
     U* as() const
     {
@@ skipping 188 matching lines @@
 // Comparison operators between (Weak)Members and Persistents
 template<typename T, typename U> inline bool operator==(const Member<T>& a, const Member<U>& b) { return a.get() == b.get(); }
 template<typename T, typename U> inline bool operator!=(const Member<T>& a, const Member<U>& b) { return a.get() != b.get(); }
 template<typename T, typename U> inline bool operator==(const Member<T>& a, const Persistent<U>& b) { return a.get() == b.get(); }
 template<typename T, typename U> inline bool operator!=(const Member<T>& a, const Persistent<U>& b) { return a.get() != b.get(); }
 template<typename T, typename U> inline bool operator==(const Persistent<T>& a, const Member<U>& b) { return a.get() == b.get(); }
 template<typename T, typename U> inline bool operator!=(const Persistent<T>& a, const Member<U>& b) { return a.get() != b.get(); }
 template<typename T, typename U> inline bool operator==(const Persistent<T>& a, const Persistent<U>& b) { return a.get() == b.get(); }
 template<typename T, typename U> inline bool operator!=(const Persistent<T>& a, const Persistent<U>& b) { return a.get() != b.get(); }
 
+// FIXME: Oilpan: Get rid of these ASAP; only here to make Node transition easier.
+template<typename T, typename U> inline bool operator==(const Member<T>& a, const RefPtr<U>& b) { return a.get() == b.get(); }
+template<typename T, typename U> inline bool operator!=(const Member<T>& a, const RefPtr<U>& b) { return a.get() != b.get(); }
+template<typename T, typename U> inline bool operator==(const RefPtr<T>& a, const Member<U>& b) { return a.get() == b.get(); }
+template<typename T, typename U> inline bool operator!=(const RefPtr<T>& a, const Member<U>& b) { return a.get() != b.get(); }
+template<typename T, typename U> inline bool operator==(const Member<T>& a, const PassRefPtr<U>& b) { return a.get() == b.get(); }
+template<typename T, typename U> inline bool operator!=(const Member<T>& a, const PassRefPtr<U>& b) { return a.get() != b.get(); }
+template<typename T, typename U> inline bool operator==(const PassRefPtr<T>& a, const Member<U>& b) { return a.get() == b.get(); }
+template<typename T, typename U> inline bool operator!=(const PassRefPtr<T>& a, const Member<U>& b) { return a.get() != b.get(); }
+
 // CPP-defined type names for the transition period where we want to
 // support both reference counting and garbage collection based on a
 // compile-time flag.
 //
 // C++11 template aliases were initially used (with clang only, not
 // with GCC nor MSVC.) However, supporting both CPP defines and
 // template aliases is problematic from outside a WebCore namespace
 // when Oilpan is disabled: e.g.,
 // WebCore::RefCountedWillBeGarbageCollected as a template alias would
 // uniquely resolve from within any namespace, but if it is backed by
 // a CPP #define, it would expand to WebCore::RefCounted, and not the
 // required WTF::RefCounted.
 //
 // Having the CPP expansion instead be fully namespace qualified, and the
 // transition type be unqualified, would dually not work for template
 // aliases. So, slightly unfortunately, fall back/down to the lowest
 // commmon denominator of using CPP macros only.
 #if ENABLE(OILPAN)
 #define PassRefPtrWillBeRawPtr WTF::RawPtr
 #define RefCountedWillBeGarbageCollected WebCore::GarbageCollected
 #define RefCountedWillBeGarbageCollectedFinalized WebCore::GarbageCollectedFinalized
 #define RefCountedWillBeRefCountedGarbageCollected WebCore::RefCountedGarbageCollected
 #define ThreadSafeRefCountedWillBeGarbageCollected WebCore::GarbageCollected
 #define ThreadSafeRefCountedWillBeGarbageCollectedFinalized WebCore::GarbageCollectedFinalized
+#define TreeSharedWillBeRefCountedGarbageCollected WebCore::RefCountedGarbageCollected
 #define PersistentWillBeMember WebCore::Member
 #define RefPtrWillBePersistent WebCore::Persistent
 #define RefPtrWillBeRawPtr WTF::RawPtr
 #define RefPtrWillBeMember WebCore::Member
 #define RefPtrWillBeCrossThreadPersistent WebCore::CrossThreadPersistent
 #define RawPtrWillBeMember WebCore::Member
 #define RawPtrWillBeWeakMember WebCore::WeakMember
 #define OwnPtrWillBeMember WebCore::Member
 #define OwnPtrWillBePersistent WebCore::Persistent
 #define OwnPtrWillBeRawPtr WTF::RawPtr
@@ skipping 64 matching lines @@
     DummyBase() { }
     ~DummyBase() { }
 };
 
 #define PassRefPtrWillBeRawPtr WTF::PassRefPtr
 #define RefCountedWillBeGarbageCollected WTF::RefCounted
 #define RefCountedWillBeGarbageCollectedFinalized WTF::RefCounted
 #define RefCountedWillBeRefCountedGarbageCollected WTF::RefCounted
 #define ThreadSafeRefCountedWillBeGarbageCollected WTF::ThreadSafeRefCounted
 #define ThreadSafeRefCountedWillBeGarbageCollectedFinalized WTF::ThreadSafeRefCounted
+#define TreeSharedWillBeRefCountedGarbageCollected WebCore::TreeShared
 #define PersistentWillBeMember WebCore::Persistent
 #define RefPtrWillBePersistent WTF::RefPtr
 #define RefPtrWillBeRawPtr WTF::RefPtr
 #define RefPtrWillBeMember WTF::RefPtr
 #define RefPtrWillBeCrossThreadPersistent WTF::RefPtr
 #define RawPtrWillBeMember WTF::RawPtr
 #define RawPtrWillBeWeakMember WTF::RawPtr
 #define OwnPtrWillBeMember WTF::OwnPtr
 #define OwnPtrWillBePersistent WTF::OwnPtr
 #define OwnPtrWillBeRawPtr WTF::OwnPtr
@@ skipping 244 matching lines @@
 struct NeedsTracing<ListHashSetNode<T, WebCore::HeapListHashSetAllocator<T, inlineCapacity> > *> {
     // All heap allocated node pointers need visiting to keep the nodes alive,
     // regardless of whether they contain pointers to other heap allocated
     // objects.
     static const bool value = true;
 };
 
 } // namespace WTF
 
 #endif