Support old and new weak handle API

include/v8.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 /** \mainpage V8 API Reference Guide
  *
  * V8 is Google's open source JavaScript engine.
  *
  * This set of documents provides reference material generated from the
  * V8 header file, include/v8.h.
@@ skipping 93 matching lines @@
 class Value;
 template <class T> class Handle;
 template <class T> class Local;
 template <class T> class Eternal;
 template<class T> class NonCopyablePersistentTraits;
 template<class T> class PersistentBase;
 template<class T,
          class M = NonCopyablePersistentTraits<T> > class Persistent;
 template<class T> class UniquePersistent;
 template<class K, class V, class T> class PersistentValueMap;
+template <class K, class V, class T>
+class PersistentValueMapBase;
+template <class K, class V, class T>
+class PhantomPersistentValueMap;
 template<class V, class T> class PersistentValueVector;
 template<class T, class P> class WeakCallbackObject;
 class FunctionTemplate;
 class ObjectTemplate;
 class Data;
 template<typename T> class FunctionCallbackInfo;
 template<typename T> class PropertyCallbackInfo;
 class StackTrace;
 class StackFrame;
 class Isolate;
@@ skipping 270 matching lines @@
   template<class F> friend class Handle;
   template<class F> friend class Local;
   template<class F> friend class FunctionCallbackInfo;
   template<class F> friend class PropertyCallbackInfo;
   friend class String;
   friend class Object;
   friend class Context;
   template<class F> friend class internal::CustomArguments;
   friend class HandleScope;
   friend class EscapableHandleScope;
-  template<class F1, class F2, class F3> friend class PersistentValueMap;
+  template <class F1, class F2, class F3>
+  friend class PersistentValueMapBase;
   template<class F1, class F2> friend class PersistentValueVector;
 
   template <class S> V8_INLINE Local(S* that) : Handle<T>(that) { }
   V8_INLINE static Local<T> New(Isolate* isolate, T* that);
 };
 
 
 // Eternal handles are set-once handles that live for the life of the isolate.
 template <class T> class Eternal {
  public:
   V8_INLINE Eternal() : index_(kInitialValue) { }
   template<class S>
   V8_INLINE Eternal(Isolate* isolate, Local<S> handle) : index_(kInitialValue) {
     Set(isolate, handle);
   }
   // Can only be safely called if already set.
   V8_INLINE Local<T> Get(Isolate* isolate);
   V8_INLINE bool IsEmpty() { return index_ == kInitialValue; }
   template<class S> V8_INLINE void Set(Isolate* isolate, Local<S> handle);
 
  private:
   static const int kInitialValue = -1;
   int index_;
 };
 
 
-template <typename T, typename U = void, typename V = void>
+template <typename T>
 class PhantomCallbackData : public internal::CallbackData<T> {
  public:
-  typedef void (*Callback)(const PhantomCallbackData<T, U, V>& data);
+  typedef void (*Callback)(const PhantomCallbackData<T>& data);
 
-  V8_INLINE U* GetInternalField1() const { return internal_field1_; }
-  V8_INLINE V* GetInternalField2() const { return internal_field2_; }
+  V8_INLINE void* GetInternalField1() const { return internal_field1_; }
+  V8_INLINE void* GetInternalField2() const { return internal_field2_; }
 
-  PhantomCallbackData(Isolate* isolate, T* parameter, U* internal_field1,
-                      V* internal_field2)
+  PhantomCallbackData(Isolate* isolate, T* parameter, void* internal_field1,
+                      void* internal_field2)
       : internal::CallbackData<T>(isolate, parameter),
         internal_field1_(internal_field1),
         internal_field2_(internal_field2) {}
 
  private:
-  U* internal_field1_;
-  V* internal_field2_;
+  void* internal_field1_;
+  void* internal_field2_;
 };
 
 
 template <class T, class P>
 class WeakCallbackData : public internal::CallbackData<P> {
  public:
   typedef void (*Callback)(const WeakCallbackData<T, P>& data);
 
   V8_INLINE Local<T> GetValue() const { return handle_; }
 
  private:
   friend class internal::GlobalHandles;
   WeakCallbackData(Isolate* isolate, P* parameter, Local<T> handle)
       : internal::CallbackData<P>(isolate, parameter), handle_(handle) {}
   Local<T> handle_;
 };
 
 
+static const int kNoInternalFieldIndex = -1;
+
+
 /**
  * An object reference that is independent of any handle scope.  Where
  * a Local handle only lives as long as the HandleScope in which it was
  * allocated, a PersistentBase handle remains valid until it is explicitly
  * disposed.
  *
  * A persistent handle contains a reference to a storage cell within
  * the v8 engine which holds an object value and which is updated by
  * the garbage collector whenever the object is moved.  A new storage
  * cell can be created using the constructor or PersistentBase::Reset and
@@ skipping 67 matching lines @@
       P* parameter,
       typename WeakCallbackData<S, P>::Callback callback);
 
   // Phantom persistents work like weak persistents, except that the pointer to
   // the object being collected is not available in the finalization callback.
   // This enables the garbage collector to collect the object and any objects
   // it references transitively in one GC cycle. At the moment you can either
   // specify a parameter for the callback or the location of two internal
   // fields in the dying object.
   template <typename P>
-  V8_INLINE void SetPhantom(
-      P* parameter,
-      typename PhantomCallbackData<P, void, void>::Callback callback);
-  template <typename P, typename Q>
-  V8_INLINE void SetPhantom(
-      P* parameter, int internal_field_index1,
-      typename PhantomCallbackData<P, Q, void>::Callback callback);
-  template <typename P, typename Q, typename R>
-  V8_INLINE void SetPhantom(
-      P* parameter, int internal_field_index1, int internal_field_index2,
-      typename PhantomCallbackData<P, Q, R>::Callback callback);
+  V8_INLINE void SetPhantom(P* parameter,
+                            typename PhantomCallbackData<P>::Callback callback,
+                            int internal_field_index1 = kNoInternalFieldIndex,
+                            int internal_field_index2 = kNoInternalFieldIndex);
 
   template<typename P>
   V8_INLINE P* ClearWeak();
 
   // TODO(dcarney): remove this.
   V8_INLINE void ClearWeak() { ClearWeak<void>(); }
 
   /**
    * Marks the reference to this object independent. Garbage collector is free
    * to ignore any object groups containing this object. Weak callback for an
@@ skipping 34 matching lines @@
 
  private:
   friend class Isolate;
   friend class Utils;
   template<class F> friend class Handle;
   template<class F> friend class Local;
   template<class F1, class F2> friend class Persistent;
   template<class F> friend class UniquePersistent;
   template<class F> friend class PersistentBase;
   template<class F> friend class ReturnValue;
-  template<class F1, class F2, class F3> friend class PersistentValueMap;
+  template <class F1, class F2, class F3>
+  friend class PersistentValueMapBase;
   template<class F1, class F2> friend class PersistentValueVector;
   friend class Object;
 
   explicit V8_INLINE PersistentBase(T* val) : val_(val) {}
   PersistentBase(PersistentBase& other); // NOLINT
   void operator=(PersistentBase&);
   V8_INLINE static T* New(Isolate* isolate, T* that);
 
   T* val_;
 };
@@ skipping 1880 matching lines @@
   Local<String> ObjectProtoToString();
 
   /**
    * Returns the name of the function invoked as a constructor for this object.
    */
   Local<String> GetConstructorName();
 
   /** Gets the number of internal fields for this Object. */
   int InternalFieldCount();
 
