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