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