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 1096 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)) { }
         }
+        invokePreFinalizer(*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::unregisterObjectWithPreFinalizerInternal(void* target)
+{
+    if (isSweepInProgress())
+        return;
+    auto it = m_objectsWithPreFinalizer.find(target);
+    ASSERT(it != m_objectsWithPreFinalizer.end());
+    m_objectsWithPreFinalizer.remove(it);
+}
+
+void ThreadState::invokePreFinalizer(Visitor& visitor)
+{
+    Vector<void*> deadObjects;
+    for (auto& entry : m_objectsWithPreFinalizer) {
+        if (entry.value(entry.key, visitor))
+            deadObjects.append(entry.key);
+    }
+    m_objectsWithPreFinalizer.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
 
 }