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