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