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 @@
 
 // --- Weak Handles ---
 
 
 /**
  * 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 isolate the current isolate
  * \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
+ *
+ * WeakReferenceCallback is deprecated. Use WeakHandleCallback instead.
  */
 typedef void (*WeakReferenceCallback)(Persistent<Value> object,
                                       void* parameter);
+typedef void (*WeakHandleCallback)(Isolate* isolate,
+                                   Persistent<Value> object,
+                                   void* parameter);
 
 
 // --- Handles ---
 
 #define TYPE_CHECK(T, S)                                       \
   while (false) {                                              \
     *(static_cast<T* volatile*>(0)) = static_cast<S*>(0);      \
   }
 
 /**
@@ skipping 233 matching lines @@
    * cell remain and IsEmpty will still return false.
    */
   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.
+   * The 2-arg MakeWeak is deprecated. The 3-arg MakeWeak should be used.
    */
   V8_INLINE(void MakeWeak(void* parameters, WeakReferenceCallback callback));
   V8_INLINE(void MakeWeak(Isolate* isolate,
                           void* parameters,
-                          WeakReferenceCallback callback));
+                          WeakHandleCallback 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 3095 matching lines @@
   static internal::Object** GlobalizeReference(internal::Object** handle);
   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);
+                       WeakHandleCallback);
   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 826 matching lines @@
 
 template <class T>
 void Persistent<T>::MakeWeak(void* parameters, WeakReferenceCallback callback) {
   V8::MakeWeak(reinterpret_cast<internal::Object**>(**this),
                parameters,
                callback);
 }
 
 template <class T>
 void Persistent<T>::MakeWeak(Isolate* isolate, void* parameters,
-                             WeakReferenceCallback callback) {
+                             WeakHandleCallback callback) {
   V8::MakeWeak(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));
 }
@@ skipping 459 matching lines @@
 
 
 }  // namespace v8
 
 
 #undef V8EXPORT
 #undef TYPE_CHECK
 
 
 #endif  // V8_H_