Oilpan: deprecate GCInfO::typeMarker and replace its checks w/ gcInfo ptr compare

Source/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 68 matching lines @@
 // 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; }
-    const char* m_typeMarker;
     TraceCallback m_trace;
     FinalizationCallback m_finalize;
     bool m_nonTrivialFinalizer;
 };
 
 // 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>
@@ skipping 19 matching lines @@
 template<typename T>
 struct FinalizerTrait {
     static const bool nonTrivialFinalizer = WTF::IsSubclassOfTemplate<T, 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>
-const char* getTypeMarker()
-{
-    return GCInfoTrait<T>::get()->m_typeMarker;
-}
-
 template<typename T> class GarbageCollected;
 class GarbageCollectedMixin;
 template<typename T, bool = WTF::IsSubclassOfTemplate<T, GarbageCollected>::value> class NeedsAdjustAndMark;
 
 template<typename T>
 class NeedsAdjustAndMark<T, true> {
 public:
     static const bool value = false;
 };
 
@@ skipping 25 matching lines @@
     {
         static_cast<T*>(self)->trace(visitor);
     }
 
     static void mark(Visitor* visitor, const T* t)
     {
         DefaultTraceTrait<T>::mark(visitor, t);
     }
 
 #ifndef NDEBUG
-    static void checkTypeMarker(Visitor* visitor, const T* t)
+    static void checkGCInfo(Visitor* visitor, const T* t)
     {
-        DefaultTraceTrait<T>::checkTypeMarker(visitor, 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>
@@ skipping 20 matching lines @@
     // 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;
 #ifndef NDEBUG
-        TraceTrait<T>::checkTypeMarker(this, t);
+        TraceTrait<T>::checkGCInfo(this, t);
 #endif
         TraceTrait<T>::mark(this, t);
     }
 
     // Member version of the one-argument templated trace method.
     template<typename T>
     void trace(const Member<T>& t)
     {
         mark(t.get());
     }
@@ skipping 128 matching lines @@
 
     virtual bool isMarked(const void*) = 0;
 
     template<typename T> inline bool isAlive(T obj) { return ObjectAliveTrait<T>::isAlive(this, obj); }
     template<typename T> inline bool isAlive(const Member<T>& member)
     {
         return isAlive(member.get());
     }
 
 #ifndef NDEBUG
-    void checkTypeMarker(const void*, const char* marker);
+    void checkGCInfo(const void*, const GCInfo*);
 #endif
 
     // Macro to declare methods needed for each typed heap.
 #define DECLARE_VISITOR_METHODS(Type)                                  \
-    DEBUG_ONLY(void checkTypeMarker(const Type*, const char* marker);) \
+    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
 
 private:
     template<typename T>
     static void handleWeakCell(Visitor* self, void* obj)
     {
@@ skipping 95 matching lines @@
 // to the default. Most of them do nothing, since the type in question cannot
 // point to other heap allocated objects.
 #define ITERATE_DO_NOTHING_TYPES(f)                                  \
     f(uint8_t)                                                       \
     f(void)
 
 #define DECLARE_DO_NOTHING_TRAIT(type)                               \
     template<>                                                       \
     class TraceTrait<type> {                                         \
     public:                                                          \
-        static void checkTypeMarker(Visitor*, const void*) { }       \
+        static void checkGCInfo(Visitor*, const void*) { }       \
         static void mark(Visitor* visitor, const type* p) {          \
             visitor->mark(p, reinterpret_cast<TraceCallback>(0));    \
         }                                                            \
     };                                                               \
     template<>                                                       \
     struct FinalizerTrait<type> {                                    \
         static void finalize(void*) { }                              \
         static const bool nonTrivialFinalizer = false;               \
     };                                                               \
     template<>                                                       \
     struct HEAP_EXPORT GCInfoTrait<type> {                           \
         static const GCInfo* get()                                   \
         {                                                            \
             return &info;                                            \
         }                                                            \
         static const GCInfo info;                                    \
     };
 
 ITERATE_DO_NOTHING_TYPES(DECLARE_DO_NOTHING_TRAIT)
 
 #undef DECLARE_DO_NOTHING_TRAIT
 
 template<typename T>
 class DefaultTraceTrait<T, false> {
 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)
     {
         // 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);
     }
 
 #ifndef NDEBUG
-    static void checkTypeMarker(Visitor* visitor, const T* t)
+    static void checkGCInfo(Visitor* visitor, const T* t)
     {
-        visitor->checkTypeMarker(const_cast<T*>(t), getTypeMarker<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)
     {
         self->adjustAndMark(visitor);
     }
 
 #ifndef NDEBUG
-    static void checkTypeMarker(Visitor*, const T*) { }
+    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)
     {
@@ skipping 62 matching lines @@
 #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
 
 template<typename T>
 struct GCInfoAtBase {
     static const GCInfo* get()
     {
-        static char pseudoTypeMarker = 'a';
         static const GCInfo gcInfo = {
-            &pseudoTypeMarker,
             TraceTrait<T>::trace,
             FinalizerTrait<T>::finalize,
             FinalizerTrait<T>::nonTrivialFinalizer,
         };
         return &gcInfo;
     }
 };
 
 template<typename T> class GarbageCollected;
 template<typename T, bool = WTF::IsSubclassOfTemplate<T, GarbageCollected>::value> struct GetGarbageCollectedBase;
@@ skipping 12 matching lines @@
 struct GCInfoTrait {
     static const GCInfo* get()
     {
         return GCInfoAtBase<typename GetGarbageCollectedBase<T>::type>::get();
     }
 };
 
 }
 
 #endif