Remove almost all of 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
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *     * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#ifndef Visitor_h
-#define Visitor_h
-
-#include "platform/PlatformExport.h"
-#include "platform/heap/ThreadState.h"
-#include "wtf/Assertions.h"
-#include "wtf/Deque.h"
-#include "wtf/Forward.h"
-#include "wtf/HashMap.h"
-#include "wtf/HashTraits.h"
-#include "wtf/InstanceCounter.h"
-#include "wtf/OwnPtr.h"
-#include "wtf/RefPtr.h"
-#include "wtf/TypeTraits.h"
-#include "wtf/WeakPtr.h"
-#if ENABLE(GC_PROFILING)
-#include "wtf/text/WTFString.h"
-#endif
-
-#if ENABLE(ASSERT)
-#define DEBUG_ONLY(x) x
-#else
-#define DEBUG_ONLY(x)
-#endif
-
-namespace blink {
-
-class FinalizedHeapObjectHeader;
-template<typename T> class GarbageCollectedFinalized;
-class HeapObjectHeader;
-template<typename T> class Member;
-template<typename T> class WeakMember;
-class Visitor;
-
-template<bool needsTracing, WTF::WeakHandlingFlag weakHandlingFlag, WTF::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); }
-};
-
-// GCInfo contains meta-data associated with objects allocated in the
-// Blink heap. This meta-data consists of a function pointer used to
-// trace the pointers in the object during garbage collection, an
-// indication of whether or not the object needs a finalization
-// callback, and a function pointer used to finalize the object when
-// the garbage collector determines that the object is no longer
-// reachable. There is a GCInfo struct for each class that directly
-// inherits from GarbageCollected or GarbageCollectedFinalized.
-struct GCInfo {
-    bool hasFinalizer() const { return m_nonTrivialFinalizer; }
-    bool hasVTable() const { return m_hasVTable; }
-    TraceCallback m_trace;
-    FinalizationCallback m_finalize;
-    bool m_nonTrivialFinalizer;
-    bool m_hasVTable;
-#if ENABLE(GC_PROFILING)
-    // |m_className| is held as a reference to prevent dtor being called at exit.
-    const String& m_className;
-#endif
-};
-
-// The FinalizerTraitImpl specifies how to finalize objects. Object
-// that inherit from GarbageCollectedFinalized are finalized by
-// calling their 'finalize' method which by default will call the
-// destructor on the object.
-template<typename T, bool isGarbageCollectedFinalized>
-struct FinalizerTraitImpl;
-
-template<typename T>
-struct FinalizerTraitImpl<T, true> {
-    static void finalize(void* obj) { static_cast<T*>(obj)->finalizeGarbageCollectedObject(); };
-};
-
-template<typename T>
-struct FinalizerTraitImpl<T, false> {
-    static void finalize(void* obj) { };
-};
-
-// The FinalizerTrait is used to determine if a type requires
-// finalization and what finalization means.
-//
-// By default classes that inherit from GarbageCollectedFinalized need
-// finalization and finalization means calling the 'finalize' method
-// of the object. The FinalizerTrait can be specialized if the default
-// behavior is not desired.
-template<typename T>
-struct FinalizerTrait {
-    static const bool nonTrivialFinalizer = WTF::IsSubclassOfTemplate<typename WTF::RemoveConst<T>::Type, GarbageCollectedFinalized>::value;
-    static void finalize(void* obj) { FinalizerTraitImpl<T, nonTrivialFinalizer>::finalize(obj); }
-};
-
-// Trait to get the GCInfo structure for types that have their
-// instances allocated in the Blink garbage-collected heap.
-template<typename T> struct GCInfoTrait;
-
-template<typename T> class GarbageCollected;
-class GarbageCollectedMixin;
-template<typename T, bool = WTF::IsSubclassOfTemplate<typename WTF::RemoveConst<T>::Type, GarbageCollected>::value> class NeedsAdjustAndMark;
-
-template<typename T>
-class NeedsAdjustAndMark<T, true> {
-public:
-    static const bool value = false;
-};
-
-template <typename T> const bool NeedsAdjustAndMark<T, true>::value;
-
-template<typename T>
-class NeedsAdjustAndMark<T, false> {
-public:
-    static const bool value = WTF::IsSubclass<typename WTF::RemoveConst<T>::Type, GarbageCollectedMixin>::value;
-};
-
-template <typename T> const bool NeedsAdjustAndMark<T, false>::value;
-
-template<typename T, bool = NeedsAdjustAndMark<T>::value> class DefaultTraceTrait;
-
-// The TraceTrait is used to specify how to mark an object pointer and
-// how to trace all of the pointers in the object.
-//
-// By default, the 'trace' method implemented on an object itself is
-// used to trace the pointers to other heap objects inside the object.
-//
-// However, the TraceTrait can be specialized to use a different
-// implementation. A common case where a TraceTrait specialization is
-// 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 void mark(Visitor* visitor, const T* t)
-    {
-    }
-};
-
-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*);
-};
-
-// Visitor is used to traverse the Blink object graph. Used for the
-// marking phase of the mark-sweep garbage collector.
-//
-// Pointers are marked and pushed on the marking stack by calling the
-// |mark| method with the pointer as an argument.
-//
-// Pointers within objects are traced by calling the |trace| methods
-// with the object as an argument. Tracing objects will mark all of the
-// contained pointers and push them on the marking stack.
-class PLATFORM_EXPORT Visitor {
-public:
-    virtual ~Visitor() { }
-
-    template<typename T>
-    static void verifyGarbageCollectedIfMember(T*)
-    {
-    }
-
-    template<typename T>
-    static void verifyGarbageCollectedIfMember(Member<T>* t)
-    {
-    }
-
-    // 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)
-    {
-    }
-
-    // Member version of the one-argument templated trace method.
-    template<typename T>
-    void trace(const Member<T>& t)
-    {
-    }
-
-    // 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)
-    {
-    }
-
-    template<typename T>
-    void trace(T* 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)
-    {
-    }
-
-    template<typename T>
-    void traceInCollection(T& t, WTF::ShouldWeakPointersBeMarkedStrongly 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)
-    {
-    }
-
-    // The following trace methods are for off-heap collections.
-    template<typename T, size_t inlineCapacity>
-    void trace(const Vector<T, inlineCapacity>& vector)
-    {
-    }
-
-    template<typename T, size_t N>
-    void trace(const Deque<T, N>& 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>&) { }
-    template<typename T> void trace(const RawPtr<T>&) { }
-    template<typename T> void trace(const WeakPtr<T>&) { }
-#endif
-
-    // This method marks an object and adds it to the set of objects
-    // that should have their trace method called. Since not all
-    // objects have vtables we have to have the callback as an
-    // explicit argument, but we can use the templated one-argument
-    // mark method above to automatically provide the callback
-    // function.
-    virtual void mark(const void*, TraceCallback) = 0;
-    virtual void markNoTracing(const void* pointer) { mark(pointer, reinterpret_cast<TraceCallback>(0)); }
-    virtual void markNoTracing(HeapObjectHeader* header) { mark(header, reinterpret_cast<TraceCallback>(0)); }
-    virtual void markNoTracing(FinalizedHeapObjectHeader* header) { mark(header, reinterpret_cast<TraceCallback>(0)); }
-
-    // Used to mark objects during conservative scanning.
-    virtual void mark(HeapObjectHeader*, TraceCallback) = 0;
-    virtual void mark(FinalizedHeapObjectHeader*, TraceCallback) = 0;
-
-    // Used to delay the marking of objects until the usual marking
-    // including emphemeron iteration is done. This is used to delay
-    // the marking of collection backing stores until we know if they
-    // are reachable from locations other than the collection front
-    // object. If collection backings are reachable from other
-    // locations we strongify them to avoid issues with iterators and
-    // weak processing.
-    virtual void registerDelayedMarkNoTracing(const void*) = 0;
-
-    // If the object calls this during the regular trace callback, then the
-    // WeakPointerCallback argument may be called later, when the strong roots
-    // have all been found. The WeakPointerCallback will normally use isAlive
-    // to find out whether some pointers are pointing to dying objects. When
-    // the WeakPointerCallback is done the object must have purged all pointers
-    // to objects where isAlive returned false. In the weak callback it is not
-    // allowed to touch other objects (except using isAlive) or to allocate on
-    // the GC heap. Note that even removing things from HeapHashSet or
-    // HeapHashMap can cause an allocation if the backing store resizes, but
-    // these collections know to remove WeakMember elements safely.
-    //
-    // The weak pointer callbacks are run on the thread that owns the
-    // object and other threads are not stopped during the
-    // callbacks. Since isAlive is used in the callback to determine
-    // if objects pointed to are alive it is crucial that the object
-    // pointed to belong to the same thread as the object receiving
-    // the weak callback. Since other threads have been resumed the
-    // mark bits are not valid for objects from other threads.
-    virtual void registerWeakMembers(const void* object, WeakPointerCallback callback) { registerWeakMembers(object, object, callback); }
-    virtual void registerWeakMembers(const void*, const void*, WeakPointerCallback) = 0;
-
-    template<typename T, void (T::*method)(Visitor*)>
-    void registerWeakMembers(const T* obj)
-    {
-        registerWeakMembers(obj, &TraceMethodDelegate<T, method>::trampoline);
-    }
-
-    // For simple cases where you just want to zero out a cell when the thing
-    // it is pointing at is garbage, you can use this. This will register a
-    // callback for each cell that needs to be zeroed, so if you have a lot of
-    // weak cells in your object you should still consider using
-    // registerWeakMembers above.
-    //
-    // In contrast to registerWeakMembers, the weak cell callbacks are
-    // run on the thread performing garbage collection. Therefore, all
-    // threads are stopped during weak cell callbacks.
-    template<typename T>
-    void registerWeakCell(T** cell)
-    {
-        registerWeakCell(reinterpret_cast<void**>(cell), &handleWeakCell<T>);
-    }
-
-    virtual void registerWeakTable(const void*, EphemeronCallback, EphemeronCallback) = 0;
-#if ENABLE(ASSERT)
-    virtual bool weakTableRegistered(const void*) = 0;
-#endif
-
-    virtual bool isMarked(const void*) = 0;
-
-    template<typename T> inline bool isAlive(T* obj)
-    {
-        // Check that we actually know the definition of T when tracing.
-        COMPILE_ASSERT(sizeof(T), WeNeedToKnowTheDefinitionOfTheTypeWeAreTracing);
-        // The strongification of collections relies on the fact that once a
-        // collection has been strongified, there is no way that it can contain
-        // non-live entries, so no entries will be removed. Since you can't set
-        // the mark bit on a null pointer, that means that null pointers are
-        // always 'alive'.
-        if (!obj)
-            return true;
-        return ObjectAliveTrait<T>::isAlive(this, obj);
-    }
-    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());
-    }
-
-    // Macro to declare methods needed for each typed heap.
-#define DECLARE_VISITOR_METHODS(Type)                                  \
-    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;
-        m_hostName = name;
-    }
-#endif
-
-protected:
-    virtual void registerWeakCell(void**, WeakPointerCallback) = 0;
-#if ENABLE(GC_PROFILE_MARKING)
-    void* m_hostObject;
-    String m_hostName;
-#endif
-
-private:
-    template<typename T>
-    static void handleWeakCell(Visitor* self, void* obj)
-    {
-        T** cell = reinterpret_cast<T**>(obj);
-        if (*cell && !self->isAlive(*cell))
-            *cell = 0;
-    }
-};
-
-// 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)
-    {
-    }
-};
-
-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)
-    {
-    }
-};
-
-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)
-    {
-    }
-};
-
-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);
-    }
-};
-
-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);
-    }
-};
-
-template<typename T>
-class DefaultObjectAliveTrait<T, true> {
-public:
-    static bool isAlive(Visitor* visitor, T* obj)
-    {
-        return obj->isAlive(visitor);
-    }
-};
-
-template<typename T> bool ObjectAliveTrait<T>::isAlive(Visitor* visitor, T* obj)
-{
-    return DefaultObjectAliveTrait<T>::isAlive(visitor, obj);
-}
-
-// The GarbageCollectedMixin interface and helper macro
-// USING_GARBAGE_COLLECTED_MIXIN can be used to automatically define
-// TraceTrait/ObjectAliveTrait on non-leftmost deriving classes
-// which need to be garbage collected.
-//
-// Consider the following case:
-// class B {};
-// class A : public GarbageCollected, public B {};
-//
-// We can't correctly handle "Member<B> p = &a" as we can't compute addr of
-// object header statically. This can be solved by using GarbageCollectedMixin:
-// class B : public GarbageCollectedMixin {};
-// class A : public GarbageCollected, public B {
-//   USING_GARBAGE_COLLECTED_MIXIN(A)
-// };
-//
-// With the helper, as long as we are using Member<B>, TypeTrait<B> will
-// dispatch adjustAndMark dynamically to find collect addr of the object header.
-// Note that this is only enabled for Member<B>. For Member<A> which we can
-// compute the object header addr statically, this dynamic dispatch is not used.
-
-class PLATFORM_EXPORT GarbageCollectedMixin {
-public:
-    virtual void adjustAndMark(Visitor*) const { };
-    virtual bool isAlive(Visitor*) const { return true; };
-    virtual void trace(Visitor*) { }
-};
-
-#define USING_GARBAGE_COLLECTED_MIXIN(TYPE) \
-public: \
-    virtual void adjustAndMark(blink::Visitor* visitor) const override    \
-    { \
-        typedef WTF::IsSubclassOfTemplate<typename WTF::RemoveConst<TYPE>::Type, blink::GarbageCollected> IsSubclassOfGarbageCollected; \
-        COMPILE_ASSERT(IsSubclassOfGarbageCollected::value, OnlyGarbageCollectedObjectsCanHaveGarbageCollectedMixins); \
-        visitor->mark(static_cast<const TYPE*>(this), &blink::TraceTrait<TYPE>::trace); \
-    } \
-    virtual bool isAlive(blink::Visitor* visitor) const override  \
-    { \
-        return visitor->isAlive(this); \
-    } \
-private:
-
-#if ENABLE(OILPAN)
-#define WILL_BE_USING_GARBAGE_COLLECTED_MIXIN(TYPE) USING_GARBAGE_COLLECTED_MIXIN(TYPE)
-#else
-#define WILL_BE_USING_GARBAGE_COLLECTED_MIXIN(TYPE)
-#endif
-
-#if ENABLE(GC_PROFILING)
-template<typename T>
-struct TypenameStringTrait {
-    static const String& get()
-    {
-        DEFINE_STATIC_LOCAL(String, typenameString, (WTF::extractTypeNameFromFunctionName(WTF::extractNameFunction<T>())));
-        return typenameString;
-    }
-};
-#endif
-
-template<typename T>
-struct GCInfoAtBase {
-    static const GCInfo* get()
-    {
-        static const GCInfo gcInfo = {
-            TraceTrait<T>::trace,
-            FinalizerTrait<T>::finalize,
-            FinalizerTrait<T>::nonTrivialFinalizer,
-            WTF::IsPolymorphic<T>::value,
-#if ENABLE(GC_PROFILING)
-            TypenameStringTrait<T>::get()
-#endif
-        };
-        return &gcInfo;
-    }
-};
-
-template<typename T> class GarbageCollected;
-template<typename T, bool = WTF::IsSubclassOfTemplate<typename WTF::RemoveConst<T>::Type, GarbageCollected>::value> struct GetGarbageCollectedBase;
-
-template<typename T>
-struct GetGarbageCollectedBase<T, true> {
-    typedef typename T::GarbageCollectedBase type;
-};
-
-template<typename T>
-struct GetGarbageCollectedBase<T, false> {
-    typedef T type;
-};
-
-template<typename T>
-struct GCInfoTrait {
-    static const GCInfo* get()
-    {
-        return GCInfoAtBase<typename GetGarbageCollectedBase<T>::type>::get();
-    }
-};
-
-}
-
-#endif