3e199c0803d9f6fa1af3fcb063935b95e8f36161
[WebKit-https.git] / Source / WebCore / dom / Node.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, 2014 Apple Inc. All rights reserved.
6  * Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies)
7  * Copyright (C) 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
8  *
9  * This library is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU Library General Public
11  * License as published by the Free Software Foundation; either
12  * version 2 of the License, or (at your option) any later version.
13  *
14  * This library is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17  * Library General Public License for more details.
18  *
19  * You should have received a copy of the GNU Library General Public License
20  * along with this library; see the file COPYING.LIB.  If not, write to
21  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
22  * Boston, MA 02110-1301, USA.
23  */
24
25 #include "config.h"
26 #include "Node.h"
27
28 #include "AXObjectCache.h"
29 #include "Attr.h"
30 #include "BeforeLoadEvent.h"
31 #include "ChildListMutationScope.h"
32 #include "Chrome.h"
33 #include "ChromeClient.h"
34 #include "CSSParser.h"
35 #include "CSSRule.h"
36 #include "CSSSelector.h"
37 #include "CSSSelectorList.h"
38 #include "CSSStyleRule.h"
39 #include "CSSStyleSheet.h"
40 #include "ContainerNodeAlgorithms.h"
41 #include "ContextMenuController.h"
42 #include "DOMImplementation.h"
43 #include "DocumentType.h"
44 #include "ElementIterator.h"
45 #include "ElementRareData.h"
46 #include "EventDispatcher.h"
47 #include "EventException.h"
48 #include "EventHandler.h"
49 #include "FlowThreadController.h"
50 #include "FrameView.h"
51 #include "HTMLCollection.h"
52 #include "HTMLElement.h"
53 #include "HTMLImageElement.h"
54 #include "HTMLStyleElement.h"
55 #include "InsertionPoint.h"
56 #include "KeyboardEvent.h"
57 #include "Logging.h"
58 #include "MutationEvent.h"
59 #include "NodeRenderStyle.h"
60 #include "PlatformMouseEvent.h"
61 #include "PlatformWheelEvent.h"
62 #include "ProcessingInstruction.h"
63 #include "ProgressEvent.h"
64 #include "Range.h"
65 #include "RenderBlock.h"
66 #include "RenderBox.h"
67 #include "RenderTextControl.h"
68 #include "RenderView.h"
69 #include "ScopedEventQueue.h"
70 #include "Settings.h"
71 #include "StorageEvent.h"
72 #include "StyleResolver.h"
73 #include "TemplateContentDocumentFragment.h"
74 #include "TextEvent.h"
75 #include "TouchEvent.h"
76 #include "TreeScopeAdopter.h"
77 #include "WheelEvent.h"
78 #include "XMLNames.h"
79 #include "htmlediting.h"
80 #include <runtime/JSCInlines.h>
81 #include <runtime/VM.h>
82 #include <wtf/RefCountedLeakCounter.h>
83 #include <wtf/text/CString.h>
84 #include <wtf/text/StringBuilder.h>
85
86 #if ENABLE(INDIE_UI)
87 #include "UIRequestEvent.h"
88 #endif
89
90 #if ENABLE(INSPECTOR)
91 #include "InspectorController.h"
92 #endif
93
94 namespace WebCore {
95
96 using namespace HTMLNames;
97
98 bool Node::isSupported(const String& feature, const String& version)
99 {
100     return DOMImplementation::hasFeature(feature, version);
101 }
102
103 #if DUMP_NODE_STATISTICS
104 static HashSet<Node*> liveNodeSet;
105 #endif
106
107 void Node::dumpStatistics()
108 {
109 #if DUMP_NODE_STATISTICS
110     size_t nodesWithRareData = 0;
111
112     size_t elementNodes = 0;
113     size_t attrNodes = 0;
114     size_t textNodes = 0;
115     size_t cdataNodes = 0;
116     size_t commentNodes = 0;
117     size_t entityReferenceNodes = 0;
118     size_t entityNodes = 0;
119     size_t piNodes = 0;
120     size_t documentNodes = 0;
121     size_t docTypeNodes = 0;
122     size_t fragmentNodes = 0;
123     size_t notationNodes = 0;
124     size_t xpathNSNodes = 0;
125     size_t shadowRootNodes = 0;
126
127     HashMap<String, size_t> perTagCount;
128
129     size_t attributes = 0;
130     size_t attributesWithAttr = 0;
131     size_t elementsWithAttributeStorage = 0;
132     size_t elementsWithRareData = 0;
133     size_t elementsWithNamedNodeMap = 0;
134
135     for (HashSet<Node*>::iterator it = liveNodeSet.begin(); it != liveNodeSet.end(); ++it) {
136         Node* node = *it;
137
138         if (node->hasRareData()) {
139             ++nodesWithRareData;
140             if (is<Element>(*node)) {
141                 ++elementsWithRareData;
142                 if (downcast<Element>(*node).hasNamedNodeMap())
143                     ++elementsWithNamedNodeMap;
144             }
145         }
146
147         switch (node->nodeType()) {
148             case ELEMENT_NODE: {
149                 ++elementNodes;
150
151                 // Tag stats
152                 Element& element = downcast<Element>(*node);
153                 HashMap<String, size_t>::AddResult result = perTagCount.add(element.tagName(), 1);
154                 if (!result.isNewEntry)
155                     result.iterator->value++;
156
157                 if (ElementData* elementData = element.elementData()) {
158                     unsigned length = elementData->length();
159                     attributes += length;
160                     ++elementsWithAttributeStorage;
161                     for (unsigned i = 0; i < length; ++i) {
162                         Attribute& attr = elementData->attributeAt(i);
163                         if (attr.attr())
164                             ++attributesWithAttr;
165                     }
166                 }
167                 break;
168             }
169             case ATTRIBUTE_NODE: {
170                 ++attrNodes;
171                 break;
172             }
173             case TEXT_NODE: {
174                 ++textNodes;
175                 break;
176             }
177             case CDATA_SECTION_NODE: {
178                 ++cdataNodes;
179                 break;
180             }
181             case COMMENT_NODE: {
182                 ++commentNodes;
183                 break;
184             }
185             case ENTITY_REFERENCE_NODE: {
186                 ++entityReferenceNodes;
187                 break;
188             }
189             case ENTITY_NODE: {
190                 ++entityNodes;
191                 break;
192             }
193             case PROCESSING_INSTRUCTION_NODE: {
194                 ++piNodes;
195                 break;
196             }
197             case DOCUMENT_NODE: {
198                 ++documentNodes;
199                 break;
200             }
201             case DOCUMENT_TYPE_NODE: {
202                 ++docTypeNodes;
203                 break;
204             }
205             case DOCUMENT_FRAGMENT_NODE: {
206                 if (node->isShadowRoot())
207                     ++shadowRootNodes;
208                 else
209                     ++fragmentNodes;
210                 break;
211             }
212             case NOTATION_NODE: {
213                 ++notationNodes;
214                 break;
215             }
216             case XPATH_NAMESPACE_NODE: {
217                 ++xpathNSNodes;
218                 break;
219             }
220         }
221     }
222
223     printf("Number of Nodes: %d\n\n", liveNodeSet.size());
224     printf("Number of Nodes with RareData: %zu\n\n", nodesWithRareData);
225
226     printf("NodeType distribution:\n");
227     printf("  Number of Element nodes: %zu\n", elementNodes);
228     printf("  Number of Attribute nodes: %zu\n", attrNodes);
229     printf("  Number of Text nodes: %zu\n", textNodes);
230     printf("  Number of CDATASection nodes: %zu\n", cdataNodes);
231     printf("  Number of Comment nodes: %zu\n", commentNodes);
232     printf("  Number of EntityReference nodes: %zu\n", entityReferenceNodes);
233     printf("  Number of Entity nodes: %zu\n", entityNodes);
234     printf("  Number of ProcessingInstruction nodes: %zu\n", piNodes);
235     printf("  Number of Document nodes: %zu\n", documentNodes);
236     printf("  Number of DocumentType nodes: %zu\n", docTypeNodes);
237     printf("  Number of DocumentFragment nodes: %zu\n", fragmentNodes);
238     printf("  Number of Notation nodes: %zu\n", notationNodes);
239     printf("  Number of XPathNS nodes: %zu\n", xpathNSNodes);
240     printf("  Number of ShadowRoot nodes: %zu\n", shadowRootNodes);
241
242     printf("Element tag name distibution:\n");
243     for (HashMap<String, size_t>::iterator it = perTagCount.begin(); it != perTagCount.end(); ++it)
244         printf("  Number of <%s> tags: %zu\n", it->key.utf8().data(), it->value);
245
246     printf("Attributes:\n");
247     printf("  Number of Attributes (non-Node and Node): %zu [%zu]\n", attributes, sizeof(Attribute));
248     printf("  Number of Attributes with an Attr: %zu\n", attributesWithAttr);
249     printf("  Number of Elements with attribute storage: %zu [%zu]\n", elementsWithAttributeStorage, sizeof(ElementData));
250     printf("  Number of Elements with RareData: %zu\n", elementsWithRareData);
251     printf("  Number of Elements with NamedNodeMap: %zu [%zu]\n", elementsWithNamedNodeMap, sizeof(NamedNodeMap));
252 #endif
253 }
254
255 DEFINE_DEBUG_ONLY_GLOBAL(WTF::RefCountedLeakCounter, nodeCounter, ("WebCoreNode"));
256
257 #ifndef NDEBUG
258 static bool shouldIgnoreLeaks = false;
259
260 static HashSet<Node*>& ignoreSet()
261 {
262     static NeverDestroyed<HashSet<Node*>> ignore;
263
264     return ignore;
265 }
266
267 #endif
268
269 void Node::startIgnoringLeaks()
270 {
271 #ifndef NDEBUG
272     shouldIgnoreLeaks = true;
273 #endif
274 }
275
276 void Node::stopIgnoringLeaks()
277 {
278 #ifndef NDEBUG
279     shouldIgnoreLeaks = false;
280 #endif
281 }
282
283 void Node::trackForDebugging()
284 {
285 #ifndef NDEBUG
286     if (shouldIgnoreLeaks)
287         ignoreSet().add(this);
288     else
289         nodeCounter.increment();
290 #endif
291
292 #if DUMP_NODE_STATISTICS
293     liveNodeSet.add(this);
294 #endif
295 }
296
297 Node::Node(Document& document, ConstructionType type)
298     : m_nodeFlags(type)
299     , m_parentNode(nullptr)
300     , m_treeScope(&document)
301     , m_previous(nullptr)
302     , m_next(nullptr)
303 {
304     document.incrementReferencingNodeCount();
305
306 #if !defined(NDEBUG) || (defined(DUMP_NODE_STATISTICS) && DUMP_NODE_STATISTICS)
307     trackForDebugging();
308 #endif
309 }
310
311 Node::~Node()
312 {
313 #ifndef NDEBUG
314     if (!ignoreSet().remove(this))
315         nodeCounter.decrement();
316 #endif
317
318 #if DUMP_NODE_STATISTICS
319     liveNodeSet.remove(this);
320 #endif
321
322     ASSERT(!renderer());
323     ASSERT(!parentNode());
324     ASSERT(!m_previous);
325     ASSERT(!m_next);
326
327     if (hasRareData())
328         clearRareData();
329
330     if (!isContainerNode())
331         willBeDeletedFrom(document());
332
333     document().decrementReferencingNodeCount();
334 }
335
336 void Node::willBeDeletedFrom(Document& document)
337 {
338     if (hasEventTargetData()) {
339 #if ENABLE(TOUCH_EVENTS) && PLATFORM(IOS)
340         document.removeTouchEventListener(this, true);
341 #endif
342         clearEventTargetData();
343     }
344
345     if (AXObjectCache* cache = document.existingAXObjectCache())
346         cache->remove(this);
347 }
348
349 void Node::materializeRareData()
350 {
351     NodeRareData* data;
352     if (is<Element>(*this))
353         data = std::make_unique<ElementRareData>(downcast<Element>(*this), downcast<RenderElement>(m_data.m_renderer)).release();
354     else
355         data = std::make_unique<NodeRareData>(m_data.m_renderer).release();
356     ASSERT(data);
357
358     m_data.m_rareData = data;
359     setFlag(HasRareDataFlag);
360 }
361
362 void Node::clearRareData()
363 {
364     ASSERT(hasRareData());
365     ASSERT(!transientMutationObserverRegistry() || transientMutationObserverRegistry()->isEmpty());
366
367     RenderObject* renderer = m_data.m_rareData->renderer();
368     if (isElementNode())
369         delete static_cast<ElementRareData*>(m_data.m_rareData);
370     else
371         delete static_cast<NodeRareData*>(m_data.m_rareData);
372     m_data.m_renderer = renderer;
373     clearFlag(HasRareDataFlag);
374 }
375
376 Node* Node::toNode()
377 {
378     return this;
379 }
380
381 HTMLInputElement* Node::toInputElement()
382 {
383     // If one of the below ASSERTs trigger, you are calling this function
384     // directly or indirectly from a constructor or destructor of this object.
385     // Don't do this!
386     ASSERT(!(isHTMLElement() && hasTagName(inputTag)));
387     return 0;
388 }
389
390 String Node::nodeValue() const
391 {
392     return String();
393 }
394
395 void Node::setNodeValue(const String& /*nodeValue*/, ExceptionCode& ec)
396 {
397     // NO_MODIFICATION_ALLOWED_ERR: Raised when the node is readonly
398     if (isReadOnlyNode()) {
399         ec = NO_MODIFICATION_ALLOWED_ERR;
400         return;
401     }
402
403     // By default, setting nodeValue has no effect.
404 }
405
406 RefPtr<NodeList> Node::childNodes()
407 {
408     if (is<ContainerNode>(*this))
409         return ensureRareData().ensureNodeLists().ensureChildNodeList(downcast<ContainerNode>(*this));
410     return ensureRareData().ensureNodeLists().ensureEmptyChildNodeList(*this);
411 }
412
413 Node *Node::lastDescendant() const
414 {
415     Node *n = const_cast<Node *>(this);
416     while (n && n->lastChild())
417         n = n->lastChild();
418     return n;
419 }
420
421 Node* Node::firstDescendant() const
422 {
423     Node *n = const_cast<Node *>(this);
424     while (n && n->firstChild())
425         n = n->firstChild();
426     return n;
427 }
428
429 bool Node::insertBefore(PassRefPtr<Node> newChild, Node* refChild, ExceptionCode& ec)
430 {
431     if (!is<ContainerNode>(*this)) {
432         ec = HIERARCHY_REQUEST_ERR;
433         return false;
434     }
435     return downcast<ContainerNode>(*this).insertBefore(newChild, refChild, ec);
436 }
437
438 bool Node::replaceChild(PassRefPtr<Node> newChild, Node* oldChild, ExceptionCode& ec)
439 {
440     if (!is<ContainerNode>(*this)) {
441         ec = HIERARCHY_REQUEST_ERR;
442         return false;
443     }
444     return downcast<ContainerNode>(*this).replaceChild(newChild, oldChild, ec);
445 }
446
447 bool Node::removeChild(Node* oldChild, ExceptionCode& ec)
448 {
449     if (!is<ContainerNode>(*this)) {
450         ec = NOT_FOUND_ERR;
451         return false;
452     }
453     return downcast<ContainerNode>(*this).removeChild(oldChild, ec);
454 }
455
456 bool Node::appendChild(PassRefPtr<Node> newChild, ExceptionCode& ec)
457 {
458     if (!is<ContainerNode>(*this)) {
459         ec = HIERARCHY_REQUEST_ERR;
460         return false;
461     }
462     return downcast<ContainerNode>(*this).appendChild(newChild, ec);
463 }
464
465 void Node::remove(ExceptionCode& ec)
466 {
467     if (ContainerNode* parent = parentNode())
468         parent->removeChild(this, ec);
469 }
470
471 void Node::normalize()
472 {
473     // Go through the subtree beneath us, normalizing all nodes. This means that
474     // any two adjacent text nodes are merged and any empty text nodes are removed.
475
476     RefPtr<Node> node = this;
477     while (Node* firstChild = node->firstChild())
478         node = firstChild;
479     while (node) {
480         NodeType type = node->nodeType();
481         if (type == ELEMENT_NODE)
482             downcast<Element>(*node).normalizeAttributes();
483
484         if (node == this)
485             break;
486
487         if (type != TEXT_NODE) {
488             node = NodeTraversal::nextPostOrder(node.get());
489             continue;
490         }
491
492         RefPtr<Text> text = downcast<Text>(node.get());
493
494         // Remove empty text nodes.
495         if (!text->length()) {
496             // Care must be taken to get the next node before removing the current node.
497             node = NodeTraversal::nextPostOrder(node.get());
498             text->remove(IGNORE_EXCEPTION);
499             continue;
500         }
501
502         // Merge text nodes.
503         while (Node* nextSibling = node->nextSibling()) {
504             if (nextSibling->nodeType() != TEXT_NODE)
505                 break;
506             RefPtr<Text> nextText = downcast<Text>(nextSibling);
507
508             // Remove empty text nodes.
509             if (!nextText->length()) {
510                 nextText->remove(IGNORE_EXCEPTION);
511                 continue;
512             }
513
514             // Both non-empty text nodes. Merge them.
515             unsigned offset = text->length();
516             text->appendData(nextText->data(), IGNORE_EXCEPTION);
517             document().textNodesMerged(nextText.get(), offset);
518             nextText->remove(IGNORE_EXCEPTION);
519         }
520
521         node = NodeTraversal::nextPostOrder(node.get());
522     }
523 }
524
525 const AtomicString& Node::prefix() const
526 {
527     // For nodes other than elements and attributes, the prefix is always null
528     return nullAtom;
529 }
530
531 void Node::setPrefix(const AtomicString& /*prefix*/, ExceptionCode& ec)
532 {
533     // The spec says that for nodes other than elements and attributes, prefix is always null.
534     // It does not say what to do when the user tries to set the prefix on another type of
535     // node, however Mozilla throws a NAMESPACE_ERR exception.
536     ec = NAMESPACE_ERR;
537 }
538
539 const AtomicString& Node::localName() const
540 {
541     return nullAtom;
542 }
543
544 const AtomicString& Node::namespaceURI() const
545 {
546     return nullAtom;
547 }
548
549 bool Node::isContentEditable(UserSelectAllTreatment treatment)
550 {
551     document().updateStyleIfNeeded();
552     return hasEditableStyle(Editable, treatment);
553 }
554
555 bool Node::isContentRichlyEditable()
556 {
557     document().updateStyleIfNeeded();
558     return hasEditableStyle(RichlyEditable, UserSelectAllIsAlwaysNonEditable);
559 }
560
561 void Node::inspect()
562 {
563 #if ENABLE(INSPECTOR)
564     if (document().page())
565         document().page()->inspectorController().inspect(this);
566 #endif
567 }
568
569 bool Node::hasEditableStyle(EditableLevel editableLevel, UserSelectAllTreatment treatment) const
570 {
571     if (!document().hasLivingRenderTree())
572         return false;
573     if (document().frame() && document().frame()->page() && document().frame()->page()->isEditable() && !containingShadowRoot())
574         return true;
575
576     if (isPseudoElement())
577         return false;
578
579     // Ideally we'd call ASSERT(!needsStyleRecalc()) here, but
580     // ContainerNode::setFocus() calls setNeedsStyleRecalc(), so the assertion
581     // would fire in the middle of Document::setFocusedElement().
582
583     for (const Node* node = this; node; node = node->parentNode()) {
584         RenderStyle* style = node->isDocumentNode() ? node->renderStyle() : const_cast<Node*>(node)->computedStyle();
585         if (!style)
586             continue;
587         if (style->display() == NONE)
588             continue;
589 #if ENABLE(USERSELECT_ALL)
590         // Elements with user-select: all style are considered atomic
591         // therefore non editable.
592         if (treatment == UserSelectAllIsAlwaysNonEditable && style->userSelect() == SELECT_ALL)
593             return false;
594 #else
595         UNUSED_PARAM(treatment);
596 #endif
597         switch (style->userModify()) {
598         case READ_ONLY:
599             return false;
600         case READ_WRITE:
601             return true;
602         case READ_WRITE_PLAINTEXT_ONLY:
603             return editableLevel != RichlyEditable;
604         }
605         ASSERT_NOT_REACHED();
606         return false;
607     }
608     return false;
609 }
610
611 bool Node::isEditableToAccessibility(EditableLevel editableLevel) const
612 {
613     if (hasEditableStyle(editableLevel))
614         return true;
615
616     // FIXME: Respect editableLevel for ARIA editable elements.
617     if (editableLevel == RichlyEditable)
618         return false;
619
620     ASSERT(AXObjectCache::accessibilityEnabled());
621     ASSERT(document().existingAXObjectCache());
622
623     if (AXObjectCache* cache = document().existingAXObjectCache())
624         return cache->rootAXEditableElement(this);
625
626     return false;
627 }
628
629 RenderBox* Node::renderBox() const
630 {
631     RenderObject* renderer = this->renderer();
632     return is<RenderBox>(renderer) ? downcast<RenderBox>(renderer) : nullptr;
633 }
634
635 RenderBoxModelObject* Node::renderBoxModelObject() const
636 {
637     RenderObject* renderer = this->renderer();
638     return is<RenderBoxModelObject>(renderer) ? downcast<RenderBoxModelObject>(renderer) : nullptr;
639 }
640     
641 LayoutRect Node::renderRect(bool* isReplaced)
642 {    
643     RenderObject* hitRenderer = this->renderer();
644     ASSERT(hitRenderer);
645     RenderObject* renderer = hitRenderer;
646     while (renderer && !renderer->isBody() && !renderer->isRoot()) {
647         if (renderer->isRenderBlock() || renderer->isInlineBlockOrInlineTable() || renderer->isReplaced()) {
648             *isReplaced = renderer->isReplaced();
649             return renderer->absoluteBoundingBoxRect();
650         }
651         renderer = renderer->parent();
652     }
653     return LayoutRect();    
654 }
655
656 void Node::refEventTarget()
657 {
658     ref();
659 }
660
661 void Node::derefEventTarget()
662 {
663     deref();
664 }
665
666 inline void Node::updateAncestorsForStyleRecalc()
667 {
668     if (ContainerNode* ancestor = is<PseudoElement>(*this) ? downcast<PseudoElement>(*this).hostElement() : parentOrShadowHostNode()) {
669         ancestor->setDirectChildNeedsStyleRecalc();
670
671         if (is<Element>(*ancestor) && downcast<Element>(*ancestor).childrenAffectedByPropertyBasedBackwardPositionalRules()) {
672             if (ancestor->styleChangeType() < FullStyleChange)
673                 ancestor->setStyleChange(FullStyleChange);
674         }
675
676         for (; ancestor && !ancestor->childNeedsStyleRecalc(); ancestor = ancestor->parentOrShadowHostNode())
677             ancestor->setChildNeedsStyleRecalc();
678     }
679
680     Document& document = this->document();
681     if (document.childNeedsStyleRecalc())
682         document.scheduleStyleRecalc();
683 }
684
685 void Node::setNeedsStyleRecalc(StyleChangeType changeType)
686 {
687     ASSERT(changeType != NoStyleChange);
688     if (!inRenderedDocument())
689         return;
690
691     StyleChangeType existingChangeType = styleChangeType();
692     if (changeType > existingChangeType)
693         setStyleChange(changeType);
694
695     if (existingChangeType == NoStyleChange || changeType == ReconstructRenderTree)
696         updateAncestorsForStyleRecalc();
697 }
698
699 unsigned Node::computeNodeIndex() const
700 {
701     unsigned count = 0;
702     for (Node* sibling = previousSibling(); sibling; sibling = sibling->previousSibling())
703         ++count;
704     return count;
705 }
706
707 template<unsigned type>
708 bool shouldInvalidateNodeListCachesForAttr(const unsigned nodeListCounts[], const QualifiedName& attrName)
709 {
710     if (nodeListCounts[type] && shouldInvalidateTypeOnAttributeChange(static_cast<NodeListInvalidationType>(type), attrName))
711         return true;
712     return shouldInvalidateNodeListCachesForAttr<type + 1>(nodeListCounts, attrName);
713 }
714
715 template<>
716 bool shouldInvalidateNodeListCachesForAttr<numNodeListInvalidationTypes>(const unsigned[], const QualifiedName&)
717 {
718     return false;
719 }
720
721 bool Document::shouldInvalidateNodeListAndCollectionCaches(const QualifiedName* attrName) const
722 {
723     if (attrName)
724         return shouldInvalidateNodeListCachesForAttr<DoNotInvalidateOnAttributeChanges + 1>(m_nodeListAndCollectionCounts, *attrName);
725
726     for (int type = 0; type < numNodeListInvalidationTypes; type++) {
727         if (m_nodeListAndCollectionCounts[type])
728             return true;
729     }
730
731     return false;
732 }
733
734 void Document::invalidateNodeListAndCollectionCaches(const QualifiedName* attrName)
735 {
736 #if !ASSERT_DISABLED
737     m_inInvalidateNodeListAndCollectionCaches = true;
738 #endif
739     HashSet<LiveNodeList*> lists = WTF::move(m_listsInvalidatedAtDocument);
740     m_listsInvalidatedAtDocument.clear();
741     for (auto* list : lists)
742         list->invalidateCacheForAttribute(attrName);
743     HashSet<HTMLCollection*> collections = WTF::move(m_collectionsInvalidatedAtDocument);
744     for (auto* collection : collections)
745         collection->invalidateCache(attrName);
746 #if !ASSERT_DISABLED
747     m_inInvalidateNodeListAndCollectionCaches = false;
748 #endif
749 }
750
751 void Node::invalidateNodeListAndCollectionCachesInAncestors(const QualifiedName* attrName, Element* attributeOwnerElement)
752 {
753     if (hasRareData() && (!attrName || isAttributeNode())) {
754         if (NodeListsNodeData* lists = rareData()->nodeLists())
755             lists->clearChildNodeListCache();
756     }
757
758     // Modifications to attributes that are not associated with an Element can't invalidate NodeList caches.
759     if (attrName && !attributeOwnerElement)
760         return;
761
762     if (!document().shouldInvalidateNodeListAndCollectionCaches(attrName))
763         return;
764
765     document().invalidateNodeListAndCollectionCaches(attrName);
766
767     for (Node* node = this; node; node = node->parentNode()) {
768         if (!node->hasRareData())
769             continue;
770         NodeRareData* data = node->rareData();
771         if (data->nodeLists())
772             data->nodeLists()->invalidateCaches(attrName);
773     }
774 }
775
776 NodeListsNodeData* Node::nodeLists()
777 {
778     return hasRareData() ? rareData()->nodeLists() : 0;
779 }
780
781 void Node::clearNodeLists()
782 {
783     rareData()->clearNodeLists();
784 }
785
786 void Node::checkSetPrefix(const AtomicString& prefix, ExceptionCode& ec)
787 {
788     // Perform error checking as required by spec for setting Node.prefix. Used by
789     // Element::setPrefix() and Attr::setPrefix()
790
791     if (!prefix.isEmpty() && !Document::isValidName(prefix)) {
792         ec = INVALID_CHARACTER_ERR;
793         return;
794     }
795
796     if (isReadOnlyNode()) {
797         ec = NO_MODIFICATION_ALLOWED_ERR;
798         return;
799     }
800
801     // FIXME: Raise NAMESPACE_ERR if prefix is malformed per the Namespaces in XML specification.
802
803     const AtomicString& nodeNamespaceURI = namespaceURI();
804     if ((nodeNamespaceURI.isEmpty() && !prefix.isEmpty())
805         || (prefix == xmlAtom && nodeNamespaceURI != XMLNames::xmlNamespaceURI)) {
806         ec = NAMESPACE_ERR;
807         return;
808     }
809     // Attribute-specific checks are in Attr::setPrefix().
810 }
811
812 bool Node::isDescendantOf(const Node* other) const
813 {
814     // Return true if other is an ancestor of this, otherwise false
815     if (!other || !other->hasChildNodes() || inDocument() != other->inDocument())
816         return false;
817     if (other->isDocumentNode())
818         return &document() == other && !isDocumentNode() && inDocument();
819     for (const ContainerNode* n = parentNode(); n; n = n->parentNode()) {
820         if (n == other)
821             return true;
822     }
823     return false;
824 }
825
826 bool Node::isDescendantOrShadowDescendantOf(const Node* other) const
827 {
828     if (!other) 
829         return false;
830     if (isDescendantOf(other))
831         return true;
832     const Node* shadowAncestorNode = deprecatedShadowAncestorNode();
833     if (!shadowAncestorNode)
834         return false;
835     return shadowAncestorNode == other || shadowAncestorNode->isDescendantOf(other);
836 }
837
838 bool Node::contains(const Node* node) const
839 {
840     if (!node)
841         return false;
842     return this == node || node->isDescendantOf(this);
843 }
844
845 bool Node::containsIncludingShadowDOM(const Node* node) const
846 {
847     for (; node; node = node->parentOrShadowHostNode()) {
848         if (node == this)
849             return true;
850     }
851     return false;
852 }
853
854 bool Node::containsIncludingHostElements(const Node* node) const
855 {
856 #if ENABLE(TEMPLATE_ELEMENT)
857     while (node) {
858         if (node == this)
859             return true;
860         if (node->isDocumentFragment() && static_cast<const DocumentFragment*>(node)->isTemplateContent())
861             node = static_cast<const TemplateContentDocumentFragment*>(node)->host();
862         else
863             node = node->parentOrShadowHostNode();
864     }
865     return false;
866 #else
867     return containsIncludingShadowDOM(node);
868 #endif
869 }
870
871 Node* Node::pseudoAwarePreviousSibling() const
872 {
873     Element* parentOrHost = is<PseudoElement>(*this) ? downcast<PseudoElement>(*this).hostElement() : parentElement();
874     if (parentOrHost && !previousSibling()) {
875         if (isAfterPseudoElement() && parentOrHost->lastChild())
876             return parentOrHost->lastChild();
877         if (!isBeforePseudoElement())
878             return parentOrHost->beforePseudoElement();
879     }
880     return previousSibling();
881 }
882
883 Node* Node::pseudoAwareNextSibling() const
884 {
885     Element* parentOrHost = is<PseudoElement>(*this) ? downcast<PseudoElement>(*this).hostElement() : parentElement();
886     if (parentOrHost && !nextSibling()) {
887         if (isBeforePseudoElement() && parentOrHost->firstChild())
888             return parentOrHost->firstChild();
889         if (!isAfterPseudoElement())
890             return parentOrHost->afterPseudoElement();
891     }
892     return nextSibling();
893 }
894
895 Node* Node::pseudoAwareFirstChild() const
896 {
897     if (is<Element>(*this)) {
898         const Element& currentElement = downcast<Element>(*this);
899         Node* first = currentElement.beforePseudoElement();
900         if (first)
901             return first;
902         first = currentElement.firstChild();
903         if (!first)
904             first = currentElement.afterPseudoElement();
905         return first;
906     }
907     return firstChild();
908 }
909
910 Node* Node::pseudoAwareLastChild() const
911 {
912     if (is<Element>(*this)) {
913         const Element& currentElement = downcast<Element>(*this);
914         Node* last = currentElement.afterPseudoElement();
915         if (last)
916             return last;
917         last = currentElement.lastChild();
918         if (!last)
919             last = currentElement.beforePseudoElement();
920         return last;
921     }
922     return lastChild();
923 }
924
925 RenderStyle* Node::computedStyle(PseudoId pseudoElementSpecifier)
926 {
927     for (Node* node = this; node; node = node->parentOrShadowHostNode()) {
928         if (is<Element>(*node))
929             return downcast<Element>(*node).computedStyle(pseudoElementSpecifier);
930     }
931     return nullptr;
932 }
933
934 int Node::maxCharacterOffset() const
935 {
936     ASSERT_NOT_REACHED();
937     return 0;
938 }
939
940 // FIXME: Shouldn't these functions be in the editing code?  Code that asks questions about HTML in the core DOM class
941 // is obviously misplaced.
942 bool Node::canStartSelection() const
943 {
944     if (hasEditableStyle())
945         return true;
946
947     if (renderer()) {
948         const RenderStyle& style = renderer()->style();
949         // We allow selections to begin within an element that has -webkit-user-select: none set,
950         // but if the element is draggable then dragging should take priority over selection.
951         if (style.userDrag() == DRAG_ELEMENT && style.userSelect() == SELECT_NONE)
952             return false;
953     }
954     return parentOrShadowHostNode() ? parentOrShadowHostNode()->canStartSelection() : true;
955 }
956
957 Element* Node::shadowHost() const
958 {
959     if (ShadowRoot* root = containingShadowRoot())
960         return root->hostElement();
961     return 0;
962 }
963
964 Node* Node::deprecatedShadowAncestorNode() const
965 {
966     if (ShadowRoot* root = containingShadowRoot())
967         return root->hostElement();
968
969     return const_cast<Node*>(this);
970 }
971
972 ShadowRoot* Node::containingShadowRoot() const
973 {
974     ContainerNode& root = treeScope().rootNode();
975     return is<ShadowRoot>(root) ? downcast<ShadowRoot>(&root) : nullptr;
976 }
977
978 Node* Node::nonBoundaryShadowTreeRootNode()
979 {
980     ASSERT(!isShadowRoot());
981     Node* root = this;
982     while (root) {
983         if (root->isShadowRoot())
984             return root;
985         Node* parent = root->parentNodeGuaranteedHostFree();
986         if (parent && parent->isShadowRoot())
987             return root;
988         root = parent;
989     }
990     return 0;
991 }
992
993 ContainerNode* Node::nonShadowBoundaryParentNode() const
994 {
995     ContainerNode* parent = parentNode();
996     return parent && !parent->isShadowRoot() ? parent : 0;
997 }
998
999 Element* Node::parentOrShadowHostElement() const
1000 {
1001     ContainerNode* parent = parentOrShadowHostNode();
1002     if (!parent)
1003         return nullptr;
1004
1005     if (is<ShadowRoot>(*parent))
1006         return downcast<ShadowRoot>(*parent).hostElement();
1007
1008     if (!is<Element>(*parent))
1009         return nullptr;
1010
1011     return downcast<Element>(parent);
1012 }
1013
1014 Node* Node::insertionParentForBinding() const
1015 {
1016     return findInsertionPointOf(this);
1017 }
1018
1019 Node::InsertionNotificationRequest Node::insertedInto(ContainerNode& insertionPoint)
1020 {
1021     ASSERT(insertionPoint.inDocument() || isContainerNode());
1022     if (insertionPoint.inDocument())
1023         setFlag(InDocumentFlag);
1024     if (parentOrShadowHostNode()->isInShadowTree())
1025         setFlag(IsInShadowTreeFlag);
1026     return InsertionDone;
1027 }
1028
1029 void Node::removedFrom(ContainerNode& insertionPoint)
1030 {
1031     ASSERT(insertionPoint.inDocument() || isContainerNode());
1032     if (insertionPoint.inDocument())
1033         clearFlag(InDocumentFlag);
1034     if (isInShadowTree() && !treeScope().rootNode().isShadowRoot())
1035         clearFlag(IsInShadowTreeFlag);
1036 }
1037
1038 bool Node::isRootEditableElement() const
1039 {
1040     return hasEditableStyle() && isElementNode() && (!parentNode() || !parentNode()->hasEditableStyle()
1041         || !parentNode()->isElementNode() || hasTagName(bodyTag));
1042 }
1043
1044 Element* Node::rootEditableElement(EditableType editableType) const
1045 {
1046     if (editableType == HasEditableAXRole) {
1047         if (AXObjectCache* cache = document().existingAXObjectCache())
1048             return const_cast<Element*>(cache->rootAXEditableElement(this));
1049     }
1050     
1051     return rootEditableElement();
1052 }
1053
1054 Element* Node::rootEditableElement() const
1055 {
1056     Element* result = nullptr;
1057     for (Node* node = const_cast<Node*>(this); node && node->hasEditableStyle(); node = node->parentNode()) {
1058         if (is<Element>(*node))
1059             result = downcast<Element>(node);
1060         if (is<HTMLBodyElement>(*node))
1061             break;
1062     }
1063     return result;
1064 }
1065
1066 // FIXME: End of obviously misplaced HTML editing functions.  Try to move these out of Node.
1067
1068 Document* Node::ownerDocument() const
1069 {
1070     Document* document = &this->document();
1071     return document == this ? nullptr : document;
1072 }
1073
1074 URL Node::baseURI() const
1075 {
1076     return parentNode() ? parentNode()->baseURI() : URL();
1077 }
1078
1079 bool Node::isEqualNode(Node* other) const
1080 {
1081     if (!other)
1082         return false;
1083     
1084     NodeType nodeType = this->nodeType();
1085     if (nodeType != other->nodeType())
1086         return false;
1087     
1088     if (nodeName() != other->nodeName())
1089         return false;
1090     
1091     if (localName() != other->localName())
1092         return false;
1093     
1094     if (namespaceURI() != other->namespaceURI())
1095         return false;
1096     
1097     if (prefix() != other->prefix())
1098         return false;
1099     
1100     if (nodeValue() != other->nodeValue())
1101         return false;
1102     
1103     if (is<Element>(*this) && !downcast<Element>(*this).hasEquivalentAttributes(downcast<Element>(other)))
1104         return false;
1105     
1106     Node* child = firstChild();
1107     Node* otherChild = other->firstChild();
1108     
1109     while (child) {
1110         if (!child->isEqualNode(otherChild))
1111             return false;
1112         
1113         child = child->nextSibling();
1114         otherChild = otherChild->nextSibling();
1115     }
1116     
1117     if (otherChild)
1118         return false;
1119     
1120     if (nodeType == DOCUMENT_TYPE_NODE) {
1121         const DocumentType* documentTypeThis = static_cast<const DocumentType*>(this);
1122         const DocumentType* documentTypeOther = static_cast<const DocumentType*>(other);
1123         
1124         if (documentTypeThis->publicId() != documentTypeOther->publicId())
1125             return false;
1126
1127         if (documentTypeThis->systemId() != documentTypeOther->systemId())
1128             return false;
1129
1130         if (documentTypeThis->internalSubset() != documentTypeOther->internalSubset())
1131             return false;
1132
1133         // FIXME: We don't compare entities or notations because currently both are always empty.
1134     }
1135     
1136     return true;
1137 }
1138
1139 bool Node::isDefaultNamespace(const AtomicString& namespaceURIMaybeEmpty) const
1140 {
1141     const AtomicString& namespaceURI = namespaceURIMaybeEmpty.isEmpty() ? nullAtom : namespaceURIMaybeEmpty;
1142
1143     switch (nodeType()) {
1144         case ELEMENT_NODE: {
1145             const Element& element = downcast<Element>(*this);
1146             
1147             if (element.prefix().isNull())
1148                 return element.namespaceURI() == namespaceURI;
1149
1150             if (element.hasAttributes()) {
1151                 for (const Attribute& attribute : element.attributesIterator()) {
1152                     if (attribute.localName() == xmlnsAtom)
1153                         return attribute.value() == namespaceURI;
1154                 }
1155             }
1156
1157             if (Element* ancestor = ancestorElement())
1158                 return ancestor->isDefaultNamespace(namespaceURI);
1159
1160             return false;
1161         }
1162         case DOCUMENT_NODE:
1163             if (Element* documentElement = downcast<Document>(*this).documentElement())
1164                 return documentElement->isDefaultNamespace(namespaceURI);
1165             return false;
1166         case ENTITY_NODE:
1167         case NOTATION_NODE:
1168         case DOCUMENT_TYPE_NODE:
1169         case DOCUMENT_FRAGMENT_NODE:
1170             return false;
1171         case ATTRIBUTE_NODE: {
1172             const Attr* attr = static_cast<const Attr*>(this);
1173             if (attr->ownerElement())
1174                 return attr->ownerElement()->isDefaultNamespace(namespaceURI);
1175             return false;
1176         }
1177         default:
1178             if (Element* ancestor = ancestorElement())
1179                 return ancestor->isDefaultNamespace(namespaceURI);
1180             return false;
1181     }
1182 }
1183
1184 String Node::lookupPrefix(const AtomicString &namespaceURI) const
1185 {
1186     // Implemented according to
1187     // http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/namespaces-algorithms.html#lookupNamespacePrefixAlgo
1188     
1189     if (namespaceURI.isEmpty())
1190         return String();
1191     
1192     switch (nodeType()) {
1193         case ELEMENT_NODE:
1194             return lookupNamespacePrefix(namespaceURI, static_cast<const Element *>(this));
1195         case DOCUMENT_NODE:
1196             if (Element* documentElement = downcast<Document>(*this).documentElement())
1197                 return documentElement->lookupPrefix(namespaceURI);
1198             return String();
1199         case ENTITY_NODE:
1200         case NOTATION_NODE:
1201         case DOCUMENT_FRAGMENT_NODE:
1202         case DOCUMENT_TYPE_NODE:
1203             return String();
1204         case ATTRIBUTE_NODE: {
1205             const Attr *attr = static_cast<const Attr *>(this);
1206             if (attr->ownerElement())
1207                 return attr->ownerElement()->lookupPrefix(namespaceURI);
1208             return String();
1209         }
1210         default:
1211             if (Element* ancestor = ancestorElement())
1212                 return ancestor->lookupPrefix(namespaceURI);
1213             return String();
1214     }
1215 }
1216
1217 String Node::lookupNamespaceURI(const String &prefix) const
1218 {
1219     // Implemented according to
1220     // http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/namespaces-algorithms.html#lookupNamespaceURIAlgo
1221     
1222     if (!prefix.isNull() && prefix.isEmpty())
1223         return String();
1224     
1225     switch (nodeType()) {
1226         case ELEMENT_NODE: {
1227             const Element *elem = static_cast<const Element *>(this);
1228             
1229             if (!elem->namespaceURI().isNull() && elem->prefix() == prefix)
1230                 return elem->namespaceURI();
1231             
1232             if (elem->hasAttributes()) {
1233                 for (const Attribute& attribute : elem->attributesIterator()) {
1234                     
1235                     if (attribute.prefix() == xmlnsAtom && attribute.localName() == prefix) {
1236                         if (!attribute.value().isEmpty())
1237                             return attribute.value();
1238                         
1239                         return String();
1240                     }
1241                     if (attribute.localName() == xmlnsAtom && prefix.isNull()) {
1242                         if (!attribute.value().isEmpty())
1243                             return attribute.value();
1244                         
1245                         return String();
1246                     }
1247                 }
1248             }
1249             if (Element* ancestor = ancestorElement())
1250                 return ancestor->lookupNamespaceURI(prefix);
1251             return String();
1252         }
1253         case DOCUMENT_NODE:
1254             if (Element* documentElement = downcast<Document>(*this).documentElement())
1255                 return documentElement->lookupNamespaceURI(prefix);
1256             return String();
1257         case ENTITY_NODE:
1258         case NOTATION_NODE:
1259         case DOCUMENT_TYPE_NODE:
1260         case DOCUMENT_FRAGMENT_NODE:
1261             return String();
1262         case ATTRIBUTE_NODE: {
1263             const Attr *attr = static_cast<const Attr *>(this);
1264             
1265             if (attr->ownerElement())
1266                 return attr->ownerElement()->lookupNamespaceURI(prefix);
1267             else
1268                 return String();
1269         }
1270         default:
1271             if (Element* ancestor = ancestorElement())
1272                 return ancestor->lookupNamespaceURI(prefix);
1273             return String();
1274     }
1275 }
1276
1277 String Node::lookupNamespacePrefix(const AtomicString &_namespaceURI, const Element *originalElement) const
1278 {
1279     if (_namespaceURI.isNull())
1280         return String();
1281             
1282     if (originalElement->lookupNamespaceURI(prefix()) == _namespaceURI)
1283         return prefix();
1284     
1285     ASSERT(is<Element>(*this));
1286     const Element& thisElement = downcast<Element>(*this);
1287     if (thisElement.hasAttributes()) {
1288         for (const Attribute& attribute : thisElement.attributesIterator()) {
1289             if (attribute.prefix() == xmlnsAtom && attribute.value() == _namespaceURI
1290                 && originalElement->lookupNamespaceURI(attribute.localName()) == _namespaceURI)
1291                 return attribute.localName();
1292         }
1293     }
1294     
1295     if (Element* ancestor = ancestorElement())
1296         return ancestor->lookupNamespacePrefix(_namespaceURI, originalElement);
1297     return String();
1298 }
1299
1300 static void appendTextContent(const Node* node, bool convertBRsToNewlines, bool& isNullString, StringBuilder& content)
1301 {
1302     switch (node->nodeType()) {
1303     case Node::TEXT_NODE:
1304     case Node::CDATA_SECTION_NODE:
1305     case Node::COMMENT_NODE:
1306         isNullString = false;
1307         content.append(static_cast<const CharacterData*>(node)->data());
1308         break;
1309
1310     case Node::PROCESSING_INSTRUCTION_NODE:
1311         isNullString = false;
1312         content.append(static_cast<const ProcessingInstruction*>(node)->data());
1313         break;
1314     
1315     case Node::ELEMENT_NODE:
1316         if (node->hasTagName(brTag) && convertBRsToNewlines) {
1317             isNullString = false;
1318             content.append('\n');
1319             break;
1320         }
1321         FALLTHROUGH;
1322     case Node::ATTRIBUTE_NODE:
1323     case Node::ENTITY_NODE:
1324     case Node::ENTITY_REFERENCE_NODE:
1325     case Node::DOCUMENT_FRAGMENT_NODE:
1326         isNullString = false;
1327         for (Node* child = node->firstChild(); child; child = child->nextSibling()) {
1328             if (child->nodeType() == Node::COMMENT_NODE || child->nodeType() == Node::PROCESSING_INSTRUCTION_NODE)
1329                 continue;
1330             appendTextContent(child, convertBRsToNewlines, isNullString, content);
1331         }
1332         break;
1333
1334     case Node::DOCUMENT_NODE:
1335     case Node::DOCUMENT_TYPE_NODE:
1336     case Node::NOTATION_NODE:
1337     case Node::XPATH_NAMESPACE_NODE:
1338         break;
1339     }
1340 }
1341
1342 String Node::textContent(bool convertBRsToNewlines) const
1343 {
1344     StringBuilder content;
1345     bool isNullString = true;
1346     appendTextContent(this, convertBRsToNewlines, isNullString, content);
1347     return isNullString ? String() : content.toString();
1348 }
1349
1350 void Node::setTextContent(const String& text, ExceptionCode& ec)
1351 {           
1352     switch (nodeType()) {
1353         case TEXT_NODE:
1354         case CDATA_SECTION_NODE:
1355         case COMMENT_NODE:
1356         case PROCESSING_INSTRUCTION_NODE:
1357             setNodeValue(text, ec);
1358             return;
1359         case ELEMENT_NODE:
1360         case ATTRIBUTE_NODE:
1361         case ENTITY_NODE:
1362         case ENTITY_REFERENCE_NODE:
1363         case DOCUMENT_FRAGMENT_NODE: {
1364             Ref<ContainerNode> container(downcast<ContainerNode>(*this));
1365             ChildListMutationScope mutation(container);
1366             container->removeChildren();
1367             if (!text.isEmpty())
1368                 container->appendChild(document().createTextNode(text), ec);
1369             return;
1370         }
1371         case DOCUMENT_NODE:
1372         case DOCUMENT_TYPE_NODE:
1373         case NOTATION_NODE:
1374         case XPATH_NAMESPACE_NODE:
1375             // Do nothing.
1376             return;
1377     }
1378     ASSERT_NOT_REACHED();
1379 }
1380
1381 Element* Node::ancestorElement() const
1382 {
1383     // In theory, there can be EntityReference nodes between elements, but this is currently not supported.
1384     for (ContainerNode* ancestor = parentNode(); ancestor; ancestor = ancestor->parentNode()) {
1385         if (is<Element>(*ancestor))
1386             return downcast<Element>(ancestor);
1387     }
1388     return nullptr;
1389 }
1390
1391 bool Node::offsetInCharacters() const
1392 {
1393     return false;
1394 }
1395
1396 unsigned short Node::compareDocumentPosition(Node* otherNode)
1397 {
1398     // It is not clear what should be done if |otherNode| is nullptr.
1399     if (!otherNode)
1400         return DOCUMENT_POSITION_DISCONNECTED;
1401
1402     if (otherNode == this)
1403         return DOCUMENT_POSITION_EQUIVALENT;
1404     
1405     Attr* attr1 = is<Attr>(*this) ? downcast<Attr>(this) : nullptr;
1406     Attr* attr2 = is<Attr>(*otherNode) ? downcast<Attr>(otherNode) : nullptr;
1407     
1408     Node* start1 = attr1 ? attr1->ownerElement() : this;
1409     Node* start2 = attr2 ? attr2->ownerElement() : otherNode;
1410     
1411     // If either of start1 or start2 is null, then we are disconnected, since one of the nodes is
1412     // an orphaned attribute node.
1413     if (!start1 || !start2)
1414         return DOCUMENT_POSITION_DISCONNECTED | DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC;
1415
1416     Vector<Node*, 16> chain1;
1417     Vector<Node*, 16> chain2;
1418     if (attr1)
1419         chain1.append(attr1);
1420     if (attr2)
1421         chain2.append(attr2);
1422     
1423     if (attr1 && attr2 && start1 == start2 && start1) {
1424         // We are comparing two attributes on the same node. Crawl our attribute map and see which one we hit first.
1425         Element* owner1 = attr1->ownerElement();
1426         owner1->synchronizeAllAttributes();
1427         for (const Attribute& attribute : owner1->attributesIterator()) {
1428             // If neither of the two determining nodes is a child node and nodeType is the same for both determining nodes, then an
1429             // implementation-dependent order between the determining nodes is returned. This order is stable as long as no nodes of
1430             // the same nodeType are inserted into or removed from the direct container. This would be the case, for example, 
1431             // when comparing two attributes of the same element, and inserting or removing additional attributes might change 
1432             // the order between existing attributes.
1433             if (attr1->qualifiedName() == attribute.name())
1434                 return DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC | DOCUMENT_POSITION_FOLLOWING;
1435             if (attr2->qualifiedName() == attribute.name())
1436                 return DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC | DOCUMENT_POSITION_PRECEDING;
1437         }
1438         
1439         ASSERT_NOT_REACHED();
1440         return DOCUMENT_POSITION_DISCONNECTED;
1441     }
1442
1443     // If one node is in the document and the other is not, we must be disconnected.
1444     // If the nodes have different owning documents, they must be disconnected.  Note that we avoid
1445     // comparing Attr nodes here, since they return false from inDocument() all the time (which seems like a bug).
1446     if (start1->inDocument() != start2->inDocument() ||
1447         &start1->treeScope() != &start2->treeScope())
1448         return DOCUMENT_POSITION_DISCONNECTED | DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC;
1449
1450     // We need to find a common ancestor container, and then compare the indices of the two immediate children.
1451     Node* current;
1452     for (current = start1; current; current = current->parentNode())
1453         chain1.append(current);
1454     for (current = start2; current; current = current->parentNode())
1455         chain2.append(current);
1456
1457     unsigned index1 = chain1.size();
1458     unsigned index2 = chain2.size();
1459
1460     // If the two elements don't have a common root, they're not in the same tree.
1461     if (chain1[index1 - 1] != chain2[index2 - 1])
1462         return DOCUMENT_POSITION_DISCONNECTED | DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC;
1463
1464     // Walk the two chains backwards and look for the first difference.
1465     for (unsigned i = std::min(index1, index2); i; --i) {
1466         Node* child1 = chain1[--index1];
1467         Node* child2 = chain2[--index2];
1468         if (child1 != child2) {
1469             // If one of the children is an attribute, it wins.
1470             if (child1->nodeType() == ATTRIBUTE_NODE)
1471                 return DOCUMENT_POSITION_FOLLOWING;
1472             if (child2->nodeType() == ATTRIBUTE_NODE)
1473                 return DOCUMENT_POSITION_PRECEDING;
1474             
1475             if (!child2->nextSibling())
1476                 return DOCUMENT_POSITION_FOLLOWING;
1477             if (!child1->nextSibling())
1478                 return DOCUMENT_POSITION_PRECEDING;
1479
1480             // Otherwise we need to see which node occurs first.  Crawl backwards from child2 looking for child1.
1481             for (Node* child = child2->previousSibling(); child; child = child->previousSibling()) {
1482                 if (child == child1)
1483                     return DOCUMENT_POSITION_FOLLOWING;
1484             }
1485             return DOCUMENT_POSITION_PRECEDING;
1486         }
1487     }
1488     
1489     // There was no difference between the two parent chains, i.e., one was a subset of the other.  The shorter
1490     // chain is the ancestor.
1491     return index1 < index2 ? 
1492                DOCUMENT_POSITION_FOLLOWING | DOCUMENT_POSITION_CONTAINED_BY :
1493                DOCUMENT_POSITION_PRECEDING | DOCUMENT_POSITION_CONTAINS;
1494 }
1495
1496 FloatPoint Node::convertToPage(const FloatPoint& p) const
1497 {
1498     // If there is a renderer, just ask it to do the conversion
1499     if (renderer())
1500         return renderer()->localToAbsolute(p, UseTransforms);
1501     
1502     // Otherwise go up the tree looking for a renderer
1503     Element *parent = ancestorElement();
1504     if (parent)
1505         return parent->convertToPage(p);
1506
1507     // No parent - no conversion needed
1508     return p;
1509 }
1510
1511 FloatPoint Node::convertFromPage(const FloatPoint& p) const
1512 {
1513     // If there is a renderer, just ask it to do the conversion
1514     if (renderer())
1515         return renderer()->absoluteToLocal(p, UseTransforms);
1516
1517     // Otherwise go up the tree looking for a renderer
1518     Element *parent = ancestorElement();
1519     if (parent)
1520         return parent->convertFromPage(p);
1521
1522     // No parent - no conversion needed
1523     return p;
1524 }
1525
1526 #ifndef NDEBUG
1527
1528 static void appendAttributeDesc(const Node* node, StringBuilder& stringBuilder, const QualifiedName& name, const char* attrDesc)
1529 {
1530     if (!is<Element>(*node))
1531         return;
1532
1533     const AtomicString& attr = downcast<Element>(*node).getAttribute(name);
1534     if (attr.isEmpty())
1535         return;
1536
1537     stringBuilder.append(attrDesc);
1538     stringBuilder.append(attr);
1539 }
1540
1541 void Node::showNode(const char* prefix) const
1542 {
1543     if (!prefix)
1544         prefix = "";
1545     if (isTextNode()) {
1546         String value = nodeValue();
1547         value.replaceWithLiteral('\\', "\\\\");
1548         value.replaceWithLiteral('\n', "\\n");
1549         fprintf(stderr, "%s%s\t%p \"%s\"\n", prefix, nodeName().utf8().data(), this, value.utf8().data());
1550     } else {
1551         StringBuilder attrs;
1552         appendAttributeDesc(this, attrs, classAttr, " CLASS=");
1553         appendAttributeDesc(this, attrs, styleAttr, " STYLE=");
1554         fprintf(stderr, "%s%s\t%p (renderer %p) %s%s%s\n", prefix, nodeName().utf8().data(), this, renderer(), attrs.toString().utf8().data(), needsStyleRecalc() ? " (needs style recalc)" : "", childNeedsStyleRecalc() ? " (child needs style recalc)" : "");
1555     }
1556 }
1557
1558 void Node::showTreeForThis() const
1559 {
1560     showTreeAndMark(this, "*");
1561 }
1562
1563 void Node::showNodePathForThis() const
1564 {
1565     Vector<const Node*, 16> chain;
1566     const Node* node = this;
1567     while (node->parentOrShadowHostNode()) {
1568         chain.append(node);
1569         node = node->parentOrShadowHostNode();
1570     }
1571     for (unsigned index = chain.size(); index > 0; --index) {
1572         const Node* node = chain[index - 1];
1573         if (is<ShadowRoot>(*node)) {
1574             int count = 0;
1575             for (const ShadowRoot* shadowRoot = downcast<ShadowRoot>(node); shadowRoot && shadowRoot != node; shadowRoot = shadowRoot->shadowRoot())
1576                 ++count;
1577             fprintf(stderr, "/#shadow-root[%d]", count);
1578             continue;
1579         }
1580
1581         switch (node->nodeType()) {
1582         case ELEMENT_NODE: {
1583             fprintf(stderr, "/%s", node->nodeName().utf8().data());
1584
1585             const Element& element = downcast<Element>(*node);
1586             const AtomicString& idattr = element.getIdAttribute();
1587             bool hasIdAttr = !idattr.isNull() && !idattr.isEmpty();
1588             if (node->previousSibling() || node->nextSibling()) {
1589                 int count = 0;
1590                 for (Node* previous = node->previousSibling(); previous; previous = previous->previousSibling())
1591                     if (previous->nodeName() == node->nodeName())
1592                         ++count;
1593                 if (hasIdAttr)
1594                     fprintf(stderr, "[@id=\"%s\" and position()=%d]", idattr.string().utf8().data(), count);
1595                 else
1596                     fprintf(stderr, "[%d]", count);
1597             } else if (hasIdAttr)
1598                 fprintf(stderr, "[@id=\"%s\"]", idattr.string().utf8().data());
1599             break;
1600         }
1601         case TEXT_NODE:
1602             fprintf(stderr, "/text()");
1603             break;
1604         case ATTRIBUTE_NODE:
1605             fprintf(stderr, "/@%s", node->nodeName().utf8().data());
1606             break;
1607         default:
1608             break;
1609         }
1610     }
1611     fprintf(stderr, "\n");
1612 }
1613
1614 static void traverseTreeAndMark(const String& baseIndent, const Node* rootNode, const Node* markedNode1, const char* markedLabel1, const Node* markedNode2, const char* markedLabel2)
1615 {
1616     for (const Node* node = rootNode; node; node = NodeTraversal::next(node)) {
1617         if (node == markedNode1)
1618             fprintf(stderr, "%s", markedLabel1);
1619         if (node == markedNode2)
1620             fprintf(stderr, "%s", markedLabel2);
1621
1622         StringBuilder indent;
1623         indent.append(baseIndent);
1624         for (const Node* tmpNode = node; tmpNode && tmpNode != rootNode; tmpNode = tmpNode->parentOrShadowHostNode())
1625             indent.append('\t');
1626         fprintf(stderr, "%s", indent.toString().utf8().data());
1627         node->showNode();
1628         indent.append('\t');
1629         if (!node->isShadowRoot()) {
1630             if (ShadowRoot* shadowRoot = node->shadowRoot())
1631                 traverseTreeAndMark(indent.toString(), shadowRoot, markedNode1, markedLabel1, markedNode2, markedLabel2);
1632         }
1633     }
1634 }
1635
1636 void Node::showTreeAndMark(const Node* markedNode1, const char* markedLabel1, const Node* markedNode2, const char* markedLabel2) const
1637 {
1638     const Node* rootNode;
1639     const Node* node = this;
1640     while (node->parentOrShadowHostNode() && !node->hasTagName(bodyTag))
1641         node = node->parentOrShadowHostNode();
1642     rootNode = node;
1643
1644     String startingIndent;
1645     traverseTreeAndMark(startingIndent, rootNode, markedNode1, markedLabel1, markedNode2, markedLabel2);
1646 }
1647
1648 void Node::formatForDebugger(char* buffer, unsigned length) const
1649 {
1650     String result;
1651     String s;
1652
1653     s = nodeName();
1654     if (s.isEmpty())
1655         result = "<none>";
1656     else
1657         result = s;
1658
1659     strncpy(buffer, result.utf8().data(), length - 1);
1660 }
1661
1662 static ContainerNode* parentOrShadowHostOrFrameOwner(const Node* node)
1663 {
1664     ContainerNode* parent = node->parentOrShadowHostNode();
1665     if (!parent && node->document().frame())
1666         parent = node->document().frame()->ownerElement();
1667     return parent;
1668 }
1669
1670 static void showSubTreeAcrossFrame(const Node* node, const Node* markedNode, const String& indent)
1671 {
1672     if (node == markedNode)
1673         fputs("*", stderr);
1674     fputs(indent.utf8().data(), stderr);
1675     node->showNode();
1676     if (!node->isShadowRoot()) {
1677         if (node->isFrameOwnerElement())
1678             showSubTreeAcrossFrame(static_cast<const HTMLFrameOwnerElement*>(node)->contentDocument(), markedNode, indent + "\t");
1679         if (ShadowRoot* shadowRoot = node->shadowRoot())
1680             showSubTreeAcrossFrame(shadowRoot, markedNode, indent + "\t");
1681     }
1682     for (Node* child = node->firstChild(); child; child = child->nextSibling())
1683         showSubTreeAcrossFrame(child, markedNode, indent + "\t");
1684 }
1685
1686 void Node::showTreeForThisAcrossFrame() const
1687 {
1688     Node* rootNode = const_cast<Node*>(this);
1689     while (parentOrShadowHostOrFrameOwner(rootNode))
1690         rootNode = parentOrShadowHostOrFrameOwner(rootNode);
1691     showSubTreeAcrossFrame(rootNode, this, "");
1692 }
1693
1694 #endif
1695
1696 // --------
1697
1698 void NodeListsNodeData::invalidateCaches(const QualifiedName* attrName)
1699 {
1700     for (auto& atomicName : m_atomicNameCaches)
1701         atomicName.value->invalidateCacheForAttribute(attrName);
1702
1703     for (auto& collection : m_cachedCollections)
1704         collection.value->invalidateCache(attrName);
1705
1706     if (attrName)
1707         return;
1708
1709     for (auto& tagNodeList : m_tagNodeListCacheNS)
1710         tagNodeList.value->invalidateCacheForAttribute(nullptr);
1711 }
1712
1713 void Node::getSubresourceURLs(ListHashSet<URL>& urls) const
1714 {
1715     addSubresourceAttributeURLs(urls);
1716 }
1717
1718 Element* Node::enclosingLinkEventParentOrSelf()
1719 {
1720     for (Node* node = this; node; node = node->parentOrShadowHostNode()) {
1721         // For imagemaps, the enclosing link element is the associated area element not the image itself.
1722         // So we don't let images be the enclosing link element, even though isLink sometimes returns
1723         // true for them.
1724         if (node->isLink() && !is<HTMLImageElement>(*node))
1725             return downcast<Element>(node);
1726     }
1727
1728     return nullptr;
1729 }
1730
1731 EventTargetInterface Node::eventTargetInterface() const
1732 {
1733     return NodeEventTargetInterfaceType;
1734 }
1735
1736 void Node::didMoveToNewDocument(Document* oldDocument)
1737 {
1738     TreeScopeAdopter::ensureDidMoveToNewDocumentWasCalled(oldDocument);
1739
1740     if (const EventTargetData* eventTargetData = this->eventTargetData()) {
1741         const EventListenerMap& listenerMap = eventTargetData->eventListenerMap;
1742         if (!listenerMap.isEmpty()) {
1743             Vector<AtomicString> types = listenerMap.eventTypes();
1744             for (unsigned i = 0; i < types.size(); ++i)
1745                 document().addListenerTypeIfNeeded(types[i]);
1746         }
1747     }
1748
1749     if (AXObjectCache::accessibilityEnabled() && oldDocument)
1750         if (AXObjectCache* cache = oldDocument->existingAXObjectCache())
1751             cache->remove(this);
1752
1753     const EventListenerVector& mousewheelListeners = getEventListeners(eventNames().mousewheelEvent);
1754     for (size_t i = 0; i < mousewheelListeners.size(); ++i) {
1755         oldDocument->didRemoveWheelEventHandler();
1756         document().didAddWheelEventHandler();
1757     }
1758
1759     const EventListenerVector& wheelListeners = getEventListeners(eventNames().wheelEvent);
1760     for (size_t i = 0; i < wheelListeners.size(); ++i) {
1761         oldDocument->didRemoveWheelEventHandler();
1762         document().didAddWheelEventHandler();
1763     }
1764
1765     Vector<AtomicString> touchEventNames = eventNames().touchEventNames();
1766     for (size_t i = 0; i < touchEventNames.size(); ++i) {
1767         const EventListenerVector& listeners = getEventListeners(touchEventNames[i]);
1768         for (size_t j = 0; j < listeners.size(); ++j) {
1769             oldDocument->didRemoveTouchEventHandler(this);
1770             document().didAddTouchEventHandler(this);
1771         }
1772     }
1773
1774     if (Vector<std::unique_ptr<MutationObserverRegistration>>* registry = mutationObserverRegistry()) {
1775         for (const auto& registration : *registry)
1776             document().addMutationObserverTypes(registration->mutationTypes());
1777     }
1778
1779     if (HashSet<MutationObserverRegistration*>* transientRegistry = transientMutationObserverRegistry()) {
1780         for (const auto& registration : *transientRegistry)
1781             document().addMutationObserverTypes(registration->mutationTypes());
1782     }
1783 }
1784
1785 static inline bool tryAddEventListener(Node* targetNode, const AtomicString& eventType, PassRefPtr<EventListener> prpListener, bool useCapture)
1786 {
1787     RefPtr<EventListener> listener = prpListener;
1788
1789     if (!targetNode->EventTarget::addEventListener(eventType, listener, useCapture))
1790         return false;
1791
1792     targetNode->document().addListenerTypeIfNeeded(eventType);
1793     if (eventType == eventNames().wheelEvent || eventType == eventNames().mousewheelEvent)
1794         targetNode->document().didAddWheelEventHandler();
1795     else if (eventNames().isTouchEventType(eventType))
1796         targetNode->document().didAddTouchEventHandler(targetNode);
1797
1798 #if PLATFORM(IOS)
1799     if (targetNode == &targetNode->document() && eventType == eventNames().scrollEvent)
1800         targetNode->document().domWindow()->incrementScrollEventListenersCount();
1801
1802     // FIXME: Would it be sufficient to special-case this code for <body> and <frameset>?
1803     //
1804     // This code was added to address <rdar://problem/5846492> Onorientationchange event not working for document.body.
1805     // Forward this call to addEventListener() to the window since these are window-only events.
1806     if (eventType == eventNames().orientationchangeEvent || eventType == eventNames().resizeEvent)
1807         targetNode->document().domWindow()->addEventListener(eventType, listener, useCapture);
1808
1809 #if ENABLE(TOUCH_EVENTS)
1810     if (eventNames().isTouchEventType(eventType))
1811         targetNode->document().addTouchEventListener(targetNode);
1812 #endif
1813 #endif // PLATFORM(IOS)
1814
1815 #if ENABLE(IOS_GESTURE_EVENTS) && ENABLE(TOUCH_EVENTS)
1816     if (eventType == eventNames().gesturestartEvent || eventType == eventNames().gesturechangeEvent || eventType == eventNames().gestureendEvent)
1817         targetNode->document().addTouchEventListener(targetNode);
1818 #endif
1819
1820     return true;
1821 }
1822
1823 bool Node::addEventListener(const AtomicString& eventType, PassRefPtr<EventListener> listener, bool useCapture)
1824 {
1825     return tryAddEventListener(this, eventType, listener, useCapture);
1826 }
1827
1828 static inline bool tryRemoveEventListener(Node* targetNode, const AtomicString& eventType, EventListener* listener, bool useCapture)
1829 {
1830     if (!targetNode->EventTarget::removeEventListener(eventType, listener, useCapture))
1831         return false;
1832
1833     // FIXME: Notify Document that the listener has vanished. We need to keep track of a number of
1834     // listeners for each type, not just a bool - see https://bugs.webkit.org/show_bug.cgi?id=33861
1835     if (eventType == eventNames().wheelEvent || eventType == eventNames().mousewheelEvent)
1836         targetNode->document().didRemoveWheelEventHandler();
1837     else if (eventNames().isTouchEventType(eventType))
1838         targetNode->document().didRemoveTouchEventHandler(targetNode);
1839
1840 #if PLATFORM(IOS)
1841     if (targetNode == &targetNode->document() && eventType == eventNames().scrollEvent)
1842         targetNode->document().domWindow()->decrementScrollEventListenersCount();
1843
1844     // FIXME: Would it be sufficient to special-case this code for <body> and <frameset>? See <rdar://problem/15647823>.
1845     // This code was added to address <rdar://problem/5846492> Onorientationchange event not working for document.body.
1846     // Forward this call to removeEventListener() to the window since these are window-only events.
1847     if (eventType == eventNames().orientationchangeEvent || eventType == eventNames().resizeEvent)
1848         targetNode->document().domWindow()->removeEventListener(eventType, listener, useCapture);
1849
1850 #if ENABLE(TOUCH_EVENTS)
1851     if (eventNames().isTouchEventType(eventType))
1852         targetNode->document().removeTouchEventListener(targetNode);
1853 #endif
1854 #endif // PLATFORM(IOS)
1855
1856 #if ENABLE(IOS_GESTURE_EVENTS) && ENABLE(TOUCH_EVENTS)
1857     if (eventType == eventNames().gesturestartEvent || eventType == eventNames().gesturechangeEvent || eventType == eventNames().gestureendEvent)
1858         targetNode->document().removeTouchEventListener(targetNode);
1859 #endif
1860
1861     return true;
1862 }
1863
1864 bool Node::removeEventListener(const AtomicString& eventType, EventListener* listener, bool useCapture)
1865 {
1866     return tryRemoveEventListener(this, eventType, listener, useCapture);
1867 }
1868
1869 typedef HashMap<Node*, std::unique_ptr<EventTargetData>> EventTargetDataMap;
1870
1871 static EventTargetDataMap& eventTargetDataMap()
1872 {
1873     static NeverDestroyed<EventTargetDataMap> map;
1874
1875     return map;
1876 }
1877
1878 EventTargetData* Node::eventTargetData()
1879 {
1880     return hasEventTargetData() ? eventTargetDataMap().get(this) : nullptr;
1881 }
1882
1883 EventTargetData& Node::ensureEventTargetData()
1884 {
1885     if (hasEventTargetData())
1886         return *eventTargetDataMap().get(this);
1887
1888     setHasEventTargetData(true);
1889     return *eventTargetDataMap().set(this, std::make_unique<EventTargetData>()).iterator->value;
1890 }
1891
1892 void Node::clearEventTargetData()
1893 {
1894     eventTargetDataMap().remove(this);
1895 }
1896
1897 Vector<std::unique_ptr<MutationObserverRegistration>>* Node::mutationObserverRegistry()
1898 {
1899     if (!hasRareData())
1900         return 0;
1901     NodeMutationObserverData* data = rareData()->mutationObserverData();
1902     if (!data)
1903         return 0;
1904     return &data->registry;
1905 }
1906
1907 HashSet<MutationObserverRegistration*>* Node::transientMutationObserverRegistry()
1908 {
1909     if (!hasRareData())
1910         return 0;
1911     NodeMutationObserverData* data = rareData()->mutationObserverData();
1912     if (!data)
1913         return 0;
1914     return &data->transientRegistry;
1915 }
1916
1917 template<typename Registry>
1918 static inline void collectMatchingObserversForMutation(HashMap<MutationObserver*, MutationRecordDeliveryOptions>& observers, Registry* registry, Node* target, MutationObserver::MutationType type, const QualifiedName* attributeName)
1919 {
1920     if (!registry)
1921         return;
1922     for (typename Registry::iterator iter = registry->begin(); iter != registry->end(); ++iter) {
1923         const MutationObserverRegistration& registration = **iter;
1924         if (registration.shouldReceiveMutationFrom(target, type, attributeName)) {
1925             MutationRecordDeliveryOptions deliveryOptions = registration.deliveryOptions();
1926             HashMap<MutationObserver*, MutationRecordDeliveryOptions>::AddResult result = observers.add(registration.observer(), deliveryOptions);
1927             if (!result.isNewEntry)
1928                 result.iterator->value |= deliveryOptions;
1929         }
1930     }
1931 }
1932
1933 void Node::getRegisteredMutationObserversOfType(HashMap<MutationObserver*, MutationRecordDeliveryOptions>& observers, MutationObserver::MutationType type, const QualifiedName* attributeName)
1934 {
1935     ASSERT((type == MutationObserver::Attributes && attributeName) || !attributeName);
1936     collectMatchingObserversForMutation(observers, mutationObserverRegistry(), this, type, attributeName);
1937     collectMatchingObserversForMutation(observers, transientMutationObserverRegistry(), this, type, attributeName);
1938     for (Node* node = parentNode(); node; node = node->parentNode()) {
1939         collectMatchingObserversForMutation(observers, node->mutationObserverRegistry(), this, type, attributeName);
1940         collectMatchingObserversForMutation(observers, node->transientMutationObserverRegistry(), this, type, attributeName);
1941     }
1942 }
1943
1944 void Node::registerMutationObserver(MutationObserver* observer, MutationObserverOptions options, const HashSet<AtomicString>& attributeFilter)
1945 {
1946     MutationObserverRegistration* registration = nullptr;
1947     auto& registry = ensureRareData().ensureMutationObserverData().registry;
1948
1949     for (size_t i = 0; i < registry.size(); ++i) {
1950         if (registry[i]->observer() == observer) {
1951             registration = registry[i].get();
1952             registration->resetObservation(options, attributeFilter);
1953         }
1954     }
1955
1956     if (!registration) {
1957         registry.append(std::make_unique<MutationObserverRegistration>(observer, this, options, attributeFilter));
1958         registration = registry.last().get();
1959     }
1960
1961     document().addMutationObserverTypes(registration->mutationTypes());
1962 }
1963
1964 void Node::unregisterMutationObserver(MutationObserverRegistration* registration)
1965 {
1966     auto* registry = mutationObserverRegistry();
1967     ASSERT(registry);
1968     if (!registry)
1969         return;
1970
1971     for (size_t i = 0; i < registry->size(); ++i) {
1972         if (registry->at(i).get() == registration) {
1973             registry->remove(i);
1974             return;
1975         }
1976     }
1977 }
1978
1979 void Node::registerTransientMutationObserver(MutationObserverRegistration* registration)
1980 {
1981     ensureRareData().ensureMutationObserverData().transientRegistry.add(registration);
1982 }
1983
1984 void Node::unregisterTransientMutationObserver(MutationObserverRegistration* registration)
1985 {
1986     HashSet<MutationObserverRegistration*>* transientRegistry = transientMutationObserverRegistry();
1987     ASSERT(transientRegistry);
1988     if (!transientRegistry)
1989         return;
1990
1991     ASSERT(transientRegistry->contains(registration));
1992     transientRegistry->remove(registration);
1993 }
1994
1995 void Node::notifyMutationObserversNodeWillDetach()
1996 {
1997     if (!document().hasMutationObservers())
1998         return;
1999
2000     for (Node* node = parentNode(); node; node = node->parentNode()) {
2001         if (auto* registry = node->mutationObserverRegistry()) {
2002             const size_t size = registry->size();
2003             for (size_t i = 0; i < size; ++i)
2004                 registry->at(i)->observedSubtreeNodeWillDetach(this);
2005         }
2006
2007         if (HashSet<MutationObserverRegistration*>* transientRegistry = node->transientMutationObserverRegistry()) {
2008             for (HashSet<MutationObserverRegistration*>::iterator iter = transientRegistry->begin(); iter != transientRegistry->end(); ++iter)
2009                 (*iter)->observedSubtreeNodeWillDetach(this);
2010         }
2011     }
2012 }
2013
2014 void Node::handleLocalEvents(Event& event)
2015 {
2016     if (!hasEventTargetData())
2017         return;
2018
2019     if (is<Element>(*this) && downcast<Element>(*this).isDisabledFormControl() && event.isMouseEvent())
2020         return;
2021
2022     fireEventListeners(&event);
2023 }
2024
2025 void Node::dispatchScopedEvent(PassRefPtr<Event> event)
2026 {
2027     EventDispatcher::dispatchScopedEvent(*this, event);
2028 }
2029
2030 bool Node::dispatchEvent(PassRefPtr<Event> event)
2031 {
2032 #if ENABLE(TOUCH_EVENTS) && !PLATFORM(IOS)
2033     if (is<TouchEvent>(*event))
2034         return dispatchTouchEvent(adoptRef(downcast<TouchEvent>(event.leakRef())));
2035 #endif
2036     return EventDispatcher::dispatchEvent(this, event);
2037 }
2038
2039 void Node::dispatchSubtreeModifiedEvent()
2040 {
2041     if (isInShadowTree())
2042         return;
2043
2044     ASSERT(!NoEventDispatchAssertion::isEventDispatchForbidden());
2045
2046     if (!document().hasListenerType(Document::DOMSUBTREEMODIFIED_LISTENER))
2047         return;
2048     const AtomicString& subtreeModifiedEventName = eventNames().DOMSubtreeModifiedEvent;
2049     if (!parentNode() && !hasEventListeners(subtreeModifiedEventName))
2050         return;
2051
2052     dispatchScopedEvent(MutationEvent::create(subtreeModifiedEventName, true));
2053 }
2054
2055 bool Node::dispatchDOMActivateEvent(int detail, PassRefPtr<Event> underlyingEvent)
2056 {
2057     ASSERT(!NoEventDispatchAssertion::isEventDispatchForbidden());
2058     RefPtr<UIEvent> event = UIEvent::create(eventNames().DOMActivateEvent, true, true, document().defaultView(), detail);
2059     event->setUnderlyingEvent(underlyingEvent);
2060     dispatchScopedEvent(event);
2061     return event->defaultHandled();
2062 }
2063
2064 #if ENABLE(TOUCH_EVENTS) && !PLATFORM(IOS)
2065 bool Node::dispatchTouchEvent(PassRefPtr<TouchEvent> event)
2066 {
2067     return EventDispatcher::dispatchEvent(this, event);
2068 }
2069 #endif
2070
2071 #if ENABLE(INDIE_UI)
2072 bool Node::dispatchUIRequestEvent(PassRefPtr<UIRequestEvent> event)
2073 {
2074     EventDispatcher::dispatchEvent(this, event);
2075     return event->defaultHandled() || event->defaultPrevented();
2076 }
2077 #endif
2078     
2079 bool Node::dispatchBeforeLoadEvent(const String& sourceURL)
2080 {
2081     if (!document().hasListenerType(Document::BEFORELOAD_LISTENER))
2082         return true;
2083
2084     Ref<Node> protect(*this);
2085     RefPtr<BeforeLoadEvent> beforeLoadEvent = BeforeLoadEvent::create(sourceURL);
2086     dispatchEvent(beforeLoadEvent.get());
2087     return !beforeLoadEvent->defaultPrevented();
2088 }
2089
2090 void Node::dispatchInputEvent()
2091 {
2092     dispatchScopedEvent(Event::create(eventNames().inputEvent, true, false));
2093 }
2094
2095 void Node::defaultEventHandler(Event* event)
2096 {
2097     if (event->target() != this)
2098         return;
2099     const AtomicString& eventType = event->type();
2100     if (eventType == eventNames().keydownEvent || eventType == eventNames().keypressEvent) {
2101         if (is<KeyboardEvent>(*event)) {
2102             if (Frame* frame = document().frame())
2103                 frame->eventHandler().defaultKeyboardEventHandler(downcast<KeyboardEvent>(event));
2104         }
2105     } else if (eventType == eventNames().clickEvent) {
2106         int detail = is<UIEvent>(*event) ? downcast<UIEvent>(*event).detail() : 0;
2107         if (dispatchDOMActivateEvent(detail, event))
2108             event->setDefaultHandled();
2109 #if ENABLE(CONTEXT_MENUS)
2110     } else if (eventType == eventNames().contextmenuEvent) {
2111         if (Frame* frame = document().frame())
2112             if (Page* page = frame->page())
2113                 page->contextMenuController().handleContextMenuEvent(event);
2114 #endif
2115     } else if (eventType == eventNames().textInputEvent) {
2116         if (is<TextEvent>(*event)) {
2117             if (Frame* frame = document().frame())
2118                 frame->eventHandler().defaultTextInputEventHandler(downcast<TextEvent>(event));
2119         }
2120 #if ENABLE(PAN_SCROLLING)
2121     } else if (eventType == eventNames().mousedownEvent && is<MouseEvent>(*event)) {
2122         if (downcast<MouseEvent>(*event).button() == MiddleButton) {
2123             if (enclosingLinkEventParentOrSelf())
2124                 return;
2125
2126             RenderObject* renderer = this->renderer();
2127             while (renderer && (!is<RenderBox>(*renderer) || !downcast<RenderBox>(*renderer).canBeScrolledAndHasScrollableArea()))
2128                 renderer = renderer->parent();
2129
2130             if (renderer) {
2131                 if (Frame* frame = document().frame())
2132                     frame->eventHandler().startPanScrolling(downcast<RenderBox>(renderer));
2133             }
2134         }
2135 #endif
2136     } else if ((eventType == eventNames().wheelEvent || eventType == eventNames().mousewheelEvent) && is<WheelEvent>(*event)) {
2137
2138         // If we don't have a renderer, send the wheel event to the first node we find with a renderer.
2139         // This is needed for <option> and <optgroup> elements so that <select>s get a wheel scroll.
2140         Node* startNode = this;
2141         while (startNode && !startNode->renderer())
2142             startNode = startNode->parentOrShadowHostNode();
2143         
2144         if (startNode && startNode->renderer())
2145             if (Frame* frame = document().frame())
2146                 frame->eventHandler().defaultWheelEventHandler(startNode, downcast<WheelEvent>(event));
2147 #if ENABLE(TOUCH_EVENTS) && PLATFORM(IOS)
2148     } else if (is<TouchEvent>(*event) && eventNames().isTouchEventType(eventType)) {
2149         RenderObject* renderer = this->renderer();
2150         while (renderer && (!is<RenderBox>(*renderer) || !downcast<RenderBox>(*renderer).canBeScrolledAndHasScrollableArea()))
2151             renderer = renderer->parent();
2152
2153         if (renderer && renderer->node()) {
2154             if (Frame* frame = document().frame())
2155                 frame->eventHandler().defaultTouchEventHandler(renderer->node(), downcast<TouchEvent>(event));
2156         }
2157 #endif
2158     } else if (event->type() == eventNames().webkitEditableContentChangedEvent) {
2159         dispatchInputEvent();
2160     }
2161 }
2162
2163 bool Node::willRespondToMouseMoveEvents()
2164 {
2165     // FIXME: Why is the iOS code path different from the non-iOS code path?
2166 #if !PLATFORM(IOS)
2167     if (!is<Element>(*this))
2168         return false;
2169     if (downcast<Element>(*this).isDisabledFormControl())
2170         return false;
2171 #endif
2172     return hasEventListeners(eventNames().mousemoveEvent) || hasEventListeners(eventNames().mouseoverEvent) || hasEventListeners(eventNames().mouseoutEvent);
2173 }
2174
2175 bool Node::willRespondToMouseClickEvents()
2176 {
2177     // FIXME: Why is the iOS code path different from the non-iOS code path?
2178 #if PLATFORM(IOS)
2179     return isContentEditable() || hasEventListeners(eventNames().mouseupEvent) || hasEventListeners(eventNames().mousedownEvent) || hasEventListeners(eventNames().clickEvent);
2180 #else
2181     if (!is<Element>(*this))
2182         return false;
2183     if (downcast<Element>(*this).isDisabledFormControl())
2184         return false;
2185     return isContentEditable(UserSelectAllIsAlwaysNonEditable) || hasEventListeners(eventNames().mouseupEvent) || hasEventListeners(eventNames().mousedownEvent) || hasEventListeners(eventNames().clickEvent) || hasEventListeners(eventNames().DOMActivateEvent);
2186 #endif
2187 }
2188
2189 bool Node::willRespondToMouseWheelEvents()
2190 {
2191     return hasEventListeners(eventNames().mousewheelEvent);
2192 }
2193
2194 // It's important not to inline removedLastRef, because we don't want to inline the code to
2195 // delete a Node at each deref call site.
2196 void Node::removedLastRef()
2197 {
2198     // An explicit check for Document here is better than a virtual function since it is
2199     // faster for non-Document nodes, and because the call to removedLastRef that is inlined
2200     // at all deref call sites is smaller if it's a non-virtual function.
2201     if (is<Document>(*this)) {
2202         downcast<Document>(*this).removedLastRef();
2203         return;
2204     }
2205
2206 #ifndef NDEBUG
2207     m_deletionHasBegun = true;
2208 #endif
2209     delete this;
2210 }
2211
2212 void Node::textRects(Vector<IntRect>& rects) const
2213 {
2214     RefPtr<Range> range = Range::create(document());
2215     range->selectNodeContents(const_cast<Node*>(this), IGNORE_EXCEPTION);
2216     range->textRects(rects);
2217 }
2218
2219 unsigned Node::connectedSubframeCount() const
2220 {
2221     return hasRareData() ? rareData()->connectedSubframeCount() : 0;
2222 }
2223
2224 void Node::incrementConnectedSubframeCount(unsigned amount)
2225 {
2226     ASSERT(isContainerNode());
2227     ensureRareData().incrementConnectedSubframeCount(amount);
2228 }
2229
2230 void Node::decrementConnectedSubframeCount(unsigned amount)
2231 {
2232     rareData()->decrementConnectedSubframeCount(amount);
2233 }
2234
2235 void Node::updateAncestorConnectedSubframeCountForRemoval() const
2236 {
2237     unsigned count = connectedSubframeCount();
2238
2239     if (!count)
2240         return;
2241
2242     for (Node* node = parentOrShadowHostNode(); node; node = node->parentOrShadowHostNode())
2243         node->decrementConnectedSubframeCount(count);
2244 }
2245
2246 void Node::updateAncestorConnectedSubframeCountForInsertion() const
2247 {
2248     unsigned count = connectedSubframeCount();
2249
2250     if (!count)
2251         return;
2252
2253     for (Node* node = parentOrShadowHostNode(); node; node = node->parentOrShadowHostNode())
2254         node->incrementConnectedSubframeCount(count);
2255 }
2256
2257 bool Node::inRenderedDocument() const
2258 {
2259     return inDocument() && document().hasLivingRenderTree();
2260 }
2261
2262 IntRect rendererBoundingBox(const Node& node)
2263 {
2264     if (RenderObject* renderer = node.renderer())
2265         return renderer->absoluteBoundingBoxRect();
2266     return IntRect();
2267 }
2268
2269 } // namespace WebCore
2270
2271 #ifndef NDEBUG
2272
2273 void showTree(const WebCore::Node* node)
2274 {
2275     if (node)
2276         node->showTreeForThis();
2277 }
2278
2279 void showNodePath(const WebCore::Node* node)
2280 {
2281     if (node)
2282         node->showNodePathForThis();
2283 }
2284
2285 #endif