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

Source/wtf/LinkedHashSet.h

 /*
  * Copyright (C) 2005, 2006, 2007, 2008, 2011, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2011, Benjamin Poulain <ikipou@gmail.com>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
@@ skipping 289 matching lines @@
 template<typename Value, typename ValueTraitsArg>
 struct LinkedHashSetTraits : public SimpleClassHashTraits<LinkedHashSetNode<Value> > {
     typedef LinkedHashSetNode<Value> Node;
     typedef ValueTraitsArg ValueTraits;
 
     // The slot is empty when the m_next field is zero so it's safe to zero
     // the backing.
     static const bool emptyValueIsZero = true;
 
     static const bool hasIsEmptyValueFunction = true;
-    static bool isEmptyValue(const Node& value) { return !value.m_next; }
+    static bool isEmptyValue(const Node& node) { return !node.m_next; }
 
     static const int deletedValue = -1;
 
     static void constructDeletedValue(Node& slot) { slot.m_next = reinterpret_cast<Node*>(deletedValue); }
     static bool isDeletedValue(const Node& slot) { return slot.m_next == reinterpret_cast<Node*>(deletedValue); }
 
     // We always need to call destructors, that's how we get linked and
     // unlinked from the chain.
     static const bool needsDestruction = true;
 
     // Whether we need to trace and do weak processing depends on the traits of
     // the type inside the node.
     template<typename U = void>
     struct NeedsTracingLazily {
         static const bool value = ValueTraits::template NeedsTracingLazily<>::value;
     };
-    static const bool isWeak = ValueTraits::isWeak;
+    static const WeakHandlingFlag weakHandlingFlag = ValueTraits::weakHandlingFlag;
+    template<typename Visitor>
+    static bool shouldRemoveFromCollection(Visitor* visitor, LinkedHashSetNode<Value>& node)
+    {
+        return ValueTraits::shouldRemoveFromCollection(visitor, node.m_value);
+    }
 };
 
 template<typename LinkedHashSetType>
 class LinkedHashSetIterator {
 private:
     typedef typename LinkedHashSetType::Node Node;
     typedef typename LinkedHashSetType::Traits Traits;
 
     typedef typename LinkedHashSetType::Value& ReferenceType;
     typedef typename LinkedHashSetType::Value* PointerType;
@@ skipping 325 matching lines @@
         return;
     m_impl.remove(it.node());
 }
 
 template<typename T, typename U, typename V, typename W>
 inline void LinkedHashSet<T, U, V, W>::remove(ValuePeekInType value)
 {
     remove(find(value));
 }
 
-template<typename T>
-struct IsWeak<LinkedHashSetNode<T> > {
-    static const bool value = IsWeak<T>::value;
-};
-
 inline void swap(LinkedHashSetNodeBase& a, LinkedHashSetNodeBase& b)
 {
     swap(a.m_prev, b.m_prev);
     swap(a.m_next, b.m_next);
     if (b.m_next) {
         b.m_next->m_prev = &b;
         b.m_prev->m_next = &b;
     }
     if (a.m_next) {
         a.m_next->m_prev = &a;
@@ skipping 20 matching lines @@
     iterator end = set.end();
     for (iterator it = set.begin(); it != end; ++it)
         delete *it;
 }
 
 }
 
 using WTF::LinkedHashSet;
 
 #endif /* WTF_LinkedHashSet_h */