Oilpan:Allow custom handling of classes that contain weak pointers that are embedded in collections.

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 591 matching lines @@
     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, bool y, ShouldWeakPointersBeMarkedStrongly z, typename U, typename V> friend struct CollectionBackingTraceTrait;
+    template<bool x, WTF::WeakHandlingFlag y, ShouldWeakPointersBeMarkedStrongly z, typename U, typename V> friend struct CollectionBackingTraceTrait;
     friend class Visitor;
 };
 
 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 412 matching lines @@
     // 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; }
 
     static PeekOutType peek(const WebCore::WeakMember<T>& value) { return value; }
     static PassOutType passOut(const WebCore::WeakMember<T>& value) { return value; }
+    static bool shouldRemoveFromCollection(WebCore::Visitor* visitor, WebCore::WeakMember<T>& value) { return !visitor->isAlive(value); }
+    static void traceInCollection(WebCore::Visitor* visitor, WebCore::WeakMember<T>& weakMember, WebCore::ShouldWeakPointersBeMarkedStrongly strongify)
+    {
+        if (strongify == WebCore::WeakPointersActStrong)
+            visitor->trace(reinterpret_cast<WebCore::Member<T>&>(weakMember)); // Strongified visit.
+    }
 };
 
 template<typename T> struct PtrHash<WebCore::Member<T> > : PtrHash<T*> {
     template<typename U>
     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; }
 };
@@ skipping 26 matching lines @@
 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;
 };
 
-template<typename Table>
-struct IsWeak<WebCore::HeapHashTableBacking<Table> > {
-    static const bool value = Table::ValueTraits::isWeak;
-};
-
 template<typename T> inline T* getPtr(const WebCore::Member<T>& p)
 {
     return p.get();
 }
 
 template<typename T, typename U>
 struct NeedsTracing<std::pair<T, U> > {
     static const bool value = NeedsTracing<T>::value || NeedsTracing<U>::value || IsWeak<T>::value || IsWeak<U>::value;
 };
 
@@ skipping 73 matching lines @@
 template<typename T> struct ParamStorageTraits<RawPtr<T> > {
     typedef WebCore::CrossThreadPersistent<T> StorageType;
 
     static StorageType wrap(RawPtr<T> value) { return value.get(); }
     static T* unwrap(const StorageType& value) { return value.get(); }
 };
 
 } // namespace WTF
 
 #endif