Allow collection of DOM objects in minor GC cycles.

include/v8.h

 // Copyright 2012 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 384 matching lines @@
 
   /**
    * Marks the reference to this object independent. Garbage collector
    * is free to ignore any object groups containing this object.
    * Weak callback for an independent handle should not
    * assume that it will be preceded by a global GC prologue callback
    * or followed by a global GC epilogue callback.
    */
   inline void MarkIndependent();
 
+  /**
+   * Marks the reference to this object externally unreachable.

[Michael Starzinger, 2012/11/05 10:47:27]

The comment should not describe the underlying implementation but the intended
usage of this flag. How about the following comment?

Marks the reference to this object partially dependent. Partially dependent
handles only depend on other partially dependent handles and these dependencies
are provided through object groups. It provides a way to build smaller object
groups for young objects that represent only a subset of all external
dependencies. This mark is automatically cleared after each garbage collection.

[haraken, 2012/11/05 12:42:07]

Done.

+   * Scavenger GC treats this object unreachable if all objects
+   * in the object group which this object belongs to are neither
+   * strongly reachable nor weakly reachable. This mark is cleared
+   * after each scavenger GC.  If this object is not in the new
+   * space, this API has no effect.
+   */
+  inline void MarkExternallyUnreachable();

[Michael Starzinger, 2012/11/05 10:47:27]

As discussed offline: The name of this flag is not really accurate, because the
object is externally reachable and dependent on other objects. How about naming
it "partially dependent"?

[haraken, 2012/11/05 12:42:07]

Done.

+
   /** Returns true if this handle was previously marked as independent. */
   inline bool IsIndependent() const;
 
   /** Checks if the handle holds the only reference to an object. */
   inline bool IsNearDeath() const;
 
   /** Returns true if the handle's reference is weak.  */
   inline bool IsWeak() const;
 
   /**
@@ skipping 2832 matching lines @@
    * Removes callback that was installed by AddCallCompletedCallback.
    */
   static void RemoveCallCompletedCallback(CallCompletedCallback callback);
 
   /**
    * Allows the host application to group objects together. If one
    * object in the group is alive, all objects in the group are alive.
    * After each garbage collection, object groups are removed. It is
    * intended to be used in the before-garbage-collection callback
    * function, for instance to simulate DOM tree connections among JS
    * wrapper objects.

[Michael Starzinger, 2012/11/05 10:47:27]

Maybe we should add this comment here ...

Object groups for all dependent handles need to be provided for
kGCTypeMarkSweepCompact collections, for all other garbage collection types it
is sufficient to provide object groups for partially dependent handles only.

[haraken, 2012/11/05 12:42:07]

Done.

    * See v8-profiler.h for RetainedObjectInfo interface description.
    */
   static void AddObjectGroup(Persistent<Value>* objects,
                              size_t length,
                              RetainedObjectInfo* info = NULL);
 
   /**
    * Allows the host application to declare implicit references between
    * the objects: if |parent| is alive, all |children| are alive too.
    * After each garbage collection, all implicit references
@@ skipping 218 matching lines @@
  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 ClearWeak(internal::Object** global_handle);
   static void MarkIndependent(internal::Object** global_handle);
+  static void MarkExternallyUnreachable(internal::Object** global_handle);
   static bool IsGlobalIndependent(internal::Object** global_handle);
   static bool IsGlobalNearDeath(internal::Object** global_handle);
   static bool IsGlobalWeak(internal::Object** global_handle);
   static void SetWrapperClassId(internal::Object** global_handle,
                                 uint16_t class_id);
   static uint16_t GetWrapperClassId(internal::Object** global_handle);
 
   template <class T> friend class Handle;
   template <class T> friend class Local;
   template <class T> friend class Persistent;
@@ skipping 751 matching lines @@
 void Persistent<T>::ClearWeak() {
   V8::ClearWeak(reinterpret_cast<internal::Object**>(**this));
 }
 
 template <class T>
 void Persistent<T>::MarkIndependent() {
   V8::MarkIndependent(reinterpret_cast<internal::Object**>(**this));
 }
 
 template <class T>
+void Persistent<T>::MarkExternallyUnreachable() {
+  V8::MarkExternallyUnreachable(reinterpret_cast<internal::Object**>(**this));
+}
+
+template <class T>
 void Persistent<T>::SetWrapperClassId(uint16_t class_id) {
   V8::SetWrapperClassId(reinterpret_cast<internal::Object**>(**this), class_id);
 }
 
 template <class T>
 uint16_t Persistent<T>::WrapperClassId() const {
   return V8::GetWrapperClassId(reinterpret_cast<internal::Object**>(**this));
 }
 
 Arguments::Arguments(internal::Object** implicit_args,
@@ skipping 419 matching lines @@
 
 
 }  // namespace v8
 
 
 #undef V8EXPORT
 #undef TYPE_CHECK
 
 
 #endif  // V8_H_