Oilpan: Add ThreadState cleanup callbacks for static thread-specific persistent.

third_party/WebKit/Source/platform/heap/ThreadState.cpp

 /*
  * 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 274 matching lines @@
         // GC.
         SafePointAwareMutexLocker locker(threadAttachMutex(), BlinkGC::NoHeapPointersOnStack);
 
         // Finish sweeping.
         completeSweep();
 
         // From here on ignore all conservatively discovered
         // pointers into the heap owned by this thread.
         m_isTerminating = true;
 
+        // Invoke the cleanup hooks. This gives an opportunity to release any
+        // persistent handles that may exist, e.g. in thread-specific static
+        // locals.
+        for (const OwnPtr<SameThreadClosure>& hook : m_cleanupHooks)
+            (*hook)();
+
         // Set the terminate flag on all heap pages of this thread. This is used to
         // ensure we don't trace pages on other threads that are not part of the
         // thread local GC.
         prepareForThreadStateTermination();
 
         ProcessHeap::crossThreadPersistentRegion().prepareForThreadStateTermination(this);
 
         // Do thread local GC's as long as the count of thread local Persistents
         // changes and is above zero.
         int oldCount = -1;
@@ skipping 1047 matching lines @@
 void ThreadState::addInterruptor(PassOwnPtr<BlinkGCInterruptor> interruptor)
 {
     ASSERT(checkThread());
     SafePointScope scope(BlinkGC::HeapPointersOnStack);
     {
         MutexLocker locker(threadAttachMutex());
         m_interruptors.append(interruptor);
     }
 }
 
+void ThreadState::registerCleanupHook(PassOwnPtr<SameThreadClosure> hook)
+{
+    ASSERT(checkThread());
+    ASSERT(!isTerminating());
+    m_cleanupHooks.append(hook);
+}
+
 #if defined(LEAK_SANITIZER)
 void ThreadState::registerStaticPersistentNode(PersistentNode* node)
 {
     if (m_disabledStaticPersistentsRegistration)
         return;
 
     ASSERT(!m_staticPersistents.contains(node));
     m_staticPersistents.add(node);
 }
 
@@ skipping 179 matching lines @@
     threadDump->addScalar("dead_count", "objects", totalDeadCount);
     threadDump->addScalar("live_size", "bytes", totalLiveSize);
     threadDump->addScalar("dead_size", "bytes", totalDeadSize);
 
     WebMemoryAllocatorDump* heapsDump = BlinkGCMemoryDumpProvider::instance()->createMemoryAllocatorDumpForCurrentGC(heapsDumpName);
     WebMemoryAllocatorDump* classesDump = BlinkGCMemoryDumpProvider::instance()->createMemoryAllocatorDumpForCurrentGC(classesDumpName);
     BlinkGCMemoryDumpProvider::instance()->currentProcessMemoryDump()->addOwnershipEdge(classesDump->guid(), heapsDump->guid());
 }
 
 } // namespace blink