Source/WebCore: Remove Node::attached()
[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/Operations.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 (unsigned i = 0; i < elem->attributeCount(); i++) {
1137                     const Attribute& attribute = elem->attributeAt(i);
1138                     
1139                     if (attribute.localName() == xmlnsAtom)
1140                         return attribute.value() == namespaceURI;
1141                 }
1142             }
1143
1144             if (Element* ancestor = ancestorElement())
1145                 return ancestor->isDefaultNamespace(namespaceURI);
1146
1147             return false;
1148         }
1149         case DOCUMENT_NODE:
1150             if (Element* de = toDocument(this)->documentElement())
1151                 return de->isDefaultNamespace(namespaceURI);
1152             return false;
1153         case ENTITY_NODE:
1154         case NOTATION_NODE:
1155         case DOCUMENT_TYPE_NODE:
1156         case DOCUMENT_FRAGMENT_NODE:
1157             return false;
1158         case ATTRIBUTE_NODE: {
1159             const Attr* attr = static_cast<const Attr*>(this);
1160             if (attr->ownerElement())
1161                 return attr->ownerElement()->isDefaultNamespace(namespaceURI);
1162             return false;
1163         }
1164         default:
1165             if (Element* ancestor = ancestorElement())
1166                 return ancestor->isDefaultNamespace(namespaceURI);
1167             return false;
1168     }
1169 }
1170
1171 String Node::lookupPrefix(const AtomicString &namespaceURI) const
1172 {
1173     // Implemented according to
1174     // http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/namespaces-algorithms.html#lookupNamespacePrefixAlgo
1175     
1176     if (namespaceURI.isEmpty())
1177         return String();
1178     
1179     switch (nodeType()) {
1180         case ELEMENT_NODE:
1181             return lookupNamespacePrefix(namespaceURI, static_cast<const Element *>(this));
1182         case DOCUMENT_NODE:
1183             if (Element* de = toDocument(this)->documentElement())
1184                 return de->lookupPrefix(namespaceURI);
1185             return String();
1186         case ENTITY_NODE:
1187         case NOTATION_NODE:
1188         case DOCUMENT_FRAGMENT_NODE:
1189         case DOCUMENT_TYPE_NODE:
1190             return String();
1191         case ATTRIBUTE_NODE: {
1192             const Attr *attr = static_cast<const Attr *>(this);
1193             if (attr->ownerElement())
1194                 return attr->ownerElement()->lookupPrefix(namespaceURI);
1195             return String();
1196         }
1197         default:
1198             if (Element* ancestor = ancestorElement())
1199                 return ancestor->lookupPrefix(namespaceURI);
1200             return String();
1201     }
1202 }
1203
1204 String Node::lookupNamespaceURI(const String &prefix) const
1205 {
1206     // Implemented according to
1207     // http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/namespaces-algorithms.html#lookupNamespaceURIAlgo
1208     
1209     if (!prefix.isNull() && prefix.isEmpty())
1210         return String();
1211     
1212     switch (nodeType()) {
1213         case ELEMENT_NODE: {
1214             const Element *elem = static_cast<const Element *>(this);
1215             
1216             if (!elem->namespaceURI().isNull() && elem->prefix() == prefix)
1217                 return elem->namespaceURI();
1218             
1219             if (elem->hasAttributes()) {
1220                 for (unsigned i = 0; i < elem->attributeCount(); i++) {
1221                     const Attribute& attribute = elem->attributeAt(i);
1222                     
1223                     if (attribute.prefix() == xmlnsAtom && attribute.localName() == prefix) {
1224                         if (!attribute.value().isEmpty())
1225                             return attribute.value();
1226                         
1227                         return String();
1228                     }
1229                     if (attribute.localName() == xmlnsAtom && prefix.isNull()) {
1230                         if (!attribute.value().isEmpty())
1231                             return attribute.value();
1232                         
1233                         return String();
1234                     }
1235                 }
1236             }
1237             if (Element* ancestor = ancestorElement())
1238                 return ancestor->lookupNamespaceURI(prefix);
1239             return String();
1240         }
1241         case DOCUMENT_NODE:
1242             if (Element* de = toDocument(this)->documentElement())
1243                 return de->lookupNamespaceURI(prefix);
1244             return String();
1245         case ENTITY_NODE:
1246         case NOTATION_NODE:
1247         case DOCUMENT_TYPE_NODE:
1248         case DOCUMENT_FRAGMENT_NODE:
1249             return String();
1250         case ATTRIBUTE_NODE: {
1251             const Attr *attr = static_cast<const Attr *>(this);
1252             
1253             if (attr->ownerElement())
1254                 return attr->ownerElement()->lookupNamespaceURI(prefix);
1255             else
1256                 return String();
1257         }
1258         default:
1259             if (Element* ancestor = ancestorElement())
1260                 return ancestor->lookupNamespaceURI(prefix);
1261             return String();
1262     }
1263 }
1264
1265 String Node::lookupNamespacePrefix(const AtomicString &_namespaceURI, const Element *originalElement) const
1266 {
1267     if (_namespaceURI.isNull())
1268         return String();
1269             
1270     if (originalElement->lookupNamespaceURI(prefix()) == _namespaceURI)
1271         return prefix();
1272     
1273     ASSERT(isElementNode());
1274     const Element* thisElement = toElement(this);
1275     if (thisElement->hasAttributes()) {
1276         for (unsigned i = 0; i < thisElement->attributeCount(); i++) {
1277             const Attribute& attribute = thisElement->attributeAt(i);
1278             
1279             if (attribute.prefix() == xmlnsAtom && attribute.value() == _namespaceURI
1280                 && originalElement->lookupNamespaceURI(attribute.localName()) == _namespaceURI)
1281                 return attribute.localName();
1282         }
1283     }
1284     
1285     if (Element* ancestor = ancestorElement())
1286         return ancestor->lookupNamespacePrefix(_namespaceURI, originalElement);
1287     return String();
1288 }
1289
1290 static void appendTextContent(const Node* node, bool convertBRsToNewlines, bool& isNullString, StringBuilder& content)
1291 {
1292     switch (node->nodeType()) {
1293     case Node::TEXT_NODE:
1294     case Node::CDATA_SECTION_NODE:
1295     case Node::COMMENT_NODE:
1296         isNullString = false;
1297         content.append(static_cast<const CharacterData*>(node)->data());
1298         break;
1299
1300     case Node::PROCESSING_INSTRUCTION_NODE:
1301         isNullString = false;
1302         content.append(static_cast<const ProcessingInstruction*>(node)->data());
1303         break;
1304     
1305     case Node::ELEMENT_NODE:
1306         if (node->hasTagName(brTag) && convertBRsToNewlines) {
1307             isNullString = false;
1308             content.append('\n');
1309             break;
1310         }
1311     // Fall through.
1312     case Node::ATTRIBUTE_NODE:
1313     case Node::ENTITY_NODE:
1314     case Node::ENTITY_REFERENCE_NODE:
1315     case Node::DOCUMENT_FRAGMENT_NODE:
1316         isNullString = false;
1317         for (Node* child = node->firstChild(); child; child = child->nextSibling()) {
1318             if (child->nodeType() == Node::COMMENT_NODE || child->nodeType() == Node::PROCESSING_INSTRUCTION_NODE)
1319                 continue;
1320             appendTextContent(child, convertBRsToNewlines, isNullString, content);
1321         }
1322         break;
1323
1324     case Node::DOCUMENT_NODE:
1325     case Node::DOCUMENT_TYPE_NODE:
1326     case Node::NOTATION_NODE:
1327     case Node::XPATH_NAMESPACE_NODE:
1328         break;
1329     }
1330 }
1331
1332 String Node::textContent(bool convertBRsToNewlines) const
1333 {
1334     StringBuilder content;
1335     bool isNullString = true;
1336     appendTextContent(this, convertBRsToNewlines, isNullString, content);
1337     return isNullString ? String() : content.toString();
1338 }
1339
1340 void Node::setTextContent(const String& text, ExceptionCode& ec)
1341 {           
1342     switch (nodeType()) {
1343         case TEXT_NODE:
1344         case CDATA_SECTION_NODE:
1345         case COMMENT_NODE:
1346         case PROCESSING_INSTRUCTION_NODE:
1347             setNodeValue(text, ec);
1348             return;
1349         case ELEMENT_NODE:
1350         case ATTRIBUTE_NODE:
1351         case ENTITY_NODE:
1352         case ENTITY_REFERENCE_NODE:
1353         case DOCUMENT_FRAGMENT_NODE: {
1354             Ref<ContainerNode> container(*toContainerNode(this));
1355             ChildListMutationScope mutation(container.get());
1356             container->removeChildren();
1357             if (!text.isEmpty())
1358                 container->appendChild(document().createTextNode(text), ec);
1359             return;
1360         }
1361         case DOCUMENT_NODE:
1362         case DOCUMENT_TYPE_NODE:
1363         case NOTATION_NODE:
1364         case XPATH_NAMESPACE_NODE:
1365             // Do nothing.
1366             return;
1367     }
1368     ASSERT_NOT_REACHED();
1369 }
1370
1371 Element* Node::ancestorElement() const
1372 {
1373     // In theory, there can be EntityReference nodes between elements, but this is currently not supported.
1374     for (ContainerNode* n = parentNode(); n; n = n->parentNode()) {
1375         if (n->isElementNode())
1376             return toElement(n);
1377     }
1378     return 0;
1379 }
1380
1381 bool Node::offsetInCharacters() const
1382 {
1383     return false;
1384 }
1385
1386 static inline unsigned short compareDetachedElementsPosition(Node* firstNode, Node* secondNode)
1387 {
1388     // If the 2 nodes are not in the same tree, return the result of adding DOCUMENT_POSITION_DISCONNECTED,
1389     // DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC, and either DOCUMENT_POSITION_PRECEDING or
1390     // DOCUMENT_POSITION_FOLLOWING, with the constraint that this is to be consistent. Whether to return
1391     // DOCUMENT_POSITION_PRECEDING or DOCUMENT_POSITION_FOLLOWING is implemented here via pointer
1392     // comparison.
1393     // See step 3 in http://www.w3.org/TR/2012/WD-dom-20121206/#dom-node-comparedocumentposition
1394     unsigned short direction = (firstNode > secondNode) ? Node::DOCUMENT_POSITION_PRECEDING : Node::DOCUMENT_POSITION_FOLLOWING;
1395     return Node::DOCUMENT_POSITION_DISCONNECTED | Node::DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC | direction;
1396 }
1397
1398 unsigned short Node::compareDocumentPosition(Node* otherNode)
1399 {
1400     // It is not clear what should be done if |otherNode| is 0.
1401     if (!otherNode)
1402         return DOCUMENT_POSITION_DISCONNECTED;
1403
1404     if (otherNode == this)
1405         return DOCUMENT_POSITION_EQUIVALENT;
1406     
1407     Attr* attr1 = isAttributeNode() ? toAttr(this) : nullptr;
1408     Attr* attr2 = otherNode->isAttributeNode() ? toAttr(otherNode) : nullptr;
1409     
1410     Node* start1 = attr1 ? attr1->ownerElement() : this;
1411     Node* start2 = attr2 ? attr2->ownerElement() : otherNode;
1412     
1413     // If either of start1 or start2 is null, then we are disconnected, since one of the nodes is
1414     // an orphaned attribute node.
1415     if (!start1 || !start2)
1416         return compareDetachedElementsPosition(this, otherNode);
1417
1418     Vector<Node*, 16> chain1;
1419     Vector<Node*, 16> chain2;
1420     if (attr1)
1421         chain1.append(attr1);
1422     if (attr2)
1423         chain2.append(attr2);
1424     
1425     if (attr1 && attr2 && start1 == start2 && start1) {
1426         // We are comparing two attributes on the same node. Crawl our attribute map and see which one we hit first.
1427         Element* owner1 = attr1->ownerElement();
1428         owner1->synchronizeAllAttributes();
1429         unsigned length = owner1->attributeCount();
1430         for (unsigned i = 0; i < length; ++i) {
1431             // If neither of the two determining nodes is a child node and nodeType is the same for both determining nodes, then an 
1432             // implementation-dependent order between the determining nodes is returned. This order is stable as long as no nodes of
1433             // the same nodeType are inserted into or removed from the direct container. This would be the case, for example, 
1434             // when comparing two attributes of the same element, and inserting or removing additional attributes might change 
1435             // the order between existing attributes.
1436             const Attribute& attribute = owner1->attributeAt(i);
1437             if (attr1->qualifiedName() == attribute.name())
1438                 return DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC | DOCUMENT_POSITION_FOLLOWING;
1439             if (attr2->qualifiedName() == attribute.name())
1440                 return DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC | DOCUMENT_POSITION_PRECEDING;
1441         }
1442         
1443         ASSERT_NOT_REACHED();
1444         return DOCUMENT_POSITION_DISCONNECTED;
1445     }
1446
1447     // If one node is in the document and the other is not, we must be disconnected.
1448     // If the nodes have different owning documents, they must be disconnected.  Note that we avoid
1449     // comparing Attr nodes here, since they return false from inDocument() all the time (which seems like a bug).
1450     if (start1->inDocument() != start2->inDocument() ||
1451         &start1->treeScope() != &start2->treeScope())
1452         return compareDetachedElementsPosition(this, otherNode);
1453
1454     // We need to find a common ancestor container, and then compare the indices of the two immediate children.
1455     Node* current;
1456     for (current = start1; current; current = current->parentNode())
1457         chain1.append(current);
1458     for (current = start2; current; current = current->parentNode())
1459         chain2.append(current);
1460
1461     unsigned index1 = chain1.size();
1462     unsigned index2 = chain2.size();
1463
1464     // If the two elements don't have a common root, they're not in the same tree.
1465     if (chain1[index1 - 1] != chain2[index2 - 1])
1466         return compareDetachedElementsPosition(this, otherNode);
1467
1468     // Walk the two chains backwards and look for the first difference.
1469     for (unsigned i = std::min(index1, index2); i; --i) {
1470         Node* child1 = chain1[--index1];
1471         Node* child2 = chain2[--index2];
1472         if (child1 != child2) {
1473             // If one of the children is an attribute, it wins.
1474             if (child1->nodeType() == ATTRIBUTE_NODE)
1475                 return DOCUMENT_POSITION_FOLLOWING;
1476             if (child2->nodeType() == ATTRIBUTE_NODE)
1477                 return DOCUMENT_POSITION_PRECEDING;
1478             
1479             if (!child2->nextSibling())
1480                 return DOCUMENT_POSITION_FOLLOWING;
1481             if (!child1->nextSibling())
1482                 return DOCUMENT_POSITION_PRECEDING;
1483
1484             // Otherwise we need to see which node occurs first.  Crawl backwards from child2 looking for child1.
1485             for (Node* child = child2->previousSibling(); child; child = child->previousSibling()) {
1486                 if (child == child1)
1487                     return DOCUMENT_POSITION_FOLLOWING;
1488             }
1489             return DOCUMENT_POSITION_PRECEDING;
1490         }
1491     }
1492     
1493     // There was no difference between the two parent chains, i.e., one was a subset of the other.  The shorter
1494     // chain is the ancestor.
1495     return index1 < index2 ? 
1496                DOCUMENT_POSITION_FOLLOWING | DOCUMENT_POSITION_CONTAINED_BY :
1497                DOCUMENT_POSITION_PRECEDING | DOCUMENT_POSITION_CONTAINS;
1498 }
1499
1500 FloatPoint Node::convertToPage(const FloatPoint& p) const
1501 {
1502     // If there is a renderer, just ask it to do the conversion
1503     if (renderer())
1504         return renderer()->localToAbsolute(p, UseTransforms);
1505     
1506     // Otherwise go up the tree looking for a renderer
1507     Element *parent = ancestorElement();
1508     if (parent)
1509         return parent->convertToPage(p);
1510
1511     // No parent - no conversion needed
1512     return p;
1513 }
1514
1515 FloatPoint Node::convertFromPage(const FloatPoint& p) const
1516 {
1517     // If there is a renderer, just ask it to do the conversion
1518     if (renderer())
1519         return renderer()->absoluteToLocal(p, UseTransforms);
1520
1521     // Otherwise go up the tree looking for a renderer
1522     Element *parent = ancestorElement();
1523     if (parent)
1524         return parent->convertFromPage(p);
1525
1526     // No parent - no conversion needed
1527     return p;
1528 }
1529
1530 #ifndef NDEBUG
1531
1532 static void appendAttributeDesc(const Node* node, StringBuilder& stringBuilder, const QualifiedName& name, const char* attrDesc)
1533 {
1534     if (!node->isElementNode())
1535         return;
1536
1537     String attr = toElement(node)->getAttribute(name);
1538     if (attr.isEmpty())
1539         return;
1540
1541     stringBuilder.append(attrDesc);
1542     stringBuilder.append(attr);
1543 }
1544
1545 void Node::showNode(const char* prefix) const
1546 {
1547     if (!prefix)
1548         prefix = "";
1549     if (isTextNode()) {
1550         String value = nodeValue();
1551         value.replaceWithLiteral('\\', "\\\\");
1552         value.replaceWithLiteral('\n', "\\n");
1553         fprintf(stderr, "%s%s\t%p \"%s\"\n", prefix, nodeName().utf8().data(), this, value.utf8().data());
1554     } else {
1555         StringBuilder attrs;
1556         appendAttributeDesc(this, attrs, classAttr, " CLASS=");
1557         appendAttributeDesc(this, attrs, styleAttr, " STYLE=");
1558         fprintf(stderr, "%s%s\t%p%s\n", prefix, nodeName().utf8().data(), this, attrs.toString().utf8().data());
1559     }
1560 }
1561
1562 void Node::showTreeForThis() const
1563 {
1564     showTreeAndMark(this, "*");
1565 }
1566
1567 void Node::showNodePathForThis() const
1568 {
1569     Vector<const Node*, 16> chain;
1570     const Node* node = this;
1571     while (node->parentOrShadowHostNode()) {
1572         chain.append(node);
1573         node = node->parentOrShadowHostNode();
1574     }
1575     for (unsigned index = chain.size(); index > 0; --index) {
1576         const Node* node = chain[index - 1];
1577         if (node->isShadowRoot()) {
1578             int count = 0;
1579             for (const ShadowRoot* shadowRoot = toShadowRoot(node); shadowRoot && shadowRoot != node; shadowRoot = shadowRoot->shadowRoot())
1580                 ++count;
1581             fprintf(stderr, "/#shadow-root[%d]", count);
1582             continue;
1583         }
1584
1585         switch (node->nodeType()) {
1586         case ELEMENT_NODE: {
1587             fprintf(stderr, "/%s", node->nodeName().utf8().data());
1588
1589             const Element* element = toElement(node);
1590             const AtomicString& idattr = element->getIdAttribute();
1591             bool hasIdAttr = !idattr.isNull() && !idattr.isEmpty();
1592             if (node->previousSibling() || node->nextSibling()) {
1593                 int count = 0;
1594                 for (Node* previous = node->previousSibling(); previous; previous = previous->previousSibling())
1595                     if (previous->nodeName() == node->nodeName())
1596                         ++count;
1597                 if (hasIdAttr)
1598                     fprintf(stderr, "[@id=\"%s\" and position()=%d]", idattr.string().utf8().data(), count);
1599                 else
1600                     fprintf(stderr, "[%d]", count);
1601             } else if (hasIdAttr)
1602                 fprintf(stderr, "[@id=\"%s\"]", idattr.string().utf8().data());
1603             break;
1604         }
1605         case TEXT_NODE:
1606             fprintf(stderr, "/text()");
1607             break;
1608         case ATTRIBUTE_NODE:
1609             fprintf(stderr, "/@%s", node->nodeName().utf8().data());
1610             break;
1611         default:
1612             break;
1613         }
1614     }
1615     fprintf(stderr, "\n");
1616 }
1617
1618 static void traverseTreeAndMark(const String& baseIndent, const Node* rootNode, const Node* markedNode1, const char* markedLabel1, const Node* markedNode2, const char* markedLabel2)
1619 {
1620     for (const Node* node = rootNode; node; node = NodeTraversal::next(node)) {
1621         if (node == markedNode1)
1622             fprintf(stderr, "%s", markedLabel1);
1623         if (node == markedNode2)
1624             fprintf(stderr, "%s", markedLabel2);
1625
1626         StringBuilder indent;
1627         indent.append(baseIndent);
1628         for (const Node* tmpNode = node; tmpNode && tmpNode != rootNode; tmpNode = tmpNode->parentOrShadowHostNode())
1629             indent.append('\t');
1630         fprintf(stderr, "%s", indent.toString().utf8().data());
1631         node->showNode();
1632         indent.append('\t');
1633         if (!node->isShadowRoot()) {
1634             if (ShadowRoot* shadowRoot = node->shadowRoot())
1635                 traverseTreeAndMark(indent.toString(), shadowRoot, markedNode1, markedLabel1, markedNode2, markedLabel2);
1636         }
1637     }
1638 }
1639
1640 void Node::showTreeAndMark(const Node* markedNode1, const char* markedLabel1, const Node* markedNode2, const char* markedLabel2) const
1641 {
1642     const Node* rootNode;
1643     const Node* node = this;
1644     while (node->parentOrShadowHostNode() && !node->hasTagName(bodyTag))
1645         node = node->parentOrShadowHostNode();
1646     rootNode = node;
1647
1648     String startingIndent;
1649     traverseTreeAndMark(startingIndent, rootNode, markedNode1, markedLabel1, markedNode2, markedLabel2);
1650 }
1651
1652 void Node::formatForDebugger(char* buffer, unsigned length) const
1653 {
1654     String result;
1655     String s;
1656
1657     s = nodeName();
1658     if (s.isEmpty())
1659         result = "<none>";
1660     else
1661         result = s;
1662
1663     strncpy(buffer, result.utf8().data(), length - 1);
1664 }
1665
1666 static ContainerNode* parentOrShadowHostOrFrameOwner(const Node* node)
1667 {
1668     ContainerNode* parent = node->parentOrShadowHostNode();
1669     if (!parent && node->document().frame())
1670         parent = node->document().frame()->ownerElement();
1671     return parent;
1672 }
1673
1674 static void showSubTreeAcrossFrame(const Node* node, const Node* markedNode, const String& indent)
1675 {
1676     if (node == markedNode)
1677         fputs("*", stderr);
1678     fputs(indent.utf8().data(), stderr);
1679     node->showNode();
1680     if (!node->isShadowRoot()) {
1681         if (node->isFrameOwnerElement())
1682             showSubTreeAcrossFrame(static_cast<const HTMLFrameOwnerElement*>(node)->contentDocument(), markedNode, indent + "\t");
1683         if (ShadowRoot* shadowRoot = node->shadowRoot())
1684             showSubTreeAcrossFrame(shadowRoot, markedNode, indent + "\t");
1685     }
1686     for (Node* child = node->firstChild(); child; child = child->nextSibling())
1687         showSubTreeAcrossFrame(child, markedNode, indent + "\t");
1688 }
1689
1690 void Node::showTreeForThisAcrossFrame() const
1691 {
1692     Node* rootNode = const_cast<Node*>(this);
1693     while (parentOrShadowHostOrFrameOwner(rootNode))
1694         rootNode = parentOrShadowHostOrFrameOwner(rootNode);
1695     showSubTreeAcrossFrame(rootNode, this, "");
1696 }
1697
1698 #endif
1699
1700 // --------
1701
1702 void NodeListsNodeData::invalidateCaches(const QualifiedName* attrName)
1703 {
1704     for (auto it = m_atomicNameCaches.begin(), end = m_atomicNameCaches.end(); it != end; ++it)
1705         it->value->invalidateCache(attrName);
1706
1707     for (auto it = m_nameCaches.begin(), end = m_nameCaches.end(); it != end; ++it)
1708         it->value->invalidateCache(attrName);
1709
1710     for (auto it = m_cachedCollections.begin(), end = m_cachedCollections.end(); it != end; ++it)
1711         it->value->invalidateCache(attrName);
1712
1713     if (attrName)
1714         return;
1715
1716     for (auto it = m_tagNodeListCacheNS.begin(), end = m_tagNodeListCacheNS.end(); it != end; ++it)
1717         it->value->invalidateCache();
1718 }
1719
1720 void Node::getSubresourceURLs(ListHashSet<URL>& urls) const
1721 {
1722     addSubresourceAttributeURLs(urls);
1723 }
1724
1725 Element* Node::enclosingLinkEventParentOrSelf()
1726 {
1727     for (Node* node = this; node; node = node->parentOrShadowHostNode()) {
1728         // For imagemaps, the enclosing link element is the associated area element not the image itself.
1729         // So we don't let images be the enclosing link element, even though isLink sometimes returns
1730         // true for them.
1731         if (node->isLink() && !isHTMLImageElement(node))
1732             return toElement(node);
1733     }
1734
1735     return 0;
1736 }
1737
1738 EventTargetInterface Node::eventTargetInterface() const
1739 {
1740     return NodeEventTargetInterfaceType;
1741 }
1742
1743 void Node::didMoveToNewDocument(Document* oldDocument)
1744 {
1745     TreeScopeAdopter::ensureDidMoveToNewDocumentWasCalled(oldDocument);
1746
1747     if (const EventTargetData* eventTargetData = this->eventTargetData()) {
1748         const EventListenerMap& listenerMap = eventTargetData->eventListenerMap;
1749         if (!listenerMap.isEmpty()) {
1750             Vector<AtomicString> types = listenerMap.eventTypes();
1751             for (unsigned i = 0; i < types.size(); ++i)
1752                 document().addListenerTypeIfNeeded(types[i]);
1753         }
1754     }
1755
1756     if (AXObjectCache::accessibilityEnabled() && oldDocument)
1757         if (AXObjectCache* cache = oldDocument->existingAXObjectCache())
1758             cache->remove(this);
1759
1760     const EventListenerVector& mousewheelListeners = getEventListeners(eventNames().mousewheelEvent);
1761     for (size_t i = 0; i < mousewheelListeners.size(); ++i) {
1762         oldDocument->didRemoveWheelEventHandler();
1763         document().didAddWheelEventHandler();
1764     }
1765
1766     const EventListenerVector& wheelListeners = getEventListeners(eventNames().wheelEvent);
1767     for (size_t i = 0; i < wheelListeners.size(); ++i) {
1768         oldDocument->didRemoveWheelEventHandler();
1769         document().didAddWheelEventHandler();
1770     }
1771
1772     Vector<AtomicString> touchEventNames = eventNames().touchEventNames();
1773     for (size_t i = 0; i < touchEventNames.size(); ++i) {
1774         const EventListenerVector& listeners = getEventListeners(touchEventNames[i]);
1775         for (size_t j = 0; j < listeners.size(); ++j) {
1776             oldDocument->didRemoveTouchEventHandler(this);
1777             document().didAddTouchEventHandler(this);
1778         }
1779     }
1780
1781     if (Vector<OwnPtr<MutationObserverRegistration>>* registry = mutationObserverRegistry()) {
1782         for (size_t i = 0; i < registry->size(); ++i) {
1783             document().addMutationObserverTypes(registry->at(i)->mutationTypes());
1784         }
1785     }
1786
1787     if (HashSet<MutationObserverRegistration*>* transientRegistry = transientMutationObserverRegistry()) {
1788         for (HashSet<MutationObserverRegistration*>::iterator iter = transientRegistry->begin(); iter != transientRegistry->end(); ++iter) {
1789             document().addMutationObserverTypes((*iter)->mutationTypes());
1790         }
1791     }
1792 }
1793
1794 static inline bool tryAddEventListener(Node* targetNode, const AtomicString& eventType, PassRefPtr<EventListener> prpListener, bool useCapture)
1795 {
1796     RefPtr<EventListener> listener = prpListener;
1797
1798     if (!targetNode->EventTarget::addEventListener(eventType, listener, useCapture))
1799         return false;
1800
1801     targetNode->document().addListenerTypeIfNeeded(eventType);
1802     if (eventType == eventNames().wheelEvent || eventType == eventNames().mousewheelEvent)
1803         targetNode->document().didAddWheelEventHandler();
1804     else if (eventNames().isTouchEventType(eventType))
1805         targetNode->document().didAddTouchEventHandler(targetNode);
1806
1807 #if PLATFORM(IOS)
1808     if (targetNode == &targetNode->document() && eventType == eventNames().scrollEvent)
1809         targetNode->document().domWindow()->incrementScrollEventListenersCount();
1810
1811     // FIXME: Would it be sufficient to special-case this code for <body> and <frameset>?
1812     //
1813     // This code was added to address <rdar://problem/5846492> Onorientationchange event not working for document.body.
1814     // Forward this call to addEventListener() to the window since these are window-only events.
1815     if (eventType == eventNames().orientationchangeEvent || eventType == eventNames().resizeEvent)
1816         targetNode->document().domWindow()->addEventListener(eventType, listener, useCapture);
1817
1818 #if ENABLE(TOUCH_EVENTS)
1819     if (eventNames().isTouchEventType(eventType))
1820         targetNode->document().addTouchEventListener(targetNode);
1821 #endif
1822 #endif // PLATFORM(IOS)
1823
1824 #if ENABLE(IOS_GESTURE_EVENTS) && ENABLE(TOUCH_EVENTS)
1825     if (eventType == eventNames().gesturestartEvent || eventType == eventNames().gesturechangeEvent || eventType == eventNames().gestureendEvent)
1826         targetNode->document().addTouchEventListener(targetNode);
1827 #endif
1828
1829     return true;
1830 }
1831
1832 bool Node::addEventListener(const AtomicString& eventType, PassRefPtr<EventListener> listener, bool useCapture)
1833 {
1834     return tryAddEventListener(this, eventType, listener, useCapture);
1835 }
1836
1837 static inline bool tryRemoveEventListener(Node* targetNode, const AtomicString& eventType, EventListener* listener, bool useCapture)
1838 {
1839     if (!targetNode->EventTarget::removeEventListener(eventType, listener, useCapture))
1840         return false;
1841
1842     // FIXME: Notify Document that the listener has vanished. We need to keep track of a number of
1843     // listeners for each type, not just a bool - see https://bugs.webkit.org/show_bug.cgi?id=33861
1844     if (eventType == eventNames().wheelEvent || eventType == eventNames().mousewheelEvent)
1845         targetNode->document().didRemoveWheelEventHandler();
1846     else if (eventNames().isTouchEventType(eventType))
1847         targetNode->document().didRemoveTouchEventHandler(targetNode);
1848
1849 #if PLATFORM(IOS)
1850     if (targetNode == &targetNode->document() && eventType == eventNames().scrollEvent)
1851         targetNode->document().domWindow()->decrementScrollEventListenersCount();
1852
1853     // FIXME: Would it be sufficient to special-case this code for <body> and <frameset>? See <rdar://problem/15647823>.
1854     // This code was added to address <rdar://problem/5846492> Onorientationchange event not working for document.body.
1855     // Forward this call to removeEventListener() to the window since these are window-only events.
1856     if (eventType == eventNames().orientationchangeEvent || eventType == eventNames().resizeEvent)
1857         targetNode->document().domWindow()->removeEventListener(eventType, listener, useCapture);
1858
1859 #if ENABLE(TOUCH_EVENTS)
1860     if (eventNames().isTouchEventType(eventType))
1861         targetNode->document().removeTouchEventListener(targetNode);
1862 #endif
1863 #endif // PLATFORM(IOS)
1864
1865 #if ENABLE(IOS_GESTURE_EVENTS) && ENABLE(TOUCH_EVENTS)
1866     if (eventType == eventNames().gesturestartEvent || eventType == eventNames().gesturechangeEvent || eventType == eventNames().gestureendEvent)
1867         targetNode->document().removeTouchEventListener(targetNode);
1868 #endif
1869
1870     return true;
1871 }
1872
1873 bool Node::removeEventListener(const AtomicString& eventType, EventListener* listener, bool useCapture)
1874 {
1875     return tryRemoveEventListener(this, eventType, listener, useCapture);
1876 }
1877
1878 typedef HashMap<Node*, OwnPtr<EventTargetData>> EventTargetDataMap;
1879
1880 static EventTargetDataMap& eventTargetDataMap()
1881 {
1882     DEFINE_STATIC_LOCAL(EventTargetDataMap, map, ());
1883     return map;
1884 }
1885
1886 EventTargetData* Node::eventTargetData()
1887 {
1888     return hasEventTargetData() ? eventTargetDataMap().get(this) : 0;
1889 }
1890
1891 EventTargetData& Node::ensureEventTargetData()
1892 {
1893     if (hasEventTargetData())
1894         return *eventTargetDataMap().get(this);
1895     setHasEventTargetData(true);
1896     EventTargetData* data = new EventTargetData;
1897     eventTargetDataMap().set(this, adoptPtr(data));
1898     return *data;
1899 }
1900
1901 void Node::clearEventTargetData()
1902 {
1903     eventTargetDataMap().remove(this);
1904 }
1905
1906 Vector<OwnPtr<MutationObserverRegistration>>* Node::mutationObserverRegistry()
1907 {
1908     if (!hasRareData())
1909         return 0;
1910     NodeMutationObserverData* data = rareData()->mutationObserverData();
1911     if (!data)
1912         return 0;
1913     return &data->registry;
1914 }
1915
1916 HashSet<MutationObserverRegistration*>* Node::transientMutationObserverRegistry()
1917 {
1918     if (!hasRareData())
1919         return 0;
1920     NodeMutationObserverData* data = rareData()->mutationObserverData();
1921     if (!data)
1922         return 0;
1923     return &data->transientRegistry;
1924 }
1925
1926 template<typename Registry>
1927 static inline void collectMatchingObserversForMutation(HashMap<MutationObserver*, MutationRecordDeliveryOptions>& observers, Registry* registry, Node* target, MutationObserver::MutationType type, const QualifiedName* attributeName)
1928 {
1929     if (!registry)
1930         return;
1931     for (typename Registry::iterator iter = registry->begin(); iter != registry->end(); ++iter) {
1932         const MutationObserverRegistration& registration = **iter;
1933         if (registration.shouldReceiveMutationFrom(target, type, attributeName)) {
1934             MutationRecordDeliveryOptions deliveryOptions = registration.deliveryOptions();
1935             HashMap<MutationObserver*, MutationRecordDeliveryOptions>::AddResult result = observers.add(registration.observer(), deliveryOptions);
1936             if (!result.isNewEntry)
1937                 result.iterator->value |= deliveryOptions;
1938         }
1939     }
1940 }
1941
1942 void Node::getRegisteredMutationObserversOfType(HashMap<MutationObserver*, MutationRecordDeliveryOptions>& observers, MutationObserver::MutationType type, const QualifiedName* attributeName)
1943 {
1944     ASSERT((type == MutationObserver::Attributes && attributeName) || !attributeName);
1945     collectMatchingObserversForMutation(observers, mutationObserverRegistry(), this, type, attributeName);
1946     collectMatchingObserversForMutation(observers, transientMutationObserverRegistry(), this, type, attributeName);
1947     for (Node* node = parentNode(); node; node = node->parentNode()) {
1948         collectMatchingObserversForMutation(observers, node->mutationObserverRegistry(), this, type, attributeName);
1949         collectMatchingObserversForMutation(observers, node->transientMutationObserverRegistry(), this, type, attributeName);
1950     }
1951 }
1952
1953 void Node::registerMutationObserver(MutationObserver* observer, MutationObserverOptions options, const HashSet<AtomicString>& attributeFilter)
1954 {
1955     MutationObserverRegistration* registration = 0;
1956     Vector<OwnPtr<MutationObserverRegistration>>& registry = ensureRareData().ensureMutationObserverData().registry;
1957     for (size_t i = 0; i < registry.size(); ++i) {
1958         if (registry[i]->observer() == observer) {
1959             registration = registry[i].get();
1960             registration->resetObservation(options, attributeFilter);
1961         }
1962     }
1963
1964     if (!registration) {
1965         registry.append(MutationObserverRegistration::create(observer, this, options, attributeFilter));
1966         registration = registry.last().get();
1967     }
1968
1969     document().addMutationObserverTypes(registration->mutationTypes());
1970 }
1971
1972 void Node::unregisterMutationObserver(MutationObserverRegistration* registration)
1973 {
1974     Vector<OwnPtr<MutationObserverRegistration>>* registry = mutationObserverRegistry();
1975     ASSERT(registry);
1976     if (!registry)
1977         return;
1978
1979     size_t index = registry->find(registration);
1980     ASSERT(index != notFound);
1981     if (index == notFound)
1982         return;
1983
1984     registry->remove(index);
1985 }
1986
1987 void Node::registerTransientMutationObserver(MutationObserverRegistration* registration)
1988 {
1989     ensureRareData().ensureMutationObserverData().transientRegistry.add(registration);
1990 }
1991
1992 void Node::unregisterTransientMutationObserver(MutationObserverRegistration* registration)
1993 {
1994     HashSet<MutationObserverRegistration*>* transientRegistry = transientMutationObserverRegistry();
1995     ASSERT(transientRegistry);
1996     if (!transientRegistry)
1997         return;
1998
1999     ASSERT(transientRegistry->contains(registration));
2000     transientRegistry->remove(registration);
2001 }
2002
2003 void Node::notifyMutationObserversNodeWillDetach()
2004 {
2005     if (!document().hasMutationObservers())
2006         return;
2007
2008     for (Node* node = parentNode(); node; node = node->parentNode()) {
2009         if (Vector<OwnPtr<MutationObserverRegistration>>* registry = node->mutationObserverRegistry()) {
2010             const size_t size = registry->size();
2011             for (size_t i = 0; i < size; ++i)
2012                 registry->at(i)->observedSubtreeNodeWillDetach(this);
2013         }
2014
2015         if (HashSet<MutationObserverRegistration*>* transientRegistry = node->transientMutationObserverRegistry()) {
2016             for (HashSet<MutationObserverRegistration*>::iterator iter = transientRegistry->begin(); iter != transientRegistry->end(); ++iter)
2017                 (*iter)->observedSubtreeNodeWillDetach(this);
2018         }
2019     }
2020 }
2021
2022 void Node::handleLocalEvents(Event& event)
2023 {
2024     if (!hasEventTargetData())
2025         return;
2026
2027     if (isElementNode() && toElement(*this).isDisabledFormControl() && event.isMouseEvent())
2028         return;
2029
2030     fireEventListeners(&event);
2031 }
2032
2033 void Node::dispatchScopedEvent(PassRefPtr<Event> event)
2034 {
2035     EventDispatcher::dispatchScopedEvent(*this, event);
2036 }
2037
2038 bool Node::dispatchEvent(PassRefPtr<Event> event)
2039 {
2040 #if ENABLE(TOUCH_EVENTS) && !PLATFORM(IOS)
2041     if (event->isTouchEvent())
2042         return dispatchTouchEvent(adoptRef(toTouchEvent(event.leakRef())));
2043 #endif
2044     return EventDispatcher::dispatchEvent(this, event);
2045 }
2046
2047 void Node::dispatchSubtreeModifiedEvent()
2048 {
2049     if (isInShadowTree())
2050         return;
2051
2052     ASSERT(!NoEventDispatchAssertion::isEventDispatchForbidden());
2053
2054     if (!document().hasListenerType(Document::DOMSUBTREEMODIFIED_LISTENER))
2055         return;
2056     const AtomicString& subtreeModifiedEventName = eventNames().DOMSubtreeModifiedEvent;
2057     if (!parentNode() && !hasEventListeners(subtreeModifiedEventName))
2058         return;
2059
2060     dispatchScopedEvent(MutationEvent::create(subtreeModifiedEventName, true));
2061 }
2062
2063 bool Node::dispatchDOMActivateEvent(int detail, PassRefPtr<Event> underlyingEvent)
2064 {
2065     ASSERT(!NoEventDispatchAssertion::isEventDispatchForbidden());
2066     RefPtr<UIEvent> event = UIEvent::create(eventNames().DOMActivateEvent, true, true, document().defaultView(), detail);
2067     event->setUnderlyingEvent(underlyingEvent);
2068     dispatchScopedEvent(event);
2069     return event->defaultHandled();
2070 }
2071
2072 #if ENABLE(TOUCH_EVENTS) && !PLATFORM(IOS)
2073 bool Node::dispatchTouchEvent(PassRefPtr<TouchEvent> event)
2074 {
2075     return EventDispatcher::dispatchEvent(this, event);
2076 }
2077 #endif
2078
2079 #if ENABLE(INDIE_UI)
2080 bool Node::dispatchUIRequestEvent(PassRefPtr<UIRequestEvent> event)
2081 {
2082     EventDispatcher::dispatchEvent(this, event);
2083     return event->defaultHandled() || event->defaultPrevented();
2084 }
2085 #endif
2086     
2087 bool Node::dispatchBeforeLoadEvent(const String& sourceURL)
2088 {
2089     if (!document().hasListenerType(Document::BEFORELOAD_LISTENER))
2090         return true;
2091
2092     Ref<Node> protect(*this);
2093     RefPtr<BeforeLoadEvent> beforeLoadEvent = BeforeLoadEvent::create(sourceURL);
2094     dispatchEvent(beforeLoadEvent.get());
2095     return !beforeLoadEvent->defaultPrevented();
2096 }
2097
2098 void Node::dispatchInputEvent()
2099 {
2100     dispatchScopedEvent(Event::create(eventNames().inputEvent, true, false));
2101 }
2102
2103 void Node::defaultEventHandler(Event* event)
2104 {
2105     if (event->target() != this)
2106         return;
2107     const AtomicString& eventType = event->type();
2108     if (eventType == eventNames().keydownEvent || eventType == eventNames().keypressEvent) {
2109         if (event->isKeyboardEvent())
2110             if (Frame* frame = document().frame())
2111                 frame->eventHandler().defaultKeyboardEventHandler(static_cast<KeyboardEvent*>(event));
2112     } else if (eventType == eventNames().clickEvent) {
2113         int detail = event->isUIEvent() ? static_cast<UIEvent*>(event)->detail() : 0;
2114         if (dispatchDOMActivateEvent(detail, event))
2115             event->setDefaultHandled();
2116 #if ENABLE(CONTEXT_MENUS)
2117     } else if (eventType == eventNames().contextmenuEvent) {
2118         if (Frame* frame = document().frame())
2119             if (Page* page = frame->page())
2120                 page->contextMenuController().handleContextMenuEvent(event);
2121 #endif
2122     } else if (eventType == eventNames().textInputEvent) {
2123         if (event->eventInterface() == TextEventInterfaceType)
2124             if (Frame* frame = document().frame())
2125                 frame->eventHandler().defaultTextInputEventHandler(static_cast<TextEvent*>(event));
2126 #if ENABLE(PAN_SCROLLING)
2127     } else if (eventType == eventNames().mousedownEvent && event->isMouseEvent()) {
2128         MouseEvent* mouseEvent = static_cast<MouseEvent*>(event);
2129         if (mouseEvent->button() == MiddleButton) {
2130             if (enclosingLinkEventParentOrSelf())
2131                 return;
2132
2133             RenderObject* renderer = this->renderer();
2134             while (renderer && (!renderer->isBox() || !toRenderBox(renderer)->canBeScrolledAndHasScrollableArea()))
2135                 renderer = renderer->parent();
2136
2137             if (renderer) {
2138                 if (Frame* frame = document().frame())
2139                     frame->eventHandler().startPanScrolling(toRenderBox(renderer));
2140             }
2141         }
2142 #endif
2143     } else if ((eventType == eventNames().wheelEvent || eventType == eventNames().mousewheelEvent) && event->eventInterface() == WheelEventInterfaceType) {
2144         WheelEvent* wheelEvent = static_cast<WheelEvent*>(event);
2145         
2146         // If we don't have a renderer, send the wheel event to the first node we find with a renderer.
2147         // This is needed for <option> and <optgroup> elements so that <select>s get a wheel scroll.
2148         Node* startNode = this;
2149         while (startNode && !startNode->renderer())
2150             startNode = startNode->parentOrShadowHostNode();
2151         
2152         if (startNode && startNode->renderer())
2153             if (Frame* frame = document().frame())
2154                 frame->eventHandler().defaultWheelEventHandler(startNode, wheelEvent);
2155 #if ENABLE(TOUCH_EVENTS) && PLATFORM(IOS)
2156     } else if (event->eventInterface() == TouchEventInterfaceType && eventNames().isTouchEventType(eventType)) {
2157         TouchEvent* touchEvent = static_cast<TouchEvent*>(event);
2158
2159         RenderObject* renderer = this->renderer();
2160         while (renderer && (!renderer->isBox() || !toRenderBox(renderer)->canBeScrolledAndHasScrollableArea()))
2161             renderer = renderer->parent();
2162
2163         if (renderer && renderer->node()) {
2164             if (Frame* frame = document().frame())
2165                 frame->eventHandler().defaultTouchEventHandler(renderer->node(), touchEvent);
2166         }
2167 #endif
2168     } else if (event->type() == eventNames().webkitEditableContentChangedEvent) {
2169         dispatchInputEvent();
2170     }
2171 }
2172
2173 bool Node::willRespondToMouseMoveEvents()
2174 {
2175     // FIXME: Why is the iOS code path different from the non-iOS code path?
2176 #if !PLATFORM(IOS)
2177     if (!isElementNode())
2178         return false;
2179     if (toElement(this)->isDisabledFormControl())
2180         return false;
2181 #endif
2182     return hasEventListeners(eventNames().mousemoveEvent) || hasEventListeners(eventNames().mouseoverEvent) || hasEventListeners(eventNames().mouseoutEvent);
2183 }
2184
2185 bool Node::willRespondToMouseClickEvents()
2186 {
2187     // FIXME: Why is the iOS code path different from the non-iOS code path?
2188 #if PLATFORM(IOS)
2189     return isContentEditable() || hasEventListeners(eventNames().mouseupEvent) || hasEventListeners(eventNames().mousedownEvent) || hasEventListeners(eventNames().clickEvent);
2190 #else
2191     if (!isElementNode())
2192         return false;
2193     if (toElement(this)->isDisabledFormControl())
2194         return false;
2195     return isContentEditable(UserSelectAllIsAlwaysNonEditable) || hasEventListeners(eventNames().mouseupEvent) || hasEventListeners(eventNames().mousedownEvent) || hasEventListeners(eventNames().clickEvent) || hasEventListeners(eventNames().DOMActivateEvent);
2196 #endif
2197 }
2198
2199 bool Node::willRespondToMouseWheelEvents()
2200 {
2201     return hasEventListeners(eventNames().mousewheelEvent);
2202 }
2203
2204 bool Node::willRespondToTouchEvents()
2205 {
2206 #if ENABLE(TOUCH_EVENTS)
2207     if (!isElementNode())
2208         return false;
2209     if (toElement(this)->isDisabledFormControl())
2210         return false;
2211     return hasEventListeners(eventNames().touchstartEvent) || hasEventListeners(eventNames().touchmoveEvent) || hasEventListeners(eventNames().touchcancelEvent) || hasEventListeners(eventNames().touchendEvent);
2212 #else
2213     return false;
2214 #endif
2215 }
2216
2217 // This is here so it can be inlined into Node::removedLastRef.
2218 // FIXME: Really? Seems like this could be inlined into Node::removedLastRef if it was in TreeScope.h.
2219 // FIXME: It also not seem important to inline this. Is this really hot?
2220 inline void TreeScope::removedLastRefToScope()
2221 {
2222     ASSERT(!deletionHasBegun());
2223     if (m_selfOnlyRefCount) {
2224         // If removing a child removes the last self-only ref, we don't want the scope to be destroyed
2225         // until after removeDetachedChildren returns, so we protect ourselves with an extra self-only ref.
2226         selfOnlyRef();
2227         dropChildren();
2228 #ifndef NDEBUG
2229         // We need to do this right now since selfOnlyDeref() can delete this.
2230         rootNode()->m_inRemovedLastRefFunction = false;
2231 #endif
2232         selfOnlyDeref();
2233     } else {
2234 #ifndef NDEBUG
2235         rootNode()->m_inRemovedLastRefFunction = false;
2236         beginDeletion();
2237 #endif
2238         delete this;
2239     }
2240 }
2241
2242 // It's important not to inline removedLastRef, because we don't want to inline the code to
2243 // delete a Node at each deref call site.
2244 void Node::removedLastRef()
2245 {
2246     // An explicit check for Document here is better than a virtual function since it is
2247     // faster for non-Document nodes, and because the call to removedLastRef that is inlined
2248     // at all deref call sites is smaller if it's a non-virtual function.
2249     if (isTreeScope()) {
2250         treeScope().removedLastRefToScope();
2251         return;
2252     }
2253
2254 #ifndef NDEBUG
2255     m_deletionHasBegun = true;
2256 #endif
2257     delete this;
2258 }
2259
2260 void Node::textRects(Vector<IntRect>& rects) const
2261 {
2262     RefPtr<Range> range = Range::create(document());
2263     range->selectNodeContents(const_cast<Node*>(this), IGNORE_EXCEPTION);
2264     range->textRects(rects);
2265 }
2266
2267 unsigned Node::connectedSubframeCount() const
2268 {
2269     return hasRareData() ? rareData()->connectedSubframeCount() : 0;
2270 }
2271
2272 void Node::incrementConnectedSubframeCount(unsigned amount)
2273 {
2274     ASSERT(isContainerNode());
2275     ensureRareData().incrementConnectedSubframeCount(amount);
2276 }
2277
2278 void Node::decrementConnectedSubframeCount(unsigned amount)
2279 {
2280     rareData()->decrementConnectedSubframeCount(amount);
2281 }
2282
2283 void Node::updateAncestorConnectedSubframeCountForRemoval() const
2284 {
2285     unsigned count = connectedSubframeCount();
2286
2287     if (!count)
2288         return;
2289
2290     for (Node* node = parentOrShadowHostNode(); node; node = node->parentOrShadowHostNode())
2291         node->decrementConnectedSubframeCount(count);
2292 }
2293
2294 void Node::updateAncestorConnectedSubframeCountForInsertion() const
2295 {
2296     unsigned count = connectedSubframeCount();
2297
2298     if (!count)
2299         return;
2300
2301     for (Node* node = parentOrShadowHostNode(); node; node = node->parentOrShadowHostNode())
2302         node->incrementConnectedSubframeCount(count);
2303 }
2304
2305 bool Node::inRenderedDocument() const
2306 {
2307     return inDocument() && document().hasLivingRenderTree();
2308 }
2309
2310 } // namespace WebCore
2311
2312 #ifndef NDEBUG
2313
2314 void showTree(const WebCore::Node* node)
2315 {
2316     if (node)
2317         node->showTreeForThis();
2318 }
2319
2320 void showNodePath(const WebCore::Node* node)
2321 {
2322     if (node)
2323         node->showNodePathForThis();
2324 }
2325
2326 #endif