Rename BaseHeap to BaseArena

third_party/WebKit/Source/platform/heap/ThreadState.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 77 matching lines @@
 #endif
     , m_startOfStack(reinterpret_cast<intptr_t*>(StackFrameDepth::getStackStart()))
     , m_endOfStack(reinterpret_cast<intptr_t*>(StackFrameDepth::getStackStart()))
     , m_safePointScopeMarker(nullptr)
     , m_atSafePoint(false)
     , m_interruptors()
     , m_sweepForbidden(false)
     , m_noAllocationCount(0)
     , m_gcForbiddenCount(0)
     , m_accumulatedSweepingTime(0)
-    , m_vectorBackingHeapIndex(BlinkGC::Vector1HeapIndex)
-    , m_currentHeapAges(0)
+    , m_vectorBackingArenaIndex(BlinkGC::Vector1ArenaIndex)
+    , m_currentArenaAges(0)
     , m_isTerminating(false)
     , m_gcMixinMarker(nullptr)
     , m_shouldFlushHeapDoesNotContainCache(false)
     , m_gcState(NoGCScheduled)
     , m_isolate(nullptr)
     , m_traceDOMWrappers(nullptr)
 #if defined(ADDRESS_SANITIZER)
     , m_asanFakeStack(__asan_get_current_fake_stack())
 #endif
 #if defined(LEAK_SANITIZER)
     , m_disabledStaticPersistentsRegistration(0)
 #endif
     , m_allocatedObjectSize(0)
     , m_markedObjectSize(0)
     , m_reportedMemoryToV8(0)
 {
     ASSERT(checkThread());
     ASSERT(!**s_threadSpecific);
     **s_threadSpecific = this;
 
     if (isMainThread()) {
         s_mainThreadStackStart = reinterpret_cast<uintptr_t>(m_startOfStack) - sizeof(void*);
         size_t underestimatedStackSize = StackFrameDepth::getUnderestimatedStackSize();
         if (underestimatedStackSize > sizeof(void*))
             s_mainThreadUnderestimatedStackSize = underestimatedStackSize - sizeof(void*);
     }
 
-    for (int heapIndex = 0; heapIndex < BlinkGC::LargeObjectHeapIndex; heapIndex++)
-        m_heaps[heapIndex] = new NormalPageHeap(this, heapIndex);
-    m_heaps[BlinkGC::LargeObjectHeapIndex] = new LargeObjectHeap(this, BlinkGC::LargeObjectHeapIndex);
+    for (int arenaIndex = 0; arenaIndex < BlinkGC::LargeObjectArenaIndex; arenaIndex++)
+        m_arenas[arenaIndex] = new NormalPageHeap(this, arenaIndex);
+    m_arenas[BlinkGC::LargeObjectArenaIndex] = new LargeObjectHeap(this, BlinkGC::LargeObjectArenaIndex);
 
     m_likelyToBePromptlyFreed = adoptArrayPtr(new int[likelyToBePromptlyFreedArraySize]);
-    clearHeapAges();
+    clearArenaAges();
 
     // There is little use of weak references and collections off the main thread;
     // use a much lower initial block reservation.
     size_t initialBlockSize = isMainThread() ? CallbackStack::kDefaultBlockSize : CallbackStack::kMinimalBlockSize;
     m_threadLocalWeakCallbackStack = new CallbackStack(initialBlockSize);
 }
 
 ThreadState::~ThreadState()
 {
     ASSERT(checkThread());
     delete m_threadLocalWeakCallbackStack;
     m_threadLocalWeakCallbackStack = nullptr;
-    for (int i = 0; i < BlinkGC::NumberOfHeaps; ++i)
-        delete m_heaps[i];
+    for (int i = 0; i < BlinkGC::NumberOfArenas; ++i)
+        delete m_arenas[i];
 
     **s_threadSpecific = nullptr;
     if (isMainThread()) {
         s_mainThreadStackStart = 0;
         s_mainThreadUnderestimatedStackSize = 0;
     }
 }
 
 void ThreadState::init()
 {
@@ skipping 92 matching lines @@
 {
     RELEASE_ASSERT(!Heap::s_shutdownCalled);
     MutexLocker locker(threadAttachMutex());
     ThreadState* state = new ThreadState();
     attachedThreads().add(state);
 }
 
 void ThreadState::cleanupPages()
 {
     ASSERT(checkThread());
-    for (int i = 0; i < BlinkGC::NumberOfHeaps; ++i)
-        m_heaps[i]->cleanupPages();
+    for (int i = 0; i < BlinkGC::NumberOfArenas; ++i)
+        m_arenas[i]->cleanupPages();
 }
 
 void ThreadState::cleanup()
 {
     ASSERT(checkThread());
     {
         // Grab the threadAttachMutex to ensure only one thread can shutdown at
         // a time and that no other thread can do a global GC. It also allows
         // safe iteration of the attachedThreads set which happens as part of
         // thread local GC asserts. We enter a safepoint while waiting for the
@@ skipping 26 matching lines @@
             currentCount = persistentRegion()->numberOfPersistents();
         }
         // We should not have any persistents left when getting to this point,
         // if we have it is probably a bug so adding a debug ASSERT to catch this.
         ASSERT(!currentCount);
         // All of pre-finalizers should be consumed.
         ASSERT(m_orderedPreFinalizers.isEmpty());
         RELEASE_ASSERT(gcState() == NoGCScheduled);
 
         // Add pages to the orphaned page pool to ensure any global GCs from this point
-        // on will not trace objects on this thread's heaps.
+        // on will not trace objects on this thread's arenas.
         cleanupPages();
 
         ASSERT(attachedThreads().contains(this));
         attachedThreads().remove(this);
     }
 }
 
 void ThreadState::detach()
 {
     ThreadState* state = current();
@@ skipping 452 matching lines @@
         return;
 
     TRACE_EVENT1("blink_gc,devtools.timeline", "ThreadState::performIdleLazySweep", "idleDeltaInSeconds", deadlineSeconds - monotonicallyIncreasingTime());
 
     bool sweepCompleted = true;
     SweepForbiddenScope scope(this);
     {
         double startTime = WTF::currentTimeMS();
         ScriptForbiddenIfMainThreadScope scriptForbiddenScope;
 
-        for (int i = 0; i < BlinkGC::NumberOfHeaps; i++) {
+        for (int i = 0; i < BlinkGC::NumberOfArenas; i++) {
             // lazySweepWithDeadline() won't check the deadline until it sweeps
             // 10 pages. So we give a small slack for safety.
             double slack = 0.001;
             double remainingBudget = deadlineSeconds - slack - monotonicallyIncreasingTime();
-            if (remainingBudget <= 0 || !m_heaps[i]->lazySweepWithDeadline(deadlineSeconds)) {
+            if (remainingBudget <= 0 || !m_arenas[i]->lazySweepWithDeadline(deadlineSeconds)) {
                 // We couldn't finish the sweeping within the deadline.
                 // We request another idle task for the remaining sweeping.
                 scheduleIdleLazySweep();
                 sweepCompleted = false;
                 break;
             }
         }
 
         accumulateSweepingTime(WTF::currentTimeMS() - startTime);
     }
@@ skipping 152 matching lines @@
     if (m_shouldFlushHeapDoesNotContainCache) {
         Heap::flushHeapDoesNotContainCache();
         m_shouldFlushHeapDoesNotContainCache = false;
     }
 }
 
 void ThreadState::makeConsistentForGC()
 {
     ASSERT(isInGC());
     TRACE_EVENT0("blink_gc", "ThreadState::makeConsistentForGC");
-    for (int i = 0; i < BlinkGC::NumberOfHeaps; ++i)
-        m_heaps[i]->makeConsistentForGC();
+    for (int i = 0; i < BlinkGC::NumberOfArenas; ++i)
+        m_arenas[i]->makeConsistentForGC();
 }
 
 void ThreadState::makeConsistentForMutator()
 {
     ASSERT(isInGC());
-    for (int i = 0; i < BlinkGC::NumberOfHeaps; ++i)
-        m_heaps[i]->makeConsistentForMutator();
+    for (int i = 0; i < BlinkGC::NumberOfArenas; ++i)
+        m_arenas[i]->makeConsistentForMutator();
 }
 
 void ThreadState::preGC()
 {
     ASSERT(!isInGC());
     setGCState(GCRunning);
     makeConsistentForGC();
     flushHeapDoesNotContainCacheIfNeeded();
-    clearHeapAges();
+    clearArenaAges();
 }
 
 void ThreadState::postGC(BlinkGC::GCType gcType)
 {
     ASSERT(isInGC());
-    for (int i = 0; i < BlinkGC::NumberOfHeaps; i++)
-        m_heaps[i]->prepareForSweep();
+    for (int i = 0; i < BlinkGC::NumberOfArenas; i++)
+        m_arenas[i]->prepareForSweep();
 
     if (gcType == BlinkGC::GCWithSweep) {
         setGCState(EagerSweepScheduled);
     } else if (gcType == BlinkGC::GCWithoutSweep) {
         setGCState(LazySweepScheduled);
     } else {
         takeSnapshot(SnapshotType::HeapSnapshot);
 
         // This unmarks all marked objects and marks all unmarked objects dead.
         makeConsistentForMutator();
@@ skipping 20 matching lines @@
     setGCState(Sweeping);
 
     // Allocation is allowed during the pre-finalizers and destructors.
     // However, they must not mutate an object graph in a way in which
     // a dead object gets resurrected.
     invokePreFinalizers();
 
     m_accumulatedSweepingTime = 0;
 
 #if defined(ADDRESS_SANITIZER)
-    poisonEagerHeap(BlinkGC::SetPoison);
+    poisonEagerArena(BlinkGC::SetPoison);
 #endif
     eagerSweep();
 #if defined(ADDRESS_SANITIZER)
     poisonAllHeaps();
 #endif
 
     if (previousGCState == EagerSweepScheduled) {
         // Eager sweeping should happen only in testing.
         completeSweep();
     } else {
         // The default behavior is lazy sweeping.
         scheduleIdleLazySweep();
     }
 }
 
 #if defined(ADDRESS_SANITIZER)
 void ThreadState::poisonAllHeaps()
 {
     // TODO(Oilpan): enable the poisoning always.
 #if ENABLE(OILPAN)
-    // Unpoison the live objects remaining in the eager heaps..
-    poisonEagerHeap(BlinkGC::ClearPoison);
-    // ..along with poisoning all unmarked objects in the other heaps.
-    for (int i = 1; i < BlinkGC::NumberOfHeaps; i++)
-        m_heaps[i]->poisonHeap(BlinkGC::UnmarkedOnly, BlinkGC::SetPoison);
+    // Unpoison the live objects remaining in the eager arenas..
+    poisonEagerArena(BlinkGC::ClearPoison);
+    // ..along with poisoning all unmarked objects in the other arenas.
+    for (int i = 1; i < BlinkGC::NumberOfArenas; i++)
+        m_arenas[i]->poisonHeap(BlinkGC::UnmarkedOnly, BlinkGC::SetPoison);
 #endif
 }
 
-void ThreadState::poisonEagerHeap(BlinkGC::Poisoning poisoning)
+void ThreadState::poisonEagerArena(BlinkGC::Poisoning poisoning)
 {
     // TODO(Oilpan): enable the poisoning always.
 #if ENABLE(OILPAN)
-    m_heaps[BlinkGC::EagerSweepHeapIndex]->poisonHeap(BlinkGC::MarkedAndUnmarked, poisoning);
+    m_arenas[BlinkGC::EagerSweepArenaIndex]->poisonHeap(BlinkGC::MarkedAndUnmarked, poisoning);
 #endif
 }
 #endif
 
 void ThreadState::eagerSweep()
 {
     ASSERT(checkThread());
     // Some objects need to be finalized promptly and cannot be handled
     // by lazy sweeping. Keep those in a designated heap and sweep it
     // eagerly.
     ASSERT(isSweepingInProgress());
 
     // Mirroring the completeSweep() condition; see its comment.
     if (sweepForbidden())
         return;
 
     SweepForbiddenScope scope(this);
     ScriptForbiddenIfMainThreadScope scriptForbiddenScope;
 
     double startTime = WTF::currentTimeMS();
-    m_heaps[BlinkGC::EagerSweepHeapIndex]->completeSweep();
+    m_arenas[BlinkGC::EagerSweepArenaIndex]->completeSweep();
     accumulateSweepingTime(WTF::currentTimeMS() - startTime);
 }
 
 void ThreadState::completeSweep()
 {
     ASSERT(checkThread());
     // If we are not in a sweeping phase, there is nothing to do here.
     if (!isSweepingInProgress())
         return;
 
     // completeSweep() can be called recursively if finalizers can allocate
     // memory and the allocation triggers completeSweep(). This check prevents
     // the sweeping from being executed recursively.
     if (sweepForbidden())
         return;
 
     SweepForbiddenScope scope(this);
     {
         ScriptForbiddenIfMainThreadScope scriptForbiddenScope;
 
         TRACE_EVENT0("blink_gc,devtools.timeline", "ThreadState::completeSweep");
         double startTime = WTF::currentTimeMS();
 
-        static_assert(BlinkGC::EagerSweepHeapIndex == 0, "Eagerly swept heaps must be processed first.");
-        for (int i = 0; i < BlinkGC::NumberOfHeaps; i++)
-            m_heaps[i]->completeSweep();
+        static_assert(BlinkGC::EagerSweepArenaIndex == 0, "Eagerly swept arenas must be processed first.");
+        for (int i = 0; i < BlinkGC::NumberOfArenas; i++)
+            m_arenas[i]->completeSweep();
 
         double timeForCompleteSweep = WTF::currentTimeMS() - startTime;
         accumulateSweepingTime(timeForCompleteSweep);
 
         if (isMainThread()) {
             DEFINE_STATIC_LOCAL(CustomCountHistogram, completeSweepHistogram, ("BlinkGC.CompleteSweep", 1, 10 * 1000, 50));
             completeSweepHistogram.count(timeForCompleteSweep);
         }
     }
 
@@ skipping 41 matching lines @@
         scheduleIdleGC();
         break;
     default:
         ASSERT_NOT_REACHED();
     }
 }
 
 void ThreadState::prepareForThreadStateTermination()
 {
     ASSERT(checkThread());
-    for (int i = 0; i < BlinkGC::NumberOfHeaps; ++i)
-        m_heaps[i]->prepareHeapForTermination();
+    for (int i = 0; i < BlinkGC::NumberOfArenas; ++i)
+        m_arenas[i]->prepareHeapForTermination();
 }
 
 #if ENABLE(ASSERT)
 BasePage* ThreadState::findPageFromAddress(Address address)
 {
-    for (int i = 0; i < BlinkGC::NumberOfHeaps; ++i) {
-        if (BasePage* page = m_heaps[i]->findPageFromAddress(address))
+    for (int i = 0; i < BlinkGC::NumberOfArenas; ++i) {
+        if (BasePage* page = m_arenas[i]->findPageFromAddress(address))
             return page;
     }
     return nullptr;
 }
 #endif
 
 size_t ThreadState::objectPayloadSizeForTesting()
 {
     size_t objectPayloadSize = 0;
-    for (int i = 0; i < BlinkGC::NumberOfHeaps; ++i)
-        objectPayloadSize += m_heaps[i]->objectPayloadSizeForTesting();
+    for (int i = 0; i < BlinkGC::NumberOfArenas; ++i)
+        objectPayloadSize += m_arenas[i]->objectPayloadSizeForTesting();
     return objectPayloadSize;
 }
 
 bool ThreadState::stopThreads()
 {
     return s_safePointBarrier->parkOthers();
 }
 
 void ThreadState::resumeThreads()
 {
@@ skipping 224 matching lines @@
                 m_orderedPreFinalizers.remove(entry);
         } while (!done);
     }
     if (isMainThread()) {
         double timeForInvokingPreFinalizers = WTF::currentTimeMS() - startTime;
         DEFINE_STATIC_LOCAL(CustomCountHistogram, preFinalizersHistogram, ("BlinkGC.TimeForInvokingPreFinalizers", 1, 10 * 1000, 50));
         preFinalizersHistogram.count(timeForInvokingPreFinalizers);
     }
 }
 
-void ThreadState::clearHeapAges()
+void ThreadState::clearArenaAges()
 {
-    memset(m_heapAges, 0, sizeof(size_t) * BlinkGC::NumberOfHeaps);
+    memset(m_arenaAges, 0, sizeof(size_t) * BlinkGC::NumberOfArenas);
     memset(m_likelyToBePromptlyFreed.get(), 0, sizeof(int) * likelyToBePromptlyFreedArraySize);
-    m_currentHeapAges = 0;
+    m_currentArenaAges = 0;
 }
 
-int ThreadState::heapIndexOfVectorHeapLeastRecentlyExpanded(int beginHeapIndex, int endHeapIndex)
+int ThreadState::arenaIndexOfVectorArenaLeastRecentlyExpanded(int beginArenaIndex, int endArenaIndex)
 {
-    size_t minHeapAge = m_heapAges[beginHeapIndex];
-    int heapIndexWithMinHeapAge = beginHeapIndex;
-    for (int heapIndex = beginHeapIndex + 1; heapIndex <= endHeapIndex; heapIndex++) {
-        if (m_heapAges[heapIndex] < minHeapAge) {
-            minHeapAge = m_heapAges[heapIndex];
-            heapIndexWithMinHeapAge = heapIndex;
+    size_t minArenaAge = m_arenaAges[beginArenaIndex];
+    int arenaIndexWithMinArenaAge = beginArenaIndex;
+    for (int arenaIndex = beginArenaIndex + 1; arenaIndex <= endArenaIndex; arenaIndex++) {
+        if (m_arenaAges[arenaIndex] < minArenaAge) {
+            minArenaAge = m_arenaAges[arenaIndex];
+            arenaIndexWithMinArenaAge = arenaIndex;
         }
     }
-    ASSERT(isVectorHeapIndex(heapIndexWithMinHeapAge));
-    return heapIndexWithMinHeapAge;
+    ASSERT(isVectorArenaIndex(arenaIndexWithMinArenaAge));
+    return arenaIndexWithMinArenaAge;
 }
 
-BaseHeap* ThreadState::expandedVectorBackingHeap(size_t gcInfoIndex)
+BaseArena* ThreadState::expandedVectorBackingHeap(size_t gcInfoIndex)
 {
     ASSERT(checkThread());
     size_t entryIndex = gcInfoIndex & likelyToBePromptlyFreedArrayMask;
     --m_likelyToBePromptlyFreed[entryIndex];
-    int heapIndex = m_vectorBackingHeapIndex;
-    m_heapAges[heapIndex] = ++m_currentHeapAges;
-    m_vectorBackingHeapIndex = heapIndexOfVectorHeapLeastRecentlyExpanded(BlinkGC::Vector1HeapIndex, BlinkGC::Vector4HeapIndex);
-    return m_heaps[heapIndex];
+    int arenaIndex = m_vectorBackingArenaIndex;
+    m_arenaAges[arenaIndex] = ++m_currentArenaAges;
+    m_vectorBackingArenaIndex = arenaIndexOfVectorArenaLeastRecentlyExpanded(BlinkGC::Vector1ArenaIndex, BlinkGC::Vector4ArenaIndex);
+    return m_arenas[arenaIndex];
 }
 
-void ThreadState::allocationPointAdjusted(int heapIndex)
+void ThreadState::allocationPointAdjusted(int arenaIndex)
 {
-    m_heapAges[heapIndex] = ++m_currentHeapAges;
-    if (m_vectorBackingHeapIndex == heapIndex)
-        m_vectorBackingHeapIndex = heapIndexOfVectorHeapLeastRecentlyExpanded(BlinkGC::Vector1HeapIndex, BlinkGC::Vector4HeapIndex);
+    m_arenaAges[arenaIndex] = ++m_currentArenaAges;
+    if (m_vectorBackingArenaIndex == arenaIndex)
+        m_vectorBackingArenaIndex = arenaIndexOfVectorArenaLeastRecentlyExpanded(BlinkGC::Vector1ArenaIndex, BlinkGC::Vector4ArenaIndex);
 }
 
 void ThreadState::promptlyFreed(size_t gcInfoIndex)
 {
     ASSERT(checkThread());
     size_t entryIndex = gcInfoIndex & likelyToBePromptlyFreedArrayMask;
-    // See the comment in vectorBackingHeap() for why this is +3.
+    // See the comment in vectorBackingArena() for why this is +3.
     m_likelyToBePromptlyFreed[entryIndex] += 3;
 }
 
 void ThreadState::takeSnapshot(SnapshotType type)
 {
     ASSERT(isInGC());
 
     // 0 is used as index for freelist entries. Objects are indexed 1 to
     // gcInfoIndex.
     GCSnapshotInfo info(GCInfoTable::gcInfoIndex() + 1);
     String threadDumpName = String::format("blink_gc/thread_%lu", static_cast<unsigned long>(m_thread));
     const String heapsDumpName = threadDumpName + "/heaps";
     const String classesDumpName = threadDumpName + "/classes";
 
     int numberOfHeapsReported = 0;
-#define SNAPSHOT_HEAP(HeapType)                                                                \
+#define SNAPSHOT_HEAP(ArenaType)                                                                \
     {                                                                                          \
         numberOfHeapsReported++;                                                               \
         switch (type) {                                                                        \
         case SnapshotType::HeapSnapshot:                                                       \
-            m_heaps[BlinkGC::HeapType##HeapIndex]->takeSnapshot(heapsDumpName + "/" #HeapType, info);   \
+            m_arenas[BlinkGC::ArenaType##ArenaIndex]->takeSnapshot(heapsDumpName + "/" #ArenaType, info);   \
             break;                                                                             \
         case SnapshotType::FreelistSnapshot:                                                   \
-            m_heaps[BlinkGC::HeapType##HeapIndex]->takeFreelistSnapshot(heapsDumpName + "/" #HeapType); \
+            m_arenas[BlinkGC::ArenaType##ArenaIndex]->takeFreelistSnapshot(heapsDumpName + "/" #ArenaType); \
             break;                                                                             \
         default:                                                                               \
             ASSERT_NOT_REACHED();                                                              \
         }                                                                                      \
     }
 
     SNAPSHOT_HEAP(NormalPage1);
     SNAPSHOT_HEAP(NormalPage2);
     SNAPSHOT_HEAP(NormalPage3);
     SNAPSHOT_HEAP(NormalPage4);
     SNAPSHOT_HEAP(EagerSweep);
     SNAPSHOT_HEAP(Vector1);
     SNAPSHOT_HEAP(Vector2);
     SNAPSHOT_HEAP(Vector3);
     SNAPSHOT_HEAP(Vector4);
     SNAPSHOT_HEAP(InlineVector);
     SNAPSHOT_HEAP(HashTable);
     SNAPSHOT_HEAP(LargeObject);
-    FOR_EACH_TYPED_HEAP(SNAPSHOT_HEAP);
+    FOR_EACH_TYPED_ARENA(SNAPSHOT_HEAP);
 
-    ASSERT(numberOfHeapsReported == BlinkGC::NumberOfHeaps);
+    ASSERT(numberOfHeapsReported == BlinkGC::NumberOfArenas);
 
 #undef SNAPSHOT_HEAP
 
     if (type == SnapshotType::FreelistSnapshot)
         return;
 
     size_t totalLiveCount = 0;
     size_t totalDeadCount = 0;
     size_t totalLiveSize = 0;
     size_t totalDeadSize = 0;
     for (size_t gcInfoIndex = 1; gcInfoIndex <= GCInfoTable::gcInfoIndex(); ++gcInfoIndex) {
         totalLiveCount += info.liveCount[gcInfoIndex];
         totalDeadCount += info.deadCount[gcInfoIndex];
         totalLiveSize += info.liveSize[gcInfoIndex];
         totalDeadSize += info.deadSize[gcInfoIndex];
     }
 
     WebMemoryAllocatorDump* threadDump = BlinkGCMemoryDumpProvider::instance()->createMemoryAllocatorDumpForCurrentGC(threadDumpName);
     threadDump->addScalar("live_count", "objects", totalLiveCount);
     threadDump->addScalar("dead_count", "objects", totalDeadCount);
     threadDump->addScalar("live_size", "bytes", totalLiveSize);
     threadDump->addScalar("dead_size", "bytes", totalDeadSize);
 
     WebMemoryAllocatorDump* heapsDump = BlinkGCMemoryDumpProvider::instance()->createMemoryAllocatorDumpForCurrentGC(heapsDumpName);
     WebMemoryAllocatorDump* classesDump = BlinkGCMemoryDumpProvider::instance()->createMemoryAllocatorDumpForCurrentGC(classesDumpName);
     BlinkGCMemoryDumpProvider::instance()->currentProcessMemoryDump()->addOwnershipEdge(classesDump->guid(), heapsDump->guid());
 }
 
 } // namespace blink