Update V8GCController to use new V8 GC-related APIs.

Source/bindings/v8/V8GCController.cpp

 /*
  * Copyright (C) 2009 Google Inc. 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
@@ skipping 29 matching lines @@
 #include "V8Binding.h"
 #include "V8MessagePort.h"
 #include "V8MutationObserver.h"
 #include "V8Node.h"
 #include "V8RecursionScope.h"
 #include "WrapperTypeInfo.h"
 #include <algorithm>
 
 namespace WebCore {
 
-class ImplicitConnection {
-public:
-    ImplicitConnection(void* root, v8::Persistent<v8::Object> wrapper)
-        : m_root(root)
-        , m_wrapper(wrapper)
-        , m_rootNode(0)
-    {
-    }
-    ImplicitConnection(Node* root, v8::Persistent<v8::Object> wrapper)
-        : m_root(root)
-        , m_wrapper(wrapper)
-        , m_rootNode(root)
-    {
-    }
-
-    void* root() const { return m_root; }
-    v8::Persistent<v8::Object> wrapper() const { return m_wrapper; }
-
-    PassOwnPtr<RetainedObjectInfo> retainedObjectInfo()
-    {
-        if (!m_rootNode)
-            return nullptr;
-        return adoptPtr(new RetainedDOMInfo(m_rootNode));
-    }
-
-private:
-    void* m_root;
-    v8::Persistent<v8::Object> m_wrapper;
-    Node* m_rootNode;
-};
-
-bool operator<(const ImplicitConnection& left, const ImplicitConnection& right)
-{
-    return left.root() < right.root();
-}
-
-struct ImplicitReference {
-    ImplicitReference(void* parent, v8::Persistent<v8::Object> child)
-        : parent(parent)
-        , child(child)
-    {
-    }
-
-    void* parent;
-    v8::Persistent<v8::Object> child;
-};
-
-bool operator<(const ImplicitReference& left, const ImplicitReference& right)
-{
-    return left.parent < right.parent;
-}
-
-class WrapperGrouper {
-public:
-    WrapperGrouper()
-    {
-        m_liveObjects.append(V8PerIsolateData::current()->ensureLiveRoot());
-    }
-
-    void addObjectWrapperToGroup(void* root, v8::Persistent<v8::Object> wrapper)
-    {
-        m_connections.append(ImplicitConnection(root, wrapper));
-    }
-
-    void addNodeWrapperToGroup(Node* root, v8::Persistent<v8::Object> wrapper)
-    {
-        m_connections.append(ImplicitConnection(root, wrapper));
-    }
-
-    void addImplicitReference(void* parent, v8::Persistent<v8::Object> child)
-    {
-        m_references.append(ImplicitReference(parent, child));
-        m_rootGroupMap.add(parent, v8::Persistent<v8::Object>());
-    }
-
-    void keepAlive(v8::Persistent<v8::Value> wrapper)
-    {
-        m_liveObjects.append(wrapper);
-    }
-
-    void apply()
-    {
-        if (m_liveObjects.size() > 1)
-            v8::V8::AddObjectGroup(m_liveObjects.data(), m_liveObjects.size());
-
-        std::sort(m_connections.begin(), m_connections.end());
-        Vector<v8::Persistent<v8::Value> > group;
-        size_t i = 0;
-        while (i < m_connections.size()) {
-            void* root = m_connections[i].root();
-            v8::Persistent<v8::Object> groupRepresentativeWrapper = m_connections[i].wrapper();
-            OwnPtr<RetainedObjectInfo> retainedObjectInfo = m_connections[i].retainedObjectInfo();
-
-            do {
-                group.append(m_connections[i++].wrapper());
-            } while (i < m_connections.size() && root == m_connections[i].root());
-
-            if (group.size() > 1)
-                v8::V8::AddObjectGroup(group.data(), group.size(), retainedObjectInfo.leakPtr());
-
-            HashMap<void*, v8::Persistent<v8::Object> >::iterator iter = m_rootGroupMap.find(root);
-            if (iter != m_rootGroupMap.end())
-                iter->value = groupRepresentativeWrapper;
-
-            group.shrink(0);
-        }
-
-        std::sort(m_references.begin(), m_references.end());
-        i = 0;
-        while (i < m_references.size()) {
-            void* parent = m_references[i].parent;
-            v8::Persistent<v8::Object> parentWrapper = m_rootGroupMap.get(parent);
-            if (parentWrapper.IsEmpty()) {
-                ++i;
-                continue;
-            }
-
-            Vector<v8::Persistent<v8::Value> > children;
-            do {
-                children.append(m_references[i++].child);
-            } while (i < m_references.size() && parent == m_references[i].parent);
-
-            v8::V8::AddImplicitReferences(parentWrapper, children.data(), children.size());
-        }
-    }
-
-private:
-    Vector<v8::Persistent<v8::Value> > m_liveObjects;
-    Vector<ImplicitConnection> m_connections;
-    Vector<ImplicitReference> m_references;
-    HashMap<void*, v8::Persistent<v8::Object> > m_rootGroupMap;
-};
-
 // FIXME: This should use opaque GC roots.
-static void addImplicitReferencesForNodeWithEventListeners(Node* node, v8::Persistent<v8::Object> wrapper)
+static void addImplicitReferencesForNodeWithEventListeners(v8::Isolate* isolate, Node* node, v8::Persistent<v8::Object> wrapper)
 {
     ASSERT(node->hasEventListeners());
 
-    Vector<v8::Persistent<v8::Value> > listeners;
+    // Add a new object group just for the wrapper.
+    v8::UniqueId id(reinterpret_cast<intptr_t>(*wrapper));
+    v8::V8::SetObjectGroupId(isolate, wrapper, id);
 
     EventListenerIterator iterator(node);
     while (EventListener* listener = iterator.nextListener()) {
         if (listener->type() != EventListener::JSEventListenerType)
             continue;
         V8AbstractEventListener* v8listener = static_cast<V8AbstractEventListener*>(listener);
         if (!v8listener->hasExistingListenerObject())
             continue;
-        listeners.append(v8listener->existingListenerObjectPersistentHandle());
+
+        v8::V8::AddImplicitReference(isolate, id, v8listener->existingListenerObjectPersistentHandle());
     }
-
-    if (listeners.isEmpty())
-        return;
-
-    v8::V8::AddImplicitReferences(wrapper, listeners.data(), listeners.size());
 }
 
 Node* V8GCController::opaqueRootForGC(Node* node, v8::Isolate*)
 {
     // FIXME: Remove the special handling for image elements.
     // The same special handling is in V8GCController::gcTree().
     // Maybe should image elements be active DOM nodes?
     // See https://code.google.com/p/chromium/issues/detail?id=164882
     if (node->inDocument() || (node->hasTagName(HTMLNames::imgTag) && static_cast<HTMLImageElement*>(node)->hasPendingActivity()))
         return node->document();
@@ skipping 140 matching lines @@
 
         WrapperTypeInfo* type = toWrapperTypeInfo(wrapper);
         void* object = toNative(wrapper);
 
         if (V8MessagePort::info.equals(type)) {
             // Mark each port as in-use if it's entangled. For simplicity's sake,
             // we assume all ports are remotely entangled, since the Chromium port
             // implementation can't tell the difference.
             MessagePort* port = static_cast<MessagePort*>(object);
             if (port->isEntangled() || port->hasPendingActivity())
-                m_grouper.keepAlive(wrapper);
+                SetObjectGroupId(wrapper, *V8PerIsolateData::current()->ensureLiveRoot());
         } else if (V8MutationObserver::info.equals(type)) {
             // FIXME: Allow opaqueRootForGC to operate on multiple roots and move this logic into V8MutationObserverCustom.
             MutationObserver* observer = static_cast<MutationObserver*>(object);
             HashSet<Node*> observedNodes = observer->getObservedNodes();
             for (HashSet<Node*>::iterator it = observedNodes.begin(); it != observedNodes.end(); ++it)
-                m_grouper.addImplicitReference(V8GCController::opaqueRootForGC(*it, m_isolate), wrapper);
+                v8::V8::AddImplicitReference(m_isolate, v8::UniqueId(reinterpret_cast<intptr_t>(V8GCController::opaqueRootForGC(*it, m_isolate))), wrapper);
         } else {
             ActiveDOMObject* activeDOMObject = type->toActiveDOMObject(wrapper);
             if (activeDOMObject && activeDOMObject->hasPendingActivity())
-                m_grouper.keepAlive(wrapper);
+                SetObjectGroupId(wrapper, *V8PerIsolateData::current()->ensureLiveRoot());
         }
 
         if (classId == v8DOMNodeClassId) {
             UNUSED_PARAM(m_isolate);
             ASSERT(V8Node::HasInstanceInAnyWorld(wrapper, m_isolate));
             ASSERT(!wrapper.IsIndependent(m_isolate));
 
             Node* node = static_cast<Node*>(object);
 
             if (node->hasEventListeners())
-                addImplicitReferencesForNodeWithEventListeners(node, wrapper);
-
-            m_grouper.addNodeWrapperToGroup(V8GCController::opaqueRootForGC(node, m_isolate), wrapper);
+                addImplicitReferencesForNodeWithEventListeners(m_isolate, node, wrapper);
+            Node* root = V8GCController::opaqueRootForGC(node, m_isolate);
+            SetObjectGroupId(wrapper, root);
+            MaybeAddRetainedObjectInfo(root);
         } else if (classId == v8DOMObjectClassId) {
-            m_grouper.addObjectWrapperToGroup(type->opaqueRootForGC(object, wrapper, m_isolate), wrapper);
+            void* root = type->opaqueRootForGC(object, wrapper, m_isolate);
+            SetObjectGroupId(wrapper, root);
         } else {
             ASSERT_NOT_REACHED();
         }
     }
 
-    void notifyFinished()
+    void MaybeAddRetainedObjectInfo(Node* root)

[abarth-chromium, 2013/04/12 17:23:44]

MaybeAddRetainedObjectInfo -> maybeAddRetainedObjectInfo

     {
-        m_grouper.apply();
+        if (root && !groups_with_retained_info_.contains(root)) {
+            v8::V8::SetRetainedObjectInfo(m_isolate, v8::UniqueId(reinterpret_cast<intptr_t>(root)), new RetainedDOMInfo(root));
+            groups_with_retained_info_.add(root);
+        }
+    }
+
+    void SetObjectGroupId(const v8::Persistent<v8::Object>& object, void* root)

[abarth-chromium, 2013/04/12 17:23:44]

SetObjectGroupId -> setObjectGroupId

+    {
+        v8::UniqueId id(reinterpret_cast<intptr_t>(root));
+        v8::V8::SetObjectGroupId(m_isolate, object, id);
+        if (!groups_with_representative_objects_.contains(root)) {
+            v8::V8::SetObjectGroupRepresentativeObject(m_isolate, id, object);
+            groups_with_representative_objects_.add(root);
+        }
     }
 
 private:
-    WrapperGrouper m_grouper;
     v8::Isolate* m_isolate;
+    HashSet<Node*> groups_with_retained_info_;

[abarth-chromium, 2013/04/12 17:23:44]

m_groupsWithRetainedInfo

+    HashSet<void*> groups_with_representative_objects_;

[abarth-chromium, 2013/04/12 17:23:44]

m_groupsWithRepresentiveObjects

 };
 
 void V8GCController::gcPrologue(v8::GCType type, v8::GCCallbackFlags flags)
 {
     // It would be nice if the GC callbacks passed the Isolate directly....
     v8::Isolate* isolate = v8::Isolate::GetCurrent();
     if (type == v8::kGCTypeScavenge)
         minorGCPrologue(isolate);
     else if (type == v8::kGCTypeMarkSweepCompact)
         majorGCPrologue();
@@ skipping 16 matching lines @@
 // Create object groups for DOM tree nodes.
 void V8GCController::majorGCPrologue()
 {
     TRACE_EVENT_BEGIN0("v8", "GC");
 
     v8::Isolate* isolate = v8::Isolate::GetCurrent();
     v8::HandleScope scope;
 
     MajorGCWrapperVisitor visitor(isolate);
     v8::V8::VisitHandlesWithClassIds(&visitor);
-    visitor.notifyFinished();
 
     V8PerIsolateData::from(isolate)->stringCache()->clearOnGC();
 }
 
 static int workingSetEstimateMB = 0;
 
 static Mutex& workingSetEstimateMBMutex()
 {
     AtomicallyInitializedStatic(Mutex&, mutex = *new Mutex);
     return mutex;
@@ skipping 81 matching lines @@
         if (!script.IsEmpty()) {
             V8RecursionScope::MicrotaskSuppression scope;
             script->Run();
         }
     }
 
     context.clear();
 }
 
 }  // namespace WebCore