Rename BaseHeap to BaseArena part 2

third_party/WebKit/Source/platform/heap/ThreadState.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 438 matching lines @@
     }
     void leaveGCForbiddenScopeIfNeeded(GarbageCollectedMixinConstructorMarker* gcMixinMarker)
     {
         ASSERT(checkThread());
         if (m_gcMixinMarker == gcMixinMarker) {
             leaveGCForbiddenScope();
             m_gcMixinMarker = nullptr;
         }
     }
 
-    // vectorBackingArena() returns a heap that the vector allocation should use.
-    // We have four vector arenas and want to choose the best heap here.
+    // vectorBackingArena() returns an arena that the vector allocation should use.
+    // We have four vector arenas and want to choose the best arena here.
     //
     // The goal is to improve the succession rate where expand and
     // promptlyFree happen at an allocation point. This is a key for reusing
     // the same memory as much as possible and thus improves performance.
     // To achieve the goal, we use the following heuristics:
     //
     // - A vector that has been expanded recently is likely to be expanded
     //   again soon.
     // - A vector is likely to be promptly freed if the same type of vector
     //   has been frequently promptly freed in the past.
     // - Given the above, when allocating a new vector, look at the four vectors
-    //   that are placed immediately prior to the allocation point of each heap.
-    //   Choose the heap where the vector is least likely to be expanded
+    //   that are placed immediately prior to the allocation point of each arena.
+    //   Choose the arena where the vector is least likely to be expanded
     //   nor promptly freed.
     //
-    // To implement the heuristics, we add a arenaAge to each heap. The arenaAge
+    // To implement the heuristics, we add an arenaAge to each arena. The arenaAge
     // is updated if:
     //
-    // - a vector on the heap is expanded; or
-    // - a vector that meets the condition (*) is allocated on the heap
+    // - a vector on the arena is expanded; or
+    // - a vector that meets the condition (*) is allocated on the arena
     //
     //   (*) More than 33% of the same type of vectors have been promptly
     //       freed since the last GC.
     //
     BaseArena* vectorBackingArena(size_t gcInfoIndex)
     {
         ASSERT(checkThread());
         size_t entryIndex = gcInfoIndex & likelyToBePromptlyFreedArrayMask;
         --m_likelyToBePromptlyFreed[entryIndex];
         int arenaIndex = m_vectorBackingArenaIndex;
         // If m_likelyToBePromptlyFreed[entryIndex] > 0, that means that
         // more than 33% of vectors of the type have been promptly freed
         // since the last GC.
         if (m_likelyToBePromptlyFreed[entryIndex] > 0) {
             m_arenaAges[arenaIndex] = ++m_currentArenaAges;
             m_vectorBackingArenaIndex = arenaIndexOfVectorArenaLeastRecentlyExpanded(BlinkGC::Vector1ArenaIndex, BlinkGC::Vector4ArenaIndex);
         }
         ASSERT(isVectorArenaIndex(arenaIndex));
         return m_arenas[arenaIndex];
     }
-    BaseArena* expandedVectorBackingHeap(size_t gcInfoIndex);
+    BaseArena* expandedVectorBackingArena(size_t gcInfoIndex);
     static bool isVectorArenaIndex(int arenaIndex)
     {
         return BlinkGC::Vector1ArenaIndex <= arenaIndex && arenaIndex <= BlinkGC::Vector4ArenaIndex;
     }
     void allocationPointAdjusted(int arenaIndex);
     void promptlyFreed(size_t gcInfoIndex);
 
     void accumulateSweepingTime(double time) { m_accumulatedSweepingTime += time; }
 
 #if OS(WIN) && COMPILER(MSVC)
@@ skipping 195 matching lines @@
 
 template<> class ThreadStateFor<AnyThread> {
     STATIC_ONLY(ThreadStateFor);
 public:
     static ThreadState* state() { return ThreadState::current(); }
 };
 
 } // namespace blink
 
 #endif // ThreadState_h