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

Source/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 303 matching lines @@
     {
     }
 
     inline Address payload();
     inline size_t payloadSize();
 
     NO_SANITIZE_ADDRESS
     const GCInfo* gcInfo() { return m_gcInfo; }
 
     NO_SANITIZE_ADDRESS
-    const char* typeMarker() { return m_gcInfo->m_typeMarker; }
-
-    NO_SANITIZE_ADDRESS
     TraceCallback traceCallback() { return m_gcInfo->m_trace; }
 
     void finalize();
 
     NO_SANITIZE_ADDRESS
     inline bool hasFinalizer() { return m_gcInfo->hasFinalizer(); }
 
     HEAP_EXPORT static FinalizedHeapObjectHeader* fromPayload(const void*);
 
 private:
@@ skipping 1062 matching lines @@
 // specialization of GCInfoTrait for these three classes here.
 
 template<typename Key, typename Value, typename T, typename U, typename V>
 struct GCInfoTrait<HashMap<Key, Value, T, U, V, HeapAllocator> > {
     static const GCInfo* get() { return &info; }
     static const GCInfo info;
 };
 
 template<typename Key, typename Value, typename T, typename U, typename V>
 const GCInfo GCInfoTrait<HashMap<Key, Value, T, U, V, HeapAllocator> >::info = {
-    "HashMap",
     TraceTrait<HashMap<Key, Value, T, U, V, HeapAllocator> >::trace,
     0,
     false, // HashMap needs no finalizer.
 };
 
 template<typename T, typename U, typename V>
 struct GCInfoTrait<HashSet<T, U, V, HeapAllocator> > {
     static const GCInfo* get() { return &info; }
     static const GCInfo info;
 };
 
 template<typename T, typename U, typename V>
 const GCInfo GCInfoTrait<HashSet<T, U, V, HeapAllocator> >::info = {
-    "HashSet",
     TraceTrait<HashSet<T, U, V, HeapAllocator> >::trace,
     0,
     false, // HashSet needs no finalizer.
 };
 
 template<typename T>
 struct GCInfoTrait<Vector<T, 0, HeapAllocator> > {
     static const GCInfo* get() { return &info; }
     static const GCInfo info;
 };
 
 template<typename T>
 const GCInfo GCInfoTrait<Vector<T, 0, HeapAllocator> >::info = {
-    "Vector",
     TraceTrait<Vector<T, 0, HeapAllocator> >::trace,
     0,
     false, // Vector needs no finalizer if it has no inline capacity.
 };
 
 template<typename T, size_t inlineCapacity>
 struct GCInfoTrait<Vector<T, inlineCapacity, HeapAllocator> > {
     static const GCInfo* get() { return &info; }
     static const GCInfo info;
 };
 
 template<typename T, size_t inlineCapacity>
 struct FinalizerTrait<Vector<T, inlineCapacity, HeapAllocator> > : public FinalizerTraitImpl<Vector<T, inlineCapacity, HeapAllocator>, true> { };
 
 template<typename T, size_t inlineCapacity>
 const GCInfo GCInfoTrait<Vector<T, inlineCapacity, HeapAllocator> >::info = {
-    "Vector",
     TraceTrait<Vector<T, inlineCapacity, HeapAllocator> >::trace,
     FinalizerTrait<Vector<T, inlineCapacity, HeapAllocator> >::finalize,
     // Finalizer is needed to destruct things stored in the inline capacity.
     inlineCapacity && VectorTraits<T>::needsDestruction,
 };
 
 template<typename T, typename Traits>
 struct GCInfoTrait<HeapVectorBacking<T, Traits> > {
     static const GCInfo* get() { return &info; }
     static const GCInfo info;
 };
 
 template<typename T, typename Traits>
 const GCInfo GCInfoTrait<HeapVectorBacking<T, Traits> >::info = {
-    "VectorBacking",
     TraceTrait<HeapVectorBacking<T, Traits> >::trace,
     FinalizerTrait<HeapVectorBacking<T, Traits> >::finalize,
     Traits::needsDestruction,
 };
 
 template<typename T, typename U, typename V, typename W, typename X>
 struct GCInfoTrait<HeapHashTableBacking<T, U, V, W, X> > {
     static const GCInfo* get() { return &info; }
     static const GCInfo info;
 };
 
 template<typename T, typename U, typename V, typename Traits, typename W>
 const GCInfo GCInfoTrait<HeapHashTableBacking<T, U, V, Traits, W> >::info = {
-    "HashTableBacking",
     TraceTrait<HeapHashTableBacking<T, U, V, Traits, W> >::trace,
     FinalizerTrait<HeapHashTableBacking<T, U, V, Traits, W> >::finalize,
     Traits::needsDestruction,
 };
 
 template<bool markWeakMembersStrongly, typename T, typename Traits>
 struct BaseVisitVectorBackingTrait {
     static void mark(WebCore::Visitor* visitor, void* self)
     {
         // The allocator can oversize the allocation a little, according to
@@ skipping 127 matching lines @@
     static void trace(WebCore::Visitor* visitor, void* self)
     {
         COMPILE_ASSERT(!Traits::isWeak, WeDontSupportWeaknessInHeapVectors);
         if (WTF::ShouldBeTraced<Traits>::value)
             CollectionBackingTraceTrait<WTF::ShouldBeTraced<Traits>::value, false, false, HeapVectorBacking<T, Traits>, void>::mark(visitor, self);
     }
     static void mark(Visitor* visitor, const Backing* backing)
     {
         visitor->mark(backing, &trace);
     }
-    static void checkTypeMarker(Visitor* visitor, const Backing* backing)
+    static void checkGCInfo(Visitor* visitor, const Backing* backing)
     {
 #ifndef NDEBUG
-        visitor->checkTypeMarker(const_cast<Backing*>(backing), getTypeMarker<Backing>());
+        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 Key, typename Value, typename Extractor, typename Traits, typename KeyTraits>
 struct TraceTrait<HeapHashTableBacking<Key, Value, Extractor, Traits, KeyTraits> > {
     typedef HeapHashTableBacking<Key, Value, Extractor, Traits, KeyTraits> Backing;
     static void trace(WebCore::Visitor* visitor, void* self)
     {
         if (WTF::ShouldBeTraced<Traits>::value || Traits::isWeak)
             CollectionBackingTraceTrait<WTF::ShouldBeTraced<Traits>::value, Traits::isWeak, true, HeapHashTableBacking<Key, Value, Extractor, Traits, KeyTraits>, void>::mark(visitor, self);
     }
     static void mark(Visitor* visitor, const Backing* backing)
     {
         if (WTF::ShouldBeTraced<Traits>::value || Traits::isWeak)
             visitor->mark(backing, &trace);
         else
             visitor->mark(backing, 0);
     }
-    static void checkTypeMarker(Visitor* visitor, const Backing* backing)
+    static void checkGCInfo(Visitor* visitor, const Backing* backing)
     {
 #ifndef NDEBUG
-        visitor->checkTypeMarker(const_cast<Backing*>(backing), getTypeMarker<Backing>());
+        visitor->checkGCInfo(const_cast<Backing*>(backing), GCInfoTrait<Backing>::get());
 #endif
     }
 };
 
 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, size_t inlineCapacity>
 struct GCInfoTrait<HeapVector<T, inlineCapacity> > : public GCInfoTrait<Vector<T, inlineCapacity, HeapAllocator> > { };
@@ skipping 17 matching lines @@
 // to export. This forces it to export all the methods from ThreadHeap.
 template<> void ThreadHeap<FinalizedHeapObjectHeader>::addPageToHeap(const GCInfo*);
 template<> void ThreadHeap<HeapObjectHeader>::addPageToHeap(const GCInfo*);
 extern template class HEAP_EXPORT ThreadHeap<FinalizedHeapObjectHeader>;
 extern template class HEAP_EXPORT ThreadHeap<HeapObjectHeader>;
 #endif
 
 }
 
 #endif // Heap_h