Oilpan: Replace most of RefPtrs for Event objects with oilpan's transition types

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 17 matching lines @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef Handle_h
 #define Handle_h
 
 #include "heap/Heap.h"
 #include "heap/ThreadState.h"
 #include "heap/Visitor.h"
 
+#include "wtf/HashFunctions.h"
 #include "wtf/Locker.h"
 #include "wtf/RawPtr.h"
 #include "wtf/RefCounted.h"
 #include "wtf/TypeTraits.h"
 
 namespace WebCore {
 
 template<typename T> class HeapTerminatedArray;
 
 #define COMPILE_ASSERT_IS_GARBAGE_COLLECTED(T, ErrorMessage)                                          \
@@ skipping 817 matching lines @@
     static unsigned hash(const U& key) { return PtrHash<T*>::hash(key); }
     static bool equal(T* a, const WebCore::Member<T>& b) { return a == b; }
     static bool equal(const WebCore::Member<T>& a, T* b) { return a == b; }
     template<typename U, typename V>
     static bool equal(const U& a, const V& b) { return a == b; }
 };
 
 template<typename T> struct PtrHash<WebCore::WeakMember<T> > : PtrHash<WebCore::Member<T> > {
 };
 
+template<typename P> struct PtrHash<WebCore::Persistent<P> > : PtrHash<P*> {
+    using PtrHash<P*>::hash;
+    static unsigned hash(const RefPtr<P>& key) { return hash(key.get()); }
+    using PtrHash<P*>::equal;
+    static bool equal(const RefPtr<P>& a, const RefPtr<P>& b) { return a == b; }
+    static bool equal(P* a, const RefPtr<P>& b) { return a == b; }
+    static bool equal(const RefPtr<P>& a, P* b) { return a == b; }
+};
+
 // PtrHash is the default hash for hash tables with members.
 template<typename T> struct DefaultHash<WebCore::Member<T> > {
     typedef PtrHash<WebCore::Member<T> > Hash;
 };
 
 template<typename T> struct DefaultHash<WebCore::WeakMember<T> > {
     typedef PtrHash<WebCore::WeakMember<T> > Hash;
 };
 
+template<typename T> struct DefaultHash<WebCore::Persistent<T> > {
+    typedef PtrHash<WebCore::Persistent<T> > Hash;
+};
+
 template<typename T>
 struct NeedsTracing<WebCore::Member<T> > {
     static const bool value = true;
 };
 
 template<typename T>
 struct IsWeak<WebCore::WeakMember<T> > {
     static const bool value = true;
 };
 
@@ skipping 35 matching lines @@
 };
 
 template<typename T, typename U>
 struct NeedsTracing<HashMap<T, U> > {
     static const bool value = false;
 };
 
 } // namespace WTF
 
 #endif