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