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