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