-  static const int kNoInternalFieldIndex = -1;
-
   /** Same as above, but works for Persistents */
   V8_INLINE static int InternalFieldCount(
       const PersistentBase<Object>& object) {
     return object.val_->InternalFieldCount();
   }
 
   /** Gets the value from an internal field. */
   V8_INLINE Local<Value> GetInternalField(int index);
 
   /** Sets the value in an internal field. */
@@ skipping 196 matching lines @@
   V8_INLINE Isolate* GetIsolate();
 
   // Pointer setter: Uncompilable to prevent inadvertent misuse.
   template <typename S>
   V8_INLINE void Set(S* whatever);
 
  private:
   template<class F> friend class ReturnValue;
   template<class F> friend class FunctionCallbackInfo;
   template<class F> friend class PropertyCallbackInfo;
-  template<class F, class G, class H> friend class PersistentValueMap;
+  template <class F, class G, class H>
+  friend class PersistentValueMapBase;
   V8_INLINE void SetInternal(internal::Object* value) { *value_ = value; }
   V8_INLINE internal::Object* GetDefaultValue();
   V8_INLINE explicit ReturnValue(internal::Object** slot);
   internal::Object** value_;
 };
 
 
 /**
  * The argument information given to function call callbacks.  This
  * class provides access to information about the context of the call,
@@ skipping 2473 matching lines @@
   /**
    * Iterates through all the persistent handles in the current isolate's heap
    * that have class_ids and are candidates to be marked as partially dependent
    * handles. This will visit handles to young objects created since the last
    * garbage collection but is free to visit an arbitrary superset of these
    * objects.
    */
   void VisitHandlesForPartialDependence(PersistentHandleVisitor* visitor);
 
  private:
