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()

[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;
         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()

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

Ditto.

     {
         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;
@@ skipping 71 matching lines @@
     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