Add a new weak handle callback that passes an Isolate to an embedder

include/v8.h

 // Copyright 2012 the V8 project authors. 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
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 133 matching lines @@
 
 /**
  * A weak reference callback function.
  *
  * This callback should either explicitly invoke Dispose on |object| if
  * V8 wrapper is not needed anymore, or 'revive' it by invocation of MakeWeak.
  *
  * \param object the weak global object to be reclaimed by the garbage collector
  * \param parameter the value passed in when making the weak global object
  */
 typedef void (*WeakReferenceCallback)(Persistent<Value> object,

[Sven Panne, 2013/01/18 08:08:12]

We should add a remark here that this kind of callback is deprecated. Or better:
Find out if our deprecation macro somehow works for typedefs.

[haraken, 2013/01/22 00:27:37]

Done.

                                       void* parameter);
+typedef void (*WeakenedReferenceCallback)(Isolate* isolate,

[Sven Panne, 2013/01/18 08:08:12]

Hmmm, I'm not totally happy with that name. We should come up with a better one,
but I don't have a suggestion right now.

[haraken, 2013/01/22 00:27:37]

For now I changed the name to WeakHandleCallback.

+                                          Persistent<Value> object,
+                                          void* parameter);
 
 
 // --- Handles ---
 
 #define TYPE_CHECK(T, S)                                       \
   while (false) {                                              \
     *(static_cast<T* volatile*>(0)) = static_cast<S*>(0);      \
   }
 
 /**
@@ skipping 234 matching lines @@
    */
   V8_INLINE(void Dispose());
   V8_INLINE(void Dispose(Isolate* isolate));
 
   /**
    * Make the reference to this object weak.  When only weak handles
    * refer to the object, the garbage collector will perform a
    * callback to the given V8::WeakReferenceCallback function, passing
    * it the object reference and the given parameters.
    */
   V8_INLINE(void MakeWeak(void* parameters, WeakReferenceCallback callback));

[Sven Panne, 2013/01/18 08:08:12]

Add a TODO comment that this should be deprecated soon.

[haraken, 2013/01/22 00:27:37]

Done.

   V8_INLINE(void MakeWeak(Isolate* isolate,
                           void* parameters,
                           WeakReferenceCallback callback));
+  V8_INLINE(void Weaken(Isolate* isolate,

[Sven Panne, 2013/01/18 08:08:12]

As discussed offline, the 3-arg MakeWeak is brand-new, so we can just change it
to expect the new kind of callback. No need for a third API entry where 1 should
survive in the long run.

[haraken, 2013/01/22 00:27:37]

Done.

+                        void* parameters,
+                        WeakenedReferenceCallback callback));
 
   /** Clears the weak reference to this object. */
   V8_INLINE(void ClearWeak());
 
   /**
    * Marks the reference to this object independent. Garbage collector
    * is free to ignore any object groups containing this object.
    * Weak callback for an independent handle should not
    * assume that it will be preceded by a global GC prologue callback
    * or followed by a global GC epilogue callback.
@@ skipping 3096 matching lines @@
   static void DisposeGlobal(internal::Object** global_handle);
   static void DisposeGlobal(internal::Isolate* isolate,
                             internal::Object** global_handle);
   static void MakeWeak(internal::Object** global_handle,
                        void* data,
                        WeakReferenceCallback);
   static void MakeWeak(internal::Isolate* isolate,
                        internal::Object** global_handle,
                        void* data,
                        WeakReferenceCallback);
+  static void WeakenGlobal(internal::Isolate* isolate,

[Sven Panne, 2013/01/18 08:08:12]

see above

[haraken, 2013/01/22 00:27:37]

Done.

+                           internal::Object** global_handle,
+                           void* data,
+                           WeakenedReferenceCallback);
   static void ClearWeak(internal::Object** global_handle);
   static void MarkIndependent(internal::Object** global_handle);
   static void MarkIndependent(internal::Isolate* isolate,
                               internal::Object** global_handle);
   static void MarkPartiallyDependent(internal::Object** global_handle);
   static void MarkPartiallyDependent(internal::Isolate* isolate,
                                      internal::Object** global_handle);
   static bool IsGlobalIndependent(internal::Object** global_handle);
   static bool IsGlobalIndependent(internal::Isolate* isolate,
                                   internal::Object** global_handle);
@@ skipping 824 matching lines @@
 template <class T>
 void Persistent<T>::MakeWeak(Isolate* isolate, void* parameters,
                              WeakReferenceCallback callback) {
   V8::MakeWeak(reinterpret_cast<internal::Isolate*>(isolate),
                reinterpret_cast<internal::Object**>(**this),
                parameters,
                callback);
 }
 
 template <class T>
+void Persistent<T>::Weaken(Isolate* isolate, void* parameters,

[Sven Panne, 2013/01/18 08:08:12]

see above

[haraken, 2013/01/22 00:27:37]

Done.

+                           WeakenedReferenceCallback callback) {
+  V8::WeakenGlobal(reinterpret_cast<internal::Isolate*>(isolate),
+                   reinterpret_cast<internal::Object**>(**this),
+                   parameters,
+                   callback);
+}
+
+template <class T>
 void Persistent<T>::ClearWeak() {
   V8::ClearWeak(reinterpret_cast<internal::Object**>(**this));
 }
 
 template <class T>
 void Persistent<T>::MarkIndependent() {
   V8::MarkIndependent(reinterpret_cast<internal::Object**>(**this));
 }
 
 template <class T>
@@ skipping 452 matching lines @@
 
 
 }  // namespace v8
 
 
 #undef V8EXPORT
 #undef TYPE_CHECK
 
 
 #endif  // V8_H_