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