Rename a few Member and Persistent methods to make the transition

Source/heap/Handle.h

Index: Source/heap/Handle.h
diff --git a/Source/heap/Handle.h b/Source/heap/Handle.h
index 5e281866df16118b6aed095ab1e155c81cc18f05..03534db2d94b976ff0365024d414cc6d3fad4e9a 100644
--- a/Source/heap/Handle.h
+++ b/Source/heap/Handle.h
@@ -193,7 +193,7 @@ public:
 
     void trace(Visitor* visitor) { visitor->mark(m_raw); }
 
-    T* clear()
+    T* release()

[haraken, 2014/01/14 13:57:10]

Just to confirm: The places where we want to call Persistent::release() are
exactly the same as the places where we're currently calling RefPtr::release(),
right?

I'm asking this because in the replacement work in our experimental branch,
we've sometimes replaced ptr.release() with ptr and we've sometimes replaces
ptr.release() with ptr.clear().

[Mads Ager (chromium), 2014/01/14 14:03:13]

It seems to me that it should mostly be the case that if we replace a RefPtr
with a Persistent we will want to call release at the same times as well. There
will definitely be cases where we will want to and this patch makes that easier.
If/when we find cases where we do not want to call release on one of them we
will have to either introduce other methods with different meanings depending on
ENABLE_OILPAN or ifdef the code.

[haraken, 2014/01/14 14:23:15]

If there are cases where we must not replace RefPtr::release() with
Persistent::release() (I don't know if there are cases where we *must not* do
the replacement), my concern is that this CL will implicitly do the replacement
and cause unexpected, premature releases of persistent handles. I'm wondering
this since we've not always replaced RefPtr::release() with
Persistent::release().

That said, I'm OK with going with this CL and see how it goes.

     {
         T* result = m_raw;
         m_raw = 0;
@@ -234,7 +234,7 @@ public:
         return *this;
     }
 
-    T* raw() const { return m_raw; }
+    T* get() const { return m_raw; }
 
 private:
     T* m_raw;
@@ -266,7 +266,7 @@ public:
     template<typename U>
     Member(const Member<U>& other) : m_raw(other) { }
 
-    T* clear()
+    T* release()

[haraken, 2014/01/14 13:57:10]

Ditto.

     {
         T* result = m_raw;
         m_raw = 0;
@@ -321,9 +321,9 @@ public:
 
     void swap(Member<T>& other) { std::swap(m_raw, other.m_raw); }
 
-protected:
-    T* raw() const { return m_raw; }
+    T* get() const { return m_raw; }
 
+protected:
     T* m_raw;
 
     template<typename U> friend class Member;
@@ -415,14 +415,14 @@ private:
 };
 
 // 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
 
@@ -453,7 +453,7 @@ template<typename T> struct HashTraits<WebCore::Member<T> > : SimpleClassHashTra
     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
@@ -481,7 +481,7 @@ template<typename T> struct HashTraits<WebCore::WeakMember<T> > : SimpleClassHas
     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