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

Source/platform/heap/Visitor.h

 /*
  * Copyright (C) 2013 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 53 matching lines @@
 class HeapObjectHeader;
 template<typename T> class Member;
 template<typename T> class WeakMember;
 class Visitor;
 
 enum ShouldWeakPointersBeMarkedStrongly {
     WeakPointersActStrong,
     WeakPointersActWeak
 };
 
-template<bool needsTracing, bool isWeak, ShouldWeakPointersBeMarkedStrongly strongify, typename T, typename Traits> struct CollectionBackingTraceTrait;
+template<bool needsTracing, WTF::WeakHandlingFlag weakHandlingFlag, ShouldWeakPointersBeMarkedStrongly strongify, typename T, typename Traits> struct CollectionBackingTraceTrait;
 
 // The TraceMethodDelegate is used to convert a trace method for type T to a TraceCallback.
 // This allows us to pass a type's trace method as a parameter to the PersistentNode
 // constructor. The PersistentNode constructor needs the specific trace method due an issue
 // with the Windows compiler which instantiates even unused variables. This causes problems
 // in header files where we have only forward declarations of classes.
 template<typename T, void (T::*method)(Visitor*)>
 struct TraceMethodDelegate {
     static void trampoline(Visitor* visitor, void* self) { (reinterpret_cast<T*>(self)->*method)(visitor); }
 };
@@ skipping 147 matching lines @@
     template<typename T>
     void trace(const Member<T>& t)
     {
         t.verifyTypeIsGarbageCollected();
         mark(t.get());
     }
 
     // Fallback method used only when we need to trace raw pointers of T.
     // This is the case when a member is a union where we do not support members.
     template<typename T>
+    void trace(const T* t)
+    {
+        mark(const_cast<T*>(t));
+    }
+
+    template<typename T>
     void trace(T* t)
     {
         mark(t);
     }
 
     // WeakMember version of the templated trace method. It doesn't keep
     // the traced thing alive, but will write null to the WeakMember later
-    // if the pointed-to object is dead.
+    // if the pointed-to object is dead. It's lying for this to be const,
+    // but the overloading resolver prioritizes constness too high when
+    // picking the correct overload, so all these trace methods have to have
+    // the same constness on their argument to allow the type to decide.
     template<typename T>
     void trace(const WeakMember<T>& t)
     {
-        registerWeakCell(t.cell());
+        registerWeakCell(const_cast<WeakMember<T>&>(t).cell());
     }
 
-    // Fallback trace method for part objects to allow individual
-    // trace methods to trace through a part object with
-    // visitor->trace(m_partObject).
+    template<typename T>
+    void traceInCollection(T& t, ShouldWeakPointersBeMarkedStrongly strongify)
+    {
+        HashTraits<T>::traceInCollection(this, t, strongify);
+    }
+
+    // Fallback trace method for part objects to allow individual trace methods
+    // to trace through a part object with visitor->trace(m_partObject). This
+    // takes a const argument, because otherwise it will match too eagerly: a
+    // non-const argument would match a non-const Vector<T>& argument better
+    // than the specialization that takes const Vector<T>&. For a similar reason,
+    // the other specializations take a const argument even though they are
+    // usually used with non-const arguments, otherwise this function would match
+    // too well.
     template<typename T>
     void trace(const T& t)
     {
         const_cast<T&>(t).trace(this);
     }
 
     // The following trace methods are for off-heap collections.
     template<typename T, size_t inlineCapacity>
-    void trace(const Vector<T, inlineCapacity, WTF::DefaultAllocator>& vector)
+    void trace(const Vector<T, inlineCapacity>& vector)
     {
         OffHeapCollectionTraceTrait<Vector<T, inlineCapacity, WTF::DefaultAllocator> >::trace(this, vector);
     }
 
     template<typename T, typename U, typename V>
-    void trace(const HashSet<T, U, V, WTF::DefaultAllocator>& hashSet)
+    void trace(const HashSet<T, U, V>& hashSet)
     {
-        OffHeapCollectionTraceTrait<HashSet<T, U, V, WTF::DefaultAllocator> >::trace(this, hashSet);
+        OffHeapCollectionTraceTrait<HashSet<T, U, V> >::trace(this, hashSet);
     }
 
     template<typename T, size_t inlineCapacity, typename U>
     void trace(const ListHashSet<T, inlineCapacity, U>& hashSet)
     {
         OffHeapCollectionTraceTrait<ListHashSet<T, inlineCapacity, U> >::trace(this, hashSet);
     }
 
     template<typename T, typename U>
     void trace(const LinkedHashSet<T, U>& hashSet)
@@ skipping 175 matching lines @@
 template<typename T, typename HashFunctions, typename Traits>
 struct OffHeapCollectionTraceTrait<WTF::HashSet<T, HashFunctions, Traits, WTF::DefaultAllocator> > {
     typedef WTF::HashSet<T, HashFunctions, Traits, WTF::DefaultAllocator> HashSet;
 
     static void trace(Visitor* visitor, const HashSet& set)
     {
         if (set.isEmpty())
             return;
         if (WTF::ShouldBeTraced<Traits>::value) {
             HashSet& iterSet = const_cast<HashSet&>(set);
-            for (typename HashSet::iterator it = iterSet.begin(), end = iterSet.end(); it != end; ++it)
-                CollectionBackingTraceTrait<WTF::ShouldBeTraced<Traits>::value, Traits::isWeak, WeakPointersActWeak, T, Traits>::trace(visitor, *it);
+            for (typename HashSet::iterator it = iterSet.begin(), end = iterSet.end(); it != end; ++it) {
+                const T& t = *it;
+                CollectionBackingTraceTrait<WTF::ShouldBeTraced<Traits>::value, Traits::weakHandlingFlag, WeakPointersActWeak, T, Traits>::trace(visitor, const_cast<T&>(t));
+            }
         }
-        COMPILE_ASSERT(!Traits::isWeak, WeakOffHeapCollectionsConsideredDangerous0);
+        COMPILE_ASSERT(Traits::weakHandlingFlag == WTF::NoWeakHandlingInCollections, WeakOffHeapCollectionsConsideredDangerous0);
     }
 };
 
 template<typename T, size_t inlineCapacity, typename HashFunctions>
 struct OffHeapCollectionTraceTrait<ListHashSet<T, inlineCapacity, HashFunctions> > {
     typedef WTF::ListHashSet<T, inlineCapacity, HashFunctions> ListHashSet;
 
     static void trace(Visitor* visitor, const ListHashSet& set)
     {
         if (set.isEmpty())
@@ skipping 22 matching lines @@
 struct OffHeapCollectionTraceTrait<WTF::HashMap<Key, Value, HashFunctions, KeyTraits, ValueTraits, WTF::DefaultAllocator> > {
     typedef WTF::HashMap<Key, Value, HashFunctions, KeyTraits, ValueTraits, WTF::DefaultAllocator> HashMap;
 
     static void trace(Visitor* visitor, const HashMap& map)
     {
         if (map.isEmpty())
             return;
         if (WTF::ShouldBeTraced<KeyTraits>::value || WTF::ShouldBeTraced<ValueTraits>::value) {
             HashMap& iterMap = const_cast<HashMap&>(map);
             for (typename HashMap::iterator it = iterMap.begin(), end = iterMap.end(); it != end; ++it) {
-                CollectionBackingTraceTrait<WTF::ShouldBeTraced<KeyTraits>::value, KeyTraits::isWeak, WeakPointersActWeak, typename HashMap::KeyType, KeyTraits>::trace(visitor, it->key);
-                CollectionBackingTraceTrait<WTF::ShouldBeTraced<ValueTraits>::value, ValueTraits::isWeak, WeakPointersActWeak, typename HashMap::MappedType, ValueTraits>::trace(visitor, it->value);
+                CollectionBackingTraceTrait<WTF::ShouldBeTraced<KeyTraits>::value, KeyTraits::weakHandlingFlag, WeakPointersActWeak, typename HashMap::KeyType, KeyTraits>::trace(visitor, it->key);
+                CollectionBackingTraceTrait<WTF::ShouldBeTraced<ValueTraits>::value, ValueTraits::weakHandlingFlag, WeakPointersActWeak, typename HashMap::MappedType, ValueTraits>::trace(visitor, it->value);
             }
         }
-        COMPILE_ASSERT(!KeyTraits::isWeak, WeakOffHeapCollectionsConsideredDangerous1);
-        COMPILE_ASSERT(!ValueTraits::isWeak, WeakOffHeapCollectionsConsideredDangerous2);
+        COMPILE_ASSERT(KeyTraits::weakHandlingFlag == WTF::NoWeakHandlingInCollections, WeakOffHeapCollectionsConsideredDangerous1);
+        COMPILE_ASSERT(ValueTraits::weakHandlingFlag == WTF::NoWeakHandlingInCollections, WeakOffHeapCollectionsConsideredDangerous2);
     }
 };
 
 // We trace vectors by using the trace trait on each element, which means you
 // can have vectors of general objects (not just pointers to objects) that can
 // be traced.
 template<typename T, size_t N>
 struct OffHeapCollectionTraceTrait<WTF::Vector<T, N, WTF::DefaultAllocator> > {
     typedef WTF::Vector<T, N, WTF::DefaultAllocator> Vector;
 
@@ skipping 191 matching lines @@
 struct GCInfoTrait {
     static const GCInfo* get()
     {
         return GCInfoAtBase<typename GetGarbageCollectedBase<T>::type>::get();
     }
 };
 
 }
 
 #endif