Hollow out more of the tracing system in oilpan

sky/engine/platform/heap/Heap.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 1614 matching lines @@
     static void markUsingGCInfo(Visitor* visitor, const void* buffer)
     {
         visitor->mark(buffer, FinalizedHeapObjectHeader::fromPayload(buffer)->traceCallback());
     }
 
     static void markNoTracing(Visitor* visitor, const void* t) { visitor->markNoTracing(t); }
 
     template<typename T, typename Traits>
     static void trace(Visitor* visitor, T& t)
     {
-        CollectionBackingTraceTrait<WTF::ShouldBeTraced<Traits>::value, Traits::weakHandlingFlag, WTF::WeakPointersActWeak, T, Traits>::trace(visitor, t);
     }
 
     static void registerDelayedMarkNoTracing(Visitor* visitor, const void* object)
     {
         visitor->registerDelayedMarkNoTracing(object);
     }
 
     static void registerWeakMembers(Visitor* visitor, const void* closure, const void* object, WeakPointerCallback callback)
     {
         visitor->registerWeakMembers(closure, object, callback);
@@ skipping 62 matching lines @@
 
 private:
     template<typename T, size_t u, typename V> friend class WTF::Vector;
     template<typename T, typename U, typename V, typename W> friend class WTF::HashSet;
     template<typename T, typename U, typename V, typename W, typename X, typename Y> friend class WTF::HashMap;
 };
 
 template<typename Value>
 static void traceListHashSetValue(Visitor* visitor, Value& value)
 {
-    // We use the default hash traits for the value in the node, because
-    // ListHashSet does not let you specify any specific ones.
-    // We don't allow ListHashSet of WeakMember, so we set that one false
-    // (there's an assert elsewhere), but we have to specify some value for the
-    // strongify template argument, so we specify WTF::WeakPointersActWeak,
-    // arbitrarily.
-    CollectionBackingTraceTrait<WTF::ShouldBeTraced<WTF::HashTraits<Value> >::value, WTF::NoWeakHandlingInCollections, WTF::WeakPointersActWeak, Value, WTF::HashTraits<Value> >::trace(visitor, value);
 }
 
 // The inline capacity is just a dummy template argument to match the off-heap
 // allocator.
 // This inherits from the static-only HeapAllocator trait class, but we do
 // declare pointers to instances. These pointers are always null, and no
 // objects are instantiated.
 template<typename ValueArg, size_t inlineCapacity>
 struct HeapListHashSetAllocator : public HeapAllocator {
     typedef HeapAllocator TableAllocator;
@@ skipping 473 matching lines @@
 // Catch-all for types that have a way to trace that don't have special
 // handling for weakness in collections. This means that if this type
 // contains WeakMember fields, they will simply be zeroed, but the entry
 // will not be removed from the collection. This always happens for
 // things in vectors, which don't currently support special handling of
 // weak elements.
 template<ShouldWeakPointersBeMarkedStrongly strongify, typename T, typename Traits>
 struct TraceInCollectionTrait<NoWeakHandlingInCollections, strongify, T, Traits> {
     static bool trace(blink::Visitor* visitor, T& t)
     {
-        blink::TraceTrait<T>::trace(visitor, &t);
         return false;
     }
 };
 
 // Catch-all for things that have HashTrait support for tracing with weakness.
 template<ShouldWeakPointersBeMarkedStrongly strongify, typename T, typename Traits>
 struct TraceInCollectionTrait<WeakHandlingInCollections, strongify, T, Traits> {
     static bool trace(blink::Visitor* visitor, T& t)
     {
-        return Traits::traceInCollection(visitor, t, strongify);
+        return false;
     }
 };
 
 // Vector backing that needs marking. We don't support weak members in vectors.
 template<ShouldWeakPointersBeMarkedStrongly strongify, typename T, typename Traits>
 struct TraceInCollectionTrait<NoWeakHandlingInCollections, strongify, blink::HeapVectorBacking<T, Traits>, void> {
     static bool trace(blink::Visitor* visitor, void* self)
     {
-        // The allocator can oversize the allocation a little, according to
-        // the allocation granularity. The extra size is included in the
-        // payloadSize call below, since there is nowhere to store the
-        // originally allocated memory. This assert ensures that visiting the
-        // last bit of memory can't cause trouble.
-        COMPILE_ASSERT(!ShouldBeTraced<Traits>::value || sizeof(T) > blink::allocationGranularity || Traits::canInitializeWithMemset, HeapOverallocationCanCauseSpuriousVisits);
-
-        T* array = reinterpret_cast<T*>(self);
-        blink::FinalizedHeapObjectHeader* header = blink::FinalizedHeapObjectHeader::fromPayload(self);
-        // Use the payload size as recorded by the heap to determine how many
-        // elements to mark.
-        size_t length = header->payloadSize() / sizeof(T);
-        for (size_t i = 0; i < length; i++)
-            blink::CollectionBackingTraceTrait<ShouldBeTraced<Traits>::value, Traits::weakHandlingFlag, WeakPointersActStrong, T, Traits>::trace(visitor, array[i]);
         return false;
     }
 };
 
 // Almost all hash table backings are visited with this specialization.
 template<ShouldWeakPointersBeMarkedStrongly strongify, typename Table>
 struct TraceInCollectionTrait<NoWeakHandlingInCollections, strongify, blink::HeapHashTableBacking<Table>, void> {
     typedef typename Table::ValueType Value;
     typedef typename Table::ValueTraits Traits;
     static bool trace(blink::Visitor* visitor, void* self)
     {
-        Value* array = reinterpret_cast<Value*>(self);
-        blink::FinalizedHeapObjectHeader* header = blink::FinalizedHeapObjectHeader::fromPayload(self);
-        size_t length = header->payloadSize() / sizeof(Value);
-        for (size_t i = 0; i < length; i++) {
-            if (!HashTableHelper<Value, typename Table::ExtractorType, typename Table::KeyTraitsType>::isEmptyOrDeletedBucket(array[i]))
-                blink::CollectionBackingTraceTrait<ShouldBeTraced<Traits>::value, Traits::weakHandlingFlag, strongify, Value, Traits>::trace(visitor, array[i]);
-        }
         return false;
     }
 };
 
 // This specialization of TraceInCollectionTrait is for the backing of
 // HeapListHashSet. This is for the case that we find a reference to the
 // backing from the stack. That probably means we have a GC while we are in a
 // ListHashSet method since normal API use does not put pointers to the backing
 // on the stack.
 template<ShouldWeakPointersBeMarkedStrongly strongify, typename NodeContents, size_t inlineCapacity, typename T, typename U, typename V, typename W, typename X, typename Y>
 struct TraceInCollectionTrait<NoWeakHandlingInCollections, strongify, blink::HeapHashTableBacking<HashTable<ListHashSetNode<NodeContents, blink::HeapListHashSetAllocator<T, inlineCapacity> >*, U, V, W, X, Y, blink::HeapAllocator> >, void> {
     typedef ListHashSetNode<NodeContents, blink::HeapListHashSetAllocator<T, inlineCapacity> > Node;
     typedef HashTable<Node*, U, V, W, X, Y, blink::HeapAllocator> Table;
     static bool trace(blink::Visitor* visitor, void* self)
     {
-        Node** array = reinterpret_cast<Node**>(self);
-        blink::FinalizedHeapObjectHeader* header = blink::FinalizedHeapObjectHeader::fromPayload(self);
-        size_t length = header->payloadSize() / sizeof(Node*);
-        for (size_t i = 0; i < length; i++) {
-            if (!HashTableHelper<Node*, typename Table::ExtractorType, typename Table::KeyTraitsType>::isEmptyOrDeletedBucket(array[i])) {
-                traceListHashSetValue(visitor, array[i]->m_value);
-                // Just mark the node without tracing because we already traced
-                // the contents, and there is no need to trace the next and
-                // prev fields since iterating over the hash table backing will
-                // find the whole chain.
-                visitor->markNoTracing(array[i]);
-            }
-        }
         return false;
     }
 };
 
 // Key value pairs, as used in HashMap. To disambiguate template choice we have
 // to have two versions, first the one with no special weak handling, then the
 // one with weak handling.
 template<ShouldWeakPointersBeMarkedStrongly strongify, typename Key, typename Value, typename Traits>
 struct TraceInCollectionTrait<NoWeakHandlingInCollections, strongify, KeyValuePair<Key, Value>, Traits>  {
     static bool trace(blink::Visitor* visitor, KeyValuePair<Key, Value>& self)
     {
-        ASSERT(ShouldBeTraced<Traits>::value);
-        blink::CollectionBackingTraceTrait<ShouldBeTraced<typename Traits::KeyTraits>::value, NoWeakHandlingInCollections, strongify, Key, typename Traits::KeyTraits>::trace(visitor, self.key);
-        blink::CollectionBackingTraceTrait<ShouldBeTraced<typename Traits::ValueTraits>::value, NoWeakHandlingInCollections, strongify, Value, typename Traits::ValueTraits>::trace(visitor, self.value);
         return false;
     }
 };
 
 template<ShouldWeakPointersBeMarkedStrongly strongify, typename Key, typename Value, typename Traits>
 struct TraceInCollectionTrait<WeakHandlingInCollections, strongify, KeyValuePair<Key, Value>, Traits> {
     static bool trace(blink::Visitor* visitor, KeyValuePair<Key, Value>& self)
     {
-        // This is the core of the ephemeron-like functionality. If there is
-        // weakness on the key side then we first check whether there are
-        // dead weak pointers on that side, and if there are we don't mark the
-        // value side (yet). Conversely if there is weakness on the value side
-        // we check that first and don't mark the key side yet if we find dead
-        // weak pointers.
-        // Corner case: If there is weakness on both the key and value side,
-        // and there are also strong pointers on the both sides then we could
-        // unexpectedly leak. The scenario is that the weak pointer on the key
-        // side is alive, which causes the strong pointer on the key side to be
-        // marked. If that then results in the object pointed to by the weak
-        // pointer on the value side being marked live, then the whole
-        // key-value entry is leaked. To avoid unexpected leaking, we disallow
-        // this case, but if you run into this assert, please reach out to Blink
-        // reviewers, and we may relax it.
-        const bool keyIsWeak = Traits::KeyTraits::weakHandlingFlag == WeakHandlingInCollections;
-        const bool valueIsWeak = Traits::ValueTraits::weakHandlingFlag == WeakHandlingInCollections;
-        const bool keyHasStrongRefs = ShouldBeTraced<typename Traits::KeyTraits>::value;
-        const bool valueHasStrongRefs = ShouldBeTraced<typename Traits::ValueTraits>::value;
-        COMPILE_ASSERT(!keyIsWeak || !valueIsWeak || !keyHasStrongRefs || !valueHasStrongRefs, ThisConfigurationWasDisallowedToAvoidUnexpectedLeaks);
-        if ((valueIsWeak && !keyIsWeak) || (valueIsWeak && keyIsWeak && !valueHasStrongRefs)) {
-            // Check value first.
-            bool deadWeakObjectsFoundOnValueSide = blink::CollectionBackingTraceTrait<ShouldBeTraced<typename Traits::ValueTraits>::value, Traits::ValueTraits::weakHandlingFlag, strongify, Value, typename Traits::ValueTraits>::trace(visitor, self.value);
-            if (deadWeakObjectsFoundOnValueSide)
-                return true;
-            return blink::CollectionBackingTraceTrait<ShouldBeTraced<typename Traits::KeyTraits>::value, Traits::KeyTraits::weakHandlingFlag, strongify, Key, typename Traits::KeyTraits>::trace(visitor, self.key);
-        }
-        // Check key first.
-        bool deadWeakObjectsFoundOnKeySide = blink::CollectionBackingTraceTrait<ShouldBeTraced<typename Traits::KeyTraits>::value, Traits::KeyTraits::weakHandlingFlag, strongify, Key, typename Traits::KeyTraits>::trace(visitor, self.key);
-        if (deadWeakObjectsFoundOnKeySide)
-            return true;
-        return blink::CollectionBackingTraceTrait<ShouldBeTraced<typename Traits::ValueTraits>::value, Traits::ValueTraits::weakHandlingFlag, strongify, Value, typename Traits::ValueTraits>::trace(visitor, self.value);
+        return false;
     }
 };
 
 // Nodes used by LinkedHashSet. Again we need two versions to disambiguate the
 // template.
 template<ShouldWeakPointersBeMarkedStrongly strongify, typename Value, typename Allocator, typename Traits>
 struct TraceInCollectionTrait<NoWeakHandlingInCollections, strongify, LinkedHashSetNode<Value, Allocator>, Traits> {
     static bool trace(blink::Visitor* visitor, LinkedHashSetNode<Value, Allocator>& self)
     {
-        ASSERT(ShouldBeTraced<Traits>::value);
-        blink::TraceTrait<Value>::trace(visitor, &self.m_value);
         return false;
     }
 };
 
 template<ShouldWeakPointersBeMarkedStrongly strongify, typename Value, typename Allocator, typename Traits>
 struct TraceInCollectionTrait<WeakHandlingInCollections, strongify, LinkedHashSetNode<Value, Allocator>, Traits> {
     static bool trace(blink::Visitor* visitor, LinkedHashSetNode<Value, Allocator>& self)
     {
-        return TraceInCollectionTrait<WeakHandlingInCollections, strongify, Value, typename Traits::ValueTraits>::trace(visitor, self.m_value);
+        return false;
     }
 };
 
 // ListHashSetNode pointers (a ListHashSet is implemented as a hash table of these pointers).
 template<ShouldWeakPointersBeMarkedStrongly strongify, typename Value, size_t inlineCapacity, typename Traits>
 struct TraceInCollectionTrait<NoWeakHandlingInCollections, strongify, ListHashSetNode<Value, blink::HeapListHashSetAllocator<Value, inlineCapacity> >*, Traits> {
     typedef ListHashSetNode<Value, blink::HeapListHashSetAllocator<Value, inlineCapacity> > Node;
     static bool trace(blink::Visitor* visitor, Node* node)
     {
-        traceListHashSetValue(visitor, node->m_value);
-        // Just mark the node without tracing because we already traced the
-        // contents, and there is no need to trace the next and prev fields
-        // since iterating over the hash table backing will find the whole
-        // chain.
-        visitor->markNoTracing(node);
         return false;
     }
 };
 
 } // namespace WTF
 
 namespace blink {
 
 // CollectionBackingTraceTrait. Do nothing for things in collections that don't
 // need tracing, or call TraceInCollectionTrait for those that do.
 
 // Specialization for things that don't need marking and have no weak pointers. We
 // do nothing, even if WTF::WeakPointersActStrong.
 template<WTF::ShouldWeakPointersBeMarkedStrongly strongify, typename T, typename Traits>
 struct CollectionBackingTraceTrait<false, WTF::NoWeakHandlingInCollections, strongify, T, Traits> {
     static bool trace(Visitor*, T&) { return false; }
 };
 
 // Specialization for things that either need marking or have weak pointers or
 // both.
 template<bool needsTracing, WTF::WeakHandlingFlag weakHandlingFlag, WTF::ShouldWeakPointersBeMarkedStrongly strongify, typename T, typename Traits>
 struct CollectionBackingTraceTrait {
     static bool trace(Visitor* visitor, T&t)
     {
-        Visitor::verifyGarbageCollectedIfMember(reinterpret_cast<T*>(0));
-        return WTF::TraceInCollectionTrait<weakHandlingFlag, strongify, T, Traits>::trace(visitor, t);
+        return false;
     }
 };
 
 template<typename T> struct WeakHandlingHashTraits : WTF::SimpleClassHashTraits<T> {
     // We want to treat the object as a weak object in the sense that it can
     // disappear from hash sets and hash maps.
     static const WTF::WeakHandlingFlag weakHandlingFlag = WTF::WeakHandlingInCollections;
     // Normally whether or not an object needs tracing is inferred
     // automatically from the presence of the trace method, but we don't
     // necessarily have a trace method, and we may not need one because T
@@ skipping 14 matching lines @@
     {
         return t.traceInCollection(visitor, strongify);
     }
 };
 
 template<typename T, typename Traits>
 struct TraceTrait<HeapVectorBacking<T, Traits> > {
     typedef HeapVectorBacking<T, Traits> Backing;
     static void trace(Visitor* visitor, void* self)
     {
-        COMPILE_ASSERT(!WTF::IsWeak<T>::value, WeDontSupportWeaknessInHeapVectorsOrDeques);
-        if (WTF::ShouldBeTraced<Traits>::value)
-            WTF::TraceInCollectionTrait<WTF::NoWeakHandlingInCollections, WTF::WeakPointersActWeak, HeapVectorBacking<T, Traits>, void>::trace(visitor, self);
     }
     static void mark(Visitor* visitor, const Backing* backing)
     {
-        visitor->mark(backing, &trace);
-    }
-    static void checkGCInfo(Visitor* visitor, const Backing* backing)
-    {
-#if ENABLE(ASSERT)
-        visitor->checkGCInfo(const_cast<Backing*>(backing), GCInfoTrait<Backing>::get());
-#endif
     }
 };
 
 // The trace trait for the heap hashtable backing is used when we find a
 // direct pointer to the backing from the conservative stack scanner. This
 // normally indicates that there is an ongoing iteration over the table, and so
 // we disable weak processing of table entries. When the backing is found
 // through the owning hash table we mark differently, in order to do weak
 // processing.
 template<typename Table>
 struct TraceTrait<HeapHashTableBacking<Table> > {
     typedef HeapHashTableBacking<Table> Backing;
     typedef typename Table::ValueTraits Traits;
     static void trace(Visitor* visitor, void* self)
     {
-        if (WTF::ShouldBeTraced<Traits>::value || Traits::weakHandlingFlag == WTF::WeakHandlingInCollections)
-            WTF::TraceInCollectionTrait<WTF::NoWeakHandlingInCollections, WTF::WeakPointersActStrong, Backing, void>::trace(visitor, self);
     }
     static void mark(Visitor* visitor, const Backing* backing)
     {
-        if (WTF::ShouldBeTraced<Traits>::value || Traits::weakHandlingFlag == WTF::WeakHandlingInCollections)
-            visitor->mark(backing, &trace);
-        else
-            visitor->markNoTracing(backing); // If we know the trace function will do nothing there is no need to call it.
-    }
-    static void checkGCInfo(Visitor* visitor, const Backing* backing)
-    {
-#if ENABLE(ASSERT)
-        visitor->checkGCInfo(const_cast<Backing*>(backing), GCInfoTrait<Backing>::get());
-#endif
     }
 };
 
 template<typename Table>
 void HeapHashTableBacking<Table>::finalize(void* pointer)
 {
-    typedef typename Table::ValueType Value;
-    ASSERT(Table::ValueTraits::needsDestruction);
-    FinalizedHeapObjectHeader* header = FinalizedHeapObjectHeader::fromPayload(pointer);
-    // Use the payload size as recorded by the heap to determine how many
-    // elements to finalize.
-    size_t length = header->payloadSize() / sizeof(Value);
-    Value* table = reinterpret_cast<Value*>(pointer);
-    for (unsigned i = 0; i < length; i++) {
-        if (!Table::isEmptyOrDeletedBucket(table[i]))
-            table[i].~Value();
-    }
 }
 
 template<typename T, typename U, typename V, typename W, typename X>
 struct GCInfoTrait<HeapHashMap<T, U, V, W, X> > : public GCInfoTrait<HashMap<T, U, V, W, X, HeapAllocator> > { };
 template<typename T, typename U, typename V>
 struct GCInfoTrait<HeapHashSet<T, U, V> > : public GCInfoTrait<HashSet<T, U, V, HeapAllocator> > { };
 template<typename T, typename U, typename V>
 struct GCInfoTrait<HeapLinkedHashSet<T, U, V> > : public GCInfoTrait<LinkedHashSet<T, U, V, HeapAllocator> > { };
 template<typename T, size_t inlineCapacity, typename U>
 struct GCInfoTrait<HeapListHashSet<T, inlineCapacity, U> > : public GCInfoTrait<ListHashSet<T, inlineCapacity, U, HeapListHashSetAllocator<T, inlineCapacity> > > { };
@@ skipping 14 matching lines @@
 };
 
 template<typename T>
 struct IfWeakMember<WeakMember<T> > {
     static bool isDead(Visitor* visitor, const WeakMember<T>& t) { return !visitor->isAlive(t.get()); }
 };
 
 }
 
 #endif // Heap_h