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