Rename a few Member and Persistent methods to make the transition

Source/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 175 matching lines @@
     }
 
     template<typename U>
     U* as() const
     {
         return static_cast<U*>(m_raw);
     }
 
     void trace(Visitor* visitor) { visitor->mark(m_raw); }
 
-    T* clear()
+    T* release()
     {
         T* result = m_raw;
         m_raw = 0;
         return result;
     }
 
     T& operator*() const { return *m_raw; }
 
     bool operator!() const { return !m_raw; }
 
@@ skipping 20 matching lines @@
         return *this;
     }
 
     template<typename U>
     Persistent& operator=(const Member<U>& other)
     {
         m_raw = other;
         return *this;
     }
 
-    T* raw() const { return m_raw; }
+    T* get() const { return m_raw; }
 
 private:
     T* m_raw;
 };
 
 // Members are used in classes to contain strong pointers to other oilpan heap
 // allocated objects.
 // All Member fields of a class must be traced in the class' trace method.
 // During the mark phase of the GC all live objects are marked as live and
 // all Member fields of a live object will be traced marked as live as well.
@@ skipping 11 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) { }
 
-    T* clear()
+    T* release()
     {
         T* result = m_raw;
         m_raw = 0;
         return result;
     }
 
     template<typename U>
     U* as() const
     {
         return static_cast<U*>(m_raw);
@@ skipping 34 matching lines @@
 
     template<typename U>
     Member& operator=(U* other)
     {
         m_raw = other;
         return *this;
     }
 
     void swap(Member<T>& other) { std::swap(m_raw, other.m_raw); }
 
+    T* get() const { return m_raw; }
+
 protected:
-    T* raw() const { return m_raw; }
-
     T* m_raw;
 
-    template<typename U> friend class Member;
-    template<typename U> friend class Persistent;
-    friend class Visitor;
-    template<typename U> friend struct WTF::PtrHash;
-    // FIXME: Uncomment when HeapObjectHash is moved.
-    // friend struct HeapObjectHash<T>;
-    friend struct ObjectAliveTrait<Member<T> >;
     template<bool x, bool y, bool z, typename U, typename V> friend struct CollectionBackingTraceTrait;
-    template<typename U, typename V> friend bool operator==(const Member<U>&, const Persistent<V>&);
-    template<typename U, typename V> friend bool operator!=(const Member<U>&, const Persistent<V>&);
-    template<typename U, typename V> friend bool operator==(const Persistent<U>&, const Member<V>&);
-    template<typename U, typename V> friend bool operator!=(const Persistent<U>&, const Member<V>&);
-    template<typename U, typename V> friend bool operator==(const Member<U>&, const Member<V>&);
-    template<typename U, typename V> friend bool operator!=(const Member<U>&, const Member<V>&);
 };
 
 template<typename T>
 class TraceTrait<Member<T> > {
 public:
     static void trace(Visitor* visitor, void* self)
     {
         TraceTrait<T>::mark(visitor, *static_cast<Member<T>*>(self));
     }
 };
@@ skipping 44 matching lines @@
     template<typename U>
     WeakMember& operator=(U* other)
     {
         this->m_raw = other;
         return *this;
     }
 
 private:
     T** cell() const { return const_cast<T**>(&this->m_raw); }
 
-    template<typename U> friend class Member;
-    template<typename U> friend class WeakMember;
-    template<typename U> friend class Persistent;
     friend class Visitor;
-    template<typename U> friend struct WTF::PtrHash;
-    // FIXME: Uncomment when moving HeapObjectHash to trunk.
-    // friend struct HeapObjectHash<T>;
-    friend struct ObjectAliveTrait<WeakMember<T> >;
 };
 
 // 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.m_raw == b.m_raw; }
