[Oilpan] Refactoring: Rename GarbageCollectedBase to GarbageCollectedType

third_party/WebKit/Source/platform/heap/GCInfo.h

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef GCInfo_h
 #define GCInfo_h
 
 #include "platform/heap/Visitor.h"
 #include "wtf/Assertions.h"
 #include "wtf/Atomics.h"
@@ skipping 135 matching lines @@
     // encounter.
     static const size_t maxIndex = 1 << 14;
 
 private:
     static void resize();
 
     static int s_gcInfoIndex;
     static size_t s_gcInfoTableSize;
 };
 
-// This macro should be used when returning a unique 14 bit integer
+// GCInfotAtBaseType should be used when returning a unique 14 bit integer
 // for a given gcInfo.
-#define RETURN_GCINFO_INDEX()                                  \
-    static size_t gcInfoIndex = 0;                             \
-    ASSERT(s_gcInfoTable);                                     \
-    if (!acquireLoad(&gcInfoIndex))                            \
-        GCInfoTable::ensureGCInfoIndex(&gcInfo, &gcInfoIndex); \
-    ASSERT(gcInfoIndex >= 1);                                  \
-    ASSERT(gcInfoIndex < GCInfoTable::maxIndex);               \
-    return gcInfoIndex;
-
 template<typename T>
-struct GCInfoAtBase {
+struct GCInfoAtBaseType {
     static size_t index()
     {
         static_assert(sizeof(T), "T must be fully defined");
         static const GCInfo gcInfo = {
             TraceTrait<T>::trace,
             FinalizerTrait<T>::finalize,
             FinalizerTrait<T>::nonTrivialFinalizer,
             WTF::IsPolymorphic<T>::value,
 #if ENABLE(GC_PROFILING) || ENABLE(DETAILED_MEMORY_INFRA)
             TypenameStringTrait<T>::get
 #endif
         };
-        RETURN_GCINFO_INDEX();
+
+        static size_t gcInfoIndex = 0;
+        ASSERT(s_gcInfoTable);
+        if (!acquireLoad(&gcInfoIndex))
+            GCInfoTable::ensureGCInfoIndex(&gcInfo, &gcInfoIndex);
+        ASSERT(gcInfoIndex >= 1);
+        ASSERT(gcInfoIndex < GCInfoTable::maxIndex);
+        return gcInfoIndex;
     }
 };
 
-template<typename T, bool = WTF::IsSubclassOfTemplate<typename WTF::RemoveConst<T>::Type, GarbageCollected>::value> struct GetGarbageCollectedBase;
+template<typename T, bool = WTF::IsSubclassOfTemplate<typename WTF::RemoveConst<T>::Type, GarbageCollected>::value> struct GetGarbageCollectedType;
 
 template<typename T>
-struct GetGarbageCollectedBase<T, true> {
-    typedef typename T::GarbageCollectedBase type;
+struct GetGarbageCollectedType<T, true> {
+    using type = typename T::GarbageCollectedType;
 };
 
 template<typename T>
-struct GetGarbageCollectedBase<T, false> {
-    typedef T type;
+struct GetGarbageCollectedType<T, false> {
+    using type = T;
 };
 
 template<typename T>
 struct GCInfoTrait {
     static size_t index()
     {
-        return GCInfoAtBase<typename GetGarbageCollectedBase<T>::type>::index();
+        return GCInfoAtBaseType<typename GetGarbageCollectedType<T>::type>::index();
     }
 };
 
 template<typename U> class GCInfoTrait<const U> : public GCInfoTrait<U> { };
 
 template<typename T, typename U, typename V, typename W, typename X> class HeapHashMap;
 template<typename T, typename U, typename V> class HeapHashSet;
 template<typename T, typename U, typename V> class HeapLinkedHashSet;
 template<typename T, size_t inlineCapacity, typename U> class HeapListHashSet;
 template<typename T, size_t inlineCapacity> class HeapVector;
@@ skipping 11 matching lines @@
 template<typename T, size_t inlineCapacity>
 struct GCInfoTrait<HeapVector<T, inlineCapacity>> : public GCInfoTrait<Vector<T, inlineCapacity, HeapAllocator>> { };
 template<typename T, size_t inlineCapacity>
 struct GCInfoTrait<HeapDeque<T, inlineCapacity>> : public GCInfoTrait<Deque<T, inlineCapacity, HeapAllocator>> { };
 template<typename T, typename U, typename V>
 struct GCInfoTrait<HeapHashCountedSet<T, U, V>> : public GCInfoTrait<HashCountedSet<T, U, V, HeapAllocator>> { };
 
 } // namespace blink
 
 #endif