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

[Mads Ager (chromium), 2014/06/06 09:59:16]

In the heap tests code, it looks like you added a method in the visitor for
this. Can you do visitor->traceInCollection(weakMember, strongify) here or does
that jump through hoops that you don't want here?

[Erik Corry, 2014/06/06 12:37:21]

That would go into a loop, since the visitor method you mention ultimately calls
this.

+            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 94 matching lines @@
 struct NeedsTracing<ListHashSetNode<T, WebCore::HeapListHashSetAllocator<T, inlineCapacity> > *> {
     // All heap allocated node pointers need visiting to keep the nodes alive,
     // regardless of whether they contain pointers to other heap allocated
     // objects.
     static const bool value = true;
 };
 
 } // namespace WTF
 
 #endif