c7a4798765d18e600b0383aca5c58c844c43dfaf
[WebKit-https.git] / Source / WebCore / dom / ContainerNode.cpp
1 /*
2  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
3  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
4  *           (C) 2001 Dirk Mueller (mueller@kde.org)
5  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 Apple Inc. All rights reserved.
6  *
7  * This library is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Library General Public
9  * License as published by the Free Software Foundation; either
10  * version 2 of the License, or (at your option) any later version.
11  *
12  * This library is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Library General Public License for more details.
16  *
17  * You should have received a copy of the GNU Library General Public License
18  * along with this library; see the file COPYING.LIB.  If not, write to
19  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
20  * Boston, MA 02110-1301, USA.
21  */
22
23 #include "config.h"
24 #include "ContainerNode.h"
25
26 #include "AXObjectCache.h"
27 #include "ChildListMutationScope.h"
28 #include "Chrome.h"
29 #include "ChromeClient.h"
30 #include "ContainerNodeAlgorithms.h"
31 #include "Editor.h"
32 #include "EventNames.h"
33 #include "ExceptionCode.h"
34 #include "FloatRect.h"
35 #include "Frame.h"
36 #include "FrameView.h"
37 #include "HTMLNames.h"
38 #include "InlineTextBox.h"
39 #include "InsertionPoint.h"
40 #include "InspectorInstrumentation.h"
41 #include "JSNode.h"
42 #include "LoaderStrategy.h"
43 #include "MemoryCache.h"
44 #include "MutationEvent.h"
45 #include "NodeRenderStyle.h"
46 #include "NodeTraversal.h"
47 #include "Page.h"
48 #include "PlatformStrategies.h"
49 #include "RenderBox.h"
50 #include "RenderTheme.h"
51 #include "RenderWidget.h"
52 #include "ResourceLoadScheduler.h"
53 #include "RootInlineBox.h"
54 #include "TemplateContentDocumentFragment.h"
55 #include "Text.h"
56 #include <wtf/CurrentTime.h>
57 #include <wtf/Vector.h>
58
59 #if ENABLE(DELETION_UI)
60 #include "DeleteButtonController.h"
61 #endif
62
63 using namespace std;
64
65 namespace WebCore {
66
67 static void dispatchChildInsertionEvents(Node*);
68 static void dispatchChildRemovalEvents(Node*);
69 static void updateTreeAfterInsertion(ContainerNode*, Node*, AttachBehavior);
70
71 typedef pair<RefPtr<Node>, unsigned> CallbackParameters;
72 typedef pair<NodeCallback, CallbackParameters> CallbackInfo;
73 typedef Vector<CallbackInfo> NodeCallbackQueue;
74
75 static NodeCallbackQueue* s_postAttachCallbackQueue;
76
77 static size_t s_attachDepth;
78 static bool s_shouldReEnableMemoryCacheCallsAfterAttach;
79
80 ChildNodesLazySnapshot* ChildNodesLazySnapshot::latestSnapshot = 0;
81
82 #ifndef NDEBUG
83 unsigned NoEventDispatchAssertion::s_count = 0;
84 #endif
85
86 static void collectChildrenAndRemoveFromOldParent(Node* node, NodeVector& nodes, ExceptionCode& ec)
87 {
88     if (node->nodeType() != Node::DOCUMENT_FRAGMENT_NODE) {
89         nodes.append(node);
90         if (ContainerNode* oldParent = node->parentNode())
91             oldParent->removeChild(node, ec);
92         return;
93     }
94     getChildNodes(node, nodes);
95     toContainerNode(node)->removeChildren();
96 }
97
98 void ContainerNode::removeDetachedChildren()
99 {
100     if (connectedSubframeCount()) {
101         for (Node* child = firstChild(); child; child = child->nextSibling())
102             child->updateAncestorConnectedSubframeCountForRemoval();
103     }
104     // FIXME: We should be able to ASSERT(!attached()) here: https://bugs.webkit.org/show_bug.cgi?id=107801
105     removeDetachedChildrenInContainer<Node, ContainerNode>(this);
106 }
107
108 static inline void attachChild(Node* child)
109 {
110     if (child->isElementNode())
111         Style::attachRenderTree(*toElement(child));
112     else if (child->isTextNode())
113         Style::attachTextRenderer(*toText(child));
114 }
115
116 static inline void detachChild(Node* child)
117 {
118     if (child->isElementNode())
119         Style::detachRenderTree(*toElement(child));
120     else if (child->isTextNode())
121         Style::detachTextRenderer(*toText(child));
122 }
123
124 void ContainerNode::takeAllChildrenFrom(ContainerNode* oldParent)
125 {
126     NodeVector children;
127     getChildNodes(oldParent, children);
128
129     if (oldParent->document().hasMutationObserversOfType(MutationObserver::ChildList)) {
130         ChildListMutationScope mutation(oldParent);
131         for (unsigned i = 0; i < children.size(); ++i)
132             mutation.willRemoveChild(children[i].get());
133     }
134
135     // FIXME: We need to do notifyMutationObserversNodeWillDetach() for each child,
136     // probably inside removeDetachedChildrenInContainer.
137
138     oldParent->removeDetachedChildren();
139
140     for (unsigned i = 0; i < children.size(); ++i) {
141         Node* child = children[i].get();
142         if (child->attached())
143             detachChild(child);
144         // FIXME: We need a no mutation event version of adoptNode.
145         RefPtr<Node> adoptedChild = document().adoptNode(children[i].release(), ASSERT_NO_EXCEPTION);
146         parserAppendChild(adoptedChild.get());
147         // FIXME: Together with adoptNode above, the tree scope might get updated recursively twice
148         // (if the document changed or oldParent was in a shadow tree, AND *this is in a shadow tree).
149         // Can we do better?
150         treeScope()->adoptIfNeeded(adoptedChild.get());
151         if (attached() && !adoptedChild->attached())
152             attachChild(adoptedChild.get());
153     }
154 }
155
156 ContainerNode::~ContainerNode()
157 {
158     if (Document* document = documentInternal())
159         willBeDeletedFrom(document);
160     removeDetachedChildren();
161 }
162
163 static inline bool isChildTypeAllowed(ContainerNode* newParent, Node* child)
164 {
165     if (!child->isDocumentFragment())
166         return newParent->childTypeAllowed(child->nodeType());
167
168     for (Node* node = child->firstChild(); node; node = node->nextSibling()) {
169         if (!newParent->childTypeAllowed(node->nodeType()))
170             return false;
171     }
172     return true;
173 }
174
175 static inline bool isInTemplateContent(const Node* node)
176 {
177 #if ENABLE(TEMPLATE_ELEMENT)
178     Document& document = node->document();
179     return &document == document.templateDocument();
180 #else
181     UNUSED_PARAM(node);
182     return false;
183 #endif
184 }
185
186 static inline bool containsConsideringHostElements(const Node* newChild, const Node* newParent)
187 {
188     return (newParent->isInShadowTree() || isInTemplateContent(newParent))
189         ? newChild->containsIncludingHostElements(newParent)
190         : newChild->contains(newParent);
191 }
192
193 static inline ExceptionCode checkAcceptChild(ContainerNode* newParent, Node* newChild, Node* oldChild)
194 {
195     // Not mentioned in spec: throw NOT_FOUND_ERR if newChild is null
196     if (!newChild)
197         return NOT_FOUND_ERR;
198
199     // Use common case fast path if possible.
200     if ((newChild->isElementNode() || newChild->isTextNode()) && newParent->isElementNode()) {
201         ASSERT(!newParent->isReadOnlyNode());
202         ASSERT(!newParent->isDocumentTypeNode());
203         ASSERT(isChildTypeAllowed(newParent, newChild));
204         if (containsConsideringHostElements(newChild, newParent))
205             return HIERARCHY_REQUEST_ERR;
206         return 0;
207     }
208
209     // This should never happen, but also protect release builds from tree corruption.
210     ASSERT(!newChild->isPseudoElement());
211     if (newChild->isPseudoElement())
212         return HIERARCHY_REQUEST_ERR;
213
214     if (newParent->isReadOnlyNode())
215         return NO_MODIFICATION_ALLOWED_ERR;
216     if (containsConsideringHostElements(newChild, newParent))
217         return HIERARCHY_REQUEST_ERR;
218
219     if (oldChild && newParent->isDocumentNode()) {
220         if (!toDocument(newParent)->canReplaceChild(newChild, oldChild))
221             return HIERARCHY_REQUEST_ERR;
222     } else if (!isChildTypeAllowed(newParent, newChild))
223         return HIERARCHY_REQUEST_ERR;
224
225     return 0;
226 }
227
228 static inline bool checkAcceptChildGuaranteedNodeTypes(ContainerNode* newParent, Node* newChild, ExceptionCode& ec)
229 {
230     ASSERT(!newParent->isReadOnlyNode());
231     ASSERT(!newParent->isDocumentTypeNode());
232     ASSERT(isChildTypeAllowed(newParent, newChild));
233     if (newChild->contains(newParent)) {
234         ec = HIERARCHY_REQUEST_ERR;
235         return false;
236     }
237
238     return true;
239 }
240
241 static inline bool checkAddChild(ContainerNode* newParent, Node* newChild, ExceptionCode& ec)
242 {
243     ec = checkAcceptChild(newParent, newChild, 0);
244     if (ec)
245         return false;
246
247     return true;
248 }
249
250 static inline bool checkReplaceChild(ContainerNode* newParent, Node* newChild, Node* oldChild, ExceptionCode& ec)
251 {
252     ec = checkAcceptChild(newParent, newChild, oldChild);
253     if (ec)
254         return false;
255
256     return true;
257 }
258
259 bool ContainerNode::insertBefore(PassRefPtr<Node> newChild, Node* refChild, ExceptionCode& ec, AttachBehavior attachBehavior)
260 {
261     // Check that this node is not "floating".
262     // If it is, it can be deleted as a side effect of sending mutation events.
263     ASSERT(refCount() || parentOrShadowHostNode());
264
265     RefPtr<Node> protect(this);
266
267     ec = 0;
268
269     // insertBefore(node, 0) is equivalent to appendChild(node)
270     if (!refChild)
271         return appendChild(newChild, ec, attachBehavior);
272
273     // Make sure adding the new child is OK.
274     if (!checkAddChild(this, newChild.get(), ec))
275         return false;
276
277     // NOT_FOUND_ERR: Raised if refChild is not a child of this node
278     if (refChild->parentNode() != this) {
279         ec = NOT_FOUND_ERR;
280         return false;
281     }
282
283     if (refChild->previousSibling() == newChild || refChild == newChild) // nothing to do
284         return true;
285
286     RefPtr<Node> next = refChild;
287
288     NodeVector targets;
289     collectChildrenAndRemoveFromOldParent(newChild.get(), targets, ec);
290     if (ec)
291         return false;
292     if (targets.isEmpty())
293         return true;
294
295     // We need this extra check because collectChildrenAndRemoveFromOldParent() can fire mutation events.
296     if (!checkAcceptChildGuaranteedNodeTypes(this, newChild.get(), ec))
297         return false;
298
299     InspectorInstrumentation::willInsertDOMNode(&document(), this);
300
301     ChildListMutationScope mutation(this);
302     for (NodeVector::const_iterator it = targets.begin(); it != targets.end(); ++it) {
303         Node* child = it->get();
304
305         // Due to arbitrary code running in response to a DOM mutation event it's
306         // possible that "next" is no longer a child of "this".
307         // It's also possible that "child" has been inserted elsewhere.
308         // In either of those cases, we'll just stop.
309         if (next->parentNode() != this)
310             break;
311         if (child->parentNode())
312             break;
313
314         treeScope()->adoptIfNeeded(child);
315
316         insertBeforeCommon(next.get(), child);
317
318         updateTreeAfterInsertion(this, child, attachBehavior);
319     }
320
321     dispatchSubtreeModifiedEvent();
322     return true;
323 }
324
325 void ContainerNode::insertBeforeCommon(Node* nextChild, Node* newChild)
326 {
327     NoEventDispatchAssertion assertNoEventDispatch;
328
329     ASSERT(newChild);
330     ASSERT(!newChild->parentNode()); // Use insertBefore if you need to handle reparenting (and want DOM mutation events).
331     ASSERT(!newChild->nextSibling());
332     ASSERT(!newChild->previousSibling());
333     ASSERT(!newChild->isShadowRoot());
334
335     Node* prev = nextChild->previousSibling();
336     ASSERT(m_lastChild != prev);
337     nextChild->setPreviousSibling(newChild);
338     if (prev) {
339         ASSERT(m_firstChild != nextChild);
340         ASSERT(prev->nextSibling() == nextChild);
341         prev->setNextSibling(newChild);
342     } else {
343         ASSERT(m_firstChild == nextChild);
344         m_firstChild = newChild;
345     }
346     newChild->setParentNode(this);
347     newChild->setPreviousSibling(prev);
348     newChild->setNextSibling(nextChild);
349 }
350
351 void ContainerNode::parserInsertBefore(PassRefPtr<Node> newChild, Node* nextChild)
352 {
353     ASSERT(newChild);
354     ASSERT(nextChild);
355     ASSERT(nextChild->parentNode() == this);
356     ASSERT(!newChild->isDocumentFragment());
357 #if ENABLE(TEMPLATE_ELEMENT)
358     ASSERT(!hasTagName(HTMLNames::templateTag));
359 #endif
360
361     if (nextChild->previousSibling() == newChild || nextChild == newChild) // nothing to do
362         return;
363
364     if (&document() != &newChild->document())
365         document().adoptNode(newChild.get(), ASSERT_NO_EXCEPTION);
366
367     insertBeforeCommon(nextChild, newChild.get());
368
369     newChild->updateAncestorConnectedSubframeCountForInsertion();
370
371     ChildListMutationScope(this).childAdded(newChild.get());
372
373     childrenChanged(true, newChild->previousSibling(), nextChild, 1);
374     ChildNodeInsertionNotifier(this).notify(newChild.get());
375 }
376
377 bool ContainerNode::replaceChild(PassRefPtr<Node> newChild, Node* oldChild, ExceptionCode& ec, AttachBehavior attachBehavior)
378 {
379     // Check that this node is not "floating".
380     // If it is, it can be deleted as a side effect of sending mutation events.
381     ASSERT(refCount() || parentOrShadowHostNode());
382
383     RefPtr<Node> protect(this);
384
385     ec = 0;
386
387     if (oldChild == newChild) // nothing to do
388         return true;
389
390     if (!oldChild) {
391         ec = NOT_FOUND_ERR;
392         return false;
393     }
394
395     // Make sure replacing the old child with the new is ok
396     if (!checkReplaceChild(this, newChild.get(), oldChild, ec))
397         return false;
398
399     // NOT_FOUND_ERR: Raised if oldChild is not a child of this node.
400     if (oldChild->parentNode() != this) {
401         ec = NOT_FOUND_ERR;
402         return false;
403     }
404
405     ChildListMutationScope mutation(this);
406
407     RefPtr<Node> next = oldChild->nextSibling();
408
409     // Remove the node we're replacing
410     RefPtr<Node> removedChild = oldChild;
411     removeChild(oldChild, ec);
412     if (ec)
413         return false;
414
415     if (next && (next->previousSibling() == newChild || next == newChild)) // nothing to do
416         return true;
417
418     // Does this one more time because removeChild() fires a MutationEvent.
419     if (!checkReplaceChild(this, newChild.get(), oldChild, ec))
420         return false;
421
422     NodeVector targets;
423     collectChildrenAndRemoveFromOldParent(newChild.get(), targets, ec);
424     if (ec)
425         return false;
426
427     // Does this yet another check because collectChildrenAndRemoveFromOldParent() fires a MutationEvent.
428     if (!checkReplaceChild(this, newChild.get(), oldChild, ec))
429         return false;
430
431     InspectorInstrumentation::willInsertDOMNode(&document(), this);
432
433     // Add the new child(ren)
434     for (NodeVector::const_iterator it = targets.begin(); it != targets.end(); ++it) {
435         Node* child = it->get();
436
437         // Due to arbitrary code running in response to a DOM mutation event it's
438         // possible that "next" is no longer a child of "this".
439         // It's also possible that "child" has been inserted elsewhere.
440         // In either of those cases, we'll just stop.
441         if (next && next->parentNode() != this)
442             break;
443         if (child->parentNode())
444             break;
445
446         treeScope()->adoptIfNeeded(child);
447
448         // Add child before "next".
449         {
450             NoEventDispatchAssertion assertNoEventDispatch;
451             if (next)
452                 insertBeforeCommon(next.get(), child);
453             else
454                 appendChildToContainer(child, this);
455         }
456
457         updateTreeAfterInsertion(this, child, attachBehavior);
458     }
459
460     dispatchSubtreeModifiedEvent();
461     return true;
462 }
463
464 static void willRemoveChild(Node* child)
465 {
466     ASSERT(child->parentNode());
467     ChildListMutationScope(child->parentNode()).willRemoveChild(child);
468     child->notifyMutationObserversNodeWillDetach();
469     dispatchChildRemovalEvents(child);
470     child->document().nodeWillBeRemoved(child); // e.g. mutation event listener can create a new range.
471     if (child->isContainerNode())
472         ChildFrameDisconnector(toContainerNode(child)).disconnect();
473 }
474
475 static void willRemoveChildren(ContainerNode* container)
476 {
477     NodeVector children;
478     getChildNodes(container, children);
479
480     container->document().nodeChildrenWillBeRemoved(container);
481
482     ChildListMutationScope mutation(container);
483     for (NodeVector::const_iterator it = children.begin(); it != children.end(); ++it) {
484         Node* child = it->get();
485         mutation.willRemoveChild(child);
486         child->notifyMutationObserversNodeWillDetach();
487
488         // fire removed from document mutation events.
489         dispatchChildRemovalEvents(child);
490     }
491
492     ChildFrameDisconnector(container).disconnect(ChildFrameDisconnector::DescendantsOnly);
493 }
494
495 void ContainerNode::disconnectDescendantFrames()
496 {
497     ChildFrameDisconnector(this).disconnect();
498 }
499
500 bool ContainerNode::removeChild(Node* oldChild, ExceptionCode& ec)
501 {
502     // Check that this node is not "floating".
503     // If it is, it can be deleted as a side effect of sending mutation events.
504     ASSERT(refCount() || parentOrShadowHostNode());
505
506     RefPtr<Node> protect(this);
507
508     ec = 0;
509
510     // NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.
511     if (isReadOnlyNode()) {
512         ec = NO_MODIFICATION_ALLOWED_ERR;
513         return false;
514     }
515
516     // NOT_FOUND_ERR: Raised if oldChild is not a child of this node.
517     if (!oldChild || oldChild->parentNode() != this) {
518         ec = NOT_FOUND_ERR;
519         return false;
520     }
521
522     RefPtr<Node> child = oldChild;
523
524     document().removeFocusedNodeOfSubtree(child.get());
525
526 #if ENABLE(FULLSCREEN_API)
527     document().removeFullScreenElementOfSubtree(child.get());
528 #endif
529
530     // Events fired when blurring currently focused node might have moved this
531     // child into a different parent.
532     if (child->parentNode() != this) {
533         ec = NOT_FOUND_ERR;
534         return false;
535     }
536
537     willRemoveChild(child.get());
538
539     // Mutation events might have moved this child into a different parent.
540     if (child->parentNode() != this) {
541         ec = NOT_FOUND_ERR;
542         return false;
543     }
544
545     {
546         WidgetHierarchyUpdatesSuspensionScope suspendWidgetHierarchyUpdates;
547
548         Node* prev = child->previousSibling();
549         Node* next = child->nextSibling();
550         removeBetween(prev, next, child.get());
551         childrenChanged(false, prev, next, -1);
552         ChildNodeRemovalNotifier(this).notify(child.get());
553     }
554     dispatchSubtreeModifiedEvent();
555
556     return child;
557 }
558
559 void ContainerNode::removeBetween(Node* previousChild, Node* nextChild, Node* oldChild)
560 {
561     NoEventDispatchAssertion assertNoEventDispatch;
562
563     ASSERT(oldChild);
564     ASSERT(oldChild->parentNode() == this);
565
566     // Remove from rendering tree
567     if (oldChild->attached())
568         detachChild(oldChild);
569
570     if (nextChild)
571         nextChild->setPreviousSibling(previousChild);
572     if (previousChild)
573         previousChild->setNextSibling(nextChild);
574     if (m_firstChild == oldChild)
575         m_firstChild = nextChild;
576     if (m_lastChild == oldChild)
577         m_lastChild = previousChild;
578
579     oldChild->setPreviousSibling(0);
580     oldChild->setNextSibling(0);
581     oldChild->setParentNode(0);
582
583     document().adoptIfNeeded(oldChild);
584 }
585
586 void ContainerNode::parserRemoveChild(Node* oldChild)
587 {
588     ASSERT(oldChild);
589     ASSERT(oldChild->parentNode() == this);
590     ASSERT(!oldChild->isDocumentFragment());
591
592     Node* prev = oldChild->previousSibling();
593     Node* next = oldChild->nextSibling();
594
595     oldChild->updateAncestorConnectedSubframeCountForRemoval();
596
597     ChildListMutationScope(this).willRemoveChild(oldChild);
598     oldChild->notifyMutationObserversNodeWillDetach();
599
600     removeBetween(prev, next, oldChild);
601
602     childrenChanged(true, prev, next, -1);
603     ChildNodeRemovalNotifier(this).notify(oldChild);
604 }
605
606 // this differs from other remove functions because it forcibly removes all the children,
607 // regardless of read-only status or event exceptions, e.g.
608 void ContainerNode::removeChildren()
609 {
610     if (!m_firstChild)
611         return;
612
613     // The container node can be removed from event handlers.
614     RefPtr<ContainerNode> protect(this);
615
616     // exclude this node when looking for removed focusedNode since only children will be removed
617     document().removeFocusedNodeOfSubtree(this, true);
618
619 #if ENABLE(FULLSCREEN_API)
620     document().removeFullScreenElementOfSubtree(this, true);
621 #endif
622
623     // Do any prep work needed before actually starting to detach
624     // and remove... e.g. stop loading frames, fire unload events.
625     willRemoveChildren(protect.get());
626
627     NodeVector removedChildren;
628     {
629         WidgetHierarchyUpdatesSuspensionScope suspendWidgetHierarchyUpdates;
630         {
631             NoEventDispatchAssertion assertNoEventDispatch;
632             removedChildren.reserveInitialCapacity(childNodeCount());
633             while (RefPtr<Node> n = m_firstChild) {
634                 removedChildren.append(m_firstChild);
635                 removeBetween(0, m_firstChild->nextSibling(), m_firstChild);
636             }
637         }
638
639         childrenChanged(false, 0, 0, -static_cast<int>(removedChildren.size()));
640         
641         for (size_t i = 0; i < removedChildren.size(); ++i)
642             ChildNodeRemovalNotifier(this).notify(removedChildren[i].get());
643     }
644
645     dispatchSubtreeModifiedEvent();
646 }
647
648 bool ContainerNode::appendChild(PassRefPtr<Node> newChild, ExceptionCode& ec, AttachBehavior attachBehavior)
649 {
650     RefPtr<ContainerNode> protect(this);
651
652     // Check that this node is not "floating".
653     // If it is, it can be deleted as a side effect of sending mutation events.
654     ASSERT(refCount() || parentOrShadowHostNode());
655
656     ec = 0;
657
658     // Make sure adding the new child is ok
659     if (!checkAddChild(this, newChild.get(), ec))
660         return false;
661
662     if (newChild == m_lastChild) // nothing to do
663         return newChild;
664
665     NodeVector targets;
666     collectChildrenAndRemoveFromOldParent(newChild.get(), targets, ec);
667     if (ec)
668         return false;
669
670     if (targets.isEmpty())
671         return true;
672
673     // We need this extra check because collectChildrenAndRemoveFromOldParent() can fire mutation events.
674     if (!checkAcceptChildGuaranteedNodeTypes(this, newChild.get(), ec))
675         return false;
676
677     InspectorInstrumentation::willInsertDOMNode(&document(), this);
678
679     // Now actually add the child(ren)
680     ChildListMutationScope mutation(this);
681     for (NodeVector::const_iterator it = targets.begin(); it != targets.end(); ++it) {
682         Node* child = it->get();
683
684         // If the child has a parent again, just stop what we're doing, because
685         // that means someone is doing something with DOM mutation -- can't re-parent
686         // a child that already has a parent.
687         if (child->parentNode())
688             break;
689
690         treeScope()->adoptIfNeeded(child);
691
692         // Append child to the end of the list
693         {
694             NoEventDispatchAssertion assertNoEventDispatch;
695             appendChildToContainer(child, this);
696         }
697
698         updateTreeAfterInsertion(this, child, attachBehavior);
699     }
700
701     dispatchSubtreeModifiedEvent();
702     return true;
703 }
704
705 void ContainerNode::parserAppendChild(PassRefPtr<Node> newChild)
706 {
707     ASSERT(newChild);
708     ASSERT(!newChild->parentNode()); // Use appendChild if you need to handle reparenting (and want DOM mutation events).
709     ASSERT(!newChild->isDocumentFragment());
710 #if ENABLE(TEMPLATE_ELEMENT)
711     ASSERT(!hasTagName(HTMLNames::templateTag));
712 #endif
713
714     if (&document() != &newChild->document())
715         document().adoptNode(newChild.get(), ASSERT_NO_EXCEPTION);
716
717     Node* last = m_lastChild;
718     {
719         NoEventDispatchAssertion assertNoEventDispatch;
720         // FIXME: This method should take a PassRefPtr.
721         appendChildToContainer(newChild.get(), this);
722         treeScope()->adoptIfNeeded(newChild.get());
723     }
724
725     newChild->updateAncestorConnectedSubframeCountForInsertion();
726
727     ChildListMutationScope(this).childAdded(newChild.get());
728
729     childrenChanged(true, last, 0, 1);
730     ChildNodeInsertionNotifier(this).notify(newChild.get());
731 }
732
733 void ContainerNode::suspendPostAttachCallbacks()
734 {
735     if (!s_attachDepth) {
736         ASSERT(!s_shouldReEnableMemoryCacheCallsAfterAttach);
737         if (Page* page = document().page()) {
738             // FIXME: How can this call be specific to one Page, while the
739             // s_attachDepth is a global? Doesn't make sense.
740             if (page->areMemoryCacheClientCallsEnabled()) {
741                 page->setMemoryCacheClientCallsEnabled(false);
742                 s_shouldReEnableMemoryCacheCallsAfterAttach = true;
743             }
744         }
745         platformStrategies()->loaderStrategy()->resourceLoadScheduler()->suspendPendingRequests();
746     }
747     ++s_attachDepth;
748 }
749
750 void ContainerNode::resumePostAttachCallbacks()
751 {
752     if (s_attachDepth == 1) {
753         RefPtr<ContainerNode> protect(this);
754
755         if (s_postAttachCallbackQueue)
756             dispatchPostAttachCallbacks();
757         if (s_shouldReEnableMemoryCacheCallsAfterAttach) {
758             s_shouldReEnableMemoryCacheCallsAfterAttach = false;
759             if (Page* page = document().page())
760                 page->setMemoryCacheClientCallsEnabled(true);
761         }
762         platformStrategies()->loaderStrategy()->resourceLoadScheduler()->resumePendingRequests();
763     }
764     --s_attachDepth;
765 }
766
767 void ContainerNode::queuePostAttachCallback(NodeCallback callback, Node* node, unsigned callbackData)
768 {
769     if (!s_postAttachCallbackQueue)
770         s_postAttachCallbackQueue = new NodeCallbackQueue;
771     
772     s_postAttachCallbackQueue->append(CallbackInfo(callback, CallbackParameters(node, callbackData)));
773 }
774
775 bool ContainerNode::postAttachCallbacksAreSuspended()
776 {
777     return s_attachDepth;
778 }
779
780 void ContainerNode::dispatchPostAttachCallbacks()
781 {
782     // We recalculate size() each time through the loop because a callback
783     // can add more callbacks to the end of the queue.
784     for (size_t i = 0; i < s_postAttachCallbackQueue->size(); ++i) {
785         const CallbackInfo& info = (*s_postAttachCallbackQueue)[i];
786         NodeCallback callback = info.first;
787         CallbackParameters params = info.second;
788
789         callback(params.first.get(), params.second);
790     }
791     s_postAttachCallbackQueue->clear();
792 }
793
794 static void needsStyleRecalcCallback(Node* node, unsigned data)
795 {
796     node->setNeedsStyleRecalc(static_cast<StyleChangeType>(data));
797 }
798
799 void ContainerNode::scheduleSetNeedsStyleRecalc(StyleChangeType changeType)
800 {
801     if (postAttachCallbacksAreSuspended())
802         queuePostAttachCallback(needsStyleRecalcCallback, this, static_cast<unsigned>(changeType));
803     else
804         setNeedsStyleRecalc(changeType);
805 }
806
807 void ContainerNode::childrenChanged(bool changedByParser, Node*, Node*, int childCountDelta)
808 {
809     document().incDOMTreeVersion();
810     if (!changedByParser && childCountDelta)
811         document().updateRangesAfterChildrenChanged(this);
812     invalidateNodeListCachesInAncestors();
813 }
814
815 inline static void cloneChildNodesAvoidingDeleteButton(ContainerNode* parent, ContainerNode* clonedParent, HTMLElement* deleteButtonContainerElement)
816 {
817     ExceptionCode ec = 0;
818     for (Node* child = parent->firstChild(); child && !ec; child = child->nextSibling()) {
819
820 #if ENABLE(DELETION_UI)
821         if (child == deleteButtonContainerElement)
822             continue;
823 #else
824         UNUSED_PARAM(deleteButtonContainerElement);
825 #endif
826
827         RefPtr<Node> clonedChild = child->cloneNode(false);
828         clonedParent->appendChild(clonedChild, ec);
829
830         if (!ec && child->isContainerNode())
831             cloneChildNodesAvoidingDeleteButton(toContainerNode(child), toContainerNode(clonedChild.get()), deleteButtonContainerElement);
832     }
833 }
834
835 void ContainerNode::cloneChildNodes(ContainerNode *clone)
836 {
837 #if ENABLE(DELETION_UI)
838     HTMLElement* deleteButtonContainerElement = 0;
839     if (Frame* frame = document().frame())
840         deleteButtonContainerElement = frame->editor().deleteButtonController()->containerElement();
841     cloneChildNodesAvoidingDeleteButton(this, clone, deleteButtonContainerElement);
842 #else
843     cloneChildNodesAvoidingDeleteButton(this, clone, 0);
844 #endif
845 }
846
847 bool ContainerNode::getUpperLeftCorner(FloatPoint& point) const
848 {
849     if (!renderer())
850         return false;
851     // What is this code really trying to do?
852     RenderObject* o = renderer();
853     RenderObject* p = o;
854
855     if (!o->isInline() || o->isReplaced()) {
856         point = o->localToAbsolute(FloatPoint(), UseTransforms);
857         return true;
858     }
859
860     // find the next text/image child, to get a position
861     while (o) {
862         p = o;
863         if (o->firstChild())
864             o = o->firstChild();
865         else if (o->nextSibling())
866             o = o->nextSibling();
867         else {
868             RenderObject* next = 0;
869             while (!next && o->parent()) {
870                 o = o->parent();
871                 next = o->nextSibling();
872             }
873             o = next;
874
875             if (!o)
876                 break;
877         }
878         ASSERT(o);
879
880         if (!o->isInline() || o->isReplaced()) {
881             point = o->localToAbsolute(FloatPoint(), UseTransforms);
882             return true;
883         }
884
885         if (p->node() && p->node() == this && o->isText() && !o->isBR() && !toRenderText(o)->firstTextBox()) {
886             // do nothing - skip unrendered whitespace that is a child or next sibling of the anchor
887         } else if ((o->isText() && !o->isBR()) || o->isReplaced()) {
888             point = FloatPoint();
889             if (o->isText() && toRenderText(o)->firstTextBox()) {
890                 point.move(toRenderText(o)->linesBoundingBox().x(), toRenderText(o)->firstTextBox()->root()->lineTop());
891             } else if (o->isBox()) {
892                 RenderBox* box = toRenderBox(o);
893                 point.moveBy(box->location());
894             }
895             point = o->container()->localToAbsolute(point, UseTransforms);
896             return true;
897         }
898     }
899     
900     // If the target doesn't have any children or siblings that could be used to calculate the scroll position, we must be
901     // at the end of the document. Scroll to the bottom. FIXME: who said anything about scrolling?
902     if (!o && document().view()) {
903         point = FloatPoint(0, document().view()->contentsHeight());
904         return true;
905     }
906     return false;
907 }
908
909 bool ContainerNode::getLowerRightCorner(FloatPoint& point) const
910 {
911     if (!renderer())
912         return false;
913
914     RenderObject* o = renderer();
915     if (!o->isInline() || o->isReplaced()) {
916         RenderBox* box = toRenderBox(o);
917         point = o->localToAbsolute(LayoutPoint(box->size()), UseTransforms);
918         return true;
919     }
920
921     // find the last text/image child, to get a position
922     while (o) {
923         if (o->lastChild())
924             o = o->lastChild();
925         else if (o->previousSibling())
926             o = o->previousSibling();
927         else {
928             RenderObject* prev = 0;
929             while (!prev) {
930                 o = o->parent();
931                 if (!o)
932                     return false;
933                 prev = o->previousSibling();
934             }
935             o = prev;
936         }
937         ASSERT(o);
938         if (o->isText() || o->isReplaced()) {
939             point = FloatPoint();
940             if (o->isText()) {
941                 RenderText* text = toRenderText(o);
942                 IntRect linesBox = text->linesBoundingBox();
943                 if (!linesBox.maxX() && !linesBox.maxY())
944                     continue;
945                 point.moveBy(linesBox.maxXMaxYCorner());
946             } else {
947                 RenderBox* box = toRenderBox(o);
948                 point.moveBy(box->frameRect().maxXMaxYCorner());
949             }
950             point = o->container()->localToAbsolute(point, UseTransforms);
951             return true;
952         }
953     }
954     return true;
955 }
956
957 LayoutRect ContainerNode::boundingBox() const
958 {
959     FloatPoint upperLeft, lowerRight;
960     bool foundUpperLeft = getUpperLeftCorner(upperLeft);
961     bool foundLowerRight = getLowerRightCorner(lowerRight);
962     
963     // If we've found one corner, but not the other,
964     // then we should just return a point at the corner that we did find.
965     if (foundUpperLeft != foundLowerRight) {
966         if (foundUpperLeft)
967             lowerRight = upperLeft;
968         else
969             upperLeft = lowerRight;
970     } 
971
972     return enclosingLayoutRect(FloatRect(upperLeft, lowerRight.expandedTo(upperLeft) - upperLeft));
973 }
974
975 unsigned ContainerNode::childNodeCount() const
976 {
977     unsigned count = 0;
978     Node *n;
979     for (n = firstChild(); n; n = n->nextSibling())
980         count++;
981     return count;
982 }
983
984 Node *ContainerNode::childNode(unsigned index) const
985 {
986     unsigned i;
987     Node *n = firstChild();
988     for (i = 0; n != 0 && i < index; i++)
989         n = n->nextSibling();
990     return n;
991 }
992
993 static void dispatchChildInsertionEvents(Node* child)
994 {
995     if (child->isInShadowTree())
996         return;
997
998     ASSERT(!NoEventDispatchAssertion::isEventDispatchForbidden());
999
1000     RefPtr<Node> c = child;
1001     RefPtr<Document> document = &child->document();
1002
1003     if (c->parentNode() && document->hasListenerType(Document::DOMNODEINSERTED_LISTENER))
1004         c->dispatchScopedEvent(MutationEvent::create(eventNames().DOMNodeInsertedEvent, true, c->parentNode()));
1005
1006     // dispatch the DOMNodeInsertedIntoDocument event to all descendants
1007     if (c->inDocument() && document->hasListenerType(Document::DOMNODEINSERTEDINTODOCUMENT_LISTENER)) {
1008         for (; c; c = NodeTraversal::next(c.get(), child))
1009             c->dispatchScopedEvent(MutationEvent::create(eventNames().DOMNodeInsertedIntoDocumentEvent, false));
1010     }
1011 }
1012
1013 static void dispatchChildRemovalEvents(Node* child)
1014 {
1015     if (child->isInShadowTree()) {
1016         InspectorInstrumentation::willRemoveDOMNode(&child->document(), child);
1017         return;
1018     }
1019
1020     ASSERT(!NoEventDispatchAssertion::isEventDispatchForbidden());
1021
1022     willCreatePossiblyOrphanedTreeByRemoval(child);
1023     InspectorInstrumentation::willRemoveDOMNode(&child->document(), child);
1024
1025     RefPtr<Node> c = child;
1026     RefPtr<Document> document = &child->document();
1027
1028     // dispatch pre-removal mutation events
1029     if (c->parentNode() && document->hasListenerType(Document::DOMNODEREMOVED_LISTENER))
1030         c->dispatchScopedEvent(MutationEvent::create(eventNames().DOMNodeRemovedEvent, true, c->parentNode()));
1031
1032     // dispatch the DOMNodeRemovedFromDocument event to all descendants
1033     if (c->inDocument() && document->hasListenerType(Document::DOMNODEREMOVEDFROMDOCUMENT_LISTENER)) {
1034         for (; c; c = NodeTraversal::next(c.get(), child))
1035             c->dispatchScopedEvent(MutationEvent::create(eventNames().DOMNodeRemovedFromDocumentEvent, false));
1036     }
1037 }
1038
1039 static void updateTreeAfterInsertion(ContainerNode* parent, Node* child, AttachBehavior attachBehavior)
1040 {
1041     ASSERT(parent->refCount());
1042     ASSERT(child->refCount());
1043
1044     ChildListMutationScope(parent).childAdded(child);
1045
1046     parent->childrenChanged(false, child->previousSibling(), child->nextSibling(), 1);
1047
1048     ChildNodeInsertionNotifier(parent).notify(child);
1049
1050     // FIXME: Attachment should be the first operation in this function, but some code
1051     // (for example, HTMLFormControlElement's autofocus support) requires this ordering.
1052     if (parent->attached() && !child->attached() && child->parentNode() == parent) {
1053         if (attachBehavior == AttachLazily) {
1054             if (child->isElementNode())
1055                 toElement(child)->lazyAttach();
1056             else if (child->isTextNode()) {
1057                 child->setAttached(true);
1058                 child->setNeedsStyleRecalc();
1059             }
1060         } else
1061             attachChild(child);
1062     }
1063
1064     dispatchChildInsertionEvents(child);
1065 }
1066
1067 } // namespace WebCore