Implement MarkIndependent(Isolate*) and MarkPartiallyDependent(Isolate*)

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 395 matching lines @@
   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();
+  inline void MarkIndependent(Isolate* isolate);
 
   /**
    * Marks the reference to this object partially dependent. Partially
    * dependent handles only depend on other partially dependent handles and
    * these dependencies are provided through object groups. It provides a way
    * to build smaller object groups for young objects that represent only a
    * subset of all external dependencies. This mark is automatically cleared
    * after each garbage collection.
    */
   inline void MarkPartiallyDependent();
+  inline void MarkPartiallyDependent(Isolate* isolate);
 
   /** Returns true if this handle was previously marked as independent. */
   inline bool IsIndependent() const;
   inline bool IsIndependent(Isolate* isolate) 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;
@@ skipping 3090 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 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);
   static bool IsGlobalNearDeath(internal::Object** global_handle);
   static bool IsGlobalWeak(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;
@@ skipping 782 matching lines @@
 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>
+void Persistent<T>::MarkIndependent(Isolate* isolate) {
+  V8::MarkIndependent(reinterpret_cast<internal::Isolate*>(isolate),
+                      reinterpret_cast<internal::Object**>(**this));
+}
+
+template <class T>
 void Persistent<T>::MarkPartiallyDependent() {
   V8::MarkPartiallyDependent(reinterpret_cast<internal::Object**>(**this));
 }
 
 template <class T>
+void Persistent<T>::MarkPartiallyDependent(Isolate* isolate) {
+  V8::MarkPartiallyDependent(reinterpret_cast<internal::Isolate*>(isolate),
+                             reinterpret_cast<internal::Object**>(**this));
+}
+
+template <class T>
 void Persistent<T>::SetWrapperClassId(uint16_t class_id) {
   V8::SetWrapperClassId(reinterpret_cast<internal::Object**>(**this), class_id);
 }
 
 template <class T>
 uint16_t Persistent<T>::WrapperClassId() const {
   return V8::GetWrapperClassId(reinterpret_cast<internal::Object**>(**this));
 }
 
 Arguments::Arguments(internal::Object** implicit_args,
@@ skipping 437 matching lines @@
 
 
 }  // namespace v8
 
 
 #undef V8EXPORT
 #undef TYPE_CHECK
 
 
 #endif  // V8_H_