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