Rename m_globalWeakCallbacks to m_weakCallbacks

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 255 matching lines @@
     return isHeapObjectAlive(member.get());
   }
 
   StackFrameDepth& stackFrameDepth() { return m_stackFrameDepth; }
 
   ThreadHeapStats& heapStats() { return m_stats; }
   CallbackStack* markingStack() const { return m_markingStack.get(); }
   CallbackStack* postMarkingCallbackStack() const {
     return m_postMarkingCallbackStack.get();
   }
-  CallbackStack* globalWeakCallbackStack() const {
-    return m_globalWeakCallbackStack.get();
-  }
+  CallbackStack* weakCallbackStack() const { return m_weakCallbackStack.get(); }
   CallbackStack* ephemeronStack() const { return m_ephemeronStack.get(); }
 
   void visitPersistentRoots(Visitor*);
   void visitStackRoots(Visitor*);
   void enterSafePoint(ThreadState*);
   void leaveSafePoint();
 
   // Is the finalizable GC object still alive, but slated for lazy sweeping?
   // If a lazy sweep is in progress, returns true if the object was found
   // to be not reachable during the marking phase, but it has yet to be swept
@@ skipping 44 matching lines @@
   bool popAndInvokeTraceCallback(Visitor*);
 
   // Remove an item from the post-marking callback stack and call
   // the callback with the visitor and the object pointer.  Returns
   // false when there is nothing more to do.
   bool popAndInvokePostMarkingCallback(Visitor*);
 
   // Remove an item from the weak callback work list and call the callback
   // with the visitor and the closure pointer.  Returns false when there is
   // nothing more to do.
-  bool popAndInvokeGlobalWeakCallback(Visitor*);
+  bool popAndInvokeWeakCallback(Visitor*);
 
   // Register an ephemeron table for fixed-point iteration.
   void registerWeakTable(void* containerObject,
                          EphemeronCallback,
                          EphemeronCallback);
 #if DCHECK_IS_ON()
   bool weakTableRegistered(const void*);
 #endif
 
   // Heap compaction registration methods:
@@ skipping 34 matching lines @@
                                       int arenaIndex,
                                       size_t gcInfoIndex,
                                       const char* typeName);
   template <typename T>
   static Address allocate(size_t, bool eagerlySweep = false);
   template <typename T>
   static Address reallocate(void* previous, size_t);
 
   void processMarkingStack(Visitor*);
   void postMarkingProcessing(Visitor*);
-  void globalWeakProcessing(Visitor*);
+  void weakProcessing(Visitor*);
 
   void preGC();
   void postGC(BlinkGC::GCType);
   void preSweep(BlinkGC::GCType);
 
   // Conservatively checks whether an address is a pointer in any of the
   // thread heaps.  If so marks the object pointed to as live.
   Address checkAndMarkPointer(Visitor*, Address);
 #if DCHECK_IS_ON()
   Address checkAndMarkPointer(Visitor*,
@@ skipping 36 matching lines @@
   void commitCallbackStacks();
   void decommitCallbackStacks();
 
   ThreadState* m_threadState;
   ThreadHeapStats m_stats;
   std::unique_ptr<RegionTree> m_regionTree;
   std::unique_ptr<HeapDoesNotContainCache> m_heapDoesNotContainCache;
   std::unique_ptr<PagePool> m_freePagePool;
   std::unique_ptr<CallbackStack> m_markingStack;
   std::unique_ptr<CallbackStack> m_postMarkingCallbackStack;
-  std::unique_ptr<CallbackStack> m_globalWeakCallbackStack;
+  std::unique_ptr<CallbackStack> m_weakCallbackStack;
   std::unique_ptr<CallbackStack> m_ephemeronStack;
   BlinkGC::GCReason m_lastGCReason;
   StackFrameDepth m_stackFrameDepth;
 
   std::unique_ptr<HeapCompact> m_compaction;
 
   static ThreadHeap* s_mainThreadHeap;
 
   friend class ThreadState;
 };
@@ skipping 201 matching lines @@
   T** cell = reinterpret_cast<T**>(object);
   if (*cell && !ObjectAliveTrait<T>::isHeapObjectAlive(*cell))
     *cell = nullptr;
 }
 
 }  // namespace blink
 
 #include "platform/heap/VisitorImpl.h"
 
 #endif  // Heap_h