Oilpan: Remove guardRef and guardDeref from TreeScope.

Source/core/dom/Node.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies)
  * Copyright (C) 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
@@ skipping 261 matching lines @@
     RELEASE_ASSERT(!renderer());
 
     if (!isContainerNode())
         willBeDeletedFromDocument();
 
     if (m_previous)
         m_previous->setNextSibling(0);
     if (m_next)
         m_next->setPreviousSibling(0);
 
+#if !ENABLE(OILPAN)
     if (m_treeScope)
         m_treeScope->guardDeref();
+#endif
 
     InspectorCounters::decrementCounter(InspectorCounters::NodeCounter);
 
     if (getFlag(HasWeakReferences))
         WeakNodeMap::notifyNodeDestroyed(this);
 }
 
 void Node::willBeDeletedFromDocument()
 {
+#if !ENABLE(OILPAN)
+    // With Oilpan all of this is handled with weak processing on the document.

[haraken, 2014/04/25 14:30:32]

I'd put #if !ENABLE(OILPAN) around Node::willBeDeletedFromDocument() and all
call sites of Node::willBeDeletedFromDocument().

[Mads Ager (chromium), 2014/04/28 09:45:21]

Thanks. That more clearly indicates what is going on. Done.

     if (!isTreeScopeInitialized())
         return;
 
     Document& document = this->document();
 
     if (hasEventTargetData()) {
         clearEventTargetData();
         document.didClearTouchEventHandlers(this);
         EventHandlerRegistry::from(document)->didRemoveAllEventHandlers(*this);
     }
 
     if (AXObjectCache* cache = document.existingAXObjectCache())
         cache->remove(this);
 
     document.markers().removeMarkers(this);
+#endif
 }
 
 NodeRareData* Node::rareData() const
 {
     ASSERT_WITH_SECURITY_IMPLICATION(hasRareData());
     return static_cast<NodeRareData*>(m_data.m_rareData);
 }
 
 NodeRareData& Node::ensureRareData()
 {
@@ skipping 1704 matching lines @@
 
 void Node::removeAllEventListenersRecursively()
 {
     for (Node* node = this; node; node = NodeTraversal::next(*node)) {
         node->removeAllEventListeners();
         for (ShadowRoot* root = node->youngestShadowRoot(); root; root = root->olderShadowRoot())
             root->removeAllEventListenersRecursively();
     }
 }
 
-typedef HashMap<Node*, OwnPtr<EventTargetData> > EventTargetDataMap;
+typedef WillBeHeapHashMap<RawPtrWillBeWeakMember<Node>, OwnPtr<EventTargetData> > EventTargetDataMap;
 
 static EventTargetDataMap& eventTargetDataMap()
 {
+#if ENABLE(OILPAN)
+    DEFINE_STATIC_LOCAL(Persistent<EventTargetDataMap>, map, (new EventTargetDataMap()));
+    return *map;
+#else
     DEFINE_STATIC_LOCAL(EventTargetDataMap, map, ());
     return map;
+#endif
 }
 
 EventTargetData* Node::eventTargetData()
 {
     return hasEventTargetData() ? eventTargetDataMap().get(this) : 0;
 }
 
 EventTargetData& Node::ensureEventTargetData()
 {
     if (hasEventTargetData())
         return *eventTargetDataMap().get(this);
     setHasEventTargetData(true);
     EventTargetData* data = new EventTargetData;
     eventTargetDataMap().set(this, adoptPtr(data));
     return *data;
 }
 
 void Node::clearEventTargetData()

[haraken, 2014/04/25 14:30:32]

You can add #if !ENABLE(OILPAN) to this method.

[Mads Ager (chromium), 2014/04/28 09:45:21]

Done.

 {
     eventTargetDataMap().remove(this);
 }
 
 WillBeHeapVector<OwnPtrWillBeMember<MutationObserverRegistration> >* Node::mutationObserverRegistry()
 {
     if (!hasRareData())
         return 0;
     NodeMutationObserverData* data = rareData()->mutationObserverData();
     if (!data)
@@ skipping 281 matching lines @@
 }
 
 bool Node::willRespondToTouchEvents()
 {
     if (isDisabledFormControl(this))
         return false;
     return hasEventListeners(EventTypeNames::touchstart) || hasEventListeners(EventTypeNames::touchmove) || hasEventListeners(EventTypeNames::touchcancel) || hasEventListeners(EventTypeNames::touchend);
 }
 
 // This is here for inlining
+#if ENABLE(OILPAN)
+inline void TreeScope::removedLastRefToScope()

[haraken, 2014/04/25 14:30:32]

Just help me understand: How is removedLastRef working now (for TreeScope/Node)?
Given that the TreeScope/Node can be referenced via Members, the point where the
last RefPtr is gone is not the point where we should dispatch dispose().

[Mads Ager (chromium), 2014/04/28 09:45:21]

When the last ref is removed to the tree scope we always call dispose. Before,
dispose was called only if there was a guardRef and otherwise the treescope was
deleted right away (and therefore dispose was not needed because the treescope
was being deleted instead). Now, we never eagerly delete the document. Instead,
we call dispose when there are no more RefPtrs to the document.

In my next change where we start visiting everything and move away from the
TreeShared algorithms for destruction. We will have to explicitly dispatch
dispose. A document has well-defined life-time states. I think we need to
piggy-back on that and call dispose when the document moves to one of the later
stages (stopping? stopped?).

+{
+    dispose();
+}
+#else
 inline void TreeScope::removedLastRefToScope()
 {
     ASSERT_WITH_SECURITY_IMPLICATION(!deletionHasBegun());
     if (m_guardRefCount) {
         // If removing a child removes the last self-only ref, we don't
         // want the scope to be destructed until after
         // removeDetachedChildren returns, so we guard ourselves with an
         // extra self-only ref.
         guardRef();
         dispose();
 #if !ASSERT_DISABLED
         // We need to do this right now since guardDeref() can delete this.
         rootNode().m_inRemovedLastRefFunction = false;
 #endif
         guardDeref();
     } else {
 #if !ASSERT_DISABLED
         rootNode().m_inRemovedLastRefFunction = false;
 #endif
-#if !ENABLE(OILPAN)
 #if SECURITY_ASSERT_ENABLED
         beginDeletion();
 #endif
         delete this;
-#endif
     }
 }
+#endif
 
 // It's important not to inline removedLastRef, because we don't want to inline the code to
 // delete a Node at each deref call site.
 void Node::removedLastRef()
 {
     // An explicit check for Document here is better than a virtual function since it is
     // faster for non-Document nodes, and because the call to removedLastRef that is inlined
     // at all deref call sites is smaller if it's a non-virtual function.
     if (isTreeScope()) {
         treeScope().removedLastRefToScope();
@@ skipping 141 matching lines @@
     }
 
     ASSERT(isHTMLElement() || isSVGElement());
     setFlag(CustomElement);
     setFlag(newState == Upgraded, CustomElementUpgraded);
 
     if (oldState == NotCustomElement || newState == Upgraded)
         setNeedsStyleRecalc(SubtreeStyleChange); // :unresolved has changed
 }
 
+void Node::trace(Visitor* visitor)
+{
+    visitor->trace(m_treeScope);
+}
+
 } // namespace WebCore
 
 #ifndef NDEBUG
 
 void showNode(const WebCore::Node* node)
 {
     if (node)
         node->showNode("");
 }
 
 void showTree(const WebCore::Node* node)
 {
     if (node)
         node->showTreeForThis();
 }
 
 void showNodePath(const WebCore::Node* node)
 {
     if (node)
         node->showNodePathForThis();
 }
 
 #endif