Phantom references support internal fields

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 400 matching lines @@
   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<class T>
+class CallbackData {

[rmcilroy, 2014/12/03 11:56:35]

nit - BaseCallbackData or maybe even BaseWeakCallbackData? 

Would it make sense to put this in a non-public namespace to make it obvious
this isn't intended to be used as part of the external API.

[Erik Corry, 2014/12/15 15:12:41]

Done.

+ public:
+  V8_INLINE Isolate* GetIsolate() const { return isolate_; }
+  V8_INLINE T* GetParameter() const { return parameter_; }
+
+ protected:
+  CallbackData(Isolate* isolate, T* parameter)
+    : isolate_(isolate), parameter_(parameter) { }
+
+ private:
+  Isolate* isolate_;
+  T* parameter_;
+};
+

[rmcilroy, 2014/12/03 11:56:35]

nit - two newlines between classes in V8

[Erik Corry, 2014/12/15 15:12:41]

Done.

 template<class T, class P>
-class WeakCallbackData {
+class WeakCallbackData : public CallbackData<P> {
  public:
   typedef void (*Callback)(const WeakCallbackData<T, P>& data);
 
-  V8_INLINE Isolate* GetIsolate() const { return isolate_; }
   V8_INLINE Local<T> GetValue() const { return handle_; }
-  V8_INLINE P* GetParameter() const { return parameter_; }
 
  private:
   friend class internal::GlobalHandles;
   WeakCallbackData(Isolate* isolate, Local<T> handle, P* parameter)
-    : isolate_(isolate), handle_(handle), parameter_(parameter) { }
-  Isolate* isolate_;
+    : CallbackData<P>(isolate, parameter), handle_(handle) { }
   Local<T> handle_;
-  P* parameter_;
 };
 
 
+template<typename T>
+class PhantomCallbackData : public CallbackData<T> {
+ public:
+  typedef void (*Callback)(const PhantomCallbackData<T>& data);
+
+  V8_INLINE void* GetInternalField1() const { return internal_field1_; }
+  V8_INLINE void* GetInternalField2() const { return internal_field2_; }
+
+ private:
+  friend class internal::GlobalHandles;
+  PhantomCallbackData(Isolate* isolate, void* internalField1,
+                      void* internalField2)
+    : CallbackData<T>(isolate, NULL),

[rmcilroy, 2014/12/03 11:56:35]

Do we want to expose NULL parameters to PhantomCallbacks - it feels like that
could get error prone if the caller has to know whether to check if
GetParameter() returns null (maybe this is already the case though)?  Would it
make sense to have different callbacks for either the internal field version and
the parameter version?

[Erik Corry, 2014/12/15 15:12:41]

Fixed to pass a type that has only valid fields to the callback.

+      internal_field1_(internalField1),
+      internal_field2_(internalField2) { }
+  PhantomCallbackData(Isolate* isolate, T* parameter)
+    : CallbackData<T>(isolate, parameter),
+      internal_field1_(NULL),
+      internal_field2_(NULL) { }
+  void* internal_field1_;
+  void* internal_field2_;
+};
+
+
 /**
  * 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 14 matching lines @@
   template <class S>
   V8_INLINE void Reset(Isolate* isolate, const Handle<S>& other);
 
   /**
    * If non-empty, destroy the underlying storage cell
    * and create a new one with the contents of other if other is non empty
    */
   template <class S>
   V8_INLINE void Reset(Isolate* isolate, const PersistentBase<S>& other);
 
-  V8_INLINE bool IsEmpty() const { return val_ == 0; }
+  V8_INLINE bool IsEmpty() const { return val_ == NULL; }
+  V8_INLINE void Empty() { val_ = NULL; }

[jochen (gone - plz use gerrit), 2014/12/02 10:25:59]

what do you need Empty() for?

[Erik Corry, 2014/12/02 10:40:48]

It seems I don't need it any more.  Removed.

[Erik Corry, 2014/12/15 15:12:41]

Actually I need this for the corresponding Blink change.  In the callback for
the scriptwrappable we empty the handle, which has been zapped on the V8 side.
This means we don't try to touch it from the destructor later.

 
   template <class S>
   V8_INLINE bool operator==(const PersistentBase<S>& that) const {
     internal::Object** a = reinterpret_cast<internal::Object**>(this->val_);
     internal::Object** b = reinterpret_cast<internal::Object**>(that.val_);
-    if (a == 0) return b == 0;
-    if (b == 0) return false;
+    if (a == NULL) return b == NULL;
+    if (b == NULL) return false;
     return *a == *b;
   }
 
   template <class S> V8_INLINE bool operator==(const Handle<S>& that) const {
     internal::Object** a = reinterpret_cast<internal::Object**>(this->val_);
     internal::Object** b = reinterpret_cast<internal::Object**>(that.val_);
-    if (a == 0) return b == 0;
-    if (b == 0) return false;
+    if (a == NULL) return b == NULL;
+    if (b == NULL) return false;
     return *a == *b;
   }
 
   template <class S>
   V8_INLINE bool operator!=(const PersistentBase<S>& that) const {
     return !operator==(that);
   }
 
   template <class S> V8_INLINE bool operator!=(const Handle<S>& that) const {
     return !operator==(that);
@@ skipping 14 matching lines @@
   template<typename S, typename P>
   V8_INLINE void SetWeak(
       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.
   template <typename P>
-  V8_INLINE void SetPhantom(P* parameter,
-                            typename WeakCallbackData<T, P>::Callback callback);
+  V8_INLINE void SetPhantom(
+      P* parameter, typename PhantomCallbackData<P>::Callback callback);
 
-  template <typename S, typename P>
-  V8_INLINE void SetPhantom(P* parameter,
-                            typename WeakCallbackData<S, P>::Callback callback);
+  V8_INLINE void SetPhantom(
+      typename PhantomCallbackData<void>::Callback callback,
+      int internalFieldOffset1, int internalFieldOffset2);

[jochen (gone - plz use gerrit), 2014/12/02 10:25:59]

internal_field_index1

[Erik Corry, 2014/12/02 10:40:48]

Done.

 
   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 1936 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 2984 matching lines @@
  private:
   V8();
 
   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;
+  typedef PhantomCallbackData<void>::Callback PhantomCallback;
   static void MakeWeak(internal::Object** global_handle, void* data,
-                       WeakCallback weak_callback, WeakHandleType phantom);
+                       WeakCallback weak_callback);
+  static void MakePhantom(
+      internal::Object** global_handle, void* data,
+      PhantomCallback weak_callback,
+      int internal_field_index1 = Object::kNoInternalFieldIndex,
+      int internal_field_index2 = Object::kNoInternalFieldIndex);
   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 588 matching lines @@
   static const int kTrueValueRootIndex = 8;
   static const int kFalseValueRootIndex = 9;
   static const int kEmptyStringRootIndex = 154;
 
   // The external allocation limit should be below 256 MB on all architectures
   // to avoid that resource-constrained embedders run low on memory.
   static const int kExternalAllocationLimit = 192 * 1024 * 1024;
 
   static const int kNodeClassIdOffset = 1 * kApiPointerSize;
   static const int kNodeFlagsOffset = 1 * kApiPointerSize + 3;
-  static const int kNodeStateMask = 0xf;
+  static const int kNodeStateMask = 0x7;
   static const int kNodeStateIsWeakValue = 2;
   static const int kNodeStateIsPendingValue = 3;
   static const int kNodeStateIsNearDeathValue = 4;
-  static const int kNodeIsIndependentShift = 4;
-  static const int kNodeIsPartiallyDependentShift = 5;
+  static const int kNodeIsIndependentShift = 3;
+  static const int kNodeIsPartiallyDependentShift = 4;
 
   static const int kJSObjectType = 0xbd;
   static const int kFirstNonstringType = 0x80;
   static const int kOddballType = 0x83;
   static const int kForeignType = 0x88;
 
   static const int kUndefinedOddballKind = 5;
   static const int kNullOddballKind = 3;
 
   static const uint32_t kNumIsolateDataSlots = 4;
@@ skipping 237 matching lines @@
 
 
 template <class T>
 template <typename S, typename P>
 void PersistentBase<T>::SetWeak(
     P* parameter,
     typename WeakCallbackData<S, P>::Callback callback) {
   TYPE_CHECK(S, T);
   typedef typename WeakCallbackData<Value, void>::Callback Callback;
   V8::MakeWeak(reinterpret_cast<internal::Object**>(this->val_), parameter,
-               reinterpret_cast<Callback>(callback), V8::NonphantomHandle);
+               reinterpret_cast<Callback>(callback));
 }
 
 
 template <class T>
 template <typename P>
 void PersistentBase<T>::SetWeak(
     P* parameter,
     typename WeakCallbackData<T, P>::Callback callback) {
   SetWeak<T, P>(parameter, callback);
 }
 
 
 template <class T>
-template <typename S, typename P>
-void PersistentBase<T>::SetPhantom(
-    P* parameter, typename WeakCallbackData<S, P>::Callback callback) {
-  TYPE_CHECK(S, T);
-  typedef typename WeakCallbackData<Value, void>::Callback Callback;
-  V8::MakeWeak(reinterpret_cast<internal::Object**>(this->val_), parameter,
-               reinterpret_cast<Callback>(callback), V8::PhantomHandle);
-}
-
-
-template <class T>
 template <typename P>
 void PersistentBase<T>::SetPhantom(
-    P* parameter, typename WeakCallbackData<T, P>::Callback callback) {
-  SetPhantom<T, P>(parameter, callback);
+    P* parameter, typename PhantomCallbackData<P>::Callback callback) {
+  typedef typename PhantomCallbackData<void>::Callback Callback;
+  V8::MakePhantom(reinterpret_cast<internal::Object**>(this->val_), parameter,
+                  reinterpret_cast<Callback>(callback),
+                  Object::kNoInternalFieldIndex, Object::kNoInternalFieldIndex);
 }
 
 
+template <class T>
+void PersistentBase<T>::SetPhantom(
+    typename PhantomCallbackData<void>::Callback callback,
+    int internal_field_index1, int internal_field_index2) {
+  typedef typename PhantomCallbackData<void>::Callback Callback;
+  V8::MakePhantom(reinterpret_cast<internal::Object**>(this->val_), 0,
+                  reinterpret_cast<Callback>(callback), internal_field_index1,
+                  internal_field_index2);
+}
+
+
 template <class T>
 template <typename P>
 P* PersistentBase<T>::ClearWeak() {
   return reinterpret_cast<P*>(
     V8::ClearWeak(reinterpret_cast<internal::Object**>(this->val_)));
 }
 
 
 template <class T>
 void PersistentBase<T>::MarkIndependent() {
@@ skipping 973 matching lines @@
  */
 
 
 }  // namespace v8
 
 
 #undef TYPE_CHECK
 
 
 #endif  // V8_H_