Revert of Rename Heap to ThreadHeap

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 153 matching lines @@
     size_t m_objectSizeAtLastGC;
     size_t m_markedObjectSize;
     size_t m_markedObjectSizeAtLastCompleteSweep;
     size_t m_wrapperCount;
     size_t m_wrapperCountAtLastGC;
     size_t m_collectedWrapperCount;
     size_t m_partitionAllocSizeAtLastGC;
     double m_estimatedMarkingTimePerByte;
 };
 
-class PLATFORM_EXPORT ThreadHeap {
-    STATIC_ONLY(ThreadHeap);
+class PLATFORM_EXPORT Heap {
+    STATIC_ONLY(Heap);
 public:
     static void init();
     static void shutdown();
 
 #if ENABLE(ASSERT)
     static BasePage* findPageFromAddress(Address);
     static BasePage* findPageFromAddress(const void* pointer) { return findPageFromAddress(reinterpret_cast<Address>(const_cast<void*>(pointer))); }
 #endif
 
     template<typename T>
@@ skipping 41 matching lines @@
     template<typename T>
     NO_LAZY_SWEEP_SANITIZE_ADDRESS
     static bool willObjectBeLazilySwept(const T* objectPointer)
     {
         static_assert(IsGarbageCollectedType<T>::value, "only objects deriving from GarbageCollected can be used.");
         BasePage* page = pageFromObject(objectPointer);
         if (page->hasBeenSwept())
             return false;
         ASSERT(page->arena()->getThreadState()->isSweepingInProgress());
 
-        return !ThreadHeap::isHeapObjectAlive(const_cast<T*>(objectPointer));
+        return !Heap::isHeapObjectAlive(const_cast<T*>(objectPointer));
     }
 
     // Push a trace callback on the marking stack.
     static void pushTraceCallback(void* containerObject, TraceCallback);
 
     // Push a trace callback on the post-marking callback stack.  These
     // callbacks are called after normal marking (including ephemeron
     // iteration).
     static void pushPostMarkingCallback(void*, TraceCallback);
 
@@ skipping 156 matching lines @@
 public:
     using GarbageCollectedType = T;
 
     void* operator new(size_t size)
     {
         return allocateObject(size, IsEagerlyFinalizedType<T>::value);
     }
 
     static void* allocateObject(size_t size, bool eagerlySweep)
     {
-        return ThreadHeap::allocate<T>(size, eagerlySweep);
+        return Heap::allocate<T>(size, eagerlySweep);
     }
 
     void operator delete(void* p)
     {
         ASSERT_NOT_REACHED();
     }
 
 protected:
     GarbageCollected()
     {
@@ skipping 12 matching lines @@
 //
 // An exception to the use of sized arenas is made for class types that
 // require prompt finalization after a garbage collection. That is, their
 // instances have to be finalized early and cannot be delayed until lazy
 // sweeping kicks in for their heap and page. The EAGERLY_FINALIZE()
 // macro is used to declare a class (and its derived classes) as being
 // in need of eager finalization. Must be defined with 'public' visibility
 // for a class.
 //
 
-inline int ThreadHeap::arenaIndexForObjectSize(size_t size)
+inline int Heap::arenaIndexForObjectSize(size_t size)
 {
     if (size < 64) {
         if (size < 32)
             return BlinkGC::NormalPage1ArenaIndex;
         return BlinkGC::NormalPage2ArenaIndex;
     }
     if (size < 128)
         return BlinkGC::NormalPage3ArenaIndex;
     return BlinkGC::NormalPage4ArenaIndex;
 }
 
-inline bool ThreadHeap::isNormalArenaIndex(int index)
+inline bool Heap::isNormalArenaIndex(int index)
 {
     return index >= BlinkGC::NormalPage1ArenaIndex && index <= BlinkGC::NormalPage4ArenaIndex;
 }
 
 #define DECLARE_EAGER_FINALIZATION_OPERATOR_NEW() \
 public:                                           \
     GC_PLUGIN_IGNORE("491488")                    \
     void* operator new(size_t size)               \
     {                                             \
         return allocateObject(size, true);        \
@@ skipping 19 matching lines @@
 };
 #define EAGERLY_FINALIZE()                             \
 private:                                               \
     VerifyEagerFinalization m_verifyEagerFinalization; \
 public:                                                \
     typedef int IsEagerlyFinalizedMarker
 #else
 #define EAGERLY_FINALIZE() typedef int IsEagerlyFinalizedMarker
 #endif
 
-inline Address ThreadHeap::allocateOnArenaIndex(ThreadState* state, size_t size, int arenaIndex, size_t gcInfoIndex, const char* typeName)
+inline Address Heap::allocateOnArenaIndex(ThreadState* state, size_t size, int arenaIndex, size_t gcInfoIndex, const char* typeName)
 {
     ASSERT(state->isAllocationAllowed());
     ASSERT(arenaIndex != BlinkGC::LargeObjectArenaIndex);
     NormalPageArena* arena = static_cast<NormalPageArena*>(state->arena(arenaIndex));
     Address address = arena->allocateObject(allocationSizeFromSize(size), gcInfoIndex);
     HeapAllocHooks::allocationHookIfEnabled(address, size, typeName);
     return address;
 }
 
 template<typename T>
-Address ThreadHeap::allocate(size_t size, bool eagerlySweep)
+Address Heap::allocate(size_t size, bool eagerlySweep)
 {
     ThreadState* state = ThreadStateFor<ThreadingTrait<T>::Affinity>::state();
     const char* typeName = WTF_HEAP_PROFILER_TYPE_NAME(T);
-    return ThreadHeap::allocateOnArenaIndex(state, size, eagerlySweep ? BlinkGC::EagerSweepArenaIndex : ThreadHeap::arenaIndexForObjectSize(size), GCInfoTrait<T>::index(), typeName);
+    return Heap::allocateOnArenaIndex(state, size, eagerlySweep ? BlinkGC::EagerSweepArenaIndex : Heap::arenaIndexForObjectSize(size), GCInfoTrait<T>::index(), typeName);
 }
 
 template<typename T>
-Address ThreadHeap::reallocate(void* previous, size_t size)
+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.
     if (!size) {
         // If the new size is 0 this is considered equivalent to free(previous).
         return nullptr;
     }
 
     ThreadState* state = ThreadStateFor<ThreadingTrait<T>::Affinity>::state();
     HeapObjectHeader* previousHeader = HeapObjectHeader::fromPayload(previous);
     BasePage* page = pageFromObject(previousHeader);
     ASSERT(page);
     int arenaIndex = page->arena()->arenaIndex();
     // Recompute the effective heap index if previous allocation
     // was on the normal arenas or a large object.
     if (isNormalArenaIndex(arenaIndex) || arenaIndex == BlinkGC::LargeObjectArenaIndex)
         arenaIndex = arenaIndexForObjectSize(size);
 
     // TODO(haraken): We don't support reallocate() for finalizable objects.
-    ASSERT(!ThreadHeap::gcInfo(previousHeader->gcInfoIndex())->hasFinalizer());
+    ASSERT(!Heap::gcInfo(previousHeader->gcInfoIndex())->hasFinalizer());
     ASSERT(previousHeader->gcInfoIndex() == GCInfoTrait<T>::index());
     const char* typeName = WTF_HEAP_PROFILER_TYPE_NAME(T);
     HeapAllocHooks::freeHookIfEnabled(static_cast<Address>(previous));
-    Address address = ThreadHeap::allocateOnArenaIndex(state, size, arenaIndex, GCInfoTrait<T>::index(), typeName);
+    Address address = Heap::allocateOnArenaIndex(state, size, arenaIndex, GCInfoTrait<T>::index(), typeName);
     size_t copySize = previousHeader->payloadSize();
     if (copySize > size)
         copySize = size;
     memcpy(address, previous, copySize);
     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