Rename m_globalWeakCallbacks to m_weakCallbacks

third_party/WebKit/Source/platform/heap/Heap.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 134 matching lines @@
   ProcessHeap::decreaseTotalAllocatedSpace(delta);
 }
 
 ThreadHeap::ThreadHeap(ThreadState* threadState)
     : m_threadState(threadState),
       m_regionTree(WTF::makeUnique<RegionTree>()),
       m_heapDoesNotContainCache(WTF::wrapUnique(new HeapDoesNotContainCache)),
       m_freePagePool(WTF::wrapUnique(new PagePool)),
       m_markingStack(CallbackStack::create()),
       m_postMarkingCallbackStack(CallbackStack::create()),
-      m_globalWeakCallbackStack(CallbackStack::create()),
+      m_weakCallbackStack(CallbackStack::create()),
       m_ephemeronStack(CallbackStack::create()) {
   if (ThreadState::current()->isMainThread())
     s_mainThreadHeap = this;
 }
 
 ThreadHeap::~ThreadHeap() {
 }
 
 #if DCHECK_IS_ON()
 BasePage* ThreadHeap::findPageFromAddress(Address address) {
@@ skipping 75 matching lines @@
   if (CallbackStack::Item* item = m_postMarkingCallbackStack->pop()) {
     item->call(visitor);
     return true;
   }
   return false;
 }
 
 void ThreadHeap::pushWeakCallback(void* closure, WeakCallback callback) {
   ASSERT(ThreadState::current()->isInGC());
 
-  CallbackStack::Item* slot = m_globalWeakCallbackStack->allocateEntry();
+  CallbackStack::Item* slot = m_weakCallbackStack->allocateEntry();
   *slot = CallbackStack::Item(closure, callback);
 }
 
-bool ThreadHeap::popAndInvokeGlobalWeakCallback(Visitor* visitor) {
-  if (CallbackStack::Item* item = m_globalWeakCallbackStack->pop()) {
+bool ThreadHeap::popAndInvokeWeakCallback(Visitor* visitor) {
+  if (CallbackStack::Item* item = m_weakCallbackStack->pop()) {
     item->call(visitor);
     return true;
   }
   return false;
 }
 
 void ThreadHeap::registerWeakTable(void* table,
                                    EphemeronCallback iterationCallback,
                                    EphemeronCallback iterationDoneCallback) {
   ASSERT(ThreadState::current()->isInGC());
 
   CallbackStack::Item* slot = m_ephemeronStack->allocateEntry();
   *slot = CallbackStack::Item(table, iterationCallback);
 
   // Register a post-marking callback to tell the tables that
   // ephemeron iteration is complete.
   pushPostMarkingCallback(table, iterationDoneCallback);
 }
 
 #if DCHECK_IS_ON()
 bool ThreadHeap::weakTableRegistered(const void* table) {
   ASSERT(m_ephemeronStack);
   return m_ephemeronStack->hasCallbackForObject(table);
 }
 #endif
 
 void ThreadHeap::commitCallbackStacks() {
   m_markingStack->commit();
   m_postMarkingCallbackStack->commit();
-  m_globalWeakCallbackStack->commit();
+  m_weakCallbackStack->commit();
   m_ephemeronStack->commit();
 }
 
 HeapCompact* ThreadHeap::compaction() {
   if (!m_compaction)
     m_compaction = HeapCompact::create();
   return m_compaction.get();
 }
 
 void ThreadHeap::registerMovingObjectReference(MovableReference* slot) {
   DCHECK(slot);
   DCHECK(*slot);
   compaction()->registerMovingObjectReference(slot);
 }
 
 void ThreadHeap::registerMovingObjectCallback(MovableReference reference,
                                               MovingObjectCallback callback,
                                               void* callbackData) {
   DCHECK(reference);
   compaction()->registerMovingObjectCallback(reference, callback, callbackData);
 }
 
 void ThreadHeap::decommitCallbackStacks() {
   m_markingStack->decommit();
   m_postMarkingCallbackStack->decommit();
-  m_globalWeakCallbackStack->decommit();
+  m_weakCallbackStack->decommit();
   m_ephemeronStack->decommit();
 }
 
 void ThreadHeap::preGC() {
   ASSERT(!ThreadState::current()->isInGC());
   m_threadState->preGC();
 }
 
 void ThreadHeap::postGC(BlinkGC::GCType gcType) {
   ASSERT(ThreadState::current()->isInGC());
@@ skipping 35 matching lines @@
   //    if they are only reachable from their front objects.
   while (popAndInvokePostMarkingCallback(visitor)) {
   }
 
   // Post-marking callbacks should not trace any objects and
   // therefore the marking stack should be empty after the
   // post-marking callbacks.
   ASSERT(m_markingStack->isEmpty());
 }
 
-void ThreadHeap::globalWeakProcessing(Visitor* visitor) {
-  TRACE_EVENT0("blink_gc", "ThreadHeap::globalWeakProcessing");
+void ThreadHeap::weakProcessing(Visitor* visitor) {
+  TRACE_EVENT0("blink_gc", "ThreadHeap::weakProcessing");
   double startTime = WTF::currentTimeMS();
 
   // Call weak callbacks on objects that may now be pointing to dead objects.
-  while (popAndInvokeGlobalWeakCallback(visitor)) {
+  while (popAndInvokeWeakCallback(visitor)) {
   }
 
   // It is not permitted to trace pointers of live objects in the weak
   // callback phase, so the marking stack should still be empty here.
   ASSERT(m_markingStack->isEmpty());
 
-  double timeForGlobalWeakProcessing = WTF::currentTimeMS() - startTime;
+  double timeForWeakProcessing = WTF::currentTimeMS() - startTime;
   DEFINE_THREAD_SAFE_STATIC_LOCAL(
-      CustomCountHistogram, globalWeakTimeHistogram,
+      CustomCountHistogram, weakProcessingTimeHistogram,
       new CustomCountHistogram("BlinkGC.TimeForGlobalWeakProcessing", 1,
                                10 * 1000, 50));
-  globalWeakTimeHistogram.count(timeForGlobalWeakProcessing);
+  weakProcessingTimeHistogram.count(timeForWeakProcessing);
 }
 
 void ThreadHeap::reportMemoryUsageHistogram() {
   static size_t supportedMaxSizeInMB = 4 * 1024;
   static size_t observedMaxSizeInMB = 0;
 
   // We only report the memory in the main thread.
   if (!isMainThread())
     return;
   // +1 is for rounding up the sizeInMB.
@@ skipping 119 matching lines @@
   ProcessHeap::decreaseTotalAllocatedObjectSize(m_stats.allocatedObjectSize());
   ProcessHeap::decreaseTotalMarkedObjectSize(m_stats.markedObjectSize());
 
   m_stats.reset();
   m_threadState->resetHeapCounters();
 }
 
 ThreadHeap* ThreadHeap::s_mainThreadHeap = nullptr;
 
 }  // namespace blink