Implemented really weak handles.

include/v8.h

 // Copyright 2007-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 371 matching lines @@
   inline void Dispose();
 
   /**
    * Make the reference to this object weak.  When only weak handles
    * refer to the object, the garbage collector will perform a
    * callback to the given V8::WeakReferenceCallback function, passing
    * it the object reference and the given parameters.
    */
   inline void MakeWeak(void* parameters, WeakReferenceCallback callback);
 
-  /** Clears the weak reference to this object.*/
+  /**
+   * Similar to the above function except that when the callback is
+   * invoked for a really weak handle the object may have been
+   * collected already.  Accessing the object in the callback is not
+   * allowed.  The embedder can only use the data that is stored in
+   * the handle itself.
+   */
+  inline void MakeReallyWeak(void* parameters, WeakReferenceCallback callback);

[Christian Plesner Hansen, 2009/10/06 13:47:21]

I think we need to find a more informative name.  Alternatively we could use
MakeWeak for both and use a parameter to control when the callback is issued.

+
+  /**
+   * Clears weak status of this handle.  Clearing status in weak
+   * callback is not allowed for really weak handles since the object
+   * may have been collected already.
+   */
   inline void ClearWeak();
 
   /**
-   *Checks if the handle holds the only reference to an object.
+   * Checks if the handle holds the only reference to an object.
    */
   inline bool IsNearDeath() const;
 
   /**
-   * Returns true if the handle's reference is weak.
+   * Returns true if the handle's reference is weak or really weak.
    */
   inline bool IsWeak() const;
 
  private:
   friend class ImplementationUtilities;
   friend class ObjectTemplate;
 };
 
 
  /**
@@ skipping 1950 matching lines @@
   static void LowMemoryNotification();
 
  private:
   V8();
 
   static internal::Object** GlobalizeReference(internal::Object** handle);
   static void DisposeGlobal(internal::Object** global_handle);
   static void MakeWeak(internal::Object** global_handle,
                        void* data,
                        WeakReferenceCallback);
+  static void MakeReallyWeak(internal::Object** global_handle,
+                             void* data,
+                             WeakReferenceCallback);
   static void ClearWeak(internal::Object** global_handle);
   static bool IsGlobalNearDeath(internal::Object** global_handle);
   static bool IsGlobalWeak(internal::Object** global_handle);
 
   template <class T> friend class Handle;
   template <class T> friend class Local;
   template <class T> friend class Persistent;
   friend class Context;
 };
 
@@ skipping 447 matching lines @@
 Persistent<T>::Persistent() : Handle<T>() { }
 
 template <class T>
 void Persistent<T>::MakeWeak(void* parameters, WeakReferenceCallback callback) {
   V8::MakeWeak(reinterpret_cast<internal::Object**>(**this),
                parameters,
                callback);
 }
 
 template <class T>
+void Persistent<T>::MakeReallyWeak(void* parameters,
+                                   WeakReferenceCallback callback) {
+  V8::MakeReallyWeak(reinterpret_cast<internal::Object**>(**this),
+                     parameters,
+                     callback);
+}
+
+template <class T>
 void Persistent<T>::ClearWeak() {
   V8::ClearWeak(reinterpret_cast<internal::Object**>(**this));
 }
 
 Local<Value> Arguments::operator[](int i) const {
   if (i < 0 || length_ <= i) return Local<Value>(*Undefined());
   return Local<Value>(reinterpret_cast<Value*>(values_ - i));
 }
 
 
@@ skipping 253 matching lines @@
 
 }  // namespace v8
 
 
 #undef V8EXPORT
 #undef V8EXPORT_INLINE
 #undef TYPE_CHECK
 
 
 #endif  // V8_H_