[oilpan] Handlify childrenChanged.

Source/core/dom/ContainerNode.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 Apple Inc. All rights reserved.
  *
  * 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.
@@ skipping 321 matching lines @@
 
     if (document() != newChild->document())
         document()->adoptNode(newChild.get(), ASSERT_NO_EXCEPTION);
 
     insertBeforeCommon(nextChild, newChild.get());
 
     newChild->updateAncestorConnectedSubframeCountForInsertion();
 
     ChildListMutationScope(this).childAdded(newChild.get());
 
-    childrenChanged(true, newChild->previousSibling(), nextChild, 1);
+    childrenChanged(true, adoptRawResult(newChild->previousSibling()), adoptRawResult(nextChild), 1);
     ChildNodeInsertionNotifier(selfHandle()).notify(newChild.get());
 }
 
 bool ContainerNode::replaceChild(PassRefPtr<Node> newChild, Node* oldChild, ExceptionCode& ec, AttachBehavior attachBehavior)
 {
     HandleScope scope;
     // FIXME(oilpan): not needed when all Node pointers are handlified.
     Handle<Node> protect(this);
 
     ec = 0;
@@ skipping 154 matching lines @@
         ec = NOT_FOUND_ERR;
         return false;
     }
 
     {
         WidgetHierarchyUpdatesSuspensionScope suspendWidgetHierarchyUpdates;
 
         Node* prev = child->previousSibling();
         Node* next = child->nextSibling();
         removeBetween(prev, next, child.get());
-        childrenChanged(false, prev, next, -1);
+        childrenChanged(false, adoptRawResult(prev), adoptRawResult(next), -1);
         ChildNodeRemovalNotifier(selfHandle()).notify(child.get());
     }
     dispatchSubtreeModifiedEvent();
 
     return child;
 }
 
 void ContainerNode::removeBetween(Node* previousChild, Node* nextChild, Node* oldChild)
 {
     HandleScope scope;
@@ skipping 32 matching lines @@
     Node* prev = oldChild->previousSibling();
     Node* next = oldChild->nextSibling();
 
     oldChild->updateAncestorConnectedSubframeCountForRemoval();
 
     ChildListMutationScope(this).willRemoveChild(oldChild);
     oldChild->notifyMutationObserversNodeWillDetach();
 
     removeBetween(prev, next, oldChild);
 
-    childrenChanged(true, prev, next, -1);
+    childrenChanged(true, adoptRawResult(prev), adoptRawResult(next), -1);
     ChildNodeRemovalNotifier(selfHandle()).notify(oldChild);
 }
 
 // this differs from other remove functions because it forcibly removes all the children,
 // regardless of read-only status or event exceptions, e.g.
 void ContainerNode::removeChildren()
 {
     HandleScope scope;
     if (!m_firstChild)
         return;
@@ skipping 17 matching lines @@
         {
             NoEventDispatchAssertion assertNoEventDispatch;
             removedChildren.reserveInitialCapacity(childNodeCount());
             while (m_firstChild) {
                 HandleScope scope;
                 removedChildren.append(m_firstChild);
                 removeBetween(0, m_firstChild->nextSibling(), m_firstChild);
             }
         }
 
-        childrenChanged(false, 0, 0, -static_cast<int>(removedChildren.size()));
+        childrenChanged(false, nullptr, nullptr, -static_cast<int>(removedChildren.size()));
         
         for (size_t i = 0; i < removedChildren.size(); ++i) {
             HandleScope scope;
             ChildNodeRemovalNotifier(selfHandle()).notify(removedChildren[i].get());
         }
     }
 
     dispatchSubtreeModifiedEvent();
 }
 
@@ skipping 73 matching lines @@
         NoEventDispatchAssertion assertNoEventDispatch;
         // FIXME: This method should take a PassRefPtr.
         appendChildToContainer(newChild.get(), this);
         treeScope()->adoptIfNeeded(newChild.get());
     }
 
     newChild->updateAncestorConnectedSubframeCountForInsertion();
 
     ChildListMutationScope(this).childAdded(newChild.get());
 
-    childrenChanged(true, last, 0, 1);
+    childrenChanged(true, adoptRawResult(last), nullptr, 1);
     ChildNodeInsertionNotifier(selfHandle()).notify(newChild.get());
 }
 
 void ContainerNode::suspendPostAttachCallbacks()
 {
     if (!s_attachDepth) {
         ASSERT(!s_shouldReEnableMemoryCacheCallsAfterAttach);
         if (Page* page = document()->page()) {
             // FIXME: How can this call be specific to one Page, while the
             // s_attachDepth is a global? Doesn't make sense.
@@ skipping 69 matching lines @@
     Node::attach();
 }
 
 void ContainerNode::detach()
 {
     detachChildren();
     clearChildNeedsStyleRecalc();
     Node::detach();
 }
 
-void ContainerNode::childrenChanged(bool changedByParser, Node*, Node*, int childCountDelta)
+void ContainerNode::childrenChanged(bool changedByParser, const Handle<Node>&, const Handle<Node>&, int childCountDelta)
 {
     document()->incDOMTreeVersion();
     if (!changedByParser && childCountDelta)
         document()->updateRangesAfterChildrenChanged(selfHandle());
     invalidateNodeListCachesInAncestors();
 }
 
 void ContainerNode::cloneChildNodes(const Handle<ContainerNode>& clone)
 {
     ExceptionCode ec = 0;
@@ skipping 123 matching lines @@
             c->dispatchScopedEvent(MutationEvent::create(eventNames().DOMNodeRemovedFromDocumentEvent, false));
     }
 }
 
 static void updateTreeAfterInsertion(const Handle<ContainerNode>& parent, Node* child, AttachBehavior attachBehavior)
 {
     ASSERT(child->refCount());
 
     ChildListMutationScope(parent.raw()).childAdded(child);
 
-    parent->childrenChanged(false, child->previousSibling(), child->nextSibling(), 1);
+    parent->childrenChanged(false, adoptRawResult(child->previousSibling()), adoptRawResult(child->nextSibling()), 1);
 
     ChildNodeInsertionNotifier(parent).notify(child);
 
     // FIXME: Attachment should be the first operation in this function, but some code
     // (for example, HTMLFormControlElement's autofocus support) requires this ordering.
     if (parent->attached() && !child->attached() && child->parentNode() == parent) {
         if (attachBehavior == AttachLazily)
             child->lazyAttach();
         else
             child->attach();
@@ skipping 19 matching lines @@
 #endif
 
 void ContainerNode::accept(Visitor* visitor) const
 {
     Node::accept(visitor);
     visitor->visit(m_firstChild);
     visitor->visit(m_lastChild);
 }
 
 } // namespace WebCore