Add a new weak handle callback that passes an Isolate to an embedder

src/global-handles.cc

 // Copyright 2009 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 60 matching lines @@
 #ifdef DEBUG
   ~Node() {
     // TODO(1428): if it's a weak handle we should have invoked its callback.
     // Zap the values for eager trapping.
     object_ = NULL;
     class_id_ = v8::HeapProfiler::kPersistentHandleNoClassId;
     index_ = 0;
     set_independent(false);
     set_partially_dependent(false);
     set_in_new_space_list(false);
+    set_is_new_callback(false);
+    callback_.new_callback = NULL;
     parameter_or_next_free_.next_free = NULL;
-    callback_ = NULL;
   }
 #endif
 
   void Initialize(int index, Node** first_free) {
     index_ = static_cast<uint8_t>(index);
     ASSERT(static_cast<int>(index_) == index);
     set_state(FREE);
     set_in_new_space_list(false);
     parameter_or_next_free_.next_free = *first_free;
     *first_free = this;
   }
 
   void Acquire(Object* object, GlobalHandles* global_handles) {
     ASSERT(state() == FREE);
     object_ = object;
     class_id_ = v8::HeapProfiler::kPersistentHandleNoClassId;
     set_independent(false);
     set_partially_dependent(false);
     set_state(NORMAL);
     parameter_or_next_free_.parameter = NULL;
-    callback_ = NULL;
+    set_is_new_callback(false);
+    callback_.new_callback = NULL;
     IncreaseBlockUses(global_handles);
   }
 
   void Release(GlobalHandles* global_handles) {
     ASSERT(state() != FREE);
     if (IsWeakRetainer()) {
       global_handles->number_of_weak_handles_--;
       if (object_->IsJSGlobalObject()) {
         global_handles->number_of_global_object_weak_handles_--;
       }
@@ skipping 40 matching lines @@
     flags_ = IsPartiallyDependent::update(flags_, v);
   }
 
   bool is_in_new_space_list() {
     return IsInNewSpaceList::decode(flags_);
   }
   void set_in_new_space_list(bool v) {
     flags_ = IsInNewSpaceList::update(flags_, v);
   }
 
+  bool is_new_callback() {
+    return IsNewCallback::decode(flags_);
+  }
+  void set_is_new_callback(bool v) {
+    flags_ = IsNewCallback::update(flags_, v);
+  }
+
   bool IsNearDeath() const {
     // Check for PENDING to ensure correct answer when processing callbacks.
     return state() == PENDING || state() == NEAR_DEATH;
   }
 
   bool IsWeak() const { return state() == WEAK; }
 
   bool IsRetainer() const { return state() != FREE; }
 
   bool IsStrongRetainer() const { return state() == NORMAL; }
@@ skipping 14 matching lines @@
   }
 
   void MarkPartiallyDependent(GlobalHandles* global_handles) {
     ASSERT(state() != FREE);
     if (global_handles->isolate()->heap()->InNewSpace(object_)) {
       set_partially_dependent(true);
     }
   }
   void clear_partially_dependent() { set_partially_dependent(false); }
 
-  // Callback accessor.
-  WeakReferenceCallback callback() { return callback_; }
+  // Callback accessors.
+  WeakReferenceCallback old_callback() { return callback_.old_callback; }
+  WeakenedReferenceCallback new_callback() { return callback_.new_callback; }
 
   // Callback parameter accessors.
   void set_parameter(void* parameter) {
     ASSERT(state() != FREE);
     parameter_or_next_free_.parameter = parameter;
   }
   void* parameter() const {
     ASSERT(state() != FREE);
     return parameter_or_next_free_.parameter;
   }
