Merge 111895

Source/WebCore/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 38 matching lines @@
 namespace WebCore {
 
 static void notifyChildInserted(Node*);
 static void dispatchChildInsertionEvents(Node*);
 static void dispatchChildRemovalEvents(Node*);
 
 typedef pair<RefPtr<Node>, unsigned> CallbackParameters;
 typedef pair<NodeCallback, CallbackParameters> CallbackInfo;
 typedef Vector<CallbackInfo> NodeCallbackQueue;
 
-typedef Vector<RefPtr<Node>, 1> NodeVector;
 static NodeCallbackQueue* s_postAttachCallbackQueue;
 
 static size_t s_attachDepth;
 static bool s_shouldReEnableMemoryCacheCallsAfterAttach;
 
-static inline void collectNodes(Node* node, NodeVector& nodes)
-{
-    for (Node* child = node->firstChild(); child; child = child->nextSibling())
-        nodes.append(child);
-}
-
 static void collectTargetNodes(Node* node, NodeVector& nodes)
 {
     if (node->nodeType() != Node::DOCUMENT_FRAGMENT_NODE) {
         nodes.append(node);
         return;
     }
-    collectNodes(node, nodes);
+    getChildNodes(node, nodes);
 }
 
 void ContainerNode::removeAllChildren()
 {
     removeAllChildrenInContainer<Node, ContainerNode>(this);
 }
 
 void ContainerNode::takeAllChildrenFrom(ContainerNode* oldParent)
 {
     NodeVector children;
-    collectNodes(oldParent, children);
+    getChildNodes(oldParent, children);
     oldParent->removeAllChildren();
 
     for (unsigned i = 0; i < children.size(); ++i) {
         ExceptionCode ec = 0;
         if (children[i]->attached())
             children[i]->detach();
         // FIXME: We need a no mutation event version of adoptNode.
         RefPtr<Node> child = document()->adoptNode(children[i].release(), ec);
         ASSERT(!ec);
         parserAddChild(child.get());
@@ skipping 281 matching lines @@
 
     dispatchSubtreeModifiedEvent();
     return true;
 }
 
 void ContainerNode::willRemove()
 {
     RefPtr<Node> protect(this);
 
     NodeVector children;
-    collectNodes(this, children);
+    getChildNodes(this, children);
     for (size_t i = 0; i < children.size(); ++i) {
         if (children[i]->parentNode() != this) // Check for child being removed from subtree while removing.
             continue;
         children[i]->willRemove();
     }
 
     Node::willRemove();
 }
 
 static void willRemoveChild(Node* child)
 {
     // update auxiliary doc info (e.g. iterators) to note that node is being removed
     child->document()->nodeWillBeRemoved(child);
     child->document()->incDOMTreeVersion();
 
     // fire removed from document mutation events.
     dispatchChildRemovalEvents(child);
     child->willRemove();
 }
 
 static void willRemoveChildren(ContainerNode* container)
 {
     container->document()->nodeChildrenWillBeRemoved(container);
     container->document()->incDOMTreeVersion();
 
     NodeVector children;
-    collectNodes(container, children);
+    getChildNodes(container, children);
 
 #if ENABLE(MUTATION_OBSERVERS)
     ChildListMutationScope mutation(container);
 #endif
 
     for (NodeVector::const_iterator it = children.begin(); it != children.end(); it++) {
         Node* child = it->get();
         // fire removed from document mutation events.
         dispatchChildRemovalEvents(child);
         child->willRemove();
@@ skipping 379 matching lines @@
 }
 
 void ContainerNode::insertedIntoDocument()
 {
     RefPtr<Node> protect(this);
 
     Node::insertedIntoDocument();
     insertedIntoTree(false);
 
     NodeVector children;
-    collectNodes(this, children);
+    getChildNodes(this, children);
     for (size_t i = 0; i < children.size(); ++i) {
         // If we have been removed from the document during this loop, then
         // we don't want to tell the rest of our children that they've been
         // inserted into the document because they haven't.
         if (!inDocument())
             break;
         if (children[i]->parentNode() != this)
             continue;
         children[i]->insertedIntoDocument();
     }
 }
 
 void ContainerNode::removedFromDocument()
 {
     Node::removedFromDocument();
     if (document()->cssTarget() == this) 
         document()->setCSSTarget(0); 
     clearInDocument();
     removedFromTree(false);
 
     NodeVector children;
-    collectNodes(this, children);
+    getChildNodes(this, children);
     for (size_t i = 0; i < children.size(); ++i) {
         // If we have been added to the document during this loop, then we
         // don't want to tell the rest of our children that they've been
         // removed from the document because they haven't.
         if (inDocument())
             break;
         if (children[i]->parentNode() != this)
             continue;
         children[i]->removedFromDocument();
     }
@@ skipping 345 matching lines @@
     if (!document()->hasListenerType(Document::BEFORELOAD_LISTENER))
         return true;
 
     RefPtr<ContainerNode> protector(this);
     RefPtr<BeforeLoadEvent> beforeLoadEvent = BeforeLoadEvent::create(sourceURL);
     dispatchEvent(beforeLoadEvent.get());
     return !beforeLoadEvent->defaultPrevented();
 }
 
 } // namespace WebCore