Remove thread-local weak processing

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 275 matching lines @@
   void attach(ThreadState*);
   void detach(ThreadState*);
   void lockThreadAttachMutex();
   void unlockThreadAttachMutex();
 
   void visitPersistentRoots(Visitor*);
   void visitStackRoots(Visitor*);
   void enterSafePoint(ThreadState*);
   void leaveSafePoint(ThreadState*, SafePointAwareMutexLocker*);
 
-  // Add a weak pointer callback to the weak callback work list.  General
-  // object pointer callbacks are added to a thread local weak callback work
-  // list and the callback is called on the thread that owns the object, with
-  // the closure pointer as an argument.  Most of the time, the closure and
-  // the containerObject can be the same thing, but the containerObject is
-  // constrained to be on the heap, since the heap is used to identify the
-  // correct thread.
-  void pushThreadLocalWeakCallback(void* closure,
-                                   void* containerObject,
-                                   WeakCallback);
-
   static RecursiveMutex& allHeapsMutex();
   static HashSet<ThreadHeap*>& allHeaps();
 
   // 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
   // and finalized. The predicate returns false in all other cases.
   //
   // Holding a reference to an already-dead object is not a valid state
   // to be in; willObjectBeLazilySwept() has undefined behavior if passed
@@ skipping 24 matching lines @@
   }
 
   // Push a trace callback on the marking stack.
   void pushTraceCallback(void* containerObject, TraceCallback);
 
   // Push a trace callback on the post-marking callback stack.  These
   // callbacks are called after normal marking (including ephemeron
   // iteration).
   void pushPostMarkingCallback(void*, TraceCallback);
 
-  // Similar to the more general pushThreadLocalWeakCallback, but cell
-  // pointer callbacks are added to a static callback work list and the weak
-  // callback is performed on the thread performing garbage collection.  This
-  // is OK because cells are just cleared and no deallocation can happen.
-  void pushGlobalWeakCallback(void** cell, WeakCallback);
+  // Push a weak callback. The weak callback is called when the object
+  // doesn't get marked in the current GC.
+  void pushWeakCallback(void*, WeakCallback);
 
   // Pop the top of a marking stack and call the callback with the visitor
   // and the object.  Returns false when there is nothing more to do.
   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*);
 
@@ skipping 329 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