Unify phantom and internal fields weak handle callbacks

R=dcarney@chromium.org
BUG=

Review URL: https://codereview.chromium.org/842153004

Cr-Commit-Position: refs/heads/master@{#26022}

include/v8.h

@@ -137,15 +137,18 @@ class PropertyCallbackArguments;
 class FunctionCallbackArguments;
 class GlobalHandles;
 
+template <typename T>
 class CallbackData {
  public:
   V8_INLINE v8::Isolate* GetIsolate() const { return isolate_; }
 
- protected:
-  explicit CallbackData(v8::Isolate* isolate) : isolate_(isolate) {}
+  explicit CallbackData(v8::Isolate* isolate, T* parameter)
+      : isolate_(isolate), parameter_(parameter) {}
+  V8_INLINE T* GetParameter() const { return parameter_; }
 
  private:
   v8::Isolate* isolate_;
+  T* parameter_;
 };
 }
 
@@ -425,23 +428,28 @@ template <class T> class Eternal {
 };
 
 
-template <typename T>
-class PhantomCallbackData : public internal::CallbackData {
+template <typename T, typename U = void, typename V = void>
+class PhantomCallbackData : public internal::CallbackData<T> {
  public:
-  typedef void (*Callback)(const PhantomCallbackData<T>& data);
+  typedef void (*Callback)(const PhantomCallbackData<T, U, V>& data);
 
-  V8_INLINE T* GetParameter() const { return parameter_; }
+  V8_INLINE U* GetInternalField1() const { return internal_field1_; }
+  V8_INLINE V* GetInternalField2() const { return internal_field2_; }
 
-  PhantomCallbackData<T>(Isolate* isolate, T* parameter)
-      : internal::CallbackData(isolate), parameter_(parameter) {}
+  PhantomCallbackData(Isolate* isolate, T* parameter, U* internal_field1,
+                      V* internal_field2)
+      : internal::CallbackData<T>(isolate, parameter),
+        internal_field1_(internal_field1),
+        internal_field2_(internal_field2) {}
 
  private:
-  T* parameter_;
+  U* internal_field1_;
+  V* internal_field2_;
 };
 
 
 template <class T, class P>
-class WeakCallbackData : public PhantomCallbackData<P> {
+class WeakCallbackData : public internal::CallbackData<P> {
  public:
   typedef void (*Callback)(const WeakCallbackData<T, P>& data);
 
@@ -450,31 +458,11 @@ class WeakCallbackData : public PhantomCallbackData<P> {
  private:
   friend class internal::GlobalHandles;
   WeakCallbackData(Isolate* isolate, P* parameter, Local<T> handle)
-      : PhantomCallbackData<P>(isolate, parameter), handle_(handle) {}
+      : internal::CallbackData<P>(isolate, parameter), handle_(handle) {}
   Local<T> handle_;
 };
 
 
-template <typename T, typename U>
-class InternalFieldsCallbackData : public internal::CallbackData {
- public:
-  typedef void (*Callback)(const InternalFieldsCallbackData<T, U>& data);
-
-  InternalFieldsCallbackData(Isolate* isolate, T* internalField1,
-                             U* internalField2)
-      : internal::CallbackData(isolate),
-        internal_field1_(internalField1),
-        internal_field2_(internalField2) {}
-
-  V8_INLINE T* GetInternalField1() const { return internal_field1_; }
-  V8_INLINE U* GetInternalField2() const { return internal_field2_; }
-
- private:
-  T* internal_field1_;
-  U* 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
@@ -562,13 +550,17 @@ template <class T> class PersistentBase {
   // 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>::Callback callback);
-
+  V8_INLINE void SetPhantom(
+      P* parameter,
+      typename PhantomCallbackData<P, void, void>::Callback callback);
   template <typename P, typename Q>
   V8_INLINE void SetPhantom(
-      void (*callback)(const InternalFieldsCallbackData<P, Q>&),
-      int internal_field_index1, int internal_field_index2);
+      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);
 
   template<typename P>
   V8_INLINE P* ClearWeak();
@@ -5595,13 +5587,13 @@ class V8_EXPORT V8 {
   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,
-                          PhantomCallbackData<void>::Callback weak_callback);
   static void MakePhantom(
-      internal::Object** global_handle,
-      InternalFieldsCallbackData<void, void>::Callback weak_callback,
+      internal::Object** global_handle, void* data,
+      // Must be 0 or kNoInternalFieldIndex.
       int internal_field_index1,
-      int internal_field_index2 = Object::kNoInternalFieldIndex);
+      // Must be 1 or kNoInternalFieldIndex.
+      int internal_field_index2,
+      PhantomCallbackData<void, void, void>::Callback weak_callback);
   static void* ClearWeak(internal::Object** global_handle);
   static void Eternalize(Isolate* isolate,
                          Value* handle,
@@ -6489,22 +6481,36 @@ void PersistentBase<T>::SetWeak(
 template <class T>
 template <typename P>
 void PersistentBase<T>::SetPhantom(
-    P* parameter, typename PhantomCallbackData<P>::Callback callback) {
-  typedef typename PhantomCallbackData<void>::Callback Callback;
+    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 U, typename V>
+template <typename P, typename Q, typename R>
 void PersistentBase<T>::SetPhantom(
-    void (*callback)(const InternalFieldsCallbackData<U, V>&),
-    int internal_field_index1, int internal_field_index2) {
-  typedef typename InternalFieldsCallbackData<void, void>::Callback Callback;
-  V8::MakePhantom(reinterpret_cast<internal::Object**>(this->val_),
-                  reinterpret_cast<Callback>(callback), internal_field_index1,
-                  internal_field_index2);
+    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;
+  V8::MakePhantom(reinterpret_cast<internal::Object**>(this->val_), parameter,
+                  internal_field_index1, internal_field_index2,
+                  reinterpret_cast<Callback>(callback));
 }
 
 

src/api.cc

@@ -408,18 +408,22 @@ void V8::MakeWeak(i::Object** object, void* parameter,
 }
 
 
-void V8::MakePhantom(i::Object** object, void* parameter,
-                     PhantomCallbackData<void>::Callback weak_callback) {
-  i::GlobalHandles::MakePhantom(object, parameter, weak_callback);
-}
-
-
 void V8::MakePhantom(
-    i::Object** object,
-    InternalFieldsCallbackData<void, void>::Callback weak_callback,
-    int internal_field_index1, int internal_field_index2) {
-  i::GlobalHandles::MakePhantom(object, weak_callback, internal_field_index1,
-                                internal_field_index2);
+    i::Object** object, void* parameter, int internal_field_index1,
+    int internal_field_index2,
+    PhantomCallbackData<void, void, void>::Callback weak_callback) {
+  if (internal_field_index1 == 0) {
+    if (internal_field_index2 == 1) {
+      i::GlobalHandles::MakePhantom(object, parameter, 2, weak_callback);
+    } else {
+      DCHECK_EQ(internal_field_index2, Object::kNoInternalFieldIndex);
+      i::GlobalHandles::MakePhantom(object, parameter, 1, weak_callback);
+    }
+  } else {
+    DCHECK_EQ(internal_field_index1, Object::kNoInternalFieldIndex);
+    DCHECK_EQ(internal_field_index2, Object::kNoInternalFieldIndex);
+    i::GlobalHandles::MakePhantom(object, parameter, 0, weak_callback);
+  }
 }
 
 

src/debug.cc

@@ -716,7 +716,7 @@ DebugInfoListNode::DebugInfoListNode(DebugInfo* debug_info): next_(NULL) {
   debug_info_ = Handle<DebugInfo>::cast(global_handles->Create(debug_info));
   typedef PhantomCallbackData<void>::Callback Callback;
   GlobalHandles::MakePhantom(
-      reinterpret_cast<Object**>(debug_info_.location()), this,
+      reinterpret_cast<Object**>(debug_info_.location()), this, 0,
       reinterpret_cast<Callback>(Debug::HandlePhantomDebugInfo));
 }
 

src/global-handles.h

@@ -98,9 +98,15 @@ struct ObjectGroupRetainerInfo {
 
 
 enum WeaknessType {
-  NORMAL_WEAK,          // Embedder gets a handle to the dying object.
-  PHANTOM_WEAK,         // Embedder gets the parameter they passed in earlier.
-  INTERNAL_FIELDS_WEAK  // Embedder gets 2 internal fields from dying object.
+  NORMAL_WEAK,  // Embedder gets a handle to the dying object.
+  // In the following cases, the embedder gets the parameter they passed in
+  // earlier, and the 0, 1 or 2 first internal fields. Note that the internal
+  // fields must contain aligned non-V8 pointers.  Getting pointers to V8
+  // objects through this interface would be GC unsafe so in that case the
+  // embedder gets a null pointer instead.
+  PHANTOM_WEAK_0_INTERNAL_FIELDS,
+  PHANTOM_WEAK_1_INTERNAL_FIELDS,
+  PHANTOM_WEAK_2_INTERNAL_FIELDS
 };
 
 
@@ -139,14 +145,9 @@ class GlobalHandles {
 
   // It would be nice to template this one, but it's really hard to get
   // the template instantiator to work right if you do.
-  static void MakePhantom(Object** location, void* parameter,
-                          PhantomCallbackData<void>::Callback weak_callback);
-
   static void MakePhantom(
-      Object** location,
-      v8::InternalFieldsCallbackData<void, void>::Callback weak_callback,
-      int16_t internal_field_index1,
-      int16_t internal_field_index2 = v8::Object::kNoInternalFieldIndex);
+      Object** location, void* parameter, int number_of_internal_fields,
+      PhantomCallbackData<void, void, void>::Callback weak_callback);
 
   void RecordStats(HeapStats* stats);
 
@@ -302,7 +303,6 @@ class GlobalHandles {
   class NodeBlock;
   class NodeIterator;
   class PendingPhantomCallback;
-  class PendingInternalFieldsCallback;
 
   Isolate* isolate_;
 
@@ -336,7 +336,6 @@ class GlobalHandles {
   List<ObjectGroupConnection> implicit_ref_connections_;
 
   List<PendingPhantomCallback> pending_phantom_callbacks_;
-  List<PendingInternalFieldsCallback> pending_internal_fields_callbacks_;
 
   friend class Isolate;
 
@@ -346,7 +345,7 @@ class GlobalHandles {
 
 class GlobalHandles::PendingPhantomCallback {
  public:
-  typedef PhantomCallbackData<void> Data;
+  typedef PhantomCallbackData<void, void, void> Data;
   PendingPhantomCallback(Node* node, Data data, Data::Callback callback)
       : node_(node), data_(data), callback_(callback) {}
 
@@ -361,20 +360,6 @@ class GlobalHandles::PendingPhantomCallback {
 };
 
 
-class GlobalHandles::PendingInternalFieldsCallback {
- public:
-  typedef InternalFieldsCallbackData<void, void> Data;
-  PendingInternalFieldsCallback(Data data, Data::Callback callback)
-      : data_(data), callback_(callback) {}
-
-  void invoke() { callback_(data_); }
-
- private:
-  Data data_;
-  Data::Callback callback_;
-};
-
-
 class EternalHandles {
  public:
   enum SingletonHandle {

test/cctest/test-api.cc

@@ -7796,8 +7796,10 @@ class Trivial2 {
 };
 
 
-void CheckInternalFields(
-    const v8::InternalFieldsCallbackData<Trivial, Trivial2>& data) {
+void CheckInternalFields(const v8::PhantomCallbackData<
+    v8::Persistent<v8::Object>, Trivial, Trivial2>& data) {
+  v8::Persistent<v8::Object>* handle = data.GetParameter();
+  handle->Reset();
   Trivial* t1 = data.GetInternalField1();
   Trivial2* t2 = data.GetInternalField2();
   CHECK_EQ(42, t1->x());
@@ -7835,7 +7837,8 @@ void InternalFieldCallback(bool global_gc) {
         reinterpret_cast<Trivial2*>(obj->GetAlignedPointerFromInternalField(1));
     CHECK_EQ(103, t2->x());
 
-    handle.SetPhantom(CheckInternalFields, 0, 1);
+    handle.SetPhantom<v8::Persistent<v8::Object>, Trivial, Trivial2>(
+        &handle, 0, 1, CheckInternalFields);
     if (!global_gc) {
       handle.MarkIndependent();
     }