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