Pass Isolate to MakeWeak(), IsWeak(), and AddObjectGroup().

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 371 matching lines @@
    */
   inline void Dispose();
 
   /**
    * 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.
    */
   inline void MakeWeak(void* parameters, WeakReferenceCallback callback);
+  inline void MakeWeak(Isolate* isolate, void* parameters,
+                       WeakReferenceCallback callback);
 
   /** Clears the weak reference to this object. */
   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.
    */
   inline void MarkIndependent();
 
   /** Returns true if this handle was previously marked as independent. */
   inline bool IsIndependent() const;
 
   /** Checks if the handle holds the only reference to an object. */
   inline bool IsNearDeath() const;
 
   /** Returns true if the handle's reference is weak.  */
   inline bool IsWeak() const;
+  inline bool IsWeak(Isolate* isolate) const;
 
   /**
    * Assigns a wrapper class ID to the handle. See RetainedObjectInfo
    * interface description in v8-profiler.h for details.
    */
   inline void SetWrapperClassId(uint16_t class_id);
 
   /**
    * Returns the class ID previously assigned to this handle or 0 if no class
    * ID was previously assigned.
@@ skipping 2830 matching lines @@
    * object in the group is alive, all objects in the group are alive.
    * After each garbage collection, object groups are removed. It is
    * intended to be used in the before-garbage-collection callback
    * function, for instance to simulate DOM tree connections among JS
    * wrapper objects.
    * See v8-profiler.h for RetainedObjectInfo interface description.
    */
   static void AddObjectGroup(Persistent<Value>* objects,
                              size_t length,
                              RetainedObjectInfo* info = NULL);
+  static void AddObjectGroup(Isolate* isolate,
+                             Persistent<Value>* objects,
+                             size_t length,
+                             RetainedObjectInfo* info = NULL);
 
   /**
    * Allows the host application to declare implicit references between
    * the objects: if |parent| is alive, all |children| are alive too.
    * After each garbage collection, all implicit references
    * are removed.  It is intended to be used in the before-garbage-collection
    * callback function.
    */
   static void AddImplicitReferences(Persistent<Object> parent,
                                     Persistent<Value>* children,
@@ skipping 211 matching lines @@
   static int ContextDisposedNotification();
 
  private:
   V8();
 
   static internal::Object** GlobalizeReference(internal::Object** handle);
   static void DisposeGlobal(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 ClearWeak(internal::Object** global_handle);
   static void MarkIndependent(internal::Object** global_handle);
   static bool IsGlobalIndependent(internal::Object** global_handle);
   static bool IsGlobalNearDeath(internal::Object** global_handle);
   static bool IsGlobalWeak(internal::Object** global_handle);
+  static bool IsGlobalWeak(internal::Isolate* isolate,
+                           internal::Object** global_handle);
   static void SetWrapperClassId(internal::Object** global_handle,
                                 uint16_t class_id);
   static uint16_t GetWrapperClassId(internal::Object** global_handle);
 
   template <class T> friend class Handle;
   template <class T> friend class Local;
   template <class T> friend class Persistent;
   friend class Context;
 };
 
@@ skipping 721 matching lines @@
 
 
 template <class T>
 bool Persistent<T>::IsWeak() const {
   if (this->IsEmpty()) return false;
   return V8::IsGlobalWeak(reinterpret_cast<internal::Object**>(**this));
 }
 
 
 template <class T>
+bool Persistent<T>::IsWeak(Isolate* isolate) const {
+  if (this->IsEmpty()) return false;
+  return V8::IsGlobalWeak(reinterpret_cast<internal::Isolate*>(isolate),
+                          reinterpret_cast<internal::Object**>(**this));
+}
+
+
+template <class T>
 void Persistent<T>::Dispose() {
   if (this->IsEmpty()) return;
   V8::DisposeGlobal(reinterpret_cast<internal::Object**>(**this));
 }
 
 
 template <class T>
 Persistent<T>::Persistent() : Handle<T>() { }
 
 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) {
+  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));
 }
 
 template <class T>
 void Persistent<T>::MarkIndependent() {
   V8::MarkIndependent(reinterpret_cast<internal::Object**>(**this));
 }
 
 template <class T>
@@ skipping 429 matching lines @@
 
 
 }  // namespace v8
 
 
 #undef V8EXPORT
 #undef TYPE_CHECK
 
 
 #endif  // V8_H_