-  template<class K, class V, class Traits> friend class PersistentValueMap;
+  template <class K, class V, class Traits>
+  friend class PersistentValueMapBase;
 
   Isolate();
   Isolate(const Isolate&);
   ~Isolate();
   Isolate& operator=(const Isolate&);
   void* operator new(size_t size);
   void operator delete(void*, size_t);
 
   void SetObjectGroupId(internal::Object** object, UniqueId id);
   void SetReferenceFromGroup(UniqueId id, internal::Object** object);
@@ skipping 331 matching lines @@
 
   enum WeakHandleType { PhantomHandle, NonphantomHandle };
 
   static internal::Object** GlobalizeReference(internal::Isolate* isolate,
                                                internal::Object** handle);
   static internal::Object** CopyPersistent(internal::Object** handle);
   static void DisposeGlobal(internal::Object** global_handle);
   typedef WeakCallbackData<Value, void>::Callback WeakCallback;
   static void MakeWeak(internal::Object** global_handle, void* data,
                        WeakCallback weak_callback);
-  static void MakePhantom(
-      internal::Object** global_handle, void* data,
-      // Must be 0 or kNoInternalFieldIndex.
-      int internal_field_index1,
-      // Must be 1 or kNoInternalFieldIndex.
-      int internal_field_index2,
-      PhantomCallbackData<void, void, void>::Callback weak_callback);
+  static void MakePhantom(internal::Object** global_handle, void* data,
+                          // Must be 0 or kNoInternalFieldIndex.
+                          int internal_field_index1,
+                          // Must be 1 or kNoInternalFieldIndex.
+                          int internal_field_index2,
+                          PhantomCallbackData<void>::Callback weak_callback);
   static void* ClearWeak(internal::Object** global_handle);
   static void Eternalize(Isolate* isolate,
                          Value* handle,
                          int* index);
   static Local<Value> GetEternal(Isolate* isolate, int index);
 
   template <class T> friend class Handle;
   template <class T> friend class Local;
   template <class T> friend class Eternal;
   template <class T> friend class PersistentBase;
@@ skipping 867 matching lines @@
 void PersistentBase<T>::SetWeak(
     P* parameter,
     typename WeakCallbackData<T, P>::Callback callback) {
   SetWeak<T, P>(parameter, callback);
 }
 
 
 template <class T>
 template <typename P>
 void PersistentBase<T>::SetPhantom(
-    P* parameter,
-    typename PhantomCallbackData<P, void, void>::Callback callback) {
-  typedef typename PhantomCallbackData<void, void, void>::Callback Callback;
-  V8::MakePhantom(reinterpret_cast<internal::Object**>(this->val_), parameter,
-                  Object::kNoInternalFieldIndex, Object::kNoInternalFieldIndex,
-                  reinterpret_cast<Callback>(callback));
-}
-
-
-template <class T>
-template <typename P, typename Q>
-void PersistentBase<T>::SetPhantom(
-    P* parameter, int internal_field_index1,
-    typename PhantomCallbackData<P, Q, void>::Callback callback) {
-  typedef typename PhantomCallbackData<void, void, void>::Callback Callback;
-  V8::MakePhantom(reinterpret_cast<internal::Object**>(this->val_), parameter,
-                  internal_field_index1, Object::kNoInternalFieldIndex,
-                  reinterpret_cast<Callback>(callback));
-}
-
-
-template <class T>
-template <typename P, typename Q, typename R>
-void PersistentBase<T>::SetPhantom(
-    P* parameter, int internal_field_index1, int internal_field_index2,
-    typename PhantomCallbackData<P, Q, R>::Callback callback) {
-  typedef typename PhantomCallbackData<void, void, void>::Callback Callback;
+    P* parameter, typename PhantomCallbackData<P>::Callback callback,
+    int internal_field_index1, int internal_field_index2) {
+  typedef typename PhantomCallbackData<void>::Callback Callback;
   V8::MakePhantom(reinterpret_cast<internal::Object**>(this->val_), parameter,
                   internal_field_index1, internal_field_index2,
                   reinterpret_cast<Callback>(callback));
 }
 
 
 template <class T>
 template <typename P>
 P* PersistentBase<T>::ClearWeak() {
   return reinterpret_cast<P*>(
@@ skipping 979 matching lines @@
  */
 
 
 }  // namespace v8
 
 
 #undef TYPE_CHECK
 
 
 #endif  // V8_H_