New GC APIs, try 2.

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 127 matching lines @@
 
 namespace internal {
 class Arguments;
 class Heap;
 class HeapObject;
 class Isolate;
 class Object;
 }
 
 
+/**
+ * General purpose unique identifier.
+ */
+class UniqueId {
+ public:
+  explicit UniqueId(intptr_t data)
+      : data_(data) {}
+
+  bool operator==(const UniqueId& other) const {
+    return data_ == other.data_;
+  }
+
+  bool operator!=(const UniqueId& other) const {
+    return data_ != other.data_;
+  }
+
+  bool operator<(const UniqueId& other) const {
+    return data_ < other.data_;
+  }
+
+ private:
+  intptr_t data_;
+};
+
+
 // --- Weak Handles ---
 
 
 /**
  * A weak reference callback function.
  *
  * This callback should either explicitly invoke Dispose on |object| if
  * V8 wrapper is not needed anymore, or 'revive' it by invocation of MakeWeak.
  *
  * \param object the weak global object to be reclaimed by the garbage collector
@@ skipping 2945 matching lines @@
 
   /**
    * Returns CPU profiler for this isolate. Will return NULL until the isolate
    * is initialized.
    */
   CpuProfiler* GetCpuProfiler();
 
   /** Returns the context that is on the top of the stack. */
   Local<Context> GetCurrentContext();
 
+  /**
+   * 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. 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.
+   */
+  void SetObjectGroupId(const Persistent<Value>& object,
+                        UniqueId id);
+
+  /**
+   * Allows the host application to declare implicit references from an object
+   * group to an object. If the objects of the object group are alive, the child
+   * object is alive too. After each garbage collection, all implicit references
+   * are removed. It is intended to be used in the before-garbage-collection
+   * callback function.
+   */
+  void SetReferenceFromGroup(UniqueId id,

[yurys, 2013/04/23 15:25:15]

I've just realized that this change will affect heap snapshots. Implicit
references are used to report links from DOM Node wrappers to event listeners
and with the current API when you take a heap snapshot you see which specific
node retains the listener. But with the new API you will see a link from a
random representative from the group to the event listener which may be
confusing. Can we change this method to accept "const Persistent<Value>&" as
source of the reference to supply exact element that retains the target?

[marja, 2013/04/23 16:08:52]

For implicit references which are not about event listeners: V8GCController (the
current impl) selects a "representative object" (which is basically arbitrary,
since it selects the first object, and the sorting doesn't specify order for 2
objects in the same color group) for each object group, and attaches the
implicit references to it (see the usage of m_rootGroupMap).

However, for "object and event listeners", we create a separate object group for
the object and attach implicit references to that group. So it should just work;
there's only 1 object in the object group. 

The object can then be part of another object group, nothing forbids that, but
for the group that references the event listeners, there is only a one-object
group. This group is then ignored by GlobalHandles, and only the impl references
are extracted, so the users of GlobalHandles don't even see it. From their point
of view, nothing has changed.

(This all is in the Blink side of the patch.)

+                             const Persistent<Value>& object);
+
  private:
   Isolate();
   Isolate(const Isolate&);
   ~Isolate();
   Isolate& operator=(const Isolate&);
   void* operator new(size_t size);
   void operator delete(void*, size_t);
 };
 
 
@@ skipping 384 matching lines @@
    * 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. 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.
    * See v8-profiler.h for RetainedObjectInfo interface description.
    */
+  // TODO(marja): deprecate AddObjectGroup. Use Isolate::SetObjectGroupId and
+  // HeapProfiler::SetRetainedObjectInfo instead.
   static void AddObjectGroup(Persistent<Value>* objects,
                              size_t length,
                              RetainedObjectInfo* info = NULL);
   static void AddObjectGroup(Isolate* isolate,
                              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
    * are removed.  It is intended to be used in the before-garbage-collection
    * callback function.
    */
+  // TODO(marja): Deprecate AddImplicitReferences. Use
+  // Isolate::SetReferenceFromGroup instead.
   static void AddImplicitReferences(Persistent<Object> parent,
                                     Persistent<Value>* children,
                                     size_t length);
 
   /**
    * Initializes from snapshot if possible. Otherwise, attempts to
    * initialize from scratch.  This function is called implicitly if
    * you use the API without calling it first.
    */
   static bool Initialize();
@@ skipping 1595 matching lines @@
 
 
 }  // namespace v8
 
 
 #undef V8EXPORT
 #undef TYPE_CHECK
 
 
 #endif  // V8_H_