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