Rename BaseHeap to BaseArena

third_party/WebKit/Source/platform/heap/HeapTest.cpp

 /*
  * 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 757 matching lines @@
     // so as to avoid possible warnings about linker duplicates.
     // Override operator new to allocate IntNode subtype objects onto
     // the dedicated heap for blink::Node.
     //
     // TODO(haraken): untangling the heap unit tests from Blink would
     // simplify and avoid running into this problem - http://crbug.com/425381
     GC_PLUGIN_IGNORE("crbug.com/443854")
     void* operator new(size_t size)
     {
         ThreadState* state = ThreadState::current();
-        return Heap::allocateOnHeapIndex(state, size, BlinkGC::NodeHeapIndex, GCInfoTrait<IntNode>::index());
+        return Heap::allocateOnArenaIndex(state, size, BlinkGC::NodeArenaIndex, GCInfoTrait<IntNode>::index());
     }
 
     static IntNode* create(int i)
     {
         return new IntNode(i);
     }
 
     DEFINE_INLINE_TRACE() { }
 
     int value() { return m_value; }
@@ skipping 1310 matching lines @@
     // the finalizer on all three objects.
     preciselyCollectGarbage();
     EXPECT_EQ(2, HeapTestSubClass::s_destructorCalls);
     EXPECT_EQ(3, HeapTestSuperClass::s_destructorCalls);
     // Destructors not called again when GCing again.
     preciselyCollectGarbage();
     EXPECT_EQ(2, HeapTestSubClass::s_destructorCalls);
     EXPECT_EQ(3, HeapTestSuperClass::s_destructorCalls);
 }
 
-TEST(HeapTest, TypedHeapSanity)
+TEST(HeapTest, TypedArenaSanity)
 {
     // We use TraceCounter for allocating an object on the general heap.
     Persistent<TraceCounter> generalHeapObject = TraceCounter::create();
     Persistent<IntNode> typedHeapObject = IntNode::create(0);
     EXPECT_NE(pageFromObject(generalHeapObject.get()),
         pageFromObject(typedHeapObject.get()));
 }
 
 TEST(HeapTest, NoAllocation)
 {
@@ skipping 3571 matching lines @@
             // until the main thread has done its GC.
             wakeWorkerThread();
 
             preciselyCollectGarbage();
 
             // The worker thread should not have swept yet since it is waiting
             // to get the global mutex.
             EXPECT_EQ(0, DestructorLockingObject::s_destructorCalls);
         }
         // At this point the main thread releases the global lock and the worker
-        // can acquire it and do its sweep of its heaps. Just wait for the worker
+        // can acquire it and do its sweep of its arenas. Just wait for the worker
         // to complete its sweep and check the result.
         parkMainThread();
         EXPECT_EQ(1, DestructorLockingObject::s_destructorCalls);
     }
 
 private:
     static void workerThreadMain()
     {
         MutexLocker locker(workerThreadMutex());
         ThreadState::attach();
@@ skipping 55 matching lines @@
     }
 
 private:
 
     static void workerThreadMain()
     {
         MutexLocker locker(workerThreadMutex());
 
         // Start up a worker thread and have it detach after the main thread has.
         // Do this to verify that CrossThreadPersistent<>s referring to objects
-        // on one of the main thread's heaps does not upset the CTP invalidation
+        // on one of the main thread's arenas does not upset the CTP invalidation
         // pass that ThreadState::detach() performs.
         ThreadState::attach();
 
         CrossThreadPersistent<IntWrapper> persistent(IntWrapper::create(43));
 
         // Wait for the main thread to detach.
         wakeMainThread();
         parkWorkerThread();
 
         ThreadState::detach();
@@ skipping 738 matching lines @@
     EXPECT_EQ(1u, vector2.size());
 // TODO(Oilpan): when Vector.h's contiguous container support no longer disables
 // Vector<>s with inline capacity, remove.
 #if !defined(ANNOTATE_CONTIGUOUS_CONTAINER)
     EXPECT_EQ(16u, vector1.capacity());
     EXPECT_EQ(16u, vector2.capacity());
 #endif
 }
 
 } // namespace blink