Oilpan: Remove converters between Persistent/Member and PassRefPtr/RefPtr.

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 342 matching lines @@
         m_raw = 0;
         return result;
     }
 
     T& operator*() const { return *m_raw; }
 
     bool operator!() const { return !m_raw; }
 
     operator T*() const { return m_raw; }
     operator RawPtr<T>() const { return m_raw; }
-    // FIXME: Oilpan: Remove this ASAP. Only here to make Node transition easier.
-    template<typename U>
-    operator PassRefPtr<U>() { return PassRefPtr<U>(m_raw); }
 
     T* operator->() const { return *this; }
 
     Persistent& operator=(const Persistent& other)
     {
         m_raw = other;
         return *this;
     }
 
     template<typename U>
@@ skipping 146 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 43 matching lines @@
         return *this;
     }
 
     void swap(Member<T>& other) { std::swap(m_raw, other.m_raw); }
 
     T* get() const { return m_raw; }
 
     void clear() { m_raw = 0; }
 
 
-    // FIXME: Oilpan: Remove this ASAP. Only here to make Node transition easier.
-    template<typename U>
-    operator PassRefPtr<U>() { return PassRefPtr<U>(m_raw); }
-
 protected:
     void verifyTypeIsGarbageCollected() const
     {
         COMPILE_ASSERT_IS_GARBAGE_COLLECTED(T, NonGarbageCollectedObjectInMember);
     }
 
     T* m_raw;
 
     template<bool x, WTF::WeakHandlingFlag y, ShouldWeakPointersBeMarkedStrongly z, typename U, typename V> friend struct CollectionBackingTraceTrait;
     friend class Visitor;
@@ skipping 127 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
@@ skipping 427 matching lines @@
 struct ParamStorageTraits<T*> : public PointerParamStorageTraits<T*, WebCore::IsGarbageCollectedType<T>::value> {
 };
 
 template<typename T>
 struct ParamStorageTraits<RawPtr<T> > : public PointerParamStorageTraits<T*, WebCore::IsGarbageCollectedType<T>::value> {
 };
 
 } // namespace WTF
 
 #endif