Oilpan: Add support of pre-finalization callback to Oilpan infrastructure.

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 437 matching lines @@
         int currentCount = anchor->numberOfPersistents();
         ASSERT(currentCount >= 0);
         while (currentCount != oldCount) {
             Heap::collectGarbageForTerminatingThread(this);
             oldCount = currentCount;
             currentCount = anchor->numberOfPersistents();
         }
         // We should not have any persistents left when getting to this point,
         // if we have it is probably a bug so adding a debug ASSERT to catch this.
         ASSERT(!currentCount);
+        // All of pre-finalizers should be consumed.
+        ASSERT(m_preFinalizers.isEmpty());
 
         // Add pages to the orphaned page pool to ensure any global GCs from this point
         // on will not trace objects on this thread's heaps.
         cleanupPages();
 
         ASSERT(attachedThreads().contains(this));
         attachedThreads().remove(this);
     }
 
     for (size_t i = 0; i < m_cleanupTasks.size(); i++)
@@ skipping 639 matching lines @@
     {
         NoSweepScope scope(this);
 
         // Disallow allocation during weak processing.
         enterNoAllocationScope();
         {
             TRACE_EVENT0("blink_gc", "ThreadState::threadLocalWeakProcessing");
             // Perform thread-specific weak processing.
             while (popAndInvokeWeakPointerCallback(Heap::s_markingVisitor)) { }
         }
+        {
+            TRACE_EVENT0("blink_gc", "ThreadState::invokePreFinalizers");
+            invokePreFinalizers(*Heap::s_markingVisitor);
+        }
         leaveNoAllocationScope();
 
         // Perform sweeping and finalization.
 
         // Sweeping will recalculate the stats
         m_stats.clear();
 
         // Sweep the non-finalized heap pages on multiple threads.
         // Attempt to load-balance by having the sweeper thread sweep as
         // close to half of the pages as possible.
@@ skipping 113 matching lines @@
     ASSERT(!state->isAtSafePoint());
     state->safePoint(HeapPointersOnStack);
 }
 
 ThreadState::AttachedThreadStateSet& ThreadState::attachedThreads()
 {
     DEFINE_STATIC_LOCAL(AttachedThreadStateSet, threads, ());
     return threads;
 }
 
+void ThreadState::unregisterPreFinalizerInternal(void* target)
+{
+    if (isSweepInProgress())
+        return;
+    auto it = m_preFinalizers.find(target);
+    ASSERT(it != m_preFinalizers.end());
+    m_preFinalizers.remove(it);
+}
+
+void ThreadState::invokePreFinalizers(Visitor& visitor)
+{
+    Vector<void*> deadObjects;
+    for (auto& entry : m_preFinalizers) {
+        if (entry.value(entry.key, visitor))
+            deadObjects.append(entry.key);
+    }
+    m_preFinalizers.removeAll(deadObjects);
+}
+
 #if ENABLE(GC_PROFILE_MARKING)
 const GCInfo* ThreadState::findGCInfoFromAllThreads(Address address)
 {
     bool needLockForIteration = !isAnyThreadInGC();
     if (needLockForIteration)
         threadAttachMutex().lock();
 
     ThreadState::AttachedThreadStateSet& threads = attachedThreads();
     for (ThreadState::AttachedThreadStateSet::iterator it = threads.begin(), end = threads.end(); it != end; ++it) {
         if (const GCInfo* gcInfo = (*it)->findGCInfo(address)) {
             if (needLockForIteration)
                 threadAttachMutex().unlock();
             return gcInfo;
         }
     }
     if (needLockForIteration)
         threadAttachMutex().unlock();
     return 0;
 }
 #endif
 
 }