Unify and generalize thread static persistent finalization.

third_party/WebKit/Source/platform/heap/ThreadState.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 483 matching lines @@
     }
     void allocationPointAdjusted(int arenaIndex);
     void promptlyFreed(size_t gcInfoIndex);
 
     void accumulateSweepingTime(double time) { m_accumulatedSweepingTime += time; }
 
 #if OS(WIN) && COMPILER(MSVC)
     size_t threadStackSize();
 #endif
 
-    // Registers a closure that will be called while the thread is shutting down
-    // (i.e. ThreadState::isTerminating will be true), in order to allow for any
-    // persistent handles that should be cleared.
-    void registerThreadShutdownHook(PassOwnPtr<SameThreadClosure>);
+    void freePersistentNode(PersistentNode*);
+
+    using PersistentClearCallback = void(*)(void*);
+
+    void registerStaticPersistentNode(PersistentNode*, PersistentClearCallback);
+    void releaseStaticPersistentNodes();
 
 #if defined(LEAK_SANITIZER)
-    void registerStaticPersistentNode(PersistentNode*);
-    void releaseStaticPersistentNodes();
-
     void enterStaticReferenceRegistrationDisabledScope();
     void leaveStaticReferenceRegistrationDisabledScope();
 #endif
 
     void resetHeapCounters();
     void increaseAllocatedObjectSize(size_t);
     void decreaseAllocatedObjectSize(size_t);
     void increaseMarkedObjectSize(size_t);
 
     void callThreadShutdownHooks();
@@ skipping 123 matching lines @@
     CallbackStack* m_threadLocalWeakCallbackStack;
 
     // Pre-finalizers are called in the reverse order in which they are
     // registered by the constructors (including constructors of Mixin objects)
     // for an object, by processing the m_orderedPreFinalizers back-to-front.
     ListHashSet<PreFinalizer> m_orderedPreFinalizers;
 
     v8::Isolate* m_isolate;
     void (*m_traceDOMWrappers)(v8::Isolate*, Visitor*);
 
-    // Invoked while the thread is terminating. Intended to be used to free
-    // persistent pointers into the thread's heap.
-    Vector<OwnPtr<SameThreadClosure>> m_threadShutdownHooks;
-
 #if defined(ADDRESS_SANITIZER)
     void* m_asanFakeStack;
 #endif
 
+    // PersistentNodes that are stored in static references;
+    // references that either have to be cleared upon the thread
+    // detaching from Oilpan and shutting down or references we
+    // have to clear before initiating LSan's leak detection.
+    HashMap<PersistentNode*, PersistentClearCallback> m_staticPersistents;
+
 #if defined(LEAK_SANITIZER)
-    // PersistentNodes that are stored in static references;
-    // references we have to clear before initiating LSan's leak detection.
-    HashSet<PersistentNode*> m_staticPersistents;
-
     // Count that controls scoped disabling of persistent registration.
     size_t m_disabledStaticPersistentsRegistration;
 #endif
 
     // Ideally we want to allocate an array of size |gcInfoTableMax| but it will
     // waste memory. Thus we limit the array size to 2^8 and share one entry
     // with multiple types of vectors. This won't be an issue in practice,
     // since there will be less than 2^8 types of objects in common cases.
     static const int likelyToBePromptlyFreedArraySize = (1 << 8);
     static const int likelyToBePromptlyFreedArrayMask = likelyToBePromptlyFreedArraySize - 1;
@@ skipping 20 matching lines @@
 
 template<> class ThreadStateFor<AnyThread> {
     STATIC_ONLY(ThreadStateFor);
 public:
     static ThreadState* state() { return ThreadState::current(); }
 };
 
 } // namespace blink
 
 #endif // ThreadState_h