Hollow out more of the tracing system in oilpan

sky/engine/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 151 matching lines @@
 // needed is when multiple inheritance leads to pointers that are not
 // to the start of the object in the Blink garbage-collected heap. In
 // that case the pointer has to be adjusted before marking.
 template<typename T>
 class TraceTrait {
 public:
     // Default implementation of TraceTrait<T>::trace just statically
     // dispatches to the trace method of the class T.
     static void trace(Visitor* visitor, void* self)
     {
-        static_cast<T*>(self)->trace(visitor);
     }
 
     static void mark(Visitor* visitor, const T* t)
     {
-        DefaultTraceTrait<T>::mark(visitor, t);
     }
-
-#if ENABLE(ASSERT)
-    static void checkGCInfo(Visitor* visitor, const T* t)
-    {
-        DefaultTraceTrait<T>::checkGCInfo(visitor, t);
-    }
-#endif
 };
 
 template<typename T> class TraceTrait<const T> : public TraceTrait<T> { };
 
 template<typename Collection>
 struct OffHeapCollectionTraceTrait;
 
 template<typename T>
 struct ObjectAliveTrait {
     static bool isAlive(Visitor*, T*);
@@ skipping 13 matching lines @@
     virtual ~Visitor() { }
 
     template<typename T>
     static void verifyGarbageCollectedIfMember(T*)
     {
     }
 
     template<typename T>
     static void verifyGarbageCollectedIfMember(Member<T>* t)
     {
-        t->verifyTypeIsGarbageCollected();
     }
 
     // One-argument templated mark method. This uses the static type of
     // the argument to get the TraceTrait. By default, the mark method
     // of the TraceTrait just calls the virtual two-argument mark method on this
     // visitor, where the second argument is the static trace method of the trait.
     template<typename T>
     void mark(T* t)
     {
-        if (!t)
-            return;
-#if ENABLE(ASSERT)
-        TraceTrait<T>::checkGCInfo(this, t);
-#endif
-        TraceTrait<T>::mark(this, t);
-
-        reinterpret_cast<const Member<T>*>(0)->verifyTypeIsGarbageCollected();
     }
 
     // Member version of the one-argument templated trace method.
     template<typename T>
     void trace(const Member<T>& t)
     {
-        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. 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)
     {
-        // Check that we actually know the definition of T when tracing.
-        COMPILE_ASSERT(sizeof(T), WeNeedToKnowTheDefinitionOfTheTypeWeAreTracing);
-        registerWeakCell(const_cast<WeakMember<T>&>(t).cell());
-        reinterpret_cast<const Member<T>*>(0)->verifyTypeIsGarbageCollected();
     }
 
     template<typename T>
     void traceInCollection(T& t, WTF::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)
     {
-        if (WTF::IsPolymorphic<T>::value) {
-            intptr_t vtable = *reinterpret_cast<const intptr_t*>(&t);
-            if (!vtable)
-                return;
-        }
-        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>& vector)
     {
-        OffHeapCollectionTraceTrait<Vector<T, inlineCapacity, WTF::DefaultAllocator> >::trace(this, vector);
     }
 
     template<typename T, size_t N>
     void trace(const Deque<T, N>& deque)
     {
-        OffHeapCollectionTraceTrait<Deque<T, N> >::trace(this, deque);
     }
 
 #if !ENABLE(OILPAN)
     // These trace methods are needed to allow compiling and calling trace on
     // transition types. We need to support calls in the non-oilpan build
     // because a fully transitioned type (which will have its trace method
     // called) might trace a field that is in transition. Once transition types
     // are removed these can be removed.
     template<typename T> void trace(const OwnPtr<T>&) { }
     template<typename T> void trace(const RefPtr<T>&) { }
@@ skipping 89 matching lines @@
     }
     template<typename T> inline bool isAlive(const Member<T>& member)
     {
         return isAlive(member.get());
     }
     template<typename T> inline bool isAlive(RawPtr<T> ptr)
     {
         return isAlive(ptr.get());
     }
 
