Show type names in Oilpan heap profiler

third_party/WebKit/Source/platform/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 30 matching lines @@
 #include "wtf/Allocator.h"
 #include "wtf/Assertions.h"
 #include "wtf/Atomics.h"
 #include "wtf/Forward.h"
 
 namespace blink {
 
 class PLATFORM_EXPORT HeapAllocHooks {
 public:
     // TODO(hajimehoshi): Pass a type name of the allocated object.
-    typedef void AllocationHook(Address, size_t);
+    typedef void AllocationHook(Address, size_t, const char*);
     typedef void FreeHook(Address);
 
     static void setAllocationHook(AllocationHook* hook) { m_allocationHook = hook; }
     static void setFreeHook(FreeHook* hook) { m_freeHook = hook; }
 
-    static void allocationHookIfEnabled(Address address, size_t size)
+    static void allocationHookIfEnabled(Address address, size_t size, const char* typeName)
     {
         AllocationHook* allocationHook = m_allocationHook;
         if (UNLIKELY(!!allocationHook))
-            allocationHook(address, size);
+            allocationHook(address, size, typeName);
     }
 
     static void freeHookIfEnabled(Address address)
     {
         FreeHook* freeHook = m_freeHook;
         if (UNLIKELY(!!freeHook))
             freeHook(address);
     }
 
-    static void reallocHookIfEnabled(Address oldAddress, Address newAddress, size_t size)
+    static void reallocHookIfEnabled(Address oldAddress, Address newAddress, size_t size, const char* typeName)
     {
         // Report a reallocation as a free followed by an allocation.
         AllocationHook* allocationHook = m_allocationHook;
         FreeHook* freeHook = m_freeHook;
         if (UNLIKELY(allocationHook && freeHook)) {
             freeHook(oldAddress);
-            allocationHook(newAddress, size);
+            allocationHook(newAddress, size, typeName);
         }
     }
 
 private:
     static AllocationHook* m_allocationHook;
     static FreeHook* m_freeHook;
 };
 
 class CrossThreadPersistentRegion;
 template<typename T> class Member;
@@ skipping 400 matching lines @@
     ASSERT(heapIndex != BlinkGC::LargeObjectHeapIndex);
     NormalPageHeap* heap = static_cast<NormalPageHeap*>(state->heap(heapIndex));
     return heap->allocateObject(allocationSizeFromSize(size), gcInfoIndex);
 }
 
 template<typename T>
 Address Heap::allocate(size_t size, bool eagerlySweep)
 {
     ThreadState* state = ThreadStateFor<ThreadingTrait<T>::Affinity>::state();
     Address address = Heap::allocateOnHeapIndex(state, size, eagerlySweep ? BlinkGC::EagerSweepHeapIndex : Heap::heapIndexForObjectSize(size), GCInfoTrait<T>::index());
-    HeapAllocHooks::allocationHookIfEnabled(address, size);
+    const char* typeName = WTF_HEAP_PROFILER_TYPE_NAME(T);
+    HeapAllocHooks::allocationHookIfEnabled(address, size, typeName);
     return address;
 }
 
 template<typename T>
 Address Heap::reallocate(void* previous, size_t size)
 {
     // Not intended to be a full C realloc() substitute;
     // realloc(nullptr, size) is not a supported alias for malloc(size).
 
     // TODO(sof): promptly free the previous object.
@@ skipping 13 matching lines @@
         heapIndex = heapIndexForObjectSize(size);
 
     // TODO(haraken): We don't support reallocate() for finalizable objects.
     ASSERT(!Heap::gcInfo(previousHeader->gcInfoIndex())->hasFinalizer());
     ASSERT(previousHeader->gcInfoIndex() == GCInfoTrait<T>::index());
     Address address = Heap::allocateOnHeapIndex(state, size, heapIndex, GCInfoTrait<T>::index());
     size_t copySize = previousHeader->payloadSize();
     if (copySize > size)
         copySize = size;
     memcpy(address, previous, copySize);
-    HeapAllocHooks::reallocHookIfEnabled(static_cast<Address>(previous), address, size);
+    const char* typeName = WTF_HEAP_PROFILER_TYPE_NAME(T);
+    HeapAllocHooks::reallocHookIfEnabled(static_cast<Address>(previous), address, size, typeName);
     return address;
 }
 
 template<typename Derived>
 template<typename T>
 void VisitorHelper<Derived>::handleWeakCell(Visitor* self, void* object)
 {
     T** cell = reinterpret_cast<T**>(object);
     if (*cell && !ObjectAliveTrait<T>::isHeapObjectAlive(*cell))
         *cell = nullptr;
 }
 
 } // namespace blink
 
 #endif // Heap_h