Fix PersistentHeapHashMap to work with stack allocated, heap backed weak collections

Source/heap/Heap.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 754 matching lines @@
     static void init();
     static void shutdown();
 
     static BaseHeapPage* contains(Address);
     static BaseHeapPage* contains(void* pointer) { return contains(reinterpret_cast<Address>(pointer)); }
     static BaseHeapPage* contains(const void* pointer) { return contains(const_cast<void*>(pointer)); }
 
     // Push a trace callback on the marking stack.
     static void pushTraceCallback(void* containerObject, TraceCallback);
 
-    // Push a weak pointer callback on the weak callback
-    // stack. General object pointer callbacks are pushed on a thread
-    // local weak callback stack and the callback is called on the
-    // thread that owns the object. Cell pointer callbacks are pushed
-    // on a static callback stack and the weak callback is performed
-    // on the thread performing garbage collection. This is OK because
-    // cells are just cleared and no deallocation can happen.
-    static void pushWeakObjectPointerCallback(void* containerObject, WeakPointerCallback);
+    // Add a weak pointer callback to the weak callback work list. General
+    // object pointer callbacks are added to a thread local weak callback work
+    // list and the callback is called on the thread that owns the object, with
+    // the closure pointer as an argument. Most of the time, the closure and
+    // the containerObject can be the same thing, but the containerObject is
+    // constrained to be on the heap, since the heap is used to identify the
+    // correct thread.
+    static void pushWeakObjectPointerCallback(void* closure, void* containerObject, WeakPointerCallback);
+
+    // Similar to the more general pushWeakObjectPointerCallback, but cell
+    // pointer callbacks are added to a static callback work list and the weak
+    // callback is performed on the thread performing garbage collection. This
+    // is OK because cells are just cleared and no deallocation can happen.
     static void pushWeakCellPointerCallback(void** cell, WeakPointerCallback);
 
     // Pop the top of the marking stack and call the callback with the visitor
     // and the object. Returns false when there is nothing more to do.
     static bool popAndInvokeTraceCallback(Visitor*);
 
-    // Pop the top of the weak callback stack and call the callback with the visitor
-    // and the object. Returns false when there is nothing more to do.
+    // Remove an item from the weak callback work list and call the callback
+    // with the visitor and the closure pointer. Returns false when there is
+    // nothing more to do.
     static bool popAndInvokeWeakPointerCallback(Visitor*);
 
     template<typename T> static Address allocate(size_t);
     template<typename T> static Address reallocate(void* previous, size_t);
 
     static void collectGarbage(ThreadState::StackState, GCType = Normal);
     static void collectAllGarbage(ThreadState::StackState, GCType = Normal);
 
     static void prepareForGC();
 
@@ skipping 455 matching lines @@
     {
         return !visitor->isAlive(t);
     }
 
     template<typename T, typename U>
     static bool hasDeadMember(Visitor* visitor, const WTF::KeyValuePair<T, U>& t)
     {
         return hasDeadMember(visitor, t.key) || hasDeadMember(visitor, t.value);
     }
 
-    static void registerWeakMembers(Visitor* visitor, const void* object, WeakPointerCallback callback)
+    static void registerWeakMembers(Visitor* visitor, const void* closure, const void* object, WeakPointerCallback callback)
     {
-        visitor->registerWeakMembers(object, callback);
+        visitor->registerWeakMembers(closure, object, callback);
     }
 
     template<typename T>
     struct ResultType {
         typedef T* Type;
     };
 
     // The WTF classes use Allocator::VectorBackingHelper in order to find a
     // class to template their backing allocation operation on. For off-heap
     // allocations the VectorBackingHelper is a dummy class, since the class is
@@ skipping 430 matching lines @@
 // to export. This forces it to export all the methods from ThreadHeap.
 template<> void ThreadHeap<FinalizedHeapObjectHeader>::addPageToHeap(const GCInfo*);
 template<> void ThreadHeap<HeapObjectHeader>::addPageToHeap(const GCInfo*);
 extern template class HEAP_EXPORT ThreadHeap<FinalizedHeapObjectHeader>;
 extern template class HEAP_EXPORT ThreadHeap<HeapObjectHeader>;
 #endif
 
 }
 
 #endif // Heap_h