Remove thread-local weak processing

third_party/WebKit/Source/platform/heap/VisitorImpl.h

 // Copyright 2017 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef VisitorImpl_h
 #define VisitorImpl_h
 
 #include "platform/heap/Heap.h"
 #include "platform/heap/ThreadState.h"
 #include "platform/heap/Visitor.h"
@@ skipping 38 matching lines @@
 inline void Visitor::markHeaderNoTracing(HeapObjectHeader* header) {
   markHeader(header, header->payload(), reinterpret_cast<TraceCallback>(0));
 }
 
 inline void Visitor::registerDelayedMarkNoTracing(const void* objectPointer) {
   DCHECK(getMarkingMode() != WeakProcessing);
   heap().pushPostMarkingCallback(const_cast<void*>(objectPointer),
                                  &markNoTracingCallback);
 }
 
-inline void Visitor::registerWeakMembers(const void* closure,
-                                         const void* objectPointer,
-                                         WeakCallback callback) {
-  DCHECK(getMarkingMode() != WeakProcessing);
-  // We don't want to run weak processings when taking a snapshot.
-  if (getMarkingMode() == SnapshotMarking)
-    return;
-  heap().pushThreadLocalWeakCallback(
-      const_cast<void*>(closure), const_cast<void*>(objectPointer), callback);
-}
-
 inline void Visitor::registerWeakTable(
     const void* closure,
     EphemeronCallback iterationCallback,
     EphemeronCallback iterationDoneCallback) {
   DCHECK(getMarkingMode() != WeakProcessing);
   heap().registerWeakTable(const_cast<void*>(closure), iterationCallback,
                            iterationDoneCallback);
 }
 
 #if DCHECK_IS_ON()
@@ skipping 12 matching lines @@
 #if DCHECK_IS_ON()
   markNoTracing(objectPointer);
 #else
   // Inline what the above markNoTracing() call expands to,
   // so as to make sure that we do get all the benefits (asserts excepted.)
   header->mark();
 #endif
   return true;
 }
 
-inline void Visitor::registerWeakCellWithCallback(void** cell,
-                                                  WeakCallback callback) {
+inline void Visitor::registerWeakCallback(void* closure,
+                                          WeakCallback callback) {
   DCHECK(getMarkingMode() != WeakProcessing);
   // We don't want to run weak processings when taking a snapshot.
   if (getMarkingMode() == SnapshotMarking)
     return;
-  heap().pushGlobalWeakCallback(cell, callback);
+  heap().pushWeakCallback(closure, callback);
 }
 
 inline void Visitor::registerBackingStoreReference(void* slot) {
   if (getMarkingMode() != GlobalMarkingWithCompaction)
     return;
   heap().registerMovingObjectReference(
       reinterpret_cast<MovableReference*>(slot));
 }
 
 inline void Visitor::registerBackingStoreCallback(void* backingStore,
                                                   MovingObjectCallback callback,
                                                   void* callbackData) {
   if (getMarkingMode() != GlobalMarkingWithCompaction)
     return;
   heap().registerMovingObjectCallback(
       reinterpret_cast<MovableReference>(backingStore), callback, callbackData);
 }
 
 }  // namespace blink
 
 #endif