Oilpan: move node/element rare data objects to the heap.

Source/core/dom/MutationObserverRegistration.cpp

 /*
  * Copyright (C) 2011 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 19 matching lines @@
 
 #include "config.h"
 
 #include "core/dom/MutationObserverRegistration.h"
 
 #include "core/dom/Node.h"
 #include "core/dom/QualifiedName.h"
 
 namespace WebCore {
 
-PassOwnPtrWillBeRawPtr<MutationObserverRegistration> MutationObserverRegistration::create(MutationObserver& observer, Node& registrationNode, MutationObserverOptions options, const HashSet<AtomicString>& attributeFilter)
+PassOwnPtrWillBeRawPtr<MutationObserverRegistration> MutationObserverRegistration::create(MutationObserver& observer, Node* registrationNode, MutationObserverOptions options, const HashSet<AtomicString>& attributeFilter)
 {
     return adoptPtrWillBeNoop(new MutationObserverRegistration(observer, registrationNode, options, attributeFilter));
 }
 
-MutationObserverRegistration::MutationObserverRegistration(MutationObserver& observer, Node& registrationNode, MutationObserverOptions options, const HashSet<AtomicString>& attributeFilter)
+MutationObserverRegistration::MutationObserverRegistration(MutationObserver& observer, Node* registrationNode, MutationObserverOptions options, const HashSet<AtomicString>& attributeFilter)
     : m_observer(observer)
     , m_registrationNode(registrationNode)
+#if ENABLE(OILPAN)
+    , m_keepAlive(false)
+#endif
     , m_options(options)
     , m_attributeFilter(attributeFilter)
 {
     m_observer->observationStarted(this);
 }
 
 MutationObserverRegistration::~MutationObserverRegistration()
 {
-    // dispose() hasn't been called if this assert triggers.
-    ASSERT(!m_observer);
+#if !ENABLE(OILPAN)
+    dispose();
+#endif
 }
 
 void MutationObserverRegistration::dispose()
 {
     clearTransientRegistrations();
     m_observer->observationEnded(this);
     m_observer.clear();
 }
 
 void MutationObserverRegistration::resetObservation(MutationObserverOptions options, const HashSet<AtomicString>& attributeFilter)
 {
     clearTransientRegistrations();
     m_options = options;
     m_attributeFilter = attributeFilter;
 }
 
 void MutationObserverRegistration::observedSubtreeNodeWillDetach(Node& node)
 {
     if (!isSubtree())
         return;
 
     node.registerTransientMutationObserver(this);
     m_observer->setHasTransientRegistration();
 
     if (!m_transientRegistrationNodes) {
         m_transientRegistrationNodes = adoptPtr(new NodeHashSet);
 
+#if ENABLE(OILPAN)
+        ASSERT(!m_keepAlive);
+        m_keepAlive = true;
+#else
         ASSERT(!m_registrationNodeKeepAlive);
-        m_registrationNodeKeepAlive = PassRefPtr<Node>(m_registrationNode); // Balanced in clearTransientRegistrations.
+        m_registrationNodeKeepAlive = PassRefPtr<Node>(m_registrationNode.get()); // Balanced in clearTransientRegistrations.
+#endif
     }
     m_transientRegistrationNodes->add(&node);
 }
 
 void MutationObserverRegistration::clearTransientRegistrations()
 {
     if (!m_transientRegistrationNodes) {
+#if ENABLE(OILPAN)
+        ASSERT(!m_keepAlive);
+#else
         ASSERT(!m_registrationNodeKeepAlive);
+#endif
         return;
     }
 
     for (NodeHashSet::iterator iter = m_transientRegistrationNodes->begin(); iter != m_transientRegistrationNodes->end(); ++iter)
         (*iter)->unregisterTransientMutationObserver(this);
 
     m_transientRegistrationNodes.clear();
 
+#if ENABLE(OILPAN)
+    ASSERT(m_keepAlive);
+    m_keepAlive = false;
+#else
     ASSERT(m_registrationNodeKeepAlive);
     m_registrationNodeKeepAlive = nullptr; // Balanced in observeSubtreeNodeWillDetach.
+#endif
 }
 
 void MutationObserverRegistration::unregister()
 {
-    m_registrationNode.unregisterMutationObserver(this);
+    m_registrationNode->unregisterMutationObserver(this);
     // The above line will cause this object to be deleted, so don't do any more in this function.
 }
 
 bool MutationObserverRegistration::shouldReceiveMutationFrom(Node& node, MutationObserver::MutationType type, const QualifiedName* attributeName) const
 {
     ASSERT((type == MutationObserver::Attributes && attributeName) || !attributeName);
     if (!(m_options & type))
         return false;
 
-    if (m_registrationNode != node && !isSubtree())
+    if (m_registrationNode != &node && !isSubtree())
         return false;
 
     if (type != MutationObserver::Attributes || !(m_options & MutationObserver::AttributeFilter))
         return true;
 
     if (!attributeName->namespaceURI().isNull())
         return false;
 
     return m_attributeFilter.contains(attributeName->localName());
 }
 
 void MutationObserverRegistration::addRegistrationNodesToSet(HashSet<Node*>& nodes) const
 {
-    nodes.add(&m_registrationNode);
+    nodes.add(m_registrationNode.get());
     if (!m_transientRegistrationNodes)
         return;
     for (NodeHashSet::const_iterator iter = m_transientRegistrationNodes->begin(); iter != m_transientRegistrationNodes->end(); ++iter)
         nodes.add(iter->get());
 }
 
+#if ENABLE(OILPAN)
+void MutationObserverRegistration::clearWeakMembers(Visitor* visitor)
+{
+    if (!m_keepAlive && !visitor->isAlive(m_registrationNode))
+        dispose();

[haraken, 2014/05/07 02:10:26]

Would you elaborate on why we need to call dispose() here? I expected that this
line is 'm_registrationNode = nullptr'.

It seems a bit strange to me that you need to call dispose() in
clearWeakMember(), because the fact that m_keepAlive is false implies that
clearTransientRegistrations() is already called via dispose().

If the above observation is correct, you won't need clearWeakMembers.
Alternately, you can change trace() like this:

void trace(Visitor* visitor) {
  if (m_keepAlive)
    visitor->trace(m_registrationNode);
}

[sof, 2014/05/07 07:01:01]

The pair of weak&strong fields stays the same (see the latest patch; the use of
m_keepAlive wasn't valid).

Explicitly calling dispose() vs not, is subtle. If we don't remove a
registration, we run the risk of having a MutationObserver accessing a
registration without a Node (e.g., when it samples the current set of
registrations as part of a V8 GC). Supporting such near-dead access just makes
the implementation more complex for no apparent gain. Removing it eagerly
prevents that.

+}
+#endif
+
 void MutationObserverRegistration::trace(Visitor* visitor)
 {
     visitor->trace(m_observer);
+    visitor->trace(m_registrationNode);
+#if ENABLE(OILPAN)
+    visitor->registerWeakMembers<MutationObserverRegistration, &MutationObserverRegistration::clearWeakMembers>(this);
+#endif
 }
 
 } // namespace WebCore