Remove thread-local weak processing

third_party/WebKit/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 202 matching lines @@
   // it is pointing at is garbage, you can use this. This will register a
   // callback for each cell that needs to be zeroed, so if you have a lot of
   // weak cells in your object you should still consider using
   // registerWeakMembers above.
   //
   // In contrast to registerWeakMembers, the weak cell callbacks are
   // run on the thread performing garbage collection. Therefore, all
   // threads are stopped during weak cell callbacks.
   template <typename T>
   void registerWeakCell(T** cell) {
-    registerWeakCellWithCallback(
+    registerWeakCallback(
         reinterpret_cast<void**>(
             const_cast<typename std::remove_const<T>::type**>(cell)),
         &handleWeakCell<T>);
   }
 
   template <typename T, void (T::*method)(Visitor*)>
   void registerWeakMembers(const T* obj) {
-    registerWeakMembers(obj, &TraceMethodDelegate<T, method>::trampoline);
+    registerWeakCallback(const_cast<T*>(obj),
+                         &TraceMethodDelegate<T, method>::trampoline);
   }
 
-  void registerWeakMembers(const void* object, WeakCallback callback) {
-    registerWeakMembers(object, object, callback);
-  }
 
   inline void registerBackingStoreReference(void* slot);
 
   inline void registerBackingStoreCallback(void* backingStore,
                                            MovingObjectCallback,
                                            void* callbackData);
 
   // This method marks an object and adds it to the set of objects
   // that should have their trace method called. Since not all
   // objects have vtables we have to have the callback as an
@@ skipping 17 matching lines @@
   // to find out whether some pointers are pointing to dying objects. When
   // 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 do anything that adds or extends the object graph (e.g.,
   // allocate a new object, add a new reference revive a dead object etc.)
   // Clearing out pointers to other heap objects is allowed, however. Note
   // that even removing things from HeapHashSet or HeapHashMap can cause
   // an allocation if the backing store resizes, but these collections know
   // how to remove WeakMember elements safely.
   //
   // The weak pointer callbacks are run on the thread that owns the

[sof, 2017/02/14 07:16:48]

nit: refresh this paragraph a bit?

   // 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.
-  inline void registerWeakMembers(const void* closure,
-                                  const void* pointer,
-                                  WeakCallback);
+  inline void registerWeakCallback(void* closure, WeakCallback);
 
   inline void registerWeakTable(const void* closure,
                                 EphemeronCallback iterationCallback,
                                 EphemeronCallback iterationDoneCallback);
 
 #if DCHECK_IS_ON()
   inline bool weakTableRegistered(const void* closure);
 #endif
 
   inline bool ensureMarked(const void* pointer);
 
-  inline void registerWeakCellWithCallback(void** cell, WeakCallback);
-
   inline void markNoTracing(const void* pointer) {
     mark(pointer, reinterpret_cast<TraceCallback>(0));
   }
 
   inline void markHeaderNoTracing(HeapObjectHeader*);
 
   // Used to mark objects during conservative scanning.
   inline void markHeader(HeapObjectHeader*,
                          const void* objectPointer,
                          TraceCallback);
@@ skipping 11 matching lines @@
 
   static void markNoTracingCallback(Visitor*, void*);
 
   ThreadState* const m_state;
   const MarkingMode m_markingMode;
 };
 
 }  // namespace blink
 
 #endif  // Visitor_h