Oilpan: Rename weak callback related methods

Source/platform/heap/Visitor.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 322 matching lines @@
     void registerWeakCell(T** cell)
     {
         Derived::fromHelper(this)->registerWeakCellWithCallback(reinterpret_cast<void**>(cell), &handleWeakCell<T>);
     }
 
     template<typename T, void (T::*method)(Visitor*)>
     void registerWeakMembers(const T* obj)
     {
         registerWeakMembers(obj, &TraceMethodDelegate<T, method>::trampoline);
     }
-    void registerWeakMembers(const void* object, WeakPointerCallback callback)
+    void registerWeakMembers(const void* object, WeakCallback callback)
     {
         Derived::fromHelper(this)->registerWeakMembers(object, object, callback);
     }
 
     template<typename T> inline bool isHeapObjectAlive(T* obj)
     {
         static_assert(sizeof(T), "T must be fully defined");
         // The strongification of collections relies on the fact that once a
         // collection has been strongified, there is no way that it can contain
         // non-live entries, so no entries will be removed. Since you can't set
@@ skipping 58 matching lines @@
     // Used to delay the marking of objects until the usual marking
     // including emphemeron iteration is done. This is used to delay
     // the marking of collection backing stores until we know if they
     // are reachable from locations other than the collection front
     // object. If collection backings are reachable from other
     // locations we strongify them to avoid issues with iterators and
     // weak processing.
     virtual void registerDelayedMarkNoTracing(const void*) = 0;
 
     // If the object calls this during the regular trace callback, then the
-    // WeakPointerCallback argument may be called later, when the strong roots
-    // have all been found. The WeakPointerCallback will normally use isAlive
+    // WeakCallback argument may be called later, when the strong roots
+    // have all been found. The WeakCallback will normally use isAlive
     // to find out whether some pointers are pointing to dying objects. When
-    // the WeakPointerCallback is done the object must have purged all pointers
+    // the WeakCallback is done the object must have purged all pointers
     // to objects where isAlive returned false. In the weak callback it is not
     // allowed to touch other objects (except using isAlive) or to allocate on
     // the GC heap. Note that even removing things from HeapHashSet or
     // HeapHashMap can cause an allocation if the backing store resizes, but
     // these collections know to remove WeakMember elements safely.
     //
     // The weak pointer callbacks are run on the thread that owns the
     // object and other threads are not stopped during the
     // callbacks. Since isAlive is used in the callback to determine
     // if objects pointed to are alive it is crucial that the object
     // pointed to belong to the same thread as the object receiving
     // the weak callback. Since other threads have been resumed the
     // mark bits are not valid for objects from other threads.
-    virtual void registerWeakMembers(const void*, const void*, WeakPointerCallback) = 0;
+    virtual void registerWeakMembers(const void*, const void*, WeakCallback) = 0;
     using VisitorHelper<Visitor>::registerWeakMembers;
 
     virtual void registerWeakTable(const void*, EphemeronCallback, EphemeronCallback) = 0;
 #if ENABLE(ASSERT)
     virtual bool weakTableRegistered(const void*) = 0;
 #endif
 
     virtual bool isMarked(const void*) = 0;
     virtual bool ensureMarked(const void*) = 0;
 
 #if ENABLE(GC_PROFILING)
     void setHostInfo(void* object, const String& name)
     {
         m_hostObject = object;
         m_hostName = name;
     }
 #endif
 
     inline bool isGlobalMarkingVisitor() const { return m_isGlobalMarkingVisitor; }
 
 protected:
     explicit Visitor(MarkingMode markingMode)
         : m_isGlobalMarkingVisitor(markingMode == GlobalMarking)
     { }
 
-    virtual void registerWeakCellWithCallback(void**, WeakPointerCallback) = 0;
+    virtual void registerWeakCellWithCallback(void**, WeakCallback) = 0;
 #if ENABLE(GC_PROFILING)
     virtual void recordObjectGraphEdge(const void*) = 0;
 
     void* m_hostObject;
     String m_hostName;
 #endif
 
 #if ENABLE(ASSERT)
     virtual void checkMarkingAllowed() { }
 #endif
@@ skipping 20 matching lines @@
     {
         DEFINE_STATIC_LOCAL(String, typenameString, (WTF::extractTypeNameFromFunctionName(WTF::extractNameFunction<T>())));
         return typenameString;
     }
 };
 #endif
 
 } // namespace blink
 
 #endif // Visitor_h