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