-template<typename T, typename U> inline bool operator!=(const Member<T>& a, const Member<U>& b) { return a.m_raw != b.m_raw; }
-template<typename T, typename U> inline bool operator==(const Member<T>& a, const Persistent<U>& b) { return a.m_raw == b.m_raw; }
-template<typename T, typename U> inline bool operator!=(const Member<T>& a, const Persistent<U>& b) { return a.m_raw != b.m_raw; }
-template<typename T, typename U> inline bool operator==(const Persistent<T>& a, const Member<U>& b) { return a.m_raw == b.m_raw; }
-template<typename T, typename U> inline bool operator!=(const Persistent<T>& a, const Member<U>& b) { return a.m_raw != b.m_raw; }
-template<typename T, typename U> inline bool operator==(const Persistent<T>& a, const Persistent<U>& b) { return a.m_raw == b.m_raw; }
-template<typename T, typename U> inline bool operator!=(const Persistent<T>& a, const Persistent<U>& b) { return a.m_raw != b.m_raw; }
+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(); }
 
 } // namespace WebCore
 
 namespace WTF {
 
 template <typename T> struct VectorTraits<WebCore::Member<T> > : VectorTraitsBase<false, WebCore::Member<T> > {
     static const bool needsDestruction = false;
     static const bool canInitializeWithMemset = true;
     static const bool canMoveWithMemcpy = true;
 };
@@ skipping 10 matching lines @@
     // the sake of the reference counting handles. When they are gone the two
     // types can be merged into PassInType.
     // FIXME: Implement proper const'ness for iterator types. Requires support
     // in the marking Visitor.
     typedef T* PeekInType;
     typedef T* PassInType;
     typedef T* IteratorGetType;
     typedef T* IteratorConstGetType;
     typedef T* IteratorReferenceType;
     typedef T* IteratorConstReferenceType;
-    static IteratorConstGetType getToConstGetConversion(const WebCore::Member<T>* x) { return x->raw(); }
+    static IteratorConstGetType getToConstGetConversion(const WebCore::Member<T>* x) { return x->get(); }
     static IteratorReferenceType getToReferenceConversion(IteratorGetType x) { return x; }
     static IteratorConstReferenceType getToReferenceConstConversion(IteratorConstGetType x) { return x; }
     // FIXME: Similarly, there is no need for a distinction between PeekOutType
     // and PassOutType without reference counting.
     typedef T* PeekOutType;
     typedef T* PassOutType;
 
     template<typename U>
     static void store(const U& value, WebCore::Member<T>& storage) { storage = value; }
 
     static PeekOutType peek(const WebCore::Member<T>& value) { return value; }
     static PassOutType passOut(const WebCore::Member<T>& value) { return value; }
 };
 
 template<typename T> struct HashTraits<WebCore::WeakMember<T> > : SimpleClassHashTraits<WebCore::WeakMember<T> > {
     static const bool needsDestruction = false;
     // FIXME: The distinction between PeekInType and PassInType is there for
     // the sake of the reference counting handles. When they are gone the two
     // types can be merged into PassInType.
     // FIXME: Implement proper const'ness for iterator types. Requires support
     // in the marking Visitor.
     typedef T* PeekInType;
     typedef T* PassInType;
     typedef T* IteratorGetType;
     typedef T* IteratorConstGetType;
     typedef T* IteratorReferenceType;
     typedef T* IteratorConstReferenceType;
-    static IteratorConstGetType getToConstGetConversion(const WebCore::WeakMember<T>* x) { return x->raw(); }
+    static IteratorConstGetType getToConstGetConversion(const WebCore::WeakMember<T>* x) { return x->get(); }
     static IteratorReferenceType getToReferenceConversion(IteratorGetType x) { return x; }
     static IteratorConstReferenceType getToReferenceConstConversion(IteratorConstGetType x) { return x; }
     // FIXME: Similarly, there is no need for a distinction between PeekOutType
     // and PassOutType without reference counting.
     typedef T* PeekOutType;
     typedef T* PassOutType;
 
     template<typename U>
     static void store(const U& value, WebCore::WeakMember<T>& storage) { storage = value; }
 
@@ skipping 33 matching lines @@
 };
 
 template<typename Key, typename Value, typename Extractor, typename Traits, typename KeyTraits>
 struct IsWeak<WebCore::HeapHashTableBacking<Key, Value, Extractor, Traits, KeyTraits> > {
     static const bool value = Traits::isWeak;
 };
 
 } // namespace WTF
 
 #endif