-#if ENABLE(ASSERT)
-    void checkGCInfo(const void*, const GCInfo*);
-#endif
-
     // Macro to declare methods needed for each typed heap.
 #define DECLARE_VISITOR_METHODS(Type)                                  \
-    DEBUG_ONLY(void checkGCInfo(const Type*, const GCInfo*);)          \
     virtual void mark(const Type*, TraceCallback) = 0;                 \
     virtual bool isMarked(const Type*) = 0;
 
     FOR_EACH_TYPED_HEAP(DECLARE_VISITOR_METHODS)
 #undef DECLARE_VISITOR_METHODS
 
 #if ENABLE(GC_PROFILE_MARKING)
     void setHostInfo(void* object, const String& name)
     {
         m_hostObject = object;
@@ skipping 20 matching lines @@
 
 // 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;
 
     static void trace(Visitor* visitor, const Vector& vector)
     {
-        if (vector.isEmpty())
-            return;
-        for (typename Vector::const_iterator it = vector.begin(), end = vector.end(); it != end; ++it)
-            TraceTrait<T>::trace(visitor, const_cast<T*>(it));
     }
 };
 
 template<typename T, size_t N>
 struct OffHeapCollectionTraceTrait<WTF::Deque<T, N> > {
     typedef WTF::Deque<T, N> Deque;
 
     static void trace(Visitor* visitor, const Deque& deque)
     {
-        if (deque.isEmpty())
-            return;
-        for (typename Deque::const_iterator it = deque.begin(), end = deque.end(); it != end; ++it)
-            TraceTrait<T>::trace(visitor, const_cast<T*>(&(*it)));
     }
 };
 
 template<typename T, typename Traits = WTF::VectorTraits<T> >
 class HeapVectorBacking;
 
 template<typename Table>
 class HeapHashTableBacking {
 public:
     static void finalize(void* pointer);
 };
 
 template<typename T>
 class DefaultTraceTrait<T, false> {
 public:
     static void mark(Visitor* visitor, const T* t)
     {
-        // Default mark method of the trait just calls the two-argument mark
-        // method on the visitor. The second argument is the static trace method
-        // of the trait, which by default calls the instance method
-        // trace(Visitor*) on the object.
-        visitor->mark(const_cast<T*>(t), &TraceTrait<T>::trace);
     }
-
-#if ENABLE(ASSERT)
-    static void checkGCInfo(Visitor* visitor, const T* t)
-    {
-        visitor->checkGCInfo(const_cast<T*>(t), GCInfoTrait<T>::get());
-    }
-#endif
 };
 
 template<typename T>
 class DefaultTraceTrait<T, true> {
 public:
     static void mark(Visitor* visitor, const T* self)
     {
         if (!self)
             return;
 
         // Before doing adjustAndMark we need to check if the page is orphaned
         // since we cannot call adjustAndMark if so, as there will be no vtable.
         // If orphaned just mark the page as traced.
         BaseHeapPage* heapPage = pageHeaderFromObject(self);
         if (heapPage->orphaned()) {
             heapPage->setTracedAfterOrphaned();
             return;
         }
         self->adjustAndMark(visitor);
     }
-
-#if ENABLE(ASSERT)
-    static void checkGCInfo(Visitor*, const T*) { }
-#endif
 };
 
 template<typename T, bool = NeedsAdjustAndMark<T>::value> class DefaultObjectAliveTrait;
 
 template<typename T>
 class DefaultObjectAliveTrait<T, false> {
 public:
     static bool isAlive(Visitor* visitor, T* obj)
     {
         return visitor->isMarked(obj);
@@ skipping 107 matching lines @@
 struct GCInfoTrait {
     static const GCInfo* get()
     {
         return GCInfoAtBase<typename GetGarbageCollectedBase<T>::type>::get();
     }
 };
 
 }
 
 #endif