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 761 matching lines @@
     // 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);
+    static void pushWeakObjectPointerCallback(void* closure, void* containerObject, WeakPointerCallback);

[Mads Ager (chromium), 2014/03/12 15:46:50]

Please update the comment with an explanation of what decided the thread and
what gets the callback. We might want to rename containerObject here?

Also, maybe add a comment that closure and object are usually the same but that
for heap collections, they are different because the front object needs to get
the callback but the backing store is the only thing that is guaranteed to be in
the heap.

[Erik Corry, 2014/03/13 07:46:21]

Done.

     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.
     static bool popAndInvokeWeakPointerCallback(Visitor*);
 
@@ skipping 463 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