Oilpan: move mutation observers to the Oilpan heap.

Source/core/dom/NodeRareData.h

 /*
  * Copyright (C) 2008, 2010 Apple Inc. All rights reserved.
  * Copyright (C) 2008 David Smith <catfish.man@gmail.com>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
@@ skipping 11 matching lines @@
 #ifndef NodeRareData_h
 #define NodeRareData_h
 
 #include "core/dom/ChildNodeList.h"
 #include "core/dom/EmptyNodeList.h"
 #include "core/dom/LiveNodeList.h"
 #include "core/dom/MutationObserverRegistration.h"
 #include "core/dom/QualifiedName.h"
 #include "core/dom/TagCollection.h"
 #include "core/page/Page.h"
+#include "platform/heap/Handle.h"
 #include "wtf/HashSet.h"
 #include "wtf/OwnPtr.h"
 #include "wtf/PassOwnPtr.h"
 #include "wtf/text/AtomicString.h"
 #include "wtf/text/StringHash.h"
 
 namespace WebCore {
 
 class LabelsNodeList;
 class RadioNodeList;
@@ skipping 160 matching lines @@
     }
 
     bool deleteThisAndUpdateNodeRareDataIfAboutToRemoveLastList(Node&);
 
     // Can be a ChildNodeList or an EmptyNodeList.
     NodeList* m_childNodeList;
     NodeListAtomicNameCacheMap m_atomicNameCaches;
     TagCollectionCacheNS m_tagCollectionCacheNS;
 };
 
-class NodeMutationObserverData {
-    WTF_MAKE_NONCOPYABLE(NodeMutationObserverData); WTF_MAKE_FAST_ALLOCATED;
+class NodeMutationObserverData FINAL : public NoBaseWillBeGarbageCollected<NodeMutationObserverData> {
+    WTF_MAKE_NONCOPYABLE(NodeMutationObserverData);
+    WTF_MAKE_FAST_ALLOCATED_WILL_BE_REMOVED;
 public:
-    Vector<OwnPtr<MutationObserverRegistration> > registry;
-    HashSet<MutationObserverRegistration*> transientRegistry;
+    WillBeHeapVector<OwnPtrWillBeMember<MutationObserverRegistration> > registry;
+    WillBeHeapHashSet<RawPtrWillBeMember<MutationObserverRegistration> > transientRegistry;

[Erik Corry, 2014/04/22 12:46:55]

I suppose these raw pointers were only cycle-breaking raw pointers, not weak
pointers?

[haraken, 2014/04/22 13:03:07]

It would depend on how you see these pointers. In a sense that these pointers
are just breaking cycles, they are weak poniters. On the other hand, in a sense
that these pointers are always explicitly cleared, they can be viewed as strong
pointers (Even if we make these pointers weak, there is no chance for GC to
clear out the weak pointers).

(Either is fine with me.)

[sof, 2014/04/22 13:05:29]

Ownership with these transients raw pointers lie with the registry of some child
Node (see Node::notifyMutationObserversNodeWillDetach()). We don't have ref
counting over these, so I'm not sure what that makes them.

 
-    static PassOwnPtr<NodeMutationObserverData> create() { return adoptPtr(new NodeMutationObserverData); }
+    static PassOwnPtrWillBeRawPtr<NodeMutationObserverData> create()
+    {
+        return adoptPtrWillBeNoop(new NodeMutationObserverData);
+    }
+
+    void trace(Visitor* visitor)
+    {
+        visitor->trace(registry);
+        visitor->trace(transientRegistry);
+    }
 
 private:
     NodeMutationObserverData() { }
 };
 
 class NodeRareData : public NodeRareDataBase {
     WTF_MAKE_NONCOPYABLE(NodeRareData); WTF_MAKE_FAST_ALLOCATED;
 public:
-    static PassOwnPtr<NodeRareData> create(RenderObject* renderer) { return adoptPtr(new NodeRareData(renderer)); }
+    static PassOwnPtr<NodeRareData> create(RenderObject* renderer)
+    {
+        return adoptPtr(new NodeRareData(renderer));
+    }
+
+    void dispose();
 
     void clearNodeLists() { m_nodeLists.clear(); }
     NodeListsNodeData* nodeLists() const { return m_nodeLists.get(); }
     NodeListsNodeData& ensureNodeLists()
     {
         if (!m_nodeLists)
             m_nodeLists = NodeListsNodeData::create();
         return *m_nodeLists;
     }
 
@@ skipping 33 matching lines @@
 protected:
     NodeRareData(RenderObject* renderer)
         : NodeRareDataBase(renderer)
         , m_connectedFrameCount(0)
         , m_elementFlags(0)
         , m_restyleFlags(0)
     { }
 
 private:
     OwnPtr<NodeListsNodeData> m_nodeLists;
-    OwnPtr<NodeMutationObserverData> m_mutationObserverData;
+    OwnPtrWillBePersistent<NodeMutationObserverData> m_mutationObserverData;
 
     unsigned m_connectedFrameCount : ConnectedFrameCountBits;
     unsigned m_elementFlags : NumberOfElementFlags;
     unsigned m_restyleFlags : NumberOfDynamicRestyleFlags;
 };
 
 inline bool NodeListsNodeData::deleteThisAndUpdateNodeRareDataIfAboutToRemoveLastList(Node& ownerNode)
 {
     ASSERT(ownerNode.nodeLists() == this);
     if ((m_childNodeList ? 1 : 0) + m_atomicNameCaches.size() + m_tagCollectionCacheNS.size() != 1)
         return false;
     ownerNode.clearNodeLists();
     return true;
 }
 
 } // namespace WebCore
 
 #endif // NodeRareData_h