Refactoring: Remove DETAILED_MEMORY_INFRA

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/Allocator.h"
 #include "wtf/Assertions.h"
@@ skipping 103 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 {
-    using GetClassNameCallback = const String (*)();
-
     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(DETAILED_MEMORY_INFRA)
-    const String className() const { return m_className(); }
-    GetClassNameCallback m_className;
-#endif
+    const char* className() const { return m_className; }

[Primiano Tucci (use gerrit), 2016/02/19 10:04:51]

I thought you were removing this completely.
If you want to keep it (fine), I think you want to return
extractTypeNameFromFunctionName(m_className) here.
Otherwise this CL is changing the semantic of className()

Before: Foo
Now: GcInfo::Blah<Foo> [T=Foo]

[hajimehoshi, 2016/02/19 10:32:03]

My understanding was to remove the member variable m_className but keep
className(). I failed to remove the member variable because class name can be
determined when GCInfo is created.

haraken-san, as primiano@ said, this CL changes the output. Is this allowable?

+    const char* m_className;
 };
 
 #if ENABLE(ASSERT)
 PLATFORM_EXPORT void assertObjectHasGCInfo(const void*, size_t gcInfoIndex);
 #endif
 
 class GCInfoTable {
     STATIC_ONLY(GCInfoTable);
 public:
     PLATFORM_EXPORT static void ensureGCInfoIndex(const GCInfo*, size_t*);
@@ skipping 24 matching lines @@
 struct GCInfoAtBaseType {
     STATIC_ONLY(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,
             std::is_polymorphic<T>::value,
-#if ENABLE(DETAILED_MEMORY_INFRA)
-            TypenameStringTrait<T>::get
-#endif
+            WTF_HEAP_PROFILER_TYPE_NAME(T),
         };
 
         static size_t gcInfoIndex = 0;
         ASSERT(s_gcInfoTable);
         if (!acquireLoad(&gcInfoIndex))
             GCInfoTable::ensureGCInfoIndex(&gcInfo, &gcInfoIndex);
         ASSERT(gcInfoIndex >= 1);
         ASSERT(gcInfoIndex < GCInfoTable::maxIndex);
         return gcInfoIndex;
     }
@@ skipping 43 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