@@ skipping 13 matching lines @@
                 WeakReferenceCallback callback) {
     ASSERT(state() != FREE);
     if (!IsWeakRetainer()) {
       global_handles->number_of_weak_handles_++;
       if (object_->IsJSGlobalObject()) {
         global_handles->number_of_global_object_weak_handles_++;
       }
     }
     set_state(WEAK);
     set_parameter(parameter);
-    callback_ = callback;
+    set_is_new_callback(false);
+    callback_.old_callback = callback;
+  }
+
+  void MakeWeak(GlobalHandles* global_handles,
+                void* parameter,
+                WeakenedReferenceCallback callback) {
+    ASSERT(state() != FREE);
+    if (!IsWeakRetainer()) {
+      global_handles->number_of_weak_handles_++;
+      if (object_->IsJSGlobalObject()) {
+        global_handles->number_of_global_object_weak_handles_++;
+      }
+    }
+    set_state(WEAK);
+    set_parameter(parameter);
+    set_is_new_callback(true);
+    callback_.new_callback = callback;
   }
 
   void ClearWeakness(GlobalHandles* global_handles) {
     ASSERT(state() != FREE);
     if (IsWeakRetainer()) {
       global_handles->number_of_weak_handles_--;
       if (object_->IsJSGlobalObject()) {
         global_handles->number_of_global_object_weak_handles_--;
       }
     }
     set_state(NORMAL);
     set_parameter(NULL);
   }
 
   bool PostGarbageCollectionProcessing(Isolate* isolate,
                                        GlobalHandles* global_handles) {
     if (state() != Node::PENDING) return false;
-    WeakReferenceCallback func = callback();
-    if (func == NULL) {
+    if (new_callback() == NULL) {

[Sven Panne, 2013/01/18 08:08:12]

This is a hack and works only because we don't actually check what is stored in
the union. Add an "callback_is_set()" predicate.

[haraken, 2013/01/22 00:27:37]

Done.

       Release(global_handles);
       return false;
     }
     void* par = parameter();
     set_state(NEAR_DEATH);
     set_parameter(NULL);
 
     v8::Persistent<v8::Object> object = ToApi<v8::Object>(handle());
     {
       // Check that we are not passing a finalized external string to
       // the callback.
       ASSERT(!object_->IsExternalAsciiString() ||
              ExternalAsciiString::cast(object_)->resource() != NULL);
       ASSERT(!object_->IsExternalTwoByteString() ||
              ExternalTwoByteString::cast(object_)->resource() != NULL);
       // Leaving V8.
       VMState state(isolate, EXTERNAL);
-      func(object, par);
+      if (is_new_callback()) {
+        WeakenedReferenceCallback callback = new_callback();
+        callback(reinterpret_cast<v8::Isolate*>(isolate), object, par);
+      } else {
+        WeakReferenceCallback callback = old_callback();
+        callback(object, par);
+      }
     }
     // Absence of explicit cleanup or revival of weak handle
     // in most of the cases would lead to memory leak.
     ASSERT(state() != NEAR_DEATH);
     return true;
   }
 
  private:
   inline NodeBlock* FindBlock();
   inline void IncreaseBlockUses(GlobalHandles* global_handles);
@@ skipping 11 matching lines @@
 
   // Index in the containing handle block.
   uint8_t index_;
 
   // This stores three flags (independent, partially_dependent and
   // in_new_space_list) and a State.
   class NodeState:            public BitField<State, 0, 4> {};
   class IsIndependent:        public BitField<bool,  4, 1> {};
   class IsPartiallyDependent: public BitField<bool,  5, 1> {};
   class IsInNewSpaceList:     public BitField<bool,  6, 1> {};
+  class IsNewCallback:        public BitField<bool,  7, 1> {};
 
   uint8_t flags_;
 
   // Handle specific callback.
-  WeakReferenceCallback callback_;
+  union {
+    WeakReferenceCallback old_callback;
+    WeakenedReferenceCallback new_callback;
+  } callback_;
 
   // Provided data for callback.  In FREE state, this is used for
   // the free list link.
   union {
     void* parameter;
     Node* next_free;
   } parameter_or_next_free_;
 
   DISALLOW_COPY_AND_ASSIGN(Node);
 };
@@ skipping 154 matching lines @@
 }
 
 
 void GlobalHandles::MakeWeak(Object** location, void* parameter,
                              WeakReferenceCallback callback) {
   ASSERT(callback != NULL);
   Node::FromLocation(location)->MakeWeak(this, parameter, callback);
 }
 
 
+void GlobalHandles::MakeWeak(Object** location, void* parameter,
+                             WeakenedReferenceCallback callback) {
+  ASSERT(callback != NULL);
+  Node::FromLocation(location)->MakeWeak(this, parameter, callback);
+}
+
+
 void GlobalHandles::ClearWeakness(Object** location) {
   Node::FromLocation(location)->ClearWeakness(this);
 }
 
 
 void GlobalHandles::MarkIndependent(Object** location) {
   Node::FromLocation(location)->MarkIndependent();
 }
 
 
@@ skipping 25 matching lines @@
   return Node::FromLocation(location)->wrapper_class_id();
 }
 
 void GlobalHandles::IterateWeakRoots(ObjectVisitor* v) {
   for (NodeIterator it(this); !it.done(); it.Advance()) {
     if (it.node()->IsWeakRetainer()) v->VisitPointer(it.node()->location());
   }
 }
 
 
-void GlobalHandles::IterateWeakRoots(WeakReferenceGuest f,
-                                     WeakReferenceCallback callback) {
-  for (NodeIterator it(this); !it.done(); it.Advance()) {
-    if (it.node()->IsWeak() && it.node()->callback() == callback) {
-      f(it.node()->object(), it.node()->parameter());
-    }
-  }
-}
-
-
 void GlobalHandles::IdentifyWeakHandles(WeakSlotCallback f) {
   for (NodeIterator it(this); !it.done(); it.Advance()) {
     if (it.node()->IsWeak() && f(it.node()->location())) {
       it.node()->MarkPending();
     }
   }
 }
 
 
 void GlobalHandles::IterateNewSpaceStrongAndDependentRoots(ObjectVisitor* v) {
@@ skipping 280 matching lines @@
   implicit_ref_groups_.Clear();
 }
 
 
 void GlobalHandles::TearDown() {
   // TODO(1428): invoke weak callbacks.
 }
 
 
 } }  // namespace v8::internal