c644ba1f9b38a80992ab03e2eddb009f9c0ce0ee
[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 "Attribute.h"
31 #include "BeforeLoadEvent.h"
32 #include "ChildListMutationScope.h"
33 #include "Chrome.h"
34 #include "ChromeClient.h"
35 #include "CSSParser.h"
36 #include "CSSRule.h"
37 #include "CSSSelector.h"
38 #include "CSSSelectorList.h"
39 #include "CSSStyleRule.h"
40 #include "CSSStyleSheet.h"
41 #include "ChildNodeList.h"
42 #include "ClassNodeList.h"
43 #include "ContextMenuController.h"
44 #include "DOMImplementation.h"
45 #include "DOMSettableTokenList.h"
46 #include "Document.h"
47 #include "DocumentType.h"
48 #include "DynamicNodeList.h"
49 #include "Element.h"
50 #include "ElementShadow.h"
51 #include "Event.h"
52 #include "EventContext.h"
53 #include "EventDispatchMediator.h"
54 #include "EventDispatcher.h"
55 #include "EventException.h"
56 #include "EventHandler.h"
57 #include "EventListener.h"
58 #include "EventNames.h"
59 #include "ExceptionCode.h"
60 #include "Frame.h"
61 #include "FrameView.h"
62 #include "HTMLElement.h"
63 #include "HTMLFrameOwnerElement.h"
64 #include "HTMLNames.h"
65 #include "InspectorCounters.h"
66 #include "KeyboardEvent.h"
67 #include "LabelsNodeList.h"
68 #include "Logging.h"
69 #include "MouseEvent.h"
70 #include "MutationEvent.h"
71 #include "NameNodeList.h"
72 #include "NamedNodeMap.h"
73 #include "NodeRareData.h"
74 #include "NodeRenderingContext.h"
75 #include "Page.h"
76 #include "PlatformMouseEvent.h"
77 #include "PlatformWheelEvent.h"
78 #include "ProcessingInstruction.h"
79 #include "ProgressEvent.h"
80 #include "RegisteredEventListener.h"
81 #include "RenderBlock.h"
82 #include "RenderBox.h"
83 #include "RenderTextControl.h"
84 #include "RenderView.h"
85 #include "ScopedEventQueue.h"
86 #include "SelectorQuery.h"
87 #include "Settings.h"
88 #include "ShadowRoot.h"
89 #include "StaticNodeList.h"
90 #include "StorageEvent.h"
91 #include "StyleResolver.h"
92 #include "TagNodeList.h"
93 #include "Text.h"
94 #include "TextEvent.h"
95 #include "TreeScopeAdopter.h"
96 #include "UIEvent.h"
97 #include "UIEventWithKeyState.h"
98 #include "WheelEvent.h"
99 #include "WindowEventContext.h"
100 #include "XMLNames.h"
101 #include "htmlediting.h"
102 #include <wtf/HashSet.h>
103 #include <wtf/PassOwnPtr.h>
104 #include <wtf/RefCountedLeakCounter.h>
105 #include <wtf/UnusedParam.h>
106 #include <wtf/Vector.h>
107 #include <wtf/text/CString.h>
108 #include <wtf/text/StringBuilder.h>
109
110 #if ENABLE(INSPECTOR)
111 #include "InspectorController.h"
112 #endif
113
114 #if ENABLE(SVG)
115 #include "SVGElementInstance.h"
116 #include "SVGUseElement.h"
117 #endif
118
119 #if USE(JSC)
120 #include <runtime/JSGlobalData.h>
121 #endif
122
123 #if ENABLE(MICRODATA)
124 #include "HTMLPropertiesCollection.h"
125 #endif
126
127 using namespace std;
128
129 namespace WebCore {
130
131 using namespace HTMLNames;
132
133 bool Node::isSupported(const String& feature, const String& version)
134 {
135     return DOMImplementation::hasFeature(feature, version);
136 }
137
138 #if DUMP_NODE_STATISTICS
139 static HashSet<Node*> liveNodeSet;
140 #endif
141
142 void Node::dumpStatistics()
143 {
144 #if DUMP_NODE_STATISTICS
145     size_t nodesWithRareData = 0;
146
147     size_t elementNodes = 0;
148     size_t attrNodes = 0;
149     size_t textNodes = 0;
150     size_t cdataNodes = 0;
151     size_t commentNodes = 0;
152     size_t entityReferenceNodes = 0;
153     size_t entityNodes = 0;
154     size_t piNodes = 0;
155     size_t documentNodes = 0;
156     size_t docTypeNodes = 0;
157     size_t fragmentNodes = 0;
158     size_t notationNodes = 0;
159     size_t xpathNSNodes = 0;
160     size_t shadowRootNodes = 0;
161
162     HashMap<String, size_t> perTagCount;
163
164     size_t attributes = 0;
165     size_t attributesWithAttr = 0;
166     size_t elementsWithAttributeStorage = 0;
167     size_t elementsWithRareData = 0;
168     size_t elementsWithNamedNodeMap = 0;
169
170     for (HashSet<Node*>::iterator it = liveNodeSet.begin(); it != liveNodeSet.end(); ++it) {
171         Node* node = *it;
172
173         if (node->hasRareData()) {
174             ++nodesWithRareData;
175             if (node->isElementNode()) {
176                 ++elementsWithRareData;
177                 if (toElement(node)->hasNamedNodeMap())
178                     ++elementsWithNamedNodeMap;
179             }
180         }
181
182         switch (node->nodeType()) {
183             case ELEMENT_NODE: {
184                 ++elementNodes;
185
186                 // Tag stats
187                 Element* element = static_cast<Element*>(node);
188                 HashMap<String, size_t>::AddResult result = perTagCount.add(element->tagName(), 1);
189                 if (!result.isNewEntry)
190                     result.iterator->second++;
191
192                 if (ElementAttributeData* attributeData = element->attributeData()) {
193                     attributes += attributeData->length();
194                     ++elementsWithAttributeStorage;
195                     for (unsigned i = 0; i < attributeData->length(); ++i) {
196                         Attribute* attr = attributeData->attributeItem(i);
197                         if (attr->attr())
198                             ++attributesWithAttr;
199                     }
200                 }
201                 break;
202             }
203             case ATTRIBUTE_NODE: {
204                 ++attrNodes;
205                 break;
206             }
207             case TEXT_NODE: {
208                 ++textNodes;
209                 break;
210             }
211             case CDATA_SECTION_NODE: {
212                 ++cdataNodes;
213                 break;
214             }
215             case COMMENT_NODE: {
216                 ++commentNodes;
217                 break;
218             }
219             case ENTITY_REFERENCE_NODE: {
220                 ++entityReferenceNodes;
221                 break;
222             }
223             case ENTITY_NODE: {
224                 ++entityNodes;
225                 break;
226             }
227             case PROCESSING_INSTRUCTION_NODE: {
228                 ++piNodes;
229                 break;
230             }
231             case DOCUMENT_NODE: {
232                 ++documentNodes;
233                 break;
234             }
235             case DOCUMENT_TYPE_NODE: {
236                 ++docTypeNodes;
237                 break;
238             }
239             case DOCUMENT_FRAGMENT_NODE: {
240                 if (node->isShadowRoot())
241                     ++shadowRootNodes;
242                 else
243                     ++fragmentNodes;
244                 break;
245             }
246             case NOTATION_NODE: {
247                 ++notationNodes;
248                 break;
249             }
250             case XPATH_NAMESPACE_NODE: {
251                 ++xpathNSNodes;
252                 break;
253             }
254         }
255     }
256
257     printf("Number of Nodes: %d\n\n", liveNodeSet.size());
258     printf("Number of Nodes with RareData: %zu\n\n", nodesWithRareData);
259
260     printf("NodeType distribution:\n");
261     printf("  Number of Element nodes: %zu\n", elementNodes);
262     printf("  Number of Attribute nodes: %zu\n", attrNodes);
263     printf("  Number of Text nodes: %zu\n", textNodes);
264     printf("  Number of CDATASection nodes: %zu\n", cdataNodes);
265     printf("  Number of Comment nodes: %zu\n", commentNodes);
266     printf("  Number of EntityReference nodes: %zu\n", entityReferenceNodes);
267     printf("  Number of Entity nodes: %zu\n", entityNodes);
268     printf("  Number of ProcessingInstruction nodes: %zu\n", piNodes);
269     printf("  Number of Document nodes: %zu\n", documentNodes);
270     printf("  Number of DocumentType nodes: %zu\n", docTypeNodes);
271     printf("  Number of DocumentFragment nodes: %zu\n", fragmentNodes);
272     printf("  Number of Notation nodes: %zu\n", notationNodes);
273     printf("  Number of XPathNS nodes: %zu\n", xpathNSNodes);
274     printf("  Number of ShadowRoot nodes: %zu\n", shadowRootNodes);
275
276     printf("Element tag name distibution:\n");
277     for (HashMap<String, size_t>::iterator it = perTagCount.begin(); it != perTagCount.end(); ++it)
278         printf("  Number of <%s> tags: %zu\n", it->first.utf8().data(), it->second);
279
280     printf("Attributes:\n");
281     printf("  Number of Attributes (non-Node and Node): %zu [%zu]\n", attributes, sizeof(Attribute));
282     printf("  Number of Attributes with an Attr: %zu\n", attributesWithAttr);
283     printf("  Number of Elements with attribute storage: %zu [%zu]\n", elementsWithAttributeStorage, sizeof(ElementAttributeData));
284     printf("  Number of Elements with RareData: %zu\n", elementsWithRareData);
285     printf("  Number of Elements with NamedNodeMap: %zu [%zu]\n", elementsWithNamedNodeMap, sizeof(NamedNodeMap));
286 #endif
287 }
288
289 DEFINE_DEBUG_ONLY_GLOBAL(WTF::RefCountedLeakCounter, nodeCounter, ("WebCoreNode"));
290 DEFINE_DEBUG_ONLY_GLOBAL(HashSet<Node*>, ignoreSet, );
291
292 #ifndef NDEBUG
293 static bool shouldIgnoreLeaks = false;
294 #endif
295
296 void Node::startIgnoringLeaks()
297 {
298 #ifndef NDEBUG
299     shouldIgnoreLeaks = true;
300 #endif
301 }
302
303 void Node::stopIgnoringLeaks()
304 {
305 #ifndef NDEBUG
306     shouldIgnoreLeaks = false;
307 #endif
308 }
309
310 Node::StyleChange Node::diff(const RenderStyle* s1, const RenderStyle* s2, Document* doc)
311 {
312     StyleChange ch = NoInherit;
313     EDisplay display1 = s1 ? s1->display() : NONE;
314     bool fl1 = s1 && s1->hasPseudoStyle(FIRST_LETTER);
315     EDisplay display2 = s2 ? s2->display() : NONE;
316     bool fl2 = s2 && s2->hasPseudoStyle(FIRST_LETTER);
317     
318     // We just detach if a renderer acquires or loses a column-span, since spanning elements
319     // typically won't contain much content.
320     bool colSpan1 = s1 && s1->columnSpan();
321     bool colSpan2 = s2 && s2->columnSpan();
322     
323     bool specifiesColumns1 = s1 && (!s1->hasAutoColumnCount() || !s1->hasAutoColumnWidth());
324     bool specifiesColumns2 = s2 && (!s2->hasAutoColumnCount() || !s2->hasAutoColumnWidth());
325
326     if (display1 != display2 || fl1 != fl2 || colSpan1 != colSpan2 
327         || (specifiesColumns1 != specifiesColumns2 && doc->settings()->regionBasedColumnsEnabled())
328         || (s1 && s2 && !s1->contentDataEquivalent(s2)))
329         ch = Detach;
330     else if (!s1 || !s2)
331         ch = Inherit;
332     else if (*s1 == *s2)
333         ch = NoChange;
334     else if (s1->inheritedNotEqual(s2))
335         ch = Inherit;
336     else if (s1->hasExplicitlyInheritedProperties() || s2->hasExplicitlyInheritedProperties())
337         ch = Inherit;
338
339     // For nth-child and other positional rules, treat styles as different if they have
340     // changed positionally in the DOM. This way subsequent sibling resolutions won't be confused
341     // by the wrong child index and evaluate to incorrect results.
342     if (ch == NoChange && s1->childIndex() != s2->childIndex())
343         ch = NoInherit;
344
345     // If the pseudoStyles have changed, we want any StyleChange that is not NoChange
346     // because setStyle will do the right thing with anything else.
347     if (ch == NoChange && s1->hasAnyPublicPseudoStyles()) {
348         for (PseudoId pseudoId = FIRST_PUBLIC_PSEUDOID; ch == NoChange && pseudoId < FIRST_INTERNAL_PSEUDOID; pseudoId = static_cast<PseudoId>(pseudoId + 1)) {
349             if (s1->hasPseudoStyle(pseudoId)) {
350                 RenderStyle* ps2 = s2->getCachedPseudoStyle(pseudoId);
351                 if (!ps2)
352                     ch = NoInherit;
353                 else {
354                     RenderStyle* ps1 = s1->getCachedPseudoStyle(pseudoId);
355                     ch = ps1 && *ps1 == *ps2 ? NoChange : NoInherit;
356                 }
357             }
358         }
359     }
360
361     // When text-combine property has been changed, we need to prepare a separate renderer object.
362     // When text-combine is on, we use RenderCombineText, otherwise RenderText.
363     // https://bugs.webkit.org/show_bug.cgi?id=55069
364     if ((s1 && s2) && (s1->hasTextCombine() != s2->hasTextCombine()))
365         ch = Detach;
366
367     // We need to reattach the node, so that it is moved to the correct RenderFlowThread.
368     if ((s1 && s2) && (s1->flowThread() != s2->flowThread()))
369         ch = Detach;
370
371     // When the region thread has changed, we need to prepare a separate render region object.
372     if ((s1 && s2) && (s1->regionThread() != s2->regionThread()))
373         ch = Detach;
374
375     return ch;
376 }
377
378 void Node::trackForDebugging()
379 {
380 #ifndef NDEBUG
381     if (shouldIgnoreLeaks)
382         ignoreSet.add(this);
383     else
384         nodeCounter.increment();
385 #endif
386
387 #if DUMP_NODE_STATISTICS
388     liveNodeSet.add(this);
389 #endif
390 }
391
392 Node::~Node()
393 {
394 #ifndef NDEBUG
395     HashSet<Node*>::iterator it = ignoreSet.find(this);
396     if (it != ignoreSet.end())
397         ignoreSet.remove(it);
398     else
399         nodeCounter.decrement();
400 #endif
401
402 #if DUMP_NODE_STATISTICS
403     liveNodeSet.remove(this);
404 #endif
405
406     ASSERT(hasRareData() == NodeRareData::rareDataMap().contains(this));
407     if (hasRareData())
408         clearRareData();
409
410     if (renderer())
411         detach();
412
413     Document* doc = m_document;
414     if (AXObjectCache::accessibilityEnabled() && doc && doc->axObjectCacheExists())
415         doc->axObjectCache()->removeNodeForUse(this);
416     
417     if (m_previous)
418         m_previous->setNextSibling(0);
419     if (m_next)
420         m_next->setPreviousSibling(0);
421
422     if (doc)
423         doc->guardDeref();
424
425     InspectorCounters::decrementCounter(InspectorCounters::NodeCounter);
426 }
427
428 void Node::setDocument(Document* document)
429 {
430     ASSERT(!inDocument() || m_document == document);
431     if (inDocument() || m_document == document)
432         return;
433
434     m_document = document;
435 }
436
437 NodeRareData* Node::setTreeScope(TreeScope* scope)
438 {
439     if (!scope) {
440         if (hasRareData()) {
441             NodeRareData* data = rareData();
442             data->setTreeScope(0);
443             return data;
444         }
445
446         return 0;
447     }
448
449     NodeRareData* data = ensureRareData();
450     data->setTreeScope(scope);
451     return data;
452 }
453
454 TreeScope* Node::treeScope() const
455 {
456     // FIXME: Using m_document directly is not good -> see comment with document() in the header file.
457     if (!hasRareData())
458         return m_document;
459     TreeScope* scope = rareData()->treeScope();
460     return scope ? scope : m_document;
461 }
462
463 NodeRareData* Node::rareData() const
464 {
465     ASSERT(hasRareData());
466     return NodeRareData::rareDataFromMap(this);
467 }
468
469 NodeRareData* Node::ensureRareData()
470 {
471     if (hasRareData())
472         return rareData();
473     
474     ASSERT(!NodeRareData::rareDataMap().contains(this));
475     NodeRareData* data = createRareData().leakPtr();
476     NodeRareData::rareDataMap().set(this, data);
477     setFlag(HasRareDataFlag);
478     return data;
479 }
480     
481 OwnPtr<NodeRareData> Node::createRareData()
482 {
483     return adoptPtr(new NodeRareData);
484 }
485
486 void Node::clearRareData()
487 {
488     ASSERT(hasRareData());
489     if (treeScope() && rareData()->nodeLists())
490         treeScope()->removeNodeListCache();
491
492 #if ENABLE(MUTATION_OBSERVERS)
493     ASSERT(!transientMutationObserverRegistry() || transientMutationObserverRegistry()->isEmpty());
494 #endif
495
496     NodeRareData::NodeRareDataMap& dataMap = NodeRareData::rareDataMap();
497     NodeRareData::NodeRareDataMap::iterator it = dataMap.find(this);
498     ASSERT(it != dataMap.end());
499     delete it->second;
500     dataMap.remove(it);
501     clearFlag(HasRareDataFlag);
502 }
503
504 Element* Node::shadowHost() const
505 {
506     return toElement(isShadowRoot() ? parent() : 0);
507 }
508
509 void Node::setShadowHost(Element* host)
510 {
511     ASSERT(!parentNode() && isShadowRoot());
512     setParent(host);
513 }
514
515 Node* Node::toNode()
516 {
517     return this;
518 }
519
520 HTMLInputElement* Node::toInputElement()
521 {
522     // If one of the below ASSERTs trigger, you are calling this function
523     // directly or indirectly from a constructor or destructor of this object.
524     // Don't do this!
525     ASSERT(!(isHTMLElement() && hasTagName(inputTag)));
526     return 0;
527 }
528
529 short Node::tabIndex() const
530 {
531     return hasRareData() ? rareData()->tabIndex() : 0;
532 }
533     
534 void Node::setTabIndexExplicitly(short i)
535 {
536     ensureRareData()->setTabIndexExplicitly(i);
537 }
538
539 void Node::clearTabIndexExplicitly()
540 {
541     ensureRareData()->clearTabIndexExplicitly();
542 }
543
544 String Node::nodeValue() const
545 {
546     return String();
547 }
548
549 void Node::setNodeValue(const String& /*nodeValue*/, ExceptionCode& ec)
550 {
551     // NO_MODIFICATION_ALLOWED_ERR: Raised when the node is readonly
552     if (isReadOnlyNode()) {
553         ec = NO_MODIFICATION_ALLOWED_ERR;
554         return;
555     }
556
557     // By default, setting nodeValue has no effect.
558 }
559
560 PassRefPtr<NodeList> Node::childNodes()
561 {
562     NodeRareData* data = ensureRareData();
563     if (data->childNodeList())
564         return PassRefPtr<NodeList>(data->childNodeList());
565
566     RefPtr<ChildNodeList> list = ChildNodeList::create(this);
567     data->setChildNodeList(list.get());
568     return list.release();
569 }
570
571 Node *Node::lastDescendant() const
572 {
573     Node *n = const_cast<Node *>(this);
574     while (n && n->lastChild())
575         n = n->lastChild();
576     return n;
577 }
578
579 Node* Node::firstDescendant() const
580 {
581     Node *n = const_cast<Node *>(this);
582     while (n && n->firstChild())
583         n = n->firstChild();
584     return n;
585 }
586
587 bool Node::insertBefore(PassRefPtr<Node> newChild, Node* refChild, ExceptionCode& ec, bool shouldLazyAttach)
588 {
589     if (!isContainerNode()) {
590         ec = HIERARCHY_REQUEST_ERR;
591         return false;
592     }
593     return toContainerNode(this)->insertBefore(newChild, refChild, ec, shouldLazyAttach);
594 }
595
596 bool Node::replaceChild(PassRefPtr<Node> newChild, Node* oldChild, ExceptionCode& ec, bool shouldLazyAttach)
597 {
598     if (!isContainerNode()) {
599         ec = HIERARCHY_REQUEST_ERR;
600         return false;
601     }
602     return toContainerNode(this)->replaceChild(newChild, oldChild, ec, shouldLazyAttach);
603 }
604
605 bool Node::removeChild(Node* oldChild, ExceptionCode& ec)
606 {
607     if (!isContainerNode()) {
608         ec = NOT_FOUND_ERR;
609         return false;
610     }
611     return toContainerNode(this)->removeChild(oldChild, ec);
612 }
613
614 bool Node::appendChild(PassRefPtr<Node> newChild, ExceptionCode& ec, bool shouldLazyAttach)
615 {
616     if (!isContainerNode()) {
617         ec = HIERARCHY_REQUEST_ERR;
618         return false;
619     }
620     return toContainerNode(this)->appendChild(newChild, ec, shouldLazyAttach);
621 }
622
623 void Node::remove(ExceptionCode& ec)
624 {
625     if (ContainerNode* parent = parentNode())
626         parent->removeChild(this, ec);
627     else
628         ec = HIERARCHY_REQUEST_ERR;
629 }
630
631 void Node::normalize()
632 {
633     // Go through the subtree beneath us, normalizing all nodes. This means that
634     // any two adjacent text nodes are merged and any empty text nodes are removed.
635
636     RefPtr<Node> node = this;
637     while (Node* firstChild = node->firstChild())
638         node = firstChild;
639     while (node) {
640         NodeType type = node->nodeType();
641         if (type == ELEMENT_NODE)
642             static_cast<Element*>(node.get())->normalizeAttributes();
643
644         if (node == this)
645             break;
646
647         if (type != TEXT_NODE) {
648             node = node->traverseNextNodePostOrder();
649             continue;
650         }
651
652         RefPtr<Text> text = toText(node.get());
653
654         // Remove empty text nodes.
655         if (!text->length()) {
656             // Care must be taken to get the next node before removing the current node.
657             node = node->traverseNextNodePostOrder();
658             ExceptionCode ec;
659             text->remove(ec);
660             continue;
661         }
662
663         // Merge text nodes.
664         while (Node* nextSibling = node->nextSibling()) {
665             if (nextSibling->nodeType() != TEXT_NODE)
666                 break;
667             RefPtr<Text> nextText = toText(nextSibling);
668
669             // Remove empty text nodes.
670             if (!nextText->length()) {
671                 ExceptionCode ec;
672                 nextText->remove(ec);
673                 continue;
674             }
675
676             // Both non-empty text nodes. Merge them.
677             unsigned offset = text->length();
678             ExceptionCode ec;
679             text->appendData(nextText->data(), ec);
680             document()->textNodesMerged(nextText.get(), offset);
681             nextText->remove(ec);
682         }
683
684         node = node->traverseNextNodePostOrder();
685     }
686 }
687
688 const AtomicString& Node::virtualPrefix() const
689 {
690     // For nodes other than elements and attributes, the prefix is always null
691     return nullAtom;
692 }
693
694 void Node::setPrefix(const AtomicString& /*prefix*/, ExceptionCode& ec)
695 {
696     // The spec says that for nodes other than elements and attributes, prefix is always null.
697     // It does not say what to do when the user tries to set the prefix on another type of
698     // node, however Mozilla throws a NAMESPACE_ERR exception.
699     ec = NAMESPACE_ERR;
700 }
701
702 const AtomicString& Node::virtualLocalName() const
703 {
704     return nullAtom;
705 }
706
707 const AtomicString& Node::virtualNamespaceURI() const
708 {
709     return nullAtom;
710 }
711
712 bool Node::isContentEditable()
713 {
714     document()->updateStyleIfNeeded();
715     return rendererIsEditable(Editable);
716 }
717
718 bool Node::isContentRichlyEditable()
719 {
720     document()->updateStyleIfNeeded();
721     return rendererIsEditable(RichlyEditable);
722 }
723
724 void Node::inspect()
725 {
726 #if ENABLE(INSPECTOR)
727     if (document() && document()->page())
728         document()->page()->inspectorController()->inspect(this);
729 #endif
730 }
731
732 bool Node::rendererIsEditable(EditableLevel editableLevel) const
733 {
734     if (document()->frame() && document()->frame()->page() && document()->frame()->page()->isEditable() && !shadowTreeRootNode())
735         return true;
736
737     // Ideally we'd call ASSERT(!needsStyleRecalc()) here, but
738     // ContainerNode::setFocus() calls setNeedsStyleRecalc(), so the assertion
739     // would fire in the middle of Document::setFocusedNode().
740
741     for (const Node* node = this; node; node = node->parentNode()) {
742         if ((node->isHTMLElement() || node->isDocumentNode()) && node->renderer()) {
743             switch (node->renderer()->style()->userModify()) {
744             case READ_ONLY:
745                 return false;
746             case READ_WRITE:
747                 return true;
748             case READ_WRITE_PLAINTEXT_ONLY:
749                 return editableLevel != RichlyEditable;
750             }
751             ASSERT_NOT_REACHED();
752             return false;
753         }
754     }
755
756     return false;
757 }
758
759 bool Node::isEditableToAccessibility(EditableLevel editableLevel) const
760 {
761     if (rendererIsEditable(editableLevel))
762         return true;
763
764     // FIXME: Respect editableLevel for ARIA editable elements.
765     if (editableLevel == RichlyEditable)
766         return false;
767
768     ASSERT(document());
769     ASSERT(AXObjectCache::accessibilityEnabled());
770     ASSERT(document()->axObjectCacheExists());
771
772     if (document() && AXObjectCache::accessibilityEnabled() && document()->axObjectCacheExists())
773         return document()->axObjectCache()->rootAXEditableElement(this);
774
775     return false;
776 }
777
778 bool Node::shouldUseInputMethod()
779 {
780     return isContentEditable();
781 }
782
783 RenderBox* Node::renderBox() const
784 {
785     return m_renderer && m_renderer->isBox() ? toRenderBox(m_renderer) : 0;
786 }
787
788 RenderBoxModelObject* Node::renderBoxModelObject() const
789 {
790     return m_renderer && m_renderer->isBoxModelObject() ? toRenderBoxModelObject(m_renderer) : 0;
791 }
792
793 LayoutRect Node::getRect() const
794 {
795     if (renderer())
796         return renderer()->absoluteBoundingBoxRect();
797     return LayoutRect();
798 }
799     
800 LayoutRect Node::renderRect(bool* isReplaced)
801 {    
802     RenderObject* hitRenderer = this->renderer();
803     ASSERT(hitRenderer);
804     RenderObject* renderer = hitRenderer;
805     while (renderer && !renderer->isBody() && !renderer->isRoot()) {
806         if (renderer->isRenderBlock() || renderer->isInlineBlockOrInlineTable() || renderer->isReplaced()) {
807             *isReplaced = renderer->isReplaced();
808             return renderer->absoluteBoundingBoxRect();
809         }
810         renderer = renderer->parent();
811     }
812     return LayoutRect();    
813 }
814
815 bool Node::hasNonEmptyBoundingBox() const
816 {
817     // Before calling absoluteRects, check for the common case where the renderer
818     // is non-empty, since this is a faster check and almost always returns true.
819     RenderBoxModelObject* box = renderBoxModelObject();
820     if (!box)
821         return false;
822     if (!box->borderBoundingBox().isEmpty())
823         return true;
824
825     Vector<IntRect> rects;
826     FloatPoint absPos = renderer()->localToAbsolute();
827     renderer()->absoluteRects(rects, flooredLayoutPoint(absPos));
828     size_t n = rects.size();
829     for (size_t i = 0; i < n; ++i)
830         if (!rects[i].isEmpty())
831             return true;
832
833     return false;
834 }
835
836 inline static ShadowRoot* oldestShadowRootFor(const Node* node)
837 {
838     return node->isElementNode() && toElement(node)->hasShadowRoot() ? toElement(node)->shadow()->oldestShadowRoot() : 0;
839 }
840
841 inline void Node::setStyleChange(StyleChangeType changeType)
842 {
843     m_nodeFlags = (m_nodeFlags & ~StyleChangeMask) | changeType;
844 }
845
846 inline void Node::markAncestorsWithChildNeedsStyleRecalc()
847 {
848     for (ContainerNode* p = parentOrHostNode(); p && !p->childNeedsStyleRecalc(); p = p->parentOrHostNode())
849         p->setChildNeedsStyleRecalc();
850
851     if (document()->childNeedsStyleRecalc())
852         document()->scheduleStyleRecalc();
853 }
854
855 void Node::refEventTarget()
856 {
857     ref();
858 }
859
860 void Node::derefEventTarget()
861 {
862     deref();
863 }
864
865 void Node::setNeedsStyleRecalc(StyleChangeType changeType)
866 {
867     ASSERT(changeType != NoStyleChange);
868     if (!attached()) // changed compared to what?
869         return;
870
871     StyleChangeType existingChangeType = styleChangeType();
872     if (changeType > existingChangeType)
873         setStyleChange(changeType);
874
875     if (existingChangeType == NoStyleChange)
876         markAncestorsWithChildNeedsStyleRecalc();
877 }
878
879 void Node::lazyAttach(ShouldSetAttached shouldSetAttached)
880 {
881     for (Node* n = this; n; n = n->traverseNextNode(this)) {
882         if (n->hasChildNodes())
883             n->setChildNeedsStyleRecalc();
884         n->setStyleChange(FullStyleChange);
885         if (shouldSetAttached == SetAttached)
886             n->setAttached();
887     }
888     markAncestorsWithChildNeedsStyleRecalc();
889 }
890
891 void Node::setFocus(bool b)
892
893     if (b || hasRareData())
894         ensureRareData()->setFocused(b);
895 }
896
897 bool Node::rareDataFocused() const
898 {
899     ASSERT(hasRareData());
900     return rareData()->isFocused();
901 }
902
903 bool Node::supportsFocus() const
904 {
905     return hasRareData() && rareData()->tabIndexSetExplicitly();
906 }
907     
908 bool Node::isFocusable() const
909 {
910     if (!inDocument() || !supportsFocus())
911         return false;
912     
913     if (renderer())
914         ASSERT(!renderer()->needsLayout());
915     else
916         // If the node is in a display:none tree it might say it needs style recalc but
917         // the whole document is actually up to date.
918         ASSERT(!document()->childNeedsStyleRecalc());
919     
920     // FIXME: Even if we are not visible, we might have a child that is visible.
921     // Hyatt wants to fix that some day with a "has visible content" flag or the like.
922     if (!renderer() || renderer()->style()->visibility() != VISIBLE)
923         return false;
924
925     return true;
926 }
927
928 bool Node::isKeyboardFocusable(KeyboardEvent*) const
929 {
930     return isFocusable() && tabIndex() >= 0;
931 }
932
933 bool Node::isMouseFocusable() const
934 {
935     return isFocusable();
936 }
937
938 Node* Node::focusDelegate()
939 {
940     return this;
941 }
942
943 unsigned Node::nodeIndex() const
944 {
945     Node *_tempNode = previousSibling();
946     unsigned count=0;
947     for ( count=0; _tempNode; count++ )
948         _tempNode = _tempNode->previousSibling();
949     return count;
950 }
951
952 static void removeNodeListCacheIfPossible(Node* node, NodeRareData* data)
953 {
954     if (!data->nodeLists()->isEmpty())
955         return;
956     data->clearNodeLists();
957     node->treeScope()->removeNodeListCache();
958 }
959
960 // FIXME: Move this function to Document
961 void Node::registerDynamicSubtreeNodeList(DynamicSubtreeNodeList* list)
962 {
963     ASSERT(isDocumentNode());
964     NodeRareData* data = ensureRareData();
965     data->ensureNodeLists(this)->m_listsInvalidatedAtDocument.add(list);
966 }
967
968 // FIXME: Move this function to Document
969 void Node::unregisterDynamicSubtreeNodeList(DynamicSubtreeNodeList* list)
970 {
971     ASSERT(isDocumentNode());
972     ASSERT(hasRareData());
973     ASSERT(rareData()->nodeLists());
974     NodeRareData* data = rareData();
975     data->nodeLists()->m_listsInvalidatedAtDocument.remove(list);
976     removeNodeListCacheIfPossible(this, data);
977 }
978
979 void Node::invalidateNodeListsCacheAfterAttributeChanged(const QualifiedName& attrName)
980 {
981     if (hasRareData() && isAttributeNode()) {
982         NodeRareData* data = rareData();
983         ASSERT(!data->nodeLists());
984         data->clearChildNodeListCache();
985     }
986
987     // This list should be sync'ed with NodeListsNodeData.
988     if (attrName != classAttr
989 #if ENABLE(MICRODATA)
990         && attrName != itemscopeAttr
991         && attrName != itempropAttr
992         && attrName != itemtypeAttr
993 #endif
994         && attrName != nameAttr
995         && attrName != forAttr)
996         return;
997
998     if (!treeScope()->hasNodeListCaches())
999         return;
1000
1001     for (Node* node = this; node; node = node->parentNode()) {
1002         ASSERT(this == node || !node->isAttributeNode());
1003         if (!node->hasRareData())
1004             continue;
1005         NodeRareData* data = node->rareData();
1006         if (!data->nodeLists())
1007             continue;
1008
1009         data->nodeLists()->invalidateCachesThatDependOnAttributes();
1010     }
1011 }
1012
1013 void Node::invalidateNodeListsCacheAfterChildrenChanged()
1014 {
1015     if (hasRareData())
1016         rareData()->clearChildNodeListCache();
1017
1018     if (!treeScope()->hasNodeListCaches())
1019         return;
1020     for (Node* node = this; node; node = node->parentNode()) {
1021         if (!node->hasRareData())
1022             continue;
1023         NodeRareData* data = node->rareData();
1024         if (!data->nodeLists())
1025             continue;
1026
1027         data->nodeLists()->invalidateCaches();
1028     }
1029 }
1030
1031 void Node::removeCachedClassNodeList(ClassNodeList* list, const String& className)
1032 {
1033     ASSERT(rareData());
1034     ASSERT(rareData()->nodeLists());
1035
1036     NodeListsNodeData* data = rareData()->nodeLists();
1037     ASSERT_UNUSED(list, list == data->m_classNodeListCache.get(className));
1038     data->m_classNodeListCache.remove(className);
1039 }
1040
1041 void Node::removeCachedNameNodeList(NameNodeList* list, const String& nodeName)
1042 {
1043     ASSERT(rareData());
1044     ASSERT(rareData()->nodeLists());
1045
1046     NodeListsNodeData* data = rareData()->nodeLists();
1047     ASSERT_UNUSED(list, list == data->m_nameNodeListCache.get(nodeName));
1048     data->m_nameNodeListCache.remove(nodeName);
1049 }
1050
1051 void Node::removeCachedTagNodeList(TagNodeList* list, const AtomicString& name)
1052 {
1053     ASSERT(rareData());
1054     ASSERT(rareData()->nodeLists());
1055
1056     NodeListsNodeData* data = rareData()->nodeLists();
1057     ASSERT_UNUSED(list, list == data->m_tagNodeListCache.get(name.impl()));
1058     data->m_tagNodeListCache.remove(name.impl());
1059 }
1060
1061 void Node::removeCachedTagNodeList(TagNodeList* list, const QualifiedName& name)
1062 {
1063     ASSERT(rareData());
1064     ASSERT(rareData()->nodeLists());
1065
1066     NodeListsNodeData* data = rareData()->nodeLists();
1067     ASSERT_UNUSED(list, list == data->m_tagNodeListCacheNS.get(name.impl()));
1068     data->m_tagNodeListCacheNS.remove(name.impl());
1069 }
1070
1071 void Node::removeCachedLabelsNodeList(DynamicSubtreeNodeList* list)
1072 {
1073     ASSERT(rareData());
1074     ASSERT(rareData()->nodeLists());
1075
1076     NodeListsNodeData* data = rareData()->nodeLists();
1077     ASSERT_UNUSED(list, list == data->m_labelsNodeListCache);
1078     data->m_labelsNodeListCache = 0;
1079 }
1080
1081 void Node::removeCachedChildNodeList()
1082 {
1083     ASSERT(rareData());
1084     rareData()->setChildNodeList(0);
1085 }
1086
1087 Node* Node::traverseNextNode(const Node* stayWithin) const
1088 {
1089     if (firstChild())
1090         return firstChild();
1091     if (this == stayWithin)
1092         return 0;
1093     if (nextSibling())
1094         return nextSibling();
1095     const Node *n = this;
1096     while (n && !n->nextSibling() && (!stayWithin || n->parentNode() != stayWithin))
1097         n = n->parentNode();
1098     if (n)
1099         return n->nextSibling();
1100     return 0;
1101 }
1102
1103 Node* Node::traverseNextSibling(const Node* stayWithin) const
1104 {
1105     if (this == stayWithin)
1106         return 0;
1107     if (nextSibling())
1108         return nextSibling();
1109     const Node *n = this;
1110     while (n && !n->nextSibling() && (!stayWithin || n->parentNode() != stayWithin))
1111         n = n->parentNode();
1112     if (n)
1113         return n->nextSibling();
1114     return 0;
1115 }
1116
1117 Node* Node::traverseNextNodePostOrder() const
1118 {
1119     Node* next = nextSibling();
1120     if (!next)
1121         return parentNode();
1122     while (Node* firstChild = next->firstChild())
1123         next = firstChild;
1124     return next;
1125 }
1126
1127 Node* Node::traversePreviousNode(const Node* stayWithin) const
1128 {
1129     if (this == stayWithin)
1130         return 0;
1131     if (previousSibling()) {
1132         Node *n = previousSibling();
1133         while (n->lastChild())
1134             n = n->lastChild();
1135         return n;
1136     }
1137     return parentNode();
1138 }
1139
1140 Node* Node::traversePreviousSibling(const Node* stayWithin) const
1141 {
1142     if (this == stayWithin)
1143         return 0;
1144     if (previousSibling())
1145         return previousSibling();
1146     const Node *n = this;
1147     while (n && !n->previousSibling() && (!stayWithin || n->parentNode() != stayWithin))
1148         n = n->parentNode();
1149     if (n)
1150         return n->previousSibling();
1151     return 0;
1152 }
1153
1154 Node* Node::traversePreviousNodePostOrder(const Node* stayWithin) const
1155 {
1156     if (lastChild())
1157         return lastChild();
1158     if (this == stayWithin)
1159         return 0;
1160     if (previousSibling())
1161         return previousSibling();
1162     const Node *n = this;
1163     while (n && !n->previousSibling() && (!stayWithin || n->parentNode() != stayWithin))
1164         n = n->parentNode();
1165     if (n)
1166         return n->previousSibling();
1167     return 0;
1168 }
1169
1170 Node* Node::traversePreviousSiblingPostOrder(const Node* stayWithin) const
1171 {
1172     if (this == stayWithin)
1173         return 0;
1174     if (previousSibling())
1175         return previousSibling();
1176     const Node *n = this;
1177     while (n && !n->previousSibling() && (!stayWithin || n->parentNode() != stayWithin))
1178         n = n->parentNode();
1179     if (n)
1180         return n->previousSibling();
1181     return 0;
1182 }
1183
1184 void Node::checkSetPrefix(const AtomicString& prefix, ExceptionCode& ec)
1185 {
1186     // Perform error checking as required by spec for setting Node.prefix. Used by
1187     // Element::setPrefix() and Attr::setPrefix()
1188
1189     if (!prefix.isEmpty() && !Document::isValidName(prefix)) {
1190         ec = INVALID_CHARACTER_ERR;
1191         return;
1192     }
1193
1194     if (isReadOnlyNode()) {
1195         ec = NO_MODIFICATION_ALLOWED_ERR;
1196         return;
1197     }
1198
1199     // FIXME: Raise NAMESPACE_ERR if prefix is malformed per the Namespaces in XML specification.
1200
1201     const AtomicString& nodeNamespaceURI = namespaceURI();
1202     if ((nodeNamespaceURI.isEmpty() && !prefix.isEmpty())
1203         || (prefix == xmlAtom && nodeNamespaceURI != XMLNames::xmlNamespaceURI)) {
1204         ec = NAMESPACE_ERR;
1205         return;
1206     }
1207     // Attribute-specific checks are in Attr::setPrefix().
1208 }
1209
1210 static bool isChildTypeAllowed(Node* newParent, Node* child)
1211 {
1212     if (child->nodeType() != Node::DOCUMENT_FRAGMENT_NODE) {
1213         if (!newParent->childTypeAllowed(child->nodeType()))
1214             return false;
1215         return true;
1216     }
1217     
1218     for (Node *n = child->firstChild(); n; n = n->nextSibling()) {
1219         if (!newParent->childTypeAllowed(n->nodeType()))
1220             return false;
1221     }
1222     return true;
1223 }
1224
1225 bool Node::canReplaceChild(Node* newChild, Node*)
1226 {
1227     return isChildTypeAllowed(this, newChild);
1228 }
1229
1230 static void checkAcceptChild(Node* newParent, Node* newChild, ExceptionCode& ec)
1231 {
1232     // Not mentioned in spec: throw NOT_FOUND_ERR if newChild is null
1233     if (!newChild) {
1234         ec = NOT_FOUND_ERR;
1235         return;
1236     }
1237     
1238     if (newParent->isReadOnlyNode()) {
1239         ec = NO_MODIFICATION_ALLOWED_ERR;
1240         return;
1241     }
1242
1243     if (newChild->inDocument() && newChild->nodeType() == Node::DOCUMENT_TYPE_NODE) {
1244         ec = HIERARCHY_REQUEST_ERR;
1245         return;
1246     }
1247
1248     // HIERARCHY_REQUEST_ERR: Raised if this node is of a type that does not allow children of the type of the
1249     // newChild node, or if the node to append is one of this node's ancestors.
1250
1251     if (newChild == newParent || newParent->isDescendantOf(newChild)) {
1252         ec = HIERARCHY_REQUEST_ERR;
1253         return;
1254     }
1255 }
1256
1257 void Node::checkReplaceChild(Node* newChild, Node* oldChild, ExceptionCode& ec)
1258 {
1259     if (!oldChild) {
1260         ec = NOT_FOUND_ERR;
1261         return;
1262     }
1263
1264     checkAcceptChild(this, newChild, ec);
1265     if (ec)
1266         return;
1267
1268     if (!canReplaceChild(newChild, oldChild)) {
1269         ec = HIERARCHY_REQUEST_ERR;
1270         return;
1271     }
1272 }
1273
1274 void Node::checkAddChild(Node *newChild, ExceptionCode& ec)
1275 {
1276     checkAcceptChild(this, newChild, ec);
1277     if (ec)
1278         return;
1279     
1280     if (!isChildTypeAllowed(this, newChild)) {
1281         ec = HIERARCHY_REQUEST_ERR;
1282         return;
1283     }
1284 }
1285
1286 bool Node::isDescendantOf(const Node *other) const
1287 {
1288     // Return true if other is an ancestor of this, otherwise false
1289     if (!other || !other->hasChildNodes() || inDocument() != other->inDocument())
1290         return false;
1291     if (other == other->document())
1292         return document() == other && this != document() && inDocument();
1293     for (const ContainerNode* n = parentNode(); n; n = n->parentNode()) {
1294         if (n == other)
1295             return true;
1296     }
1297     return false;
1298 }
1299
1300 bool Node::contains(const Node* node) const
1301 {
1302     if (!node)
1303         return false;
1304     return this == node || node->isDescendantOf(this);
1305 }
1306
1307 bool Node::containsIncludingShadowDOM(Node* node)
1308 {
1309     if (!node)
1310         return false;
1311     for (Node* n = node; n; n = n->parentOrHostNode()) {
1312         if (n == this)
1313             return true;
1314     }
1315     return false;
1316 }
1317
1318 void Node::attach()
1319 {
1320     ASSERT(!attached());
1321     ASSERT(!renderer() || (renderer()->style() && renderer()->parent()));
1322
1323     // FIXME: This is O(N^2) for the innerHTML case, where all children are replaced at once (and not attached).
1324     // If this node got a renderer it may be the previousRenderer() of sibling text nodes and thus affect the
1325     // result of Text::rendererIsNeeded() for those nodes.
1326     if (renderer()) {
1327         for (Node* next = nextSibling(); next; next = next->nextSibling()) {
1328             if (next->renderer())
1329                 break;
1330             if (!next->attached())
1331                 break;  // Assume this means none of the following siblings are attached.
1332             if (next->isTextNode())
1333                 next->createRendererIfNeeded();
1334         }
1335     }
1336
1337     setAttached();
1338     clearNeedsStyleRecalc();
1339 }
1340
1341 void Node::willRemove()
1342 {
1343 }
1344
1345 void Node::detach()
1346 {
1347     setFlag(InDetachFlag);
1348
1349     if (renderer())
1350         renderer()->destroyAndCleanupAnonymousWrappers();
1351     setRenderer(0);
1352
1353     Document* doc = document();
1354     if (hovered())
1355         doc->hoveredNodeDetached(this);
1356     if (inActiveChain())
1357         doc->activeChainNodeDetached(this);
1358
1359     clearFlag(IsActiveFlag);
1360     clearFlag(IsHoveredFlag);
1361     clearFlag(InActiveChainFlag);
1362     clearFlag(IsAttachedFlag);
1363
1364     clearFlag(InDetachFlag);
1365 }
1366
1367 // FIXME: This code is used by editing.  Seems like it could move over there and not pollute Node.
1368 Node *Node::previousNodeConsideringAtomicNodes() const
1369 {
1370     if (previousSibling()) {
1371         Node *n = previousSibling();
1372         while (!isAtomicNode(n) && n->lastChild())
1373             n = n->lastChild();
1374         return n;
1375     }
1376     else if (parentNode()) {
1377         return parentNode();
1378     }
1379     else {
1380         return 0;
1381     }
1382 }
1383
1384 Node *Node::nextNodeConsideringAtomicNodes() const
1385 {
1386     if (!isAtomicNode(this) && firstChild())
1387         return firstChild();
1388     if (nextSibling())
1389         return nextSibling();
1390     const Node *n = this;
1391     while (n && !n->nextSibling())
1392         n = n->parentNode();
1393     if (n)
1394         return n->nextSibling();
1395     return 0;
1396 }
1397
1398 Node *Node::previousLeafNode() const
1399 {
1400     Node *node = previousNodeConsideringAtomicNodes();
1401     while (node) {
1402         if (isAtomicNode(node))
1403             return node;
1404         node = node->previousNodeConsideringAtomicNodes();
1405     }
1406     return 0;
1407 }
1408
1409 Node *Node::nextLeafNode() const
1410 {
1411     Node *node = nextNodeConsideringAtomicNodes();
1412     while (node) {
1413         if (isAtomicNode(node))
1414             return node;
1415         node = node->nextNodeConsideringAtomicNodes();
1416     }
1417     return 0;
1418 }
1419
1420 ContainerNode* Node::parentNodeForRenderingAndStyle()
1421 {
1422     return NodeRenderingContext(this).parentNodeForRenderingAndStyle();
1423 }
1424
1425 void Node::createRendererIfNeeded()
1426 {
1427     NodeRendererFactory(this).createRendererIfNeeded();
1428 }
1429
1430 bool Node::rendererIsNeeded(const NodeRenderingContext& context)
1431 {
1432     return (document()->documentElement() == this) || (context.style()->display() != NONE);
1433 }
1434
1435 RenderObject* Node::createRenderer(RenderArena*, RenderStyle*)
1436 {
1437     ASSERT_NOT_REACHED();
1438     return 0;
1439 }
1440     
1441 RenderStyle* Node::nonRendererRenderStyle() const
1442
1443     return 0; 
1444 }   
1445
1446 void Node::setRenderStyle(PassRefPtr<RenderStyle> s)
1447 {
1448     if (m_renderer)
1449         m_renderer->setAnimatableStyle(s); 
1450 }
1451
1452 RenderStyle* Node::virtualComputedStyle(PseudoId pseudoElementSpecifier)
1453 {
1454     return parentOrHostNode() ? parentOrHostNode()->computedStyle(pseudoElementSpecifier) : 0;
1455 }
1456
1457 int Node::maxCharacterOffset() const
1458 {
1459     ASSERT_NOT_REACHED();
1460     return 0;
1461 }
1462
1463 // FIXME: Shouldn't these functions be in the editing code?  Code that asks questions about HTML in the core DOM class
1464 // is obviously misplaced.
1465 bool Node::canStartSelection() const
1466 {
1467     if (rendererIsEditable())
1468         return true;
1469
1470     if (renderer()) {
1471         RenderStyle* style = renderer()->style();
1472         // We allow selections to begin within an element that has -webkit-user-select: none set,
1473         // but if the element is draggable then dragging should take priority over selection.
1474         if (style->userDrag() == DRAG_ELEMENT && style->userSelect() == SELECT_NONE)
1475             return false;
1476     }
1477     return parentOrHostNode() ? parentOrHostNode()->canStartSelection() : true;
1478 }
1479
1480
1481 Node* Node::shadowAncestorNode() const
1482 {
1483 #if ENABLE(SVG)
1484     // SVG elements living in a shadow tree only occur when <use> created them.
1485     // For these cases we do NOT want to return the shadowParentNode() here
1486     // but the actual shadow tree element - as main difference to the HTML forms
1487     // shadow tree concept. (This function _could_ be made virtual - opinions?)
1488     if (isSVGElement())
1489         return const_cast<Node*>(this);
1490 #endif
1491
1492     Node* root = shadowTreeRootNode();
1493     if (root)
1494         return root->shadowHost();
1495     return const_cast<Node*>(this);
1496 }
1497
1498 Node* Node::shadowTreeRootNode() const
1499 {
1500     Node* root = const_cast<Node*>(this);
1501     while (root) {
1502         if (root->isShadowRoot())
1503             return root;
1504         root = root->parentNodeGuaranteedHostFree();
1505     }
1506     return 0;
1507 }
1508
1509 Node* Node::nonBoundaryShadowTreeRootNode()
1510 {
1511     ASSERT(!isShadowRoot());
1512     Node* root = this;
1513     while (root) {
1514         if (root->isShadowRoot())
1515             return root;
1516         Node* parent = root->parentNodeGuaranteedHostFree();
1517         if (parent && parent->isShadowRoot())
1518             return root;
1519         root = parent;
1520     }
1521     return 0;
1522 }
1523
1524 ContainerNode* Node::nonShadowBoundaryParentNode() const
1525 {
1526     ContainerNode* parent = parentNode();
1527     return parent && !parent->isShadowRoot() ? parent : 0;
1528 }
1529
1530 bool Node::isInShadowTree() const
1531 {
1532     return treeScope() != document();
1533 }
1534
1535 Element* Node::parentOrHostElement() const
1536 {
1537     ContainerNode* parent = parentOrHostNode();
1538     if (!parent)
1539         return 0;
1540
1541     if (parent->isShadowRoot())
1542         return parent->shadowHost();
1543
1544     if (!parent->isElementNode())
1545         return 0;
1546
1547     return toElement(parent);
1548 }
1549
1550
1551 bool Node::isBlockFlow() const
1552 {
1553     return renderer() && renderer()->isBlockFlow();
1554 }
1555
1556 bool Node::isBlockFlowOrBlockTable() const
1557 {
1558     return renderer() && (renderer()->isBlockFlow() || (renderer()->isTable() && !renderer()->isInline()));
1559 }
1560
1561 Element *Node::enclosingBlockFlowElement() const
1562 {
1563     Node *n = const_cast<Node *>(this);
1564     if (isBlockFlow())
1565         return static_cast<Element *>(n);
1566
1567     while (1) {
1568         n = n->parentNode();
1569         if (!n)
1570             break;
1571         if (n->isBlockFlow() || n->hasTagName(bodyTag))
1572             return static_cast<Element *>(n);
1573     }
1574     return 0;
1575 }
1576
1577 Element* Node::rootEditableElement(EditableType editableType) const
1578 {
1579     if (editableType == HasEditableAXRole)
1580         return const_cast<Element*>(document()->axObjectCache()->rootAXEditableElement(this));
1581
1582     return rootEditableElement();
1583 }
1584
1585 Element* Node::rootEditableElement() const
1586 {
1587     Element* result = 0;
1588     for (Node* n = const_cast<Node*>(this); n && n->rendererIsEditable(); n = n->parentNode()) {
1589         if (n->isElementNode())
1590             result = static_cast<Element*>(n);
1591         if (n->hasTagName(bodyTag))
1592             break;
1593     }
1594     return result;
1595 }
1596
1597 bool Node::inSameContainingBlockFlowElement(Node *n)
1598 {
1599     return n ? enclosingBlockFlowElement() == n->enclosingBlockFlowElement() : false;
1600 }
1601
1602 // FIXME: End of obviously misplaced HTML editing functions.  Try to move these out of Node.
1603
1604 PassRefPtr<NodeList> Node::getElementsByTagName(const AtomicString& localName)
1605 {
1606     if (localName.isNull())
1607         return 0;
1608
1609     AtomicString localNameAtom = localName;
1610
1611     NodeListsNodeData::TagNodeListCache::AddResult result = ensureRareData()->ensureNodeLists(this)->m_tagNodeListCache.add(localNameAtom, 0);
1612     if (!result.isNewEntry)
1613         return PassRefPtr<TagNodeList>(result.iterator->second);
1614
1615     RefPtr<TagNodeList> list;
1616     if (document()->isHTMLDocument())
1617         list = HTMLTagNodeList::create(this, starAtom, localNameAtom);
1618     else
1619         list = TagNodeList::create(this, starAtom, localNameAtom);
1620     result.iterator->second = list.get();
1621     return list.release();   
1622 }
1623
1624 PassRefPtr<NodeList> Node::getElementsByTagNameNS(const AtomicString& namespaceURI, const AtomicString& localName)
1625 {
1626     if (localName.isNull())
1627         return 0;
1628
1629     if (namespaceURI == starAtom)
1630         return getElementsByTagName(localName);
1631
1632     AtomicString localNameAtom = localName;
1633
1634     NodeListsNodeData::TagNodeListCacheNS::AddResult result
1635         = ensureRareData()->ensureNodeLists(this)->m_tagNodeListCacheNS.add(QualifiedName(nullAtom, localNameAtom, namespaceURI).impl(), 0);
1636     if (!result.isNewEntry)
1637         return PassRefPtr<TagNodeList>(result.iterator->second);
1638
1639     RefPtr<TagNodeList> list = TagNodeList::create(this, namespaceURI.isEmpty() ? nullAtom : namespaceURI, localNameAtom);
1640     result.iterator->second = list.get();
1641     return list.release();
1642 }
1643
1644 PassRefPtr<NodeList> Node::getElementsByName(const String& elementName)
1645 {
1646     NodeListsNodeData::NameNodeListCache::AddResult result = ensureRareData()->ensureNodeLists(this)->m_nameNodeListCache.add(elementName, 0);
1647     if (!result.isNewEntry)
1648         return PassRefPtr<NodeList>(result.iterator->second);
1649
1650     RefPtr<NameNodeList> list = NameNodeList::create(this, elementName);
1651     result.iterator->second = list.get();
1652     return list.release();
1653 }
1654
1655 PassRefPtr<NodeList> Node::getElementsByClassName(const String& classNames)
1656 {
1657     NodeListsNodeData::ClassNodeListCache::AddResult result
1658         = ensureRareData()->ensureNodeLists(this)->m_classNodeListCache.add(classNames, 0);
1659     if (!result.isNewEntry)
1660         return PassRefPtr<NodeList>(result.iterator->second);
1661
1662     RefPtr<ClassNodeList> list = ClassNodeList::create(this, classNames);
1663     result.iterator->second = list.get();
1664     return list.release();
1665 }
1666
1667 PassRefPtr<Element> Node::querySelector(const String& selectors, ExceptionCode& ec)
1668 {
1669     if (selectors.isEmpty()) {
1670         ec = SYNTAX_ERR;
1671         return 0;
1672     }
1673     CSSParser parser(document());
1674     CSSSelectorList querySelectorList;
1675     parser.parseSelector(selectors, querySelectorList);
1676
1677     if (!querySelectorList.first() || querySelectorList.hasUnknownPseudoElements()) {
1678         ec = SYNTAX_ERR;
1679         return 0;
1680     }
1681
1682     // throw a NAMESPACE_ERR if the selector includes any namespace prefixes.
1683     if (querySelectorList.selectorsNeedNamespaceResolution()) {
1684         ec = NAMESPACE_ERR;
1685         return 0;
1686     }
1687     
1688     SelectorQuery selectorQuery(this, querySelectorList);
1689     return selectorQuery.queryFirst();
1690 }
1691
1692 PassRefPtr<NodeList> Node::querySelectorAll(const String& selectors, ExceptionCode& ec)
1693 {
1694     if (selectors.isEmpty()) {
1695         ec = SYNTAX_ERR;
1696         return 0;
1697     }
1698     CSSParser p(document());
1699     CSSSelectorList querySelectorList;
1700     p.parseSelector(selectors, querySelectorList);
1701
1702     if (!querySelectorList.first() || querySelectorList.hasUnknownPseudoElements()) {
1703         ec = SYNTAX_ERR;
1704         return 0;
1705     }
1706
1707     // Throw a NAMESPACE_ERR if the selector includes any namespace prefixes.
1708     if (querySelectorList.selectorsNeedNamespaceResolution()) {
1709         ec = NAMESPACE_ERR;
1710         return 0;
1711     }
1712
1713     SelectorQuery selectorQuery(this, querySelectorList);
1714     return selectorQuery.queryAll();
1715 }
1716
1717 Document *Node::ownerDocument() const
1718 {
1719     Document *doc = document();
1720     return doc == this ? 0 : doc;
1721 }
1722
1723 KURL Node::baseURI() const
1724 {
1725     return parentNode() ? parentNode()->baseURI() : KURL();
1726 }
1727
1728 bool Node::isEqualNode(Node* other) const
1729 {
1730     if (!other)
1731         return false;
1732     
1733     NodeType nodeType = this->nodeType();
1734     if (nodeType != other->nodeType())
1735         return false;
1736     
1737     if (nodeName() != other->nodeName())
1738         return false;
1739     
1740     if (localName() != other->localName())
1741         return false;
1742     
1743     if (namespaceURI() != other->namespaceURI())
1744         return false;
1745     
1746     if (prefix() != other->prefix())
1747         return false;
1748     
1749     if (nodeValue() != other->nodeValue())
1750         return false;
1751     
1752     if (isElementNode() && !toElement(this)->hasEquivalentAttributes(toElement(other)))
1753         return false;
1754     
1755     Node* child = firstChild();
1756     Node* otherChild = other->firstChild();
1757     
1758     while (child) {
1759         if (!child->isEqualNode(otherChild))
1760             return false;
1761         
1762         child = child->nextSibling();
1763         otherChild = otherChild->nextSibling();
1764     }
1765     
1766     if (otherChild)
1767         return false;
1768     
1769     if (nodeType == DOCUMENT_TYPE_NODE) {
1770         const DocumentType* documentTypeThis = static_cast<const DocumentType*>(this);
1771         const DocumentType* documentTypeOther = static_cast<const DocumentType*>(other);
1772         
1773         if (documentTypeThis->publicId() != documentTypeOther->publicId())
1774             return false;
1775
1776         if (documentTypeThis->systemId() != documentTypeOther->systemId())
1777             return false;
1778
1779         if (documentTypeThis->internalSubset() != documentTypeOther->internalSubset())
1780             return false;
1781
1782         // FIXME: We don't compare entities or notations because currently both are always empty.
1783     }
1784     
1785     return true;
1786 }
1787
1788 bool Node::isDefaultNamespace(const AtomicString& namespaceURIMaybeEmpty) const
1789 {
1790     const AtomicString& namespaceURI = namespaceURIMaybeEmpty.isEmpty() ? nullAtom : namespaceURIMaybeEmpty;
1791
1792     switch (nodeType()) {
1793         case ELEMENT_NODE: {
1794             const Element* elem = static_cast<const Element*>(this);
1795             
1796             if (elem->prefix().isNull())
1797                 return elem->namespaceURI() == namespaceURI;
1798
1799             if (elem->hasAttributes()) {
1800                 for (unsigned i = 0; i < elem->attributeCount(); i++) {
1801                     Attribute* attr = elem->attributeItem(i);
1802                     
1803                     if (attr->localName() == xmlnsAtom)
1804                         return attr->value() == namespaceURI;
1805                 }
1806             }
1807
1808             if (Element* ancestor = ancestorElement())
1809                 return ancestor->isDefaultNamespace(namespaceURI);
1810
1811             return false;
1812         }
1813         case DOCUMENT_NODE:
1814             if (Element* de = static_cast<const Document*>(this)->documentElement())
1815                 return de->isDefaultNamespace(namespaceURI);
1816             return false;
1817         case ENTITY_NODE:
1818         case NOTATION_NODE:
1819         case DOCUMENT_TYPE_NODE:
1820         case DOCUMENT_FRAGMENT_NODE:
1821             return false;
1822         case ATTRIBUTE_NODE: {
1823             const Attr* attr = static_cast<const Attr*>(this);
1824             if (attr->ownerElement())
1825                 return attr->ownerElement()->isDefaultNamespace(namespaceURI);
1826             return false;
1827         }
1828         default:
1829             if (Element* ancestor = ancestorElement())
1830                 return ancestor->isDefaultNamespace(namespaceURI);
1831             return false;
1832     }
1833 }
1834
1835 String Node::lookupPrefix(const AtomicString &namespaceURI) const
1836 {
1837     // Implemented according to
1838     // http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/namespaces-algorithms.html#lookupNamespacePrefixAlgo
1839     
1840     if (namespaceURI.isEmpty())
1841         return String();
1842     
1843     switch (nodeType()) {
1844         case ELEMENT_NODE:
1845             return lookupNamespacePrefix(namespaceURI, static_cast<const Element *>(this));
1846         case DOCUMENT_NODE:
1847             if (Element* de = static_cast<const Document*>(this)->documentElement())
1848                 return de->lookupPrefix(namespaceURI);
1849             return String();
1850         case ENTITY_NODE:
1851         case NOTATION_NODE:
1852         case DOCUMENT_FRAGMENT_NODE:
1853         case DOCUMENT_TYPE_NODE:
1854             return String();
1855         case ATTRIBUTE_NODE: {
1856             const Attr *attr = static_cast<const Attr *>(this);
1857             if (attr->ownerElement())
1858                 return attr->ownerElement()->lookupPrefix(namespaceURI);
1859             return String();
1860         }
1861         default:
1862             if (Element* ancestor = ancestorElement())
1863                 return ancestor->lookupPrefix(namespaceURI);
1864             return String();
1865     }
1866 }
1867
1868 String Node::lookupNamespaceURI(const String &prefix) const
1869 {
1870     // Implemented according to
1871     // http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/namespaces-algorithms.html#lookupNamespaceURIAlgo
1872     
1873     if (!prefix.isNull() && prefix.isEmpty())
1874         return String();
1875     
1876     switch (nodeType()) {
1877         case ELEMENT_NODE: {
1878             const Element *elem = static_cast<const Element *>(this);
1879             
1880             if (!elem->namespaceURI().isNull() && elem->prefix() == prefix)
1881                 return elem->namespaceURI();
1882             
1883             if (elem->hasAttributes()) {
1884                 for (unsigned i = 0; i < elem->attributeCount(); i++) {
1885                     Attribute* attr = elem->attributeItem(i);
1886                     
1887                     if (attr->prefix() == xmlnsAtom && attr->localName() == prefix) {
1888                         if (!attr->value().isEmpty())
1889                             return attr->value();
1890                         
1891                         return String();
1892                     } else if (attr->localName() == xmlnsAtom && prefix.isNull()) {
1893                         if (!attr->value().isEmpty())
1894                             return attr->value();
1895                         
1896                         return String();
1897                     }
1898                 }
1899             }
1900             if (Element* ancestor = ancestorElement())
1901                 return ancestor->lookupNamespaceURI(prefix);
1902             return String();
1903         }
1904         case DOCUMENT_NODE:
1905             if (Element* de = static_cast<const Document*>(this)->documentElement())
1906                 return de->lookupNamespaceURI(prefix);
1907             return String();
1908         case ENTITY_NODE:
1909         case NOTATION_NODE:
1910         case DOCUMENT_TYPE_NODE:
1911         case DOCUMENT_FRAGMENT_NODE:
1912             return String();
1913         case ATTRIBUTE_NODE: {
1914             const Attr *attr = static_cast<const Attr *>(this);
1915             
1916             if (attr->ownerElement())
1917                 return attr->ownerElement()->lookupNamespaceURI(prefix);
1918             else
1919                 return String();
1920         }
1921         default:
1922             if (Element* ancestor = ancestorElement())
1923                 return ancestor->lookupNamespaceURI(prefix);
1924             return String();
1925     }
1926 }
1927
1928 String Node::lookupNamespacePrefix(const AtomicString &_namespaceURI, const Element *originalElement) const
1929 {
1930     if (_namespaceURI.isNull())
1931         return String();
1932             
1933     if (originalElement->lookupNamespaceURI(prefix()) == _namespaceURI)
1934         return prefix();
1935     
1936     ASSERT(isElementNode());
1937     const Element* thisElement = toElement(this);
1938     if (thisElement->hasAttributes()) {
1939         for (unsigned i = 0; i < thisElement->attributeCount(); i++) {
1940             Attribute* attr = thisElement->attributeItem(i);
1941             
1942             if (attr->prefix() == xmlnsAtom && attr->value() == _namespaceURI
1943                     && originalElement->lookupNamespaceURI(attr->localName()) == _namespaceURI)
1944                 return attr->localName();
1945         }
1946     }
1947     
1948     if (Element* ancestor = ancestorElement())
1949         return ancestor->lookupNamespacePrefix(_namespaceURI, originalElement);
1950     return String();
1951 }
1952
1953 static void appendTextContent(const Node* node, bool convertBRsToNewlines, bool& isNullString, StringBuilder& content)
1954 {
1955     switch (node->nodeType()) {
1956     case Node::TEXT_NODE:
1957     case Node::CDATA_SECTION_NODE:
1958     case Node::COMMENT_NODE:
1959         isNullString = false;
1960         content.append(static_cast<const CharacterData*>(node)->data());
1961         break;
1962
1963     case Node::PROCESSING_INSTRUCTION_NODE:
1964         isNullString = false;
1965         content.append(static_cast<const ProcessingInstruction*>(node)->data());
1966         break;
1967     
1968     case Node::ELEMENT_NODE:
1969         if (node->hasTagName(brTag) && convertBRsToNewlines) {
1970             isNullString = false;
1971             content.append('\n');
1972             break;
1973         }
1974     // Fall through.
1975     case Node::ATTRIBUTE_NODE:
1976     case Node::ENTITY_NODE:
1977     case Node::ENTITY_REFERENCE_NODE:
1978     case Node::DOCUMENT_FRAGMENT_NODE:
1979         isNullString = false;
1980         for (Node* child = node->firstChild(); child; child = child->nextSibling()) {
1981             if (child->nodeType() == Node::COMMENT_NODE || child->nodeType() == Node::PROCESSING_INSTRUCTION_NODE)
1982                 continue;
1983             appendTextContent(child, convertBRsToNewlines, isNullString, content);
1984         }
1985         break;
1986
1987     case Node::DOCUMENT_NODE:
1988     case Node::DOCUMENT_TYPE_NODE:
1989     case Node::NOTATION_NODE:
1990     case Node::XPATH_NAMESPACE_NODE:
1991         break;
1992     }
1993 }
1994
1995 String Node::textContent(bool convertBRsToNewlines) const
1996 {
1997     StringBuilder content;
1998     bool isNullString = true;
1999     appendTextContent(this, convertBRsToNewlines, isNullString, content);
2000     return isNullString ? String() : content.toString();
2001 }
2002
2003 void Node::setTextContent(const String& text, ExceptionCode& ec)
2004 {           
2005     switch (nodeType()) {
2006         case TEXT_NODE:
2007         case CDATA_SECTION_NODE:
2008         case COMMENT_NODE:
2009         case PROCESSING_INSTRUCTION_NODE:
2010             setNodeValue(text, ec);
2011             return;
2012         case ELEMENT_NODE:
2013         case ATTRIBUTE_NODE:
2014         case ENTITY_NODE:
2015         case ENTITY_REFERENCE_NODE:
2016         case DOCUMENT_FRAGMENT_NODE: {
2017             RefPtr<ContainerNode> container = toContainerNode(this);
2018 #if ENABLE(MUTATION_OBSERVERS)
2019             ChildListMutationScope mutation(this);
2020 #endif
2021             container->removeChildren();
2022             if (!text.isEmpty())
2023                 container->appendChild(document()->createTextNode(text), ec);
2024             return;
2025         }
2026         case DOCUMENT_NODE:
2027         case DOCUMENT_TYPE_NODE:
2028         case NOTATION_NODE:
2029         case XPATH_NAMESPACE_NODE:
2030             // Do nothing.
2031             return;
2032     }
2033     ASSERT_NOT_REACHED();
2034 }
2035
2036 Element* Node::ancestorElement() const
2037 {
2038     // In theory, there can be EntityReference nodes between elements, but this is currently not supported.
2039     for (ContainerNode* n = parentNode(); n; n = n->parentNode()) {
2040         if (n->isElementNode())
2041             return static_cast<Element*>(n);
2042     }
2043     return 0;
2044 }
2045
2046 bool Node::offsetInCharacters() const
2047 {
2048     return false;
2049 }
2050
2051 unsigned short Node::compareDocumentPosition(Node* otherNode)
2052 {
2053     // It is not clear what should be done if |otherNode| is 0.
2054     if (!otherNode)
2055         return DOCUMENT_POSITION_DISCONNECTED;
2056
2057     if (otherNode == this)
2058         return DOCUMENT_POSITION_EQUIVALENT;
2059     
2060     Attr* attr1 = nodeType() == ATTRIBUTE_NODE ? static_cast<Attr*>(this) : 0;
2061     Attr* attr2 = otherNode->nodeType() == ATTRIBUTE_NODE ? static_cast<Attr*>(otherNode) : 0;
2062     
2063     Node* start1 = attr1 ? attr1->ownerElement() : this;
2064     Node* start2 = attr2 ? attr2->ownerElement() : otherNode;
2065     
2066     // If either of start1 or start2 is null, then we are disconnected, since one of the nodes is
2067     // an orphaned attribute node.
2068     if (!start1 || !start2)
2069         return DOCUMENT_POSITION_DISCONNECTED | DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC;
2070
2071     Vector<Node*, 16> chain1;
2072     Vector<Node*, 16> chain2;
2073     if (attr1)
2074         chain1.append(attr1);
2075     if (attr2)
2076         chain2.append(attr2);
2077     
2078     if (attr1 && attr2 && start1 == start2 && start1) {
2079         // We are comparing two attributes on the same node. Crawl our attribute map and see which one we hit first.
2080         Element* owner1 = attr1->ownerElement();
2081         owner1->updatedAttributeData(); // Force update invalid attributes.
2082         unsigned length = owner1->attributeCount();
2083         for (unsigned i = 0; i < length; ++i) {
2084             // If neither of the two determining nodes is a child node and nodeType is the same for both determining nodes, then an 
2085             // implementation-dependent order between the determining nodes is returned. This order is stable as long as no nodes of
2086             // the same nodeType are inserted into or removed from the direct container. This would be the case, for example, 
2087             // when comparing two attributes of the same element, and inserting or removing additional attributes might change 
2088             // the order between existing attributes.
2089             Attribute* attribute = owner1->attributeItem(i);
2090             if (attr1->qualifiedName() == attribute->name())
2091                 return DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC | DOCUMENT_POSITION_FOLLOWING;
2092             if (attr2->qualifiedName() == attribute->name())
2093                 return DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC | DOCUMENT_POSITION_PRECEDING;
2094         }
2095         
2096         ASSERT_NOT_REACHED();
2097         return DOCUMENT_POSITION_DISCONNECTED;
2098     }
2099
2100     // If one node is in the document and the other is not, we must be disconnected.
2101     // If the nodes have different owning documents, they must be disconnected.  Note that we avoid
2102     // comparing Attr nodes here, since they return false from inDocument() all the time (which seems like a bug).
2103     if (start1->inDocument() != start2->inDocument() ||
2104         start1->document() != start2->document())
2105         return DOCUMENT_POSITION_DISCONNECTED | DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC;
2106
2107     // We need to find a common ancestor container, and then compare the indices of the two immediate children.
2108     Node* current;
2109     for (current = start1; current; current = current->parentNode())
2110         chain1.append(current);
2111     for (current = start2; current; current = current->parentNode())
2112         chain2.append(current);
2113    
2114     // Walk the two chains backwards and look for the first difference.
2115     unsigned index1 = chain1.size();
2116     unsigned index2 = chain2.size();
2117     for (unsigned i = min(index1, index2); i; --i) {
2118         Node* child1 = chain1[--index1];
2119         Node* child2 = chain2[--index2];
2120         if (child1 != child2) {
2121             // If one of the children is an attribute, it wins.
2122             if (child1->nodeType() == ATTRIBUTE_NODE)
2123                 return DOCUMENT_POSITION_FOLLOWING;
2124             if (child2->nodeType() == ATTRIBUTE_NODE)
2125                 return DOCUMENT_POSITION_PRECEDING;
2126             
2127             if (!child2->nextSibling())
2128                 return DOCUMENT_POSITION_FOLLOWING;
2129             if (!child1->nextSibling())
2130                 return DOCUMENT_POSITION_PRECEDING;
2131
2132             // Otherwise we need to see which node occurs first.  Crawl backwards from child2 looking for child1.
2133             for (Node* child = child2->previousSibling(); child; child = child->previousSibling()) {
2134                 if (child == child1)
2135                     return DOCUMENT_POSITION_FOLLOWING;
2136             }
2137             return DOCUMENT_POSITION_PRECEDING;
2138         }
2139     }
2140     
2141     // There was no difference between the two parent chains, i.e., one was a subset of the other.  The shorter
2142     // chain is the ancestor.
2143     return index1 < index2 ? 
2144                DOCUMENT_POSITION_FOLLOWING | DOCUMENT_POSITION_CONTAINED_BY :
2145                DOCUMENT_POSITION_PRECEDING | DOCUMENT_POSITION_CONTAINS;
2146 }
2147
2148 FloatPoint Node::convertToPage(const FloatPoint& p) const
2149 {
2150     // If there is a renderer, just ask it to do the conversion
2151     if (renderer())
2152         return renderer()->localToAbsolute(p, false, true);
2153     
2154     // Otherwise go up the tree looking for a renderer
2155     Element *parent = ancestorElement();
2156     if (parent)
2157         return parent->convertToPage(p);
2158
2159     // No parent - no conversion needed
2160     return p;
2161 }
2162
2163 FloatPoint Node::convertFromPage(const FloatPoint& p) const
2164 {
2165     // If there is a renderer, just ask it to do the conversion
2166     if (renderer())
2167         return renderer()->absoluteToLocal(p, false, true);
2168
2169     // Otherwise go up the tree looking for a renderer
2170     Element *parent = ancestorElement();
2171     if (parent)
2172         return parent->convertFromPage(p);
2173
2174     // No parent - no conversion needed
2175     return p;
2176 }
2177
2178 #ifndef NDEBUG
2179
2180 static void appendAttributeDesc(const Node* node, String& string, const QualifiedName& name, const char* attrDesc)
2181 {
2182     if (node->isElementNode()) {
2183         String attr = static_cast<const Element*>(node)->getAttribute(name);
2184         if (!attr.isEmpty()) {
2185             string += attrDesc;
2186             string += attr;
2187         }
2188     }
2189 }
2190
2191 void Node::showNode(const char* prefix) const
2192 {
2193     if (!prefix)
2194         prefix = "";
2195     if (isTextNode()) {
2196         String value = nodeValue();
2197         value.replace('\\', "\\\\");
2198         value.replace('\n', "\\n");
2199         fprintf(stderr, "%s%s\t%p \"%s\"\n", prefix, nodeName().utf8().data(), this, value.utf8().data());
2200     } else {
2201         String attrs = "";
2202         appendAttributeDesc(this, attrs, classAttr, " CLASS=");
2203         appendAttributeDesc(this, attrs, styleAttr, " STYLE=");
2204         fprintf(stderr, "%s%s\t%p%s\n", prefix, nodeName().utf8().data(), this, attrs.utf8().data());
2205     }
2206 }
2207
2208 void Node::showTreeForThis() const
2209 {
2210     showTreeAndMark(this, "*");
2211 }
2212
2213 static void traverseTreeAndMark(const String& baseIndent, const Node* rootNode, const Node* markedNode1, const char* markedLabel1, const Node* markedNode2, const char* markedLabel2)
2214 {
2215     for (const Node* node = rootNode; node; node = node->traverseNextNode()) {
2216         if (node == markedNode1)
2217             fprintf(stderr, "%s", markedLabel1);
2218         if (node == markedNode2)
2219             fprintf(stderr, "%s", markedLabel2);
2220
2221         String indent = baseIndent;
2222         for (const Node* tmpNode = node; tmpNode && tmpNode != rootNode; tmpNode = tmpNode->parentOrHostNode())
2223             indent += "\t";
2224         fprintf(stderr, "%s", indent.utf8().data());
2225         node->showNode();
2226         if (node->isShadowRoot()) {
2227             if (ShadowRoot* youngerShadowRoot = toShadowRoot(node)->youngerShadowRoot())
2228                 traverseTreeAndMark(indent + "\t", youngerShadowRoot, markedNode1, markedLabel1, markedNode2, markedLabel2);
2229         } else if (ShadowRoot* oldestShadowRoot = oldestShadowRootFor(node))
2230             traverseTreeAndMark(indent + "\t", oldestShadowRoot, markedNode1, markedLabel1, markedNode2, markedLabel2);
2231     }
2232 }
2233
2234 void Node::showTreeAndMark(const Node* markedNode1, const char* markedLabel1, const Node* markedNode2, const char* markedLabel2) const
2235 {
2236     const Node* rootNode;
2237     const Node* node = this;
2238     while (node->parentOrHostNode() && !node->hasTagName(bodyTag))
2239         node = node->parentOrHostNode();
2240     rootNode = node;
2241
2242     String startingIndent;
2243     traverseTreeAndMark(startingIndent, rootNode, markedNode1, markedLabel1, markedNode2, markedLabel2);
2244 }
2245
2246 void Node::formatForDebugger(char* buffer, unsigned length) const
2247 {
2248     String result;
2249     String s;
2250     
2251     s = nodeName();
2252     if (s.length() == 0)
2253         result += "<none>";
2254     else
2255         result += s;
2256           
2257     strncpy(buffer, result.utf8().data(), length - 1);
2258 }
2259
2260 static ContainerNode* parentOrHostOrFrameOwner(const Node* node)
2261 {
2262     ContainerNode* parent = node->parentOrHostNode();
2263     if (!parent && node->document() && node->document()->frame())
2264         parent = node->document()->frame()->ownerElement();
2265     return parent;
2266 }
2267
2268 static void showSubTreeAcrossFrame(const Node* node, const Node* markedNode, const String& indent)
2269 {
2270     if (node == markedNode)
2271         fputs("*", stderr);
2272     fputs(indent.utf8().data(), stderr);
2273     node->showNode();
2274      if (node->isShadowRoot()) {
2275          if (ShadowRoot* youngerShadowRoot = toShadowRoot(node)->youngerShadowRoot())
2276              showSubTreeAcrossFrame(youngerShadowRoot, markedNode, indent + "\t");
2277      } else {
2278          if (node->isFrameOwnerElement())
2279              showSubTreeAcrossFrame(static_cast<const HTMLFrameOwnerElement*>(node)->contentDocument(), markedNode, indent + "\t");
2280          if (ShadowRoot* oldestShadowRoot = oldestShadowRootFor(node))
2281              showSubTreeAcrossFrame(oldestShadowRoot, markedNode, indent + "\t");
2282      }
2283     for (Node* child = node->firstChild(); child; child = child->nextSibling())
2284         showSubTreeAcrossFrame(child, markedNode, indent + "\t");
2285 }
2286
2287 void Node::showTreeForThisAcrossFrame() const
2288 {
2289     Node* rootNode = const_cast<Node*>(this);
2290     while (parentOrHostOrFrameOwner(rootNode))
2291         rootNode = parentOrHostOrFrameOwner(rootNode);
2292     showSubTreeAcrossFrame(rootNode, this, "");
2293 }
2294
2295 #endif
2296
2297 // --------
2298
2299 void NodeListsNodeData::invalidateCaches()
2300 {
2301     TagNodeListCache::const_iterator tagCacheEnd = m_tagNodeListCache.end();
2302     for (TagNodeListCache::const_iterator it = m_tagNodeListCache.begin(); it != tagCacheEnd; ++it)
2303         it->second->invalidateCache();
2304     TagNodeListCacheNS::const_iterator tagCacheNSEnd = m_tagNodeListCacheNS.end();
2305     for (TagNodeListCacheNS::const_iterator it = m_tagNodeListCacheNS.begin(); it != tagCacheNSEnd; ++it)
2306         it->second->invalidateCache();
2307     invalidateCachesThatDependOnAttributes();
2308 }
2309
2310 void NodeListsNodeData::invalidateCachesThatDependOnAttributes()
2311 {
2312     // Used by labels and region node lists on document.
2313     NodeListsNodeData::NodeListSet::iterator end = m_listsInvalidatedAtDocument.end();
2314     for (NodeListsNodeData::NodeListSet::iterator it = m_listsInvalidatedAtDocument.begin(); it != end; ++it)
2315         (*it)->invalidateCache();
2316
2317     ClassNodeListCache::iterator classCacheEnd = m_classNodeListCache.end();
2318     for (ClassNodeListCache::iterator it = m_classNodeListCache.begin(); it != classCacheEnd; ++it)
2319         it->second->invalidateCache();
2320
2321     NameNodeListCache::iterator nameCacheEnd = m_nameNodeListCache.end();
2322     for (NameNodeListCache::iterator it = m_nameNodeListCache.begin(); it != nameCacheEnd; ++it)
2323         it->second->invalidateCache();
2324     if (m_labelsNodeListCache)
2325         m_labelsNodeListCache->invalidateCache();
2326
2327 #if ENABLE(MICRODATA)
2328     MicroDataItemListCache::iterator itemListCacheEnd = m_microDataItemListCache.end();
2329     for (MicroDataItemListCache::iterator it = m_microDataItemListCache.begin(); it != itemListCacheEnd; ++it)
2330         it->second->invalidateCache();
2331 #endif
2332 }
2333
2334 bool NodeListsNodeData::isEmpty() const
2335 {
2336     if (!m_listsInvalidatedAtDocument.isEmpty())
2337         return false;
2338
2339     if (!m_tagNodeListCache.isEmpty())
2340         return false;
2341     if (!m_tagNodeListCacheNS.isEmpty())
2342         return false;
2343     if (!m_classNodeListCache.isEmpty())
2344         return false;
2345     if (!m_nameNodeListCache.isEmpty())
2346         return false;
2347 #if ENABLE(MICRODATA)
2348     if (!m_microDataItemListCache.isEmpty())
2349         return false;
2350 #endif
2351
2352     if (m_labelsNodeListCache)
2353         return false;
2354     
2355     return true;
2356 }
2357
2358 void Node::getSubresourceURLs(ListHashSet<KURL>& urls) const
2359 {
2360     addSubresourceAttributeURLs(urls);
2361 }
2362
2363 Node* Node::enclosingLinkEventParentOrSelf()
2364 {
2365     for (Node* node = this; node; node = node->parentOrHostNode()) {
2366         // For imagemaps, the enclosing link node is the associated area element not the image itself.
2367         // So we don't let images be the enclosingLinkNode, even though isLink sometimes returns true
2368         // for them.
2369         if (node->isLink() && !node->hasTagName(imgTag))
2370             return node;
2371     }
2372
2373     return 0;
2374 }
2375
2376 const AtomicString& Node::interfaceName() const
2377 {
2378     return eventNames().interfaceForNode;
2379 }
2380
2381 ScriptExecutionContext* Node::scriptExecutionContext() const
2382 {
2383     return document();
2384 }
2385
2386 Node::InsertionNotificationRequest Node::insertedInto(Node* insertionPoint)
2387 {
2388     ASSERT(insertionPoint->inDocument() || isContainerNode());
2389     if (insertionPoint->inDocument())
2390         setFlag(InDocumentFlag);
2391     return InsertionDone;
2392 }
2393
2394 void Node::removedFrom(Node* insertionPoint)
2395 {
2396     ASSERT(insertionPoint->inDocument() || isContainerNode());
2397     if (insertionPoint->inDocument())
2398         clearFlag(InDocumentFlag);
2399 }
2400
2401 void Node::didMoveToNewDocument(Document* oldDocument)
2402 {
2403     TreeScopeAdopter::ensureDidMoveToNewDocumentWasCalled(oldDocument);
2404
2405     // FIXME: Event listener types for this node should be set on the new owner document here.
2406
2407 #if ENABLE(MUTATION_OBSERVERS)
2408     if (Vector<OwnPtr<MutationObserverRegistration> >* registry = mutationObserverRegistry()) {
2409         for (size_t i = 0; i < registry->size(); ++i) {
2410             document()->addMutationObserverTypes(registry->at(i)->mutationTypes());
2411         }
2412     }
2413
2414     if (HashSet<MutationObserverRegistration*>* transientRegistry = transientMutationObserverRegistry()) {
2415         for (HashSet<MutationObserverRegistration*>::iterator iter = transientRegistry->begin(); iter != transientRegistry->end(); ++iter) {
2416             document()->addMutationObserverTypes((*iter)->mutationTypes());
2417         }
2418     }
2419 #endif
2420 }
2421
2422 #if ENABLE(SVG)
2423 static inline HashSet<SVGElementInstance*> instancesForSVGElement(Node* node)
2424 {
2425     HashSet<SVGElementInstance*> instances;
2426  
2427     ASSERT(node);
2428     if (!node->isSVGElement() || node->shadowTreeRootNode())
2429         return HashSet<SVGElementInstance*>();
2430
2431     SVGElement* element = static_cast<SVGElement*>(node);
2432     if (!element->isStyled())
2433         return HashSet<SVGElementInstance*>();
2434
2435     SVGStyledElement* styledElement = static_cast<SVGStyledElement*>(element);
2436     ASSERT(!styledElement->instanceUpdatesBlocked());
2437
2438     return styledElement->instancesForElement();
2439 }
2440 #endif
2441
2442 static inline bool tryAddEventListener(Node* targetNode, const AtomicString& eventType, PassRefPtr<EventListener> listener, bool useCapture)
2443 {
2444     if (!targetNode->EventTarget::addEventListener(eventType, listener, useCapture))
2445         return false;
2446
2447     if (Document* document = targetNode->document()) {
2448         document->addListenerTypeIfNeeded(eventType);
2449         if (eventType == eventNames().mousewheelEvent)
2450             document->didAddWheelEventHandler();
2451         else if (eventNames().isTouchEventType(eventType))
2452             document->didAddTouchEventHandler();
2453     }
2454         
2455     return true;
2456 }
2457
2458 bool Node::addEventListener(const AtomicString& eventType, PassRefPtr<EventListener> listener, bool useCapture)
2459 {
2460 #if !ENABLE(SVG)
2461     return tryAddEventListener(this, eventType, listener, useCapture);
2462 #else
2463     if (!isSVGElement())
2464         return tryAddEventListener(this, eventType, listener, useCapture);
2465
2466     HashSet<SVGElementInstance*> instances = instancesForSVGElement(this);
2467     if (instances.isEmpty())
2468         return tryAddEventListener(this, eventType, listener, useCapture);
2469
2470     RefPtr<EventListener> listenerForRegularTree = listener;
2471     RefPtr<EventListener> listenerForShadowTree = listenerForRegularTree;
2472
2473     // Add event listener to regular DOM element
2474     if (!tryAddEventListener(this, eventType, listenerForRegularTree.release(), useCapture))
2475         return false;
2476
2477     // Add event listener to all shadow tree DOM element instances
2478     const HashSet<SVGElementInstance*>::const_iterator end = instances.end();
2479     for (HashSet<SVGElementInstance*>::const_iterator it = instances.begin(); it != end; ++it) {
2480         ASSERT((*it)->shadowTreeElement());
2481         ASSERT((*it)->correspondingElement() == this);
2482
2483         RefPtr<EventListener> listenerForCurrentShadowTreeElement = listenerForShadowTree;
2484         bool result = tryAddEventListener((*it)->shadowTreeElement(), eventType, listenerForCurrentShadowTreeElement.release(), useCapture);
2485         ASSERT_UNUSED(result, result);
2486     }
2487
2488     return true;
2489 #endif
2490 }
2491
2492 static inline bool tryRemoveEventListener(Node* targetNode, const AtomicString& eventType, EventListener* listener, bool useCapture)
2493 {
2494     if (!targetNode->EventTarget::removeEventListener(eventType, listener, useCapture))
2495         return false;
2496
2497     // FIXME: Notify Document that the listener has vanished. We need to keep track of a number of
2498     // listeners for each type, not just a bool - see https://bugs.webkit.org/show_bug.cgi?id=33861
2499     if (Document* document = targetNode->document()) {
2500         if (eventType == eventNames().mousewheelEvent)
2501             document->didRemoveWheelEventHandler();
2502         else if (eventNames().isTouchEventType(eventType))
2503             document->didRemoveTouchEventHandler();
2504     }
2505     
2506     return true;
2507 }
2508
2509 bool Node::removeEventListener(const AtomicString& eventType, EventListener* listener, bool useCapture)
2510 {
2511 #if !ENABLE(SVG)
2512     return tryRemoveEventListener(this, eventType, listener, useCapture);
2513 #else
2514     if (!isSVGElement())
2515         return tryRemoveEventListener(this, eventType, listener, useCapture);
2516
2517     HashSet<SVGElementInstance*> instances = instancesForSVGElement(this);
2518     if (instances.isEmpty())
2519         return tryRemoveEventListener(this, eventType, listener, useCapture);
2520
2521     // EventTarget::removeEventListener creates a PassRefPtr around the given EventListener
2522     // object when creating a temporary RegisteredEventListener object used to look up the
2523     // event listener in a cache. If we want to be able to call removeEventListener() multiple
2524     // times on different nodes, we have to delay its immediate destruction, which would happen
2525     // after the first call below.
2526     RefPtr<EventListener> protector(listener);
2527
2528     // Remove event listener from regular DOM element
2529     if (!tryRemoveEventListener(this, eventType, listener, useCapture))
2530         return false;
2531
2532     // Remove event listener from all shadow tree DOM element instances
2533     const HashSet<SVGElementInstance*>::const_iterator end = instances.end();
2534     for (HashSet<SVGElementInstance*>::const_iterator it = instances.begin(); it != end; ++it) {
2535         ASSERT((*it)->correspondingElement() == this);
2536
2537         SVGElement* shadowTreeElement = (*it)->shadowTreeElement();
2538         ASSERT(shadowTreeElement);
2539
2540         if (tryRemoveEventListener(shadowTreeElement, eventType, listener, useCapture))
2541             continue;
2542
2543         // This case can only be hit for event listeners created from markup
2544         ASSERT(listener->wasCreatedFromMarkup());
2545
2546         // If the event listener 'listener' has been created from markup and has been fired before
2547         // then JSLazyEventListener::parseCode() has been called and m_jsFunction of that listener
2548         // has been created (read: it's not 0 anymore). During shadow tree creation, the event
2549         // listener DOM attribute has been cloned, and another event listener has been setup in
2550         // the shadow tree. If that event listener has not been used yet, m_jsFunction is still 0,
2551         // and tryRemoveEventListener() above will fail. Work around that very seldom problem.
2552         EventTargetData* data = shadowTreeElement->eventTargetData();
2553         ASSERT(data);
2554
2555         data->eventListenerMap.removeFirstEventListenerCreatedFromMarkup(eventType);
2556     }
2557
2558     return true;
2559 #endif
2560 }
2561
2562 EventTargetData* Node::eventTargetData()
2563 {
2564     return hasRareData() ? rareData()->eventTargetData() : 0;
2565 }
2566
2567 EventTargetData* Node::ensureEventTargetData()
2568 {
2569     return ensureRareData()->ensureEventTargetData();
2570 }
2571
2572 #if ENABLE(MUTATION_OBSERVERS)
2573 Vector<OwnPtr<MutationObserverRegistration> >* Node::mutationObserverRegistry()
2574 {
2575     return hasRareData() ? rareData()->mutationObserverRegistry() : 0;
2576 }
2577
2578 HashSet<MutationObserverRegistration*>* Node::transientMutationObserverRegistry()
2579 {
2580     return hasRareData() ? rareData()->transientMutationObserverRegistry() : 0;
2581 }
2582
2583 void Node::collectMatchingObserversForMutation(HashMap<WebKitMutationObserver*, MutationRecordDeliveryOptions>& observers, Node* fromNode, WebKitMutationObserver::MutationType type, const QualifiedName* attributeName)
2584 {
2585     ASSERT((type == WebKitMutationObserver::Attributes && attributeName) || !attributeName);
2586     if (Vector<OwnPtr<MutationObserverRegistration> >* registry = fromNode->mutationObserverRegistry()) {
2587         const size_t size = registry->size();
2588         for (size_t i = 0; i < size; ++i) {
2589             MutationObserverRegistration* registration = registry->at(i).get();
2590             if (registration->shouldReceiveMutationFrom(this, type, attributeName)) {
2591                 MutationRecordDeliveryOptions deliveryOptions = registration->deliveryOptions();
2592                 HashMap<WebKitMutationObserver*, MutationRecordDeliveryOptions>::AddResult result = observers.add(registration->observer(), deliveryOptions);
2593                 if (!result.isNewEntry)
2594                     result.iterator->second |= deliveryOptions;
2595
2596             }
2597         }
2598     }
2599
2600     if (HashSet<MutationObserverRegistration*>* transientRegistry = fromNode->transientMutationObserverRegistry()) {
2601         for (HashSet<MutationObserverRegistration*>::iterator iter = transientRegistry->begin(); iter != transientRegistry->end(); ++iter) {
2602             MutationObserverRegistration* registration = *iter;
2603             if (registration->shouldReceiveMutationFrom(this, type, attributeName)) {
2604                 MutationRecordDeliveryOptions deliveryOptions = registration->deliveryOptions();
2605                 HashMap<WebKitMutationObserver*, MutationRecordDeliveryOptions>::AddResult result = observers.add(registration->observer(), deliveryOptions);
2606                 if (!result.isNewEntry)
2607                     result.iterator->second |= deliveryOptions;
2608             }
2609         }
2610     }
2611 }
2612
2613 void Node::getRegisteredMutationObserversOfType(HashMap<WebKitMutationObserver*, MutationRecordDeliveryOptions>& observers, WebKitMutationObserver::MutationType type, const QualifiedName* attributeName)
2614 {
2615     ASSERT((type == WebKitMutationObserver::Attributes && attributeName) || !attributeName);
2616     collectMatchingObserversForMutation(observers, this, type, attributeName);
2617     for (Node* node = parentNode(); node; node = node->parentNode())
2618         collectMatchingObserversForMutation(observers, node, type, attributeName);
2619 }
2620
2621 MutationObserverRegistration* Node::registerMutationObserver(PassRefPtr<WebKitMutationObserver> observer)
2622 {
2623     Vector<OwnPtr<MutationObserverRegistration> >* registry = ensureRareData()->ensureMutationObserverRegistry();
2624     for (size_t i = 0; i < registry->size(); ++i) {
2625         if (registry->at(i)->observer() == observer)
2626             return registry->at(i).get();
2627     }
2628
2629     OwnPtr<MutationObserverRegistration> registration = MutationObserverRegistration::create(observer, this);
2630     MutationObserverRegistration* registrationPtr = registration.get();
2631     registry->append(registration.release());
2632     return registrationPtr;
2633 }
2634
2635 void Node::unregisterMutationObserver(MutationObserverRegistration* registration)
2636 {
2637     Vector<OwnPtr<MutationObserverRegistration> >* registry = mutationObserverRegistry();
2638     ASSERT(registry);
2639     if (!registry)
2640         return;
2641
2642     size_t index = registry->find(registration);
2643     ASSERT(index != notFound);
2644     if (index == notFound)
2645         return;
2646
2647     registry->remove(index);
2648 }
2649
2650 void Node::registerTransientMutationObserver(MutationObserverRegistration* registration)
2651 {
2652     ensureRareData()->ensureTransientMutationObserverRegistry()->add(registration);
2653 }
2654
2655 void Node::unregisterTransientMutationObserver(MutationObserverRegistration* registration)
2656 {
2657     HashSet<MutationObserverRegistration*>* transientRegistry = transientMutationObserverRegistry();
2658     ASSERT(transientRegistry);
2659     if (!transientRegistry)
2660         return;
2661
2662     ASSERT(transientRegistry->contains(registration));
2663     transientRegistry->remove(registration);
2664 }
2665
2666 void Node::notifyMutationObserversNodeWillDetach()
2667 {
2668     if (!document()->hasMutationObservers())
2669         return;
2670
2671     for (Node* node = parentNode(); node; node = node->parentNode()) {
2672         if (Vector<OwnPtr<MutationObserverRegistration> >* registry = node->mutationObserverRegistry()) {
2673             const size_t size = registry->size();
2674             for (size_t i = 0; i < size; ++i)
2675                 registry->at(i)->observedSubtreeNodeWillDetach(this);
2676         }
2677
2678         if (HashSet<MutationObserverRegistration*>* transientRegistry = node->transientMutationObserverRegistry()) {
2679             for (HashSet<MutationObserverRegistration*>::iterator iter = transientRegistry->begin(); iter != transientRegistry->end(); ++iter)
2680                 (*iter)->observedSubtreeNodeWillDetach(this);
2681         }
2682     }
2683 }
2684 #endif // ENABLE(MUTATION_OBSERVERS)
2685
2686 #if ENABLE(STYLE_SCOPED)
2687 bool Node::hasScopedHTMLStyleChild() const
2688 {
2689     return hasRareData() && rareData()->hasScopedHTMLStyleChild();
2690 }
2691
2692 size_t Node::numberOfScopedHTMLStyleChildren() const
2693 {
2694     return hasRareData() ? rareData()->numberOfScopedHTMLStyleChildren() : 0;
2695 }
2696
2697 void Node::registerScopedHTMLStyleChild()
2698 {
2699     ensureRareData()->registerScopedHTMLStyleChild();
2700 }
2701
2702 void Node::unregisterScopedHTMLStyleChild()
2703 {
2704     ASSERT(hasRareData());
2705     if (hasRareData())
2706         rareData()->unregisterScopedHTMLStyleChild();
2707 }
2708 #else
2709 bool Node::hasScopedHTMLStyleChild() const
2710 {
2711     return 0;
2712 }
2713
2714 size_t Node::numberOfScopedHTMLStyleChildren() const
2715 {
2716     return 0;
2717 }
2718 #endif
2719
2720 void Node::handleLocalEvents(Event* event)
2721 {
2722     if (!hasRareData() || !rareData()->eventTargetData())
2723         return;
2724
2725     if (disabled() && event->isMouseEvent())
2726         return;
2727
2728     fireEventListeners(event);
2729 }
2730
2731 void Node::dispatchScopedEvent(PassRefPtr<Event> event)
2732 {
2733     dispatchScopedEventDispatchMediator(EventDispatchMediator::create(event));
2734 }
2735
2736 void Node::dispatchScopedEventDispatchMediator(PassRefPtr<EventDispatchMediator> eventDispatchMediator)
2737 {
2738     EventDispatcher::dispatchScopedEvent(this, eventDispatchMediator);
2739 }
2740
2741 bool Node::dispatchEvent(PassRefPtr<Event> event)
2742 {
2743     return EventDispatcher::dispatchEvent(this, EventDispatchMediator::create(event));
2744 }
2745
2746 void Node::dispatchRegionLayoutUpdateEvent()
2747 {
2748     ASSERT(!eventDispatchForbidden());
2749
2750     if (!document()->hasListenerType(Document::REGIONLAYOUTUPDATE_LISTENER))
2751         return;
2752
2753     dispatchScopedEvent(UIEvent::create(eventNames().webkitRegionLayoutUpdateEvent, true, true, document()->defaultView(), 0));
2754 }
2755
2756 void Node::dispatchSubtreeModifiedEvent()
2757 {
2758     if (isInShadowTree())
2759         return;
2760
2761     ASSERT(!eventDispatchForbidden());
2762
2763     if (!document()->hasListenerType(Document::DOMSUBTREEMODIFIED_LISTENER))
2764         return;
2765
2766     dispatchScopedEvent(MutationEvent::create(eventNames().DOMSubtreeModifiedEvent, true));
2767 }
2768
2769 void Node::dispatchFocusInEvent(const AtomicString& eventType, PassRefPtr<Node> oldFocusedNode)
2770 {
2771     ASSERT(!eventDispatchForbidden());
2772     ASSERT(eventType == eventNames().focusinEvent || eventType == eventNames().DOMFocusInEvent);
2773     dispatchScopedEventDispatchMediator(FocusInEventDispatchMediator::create(UIEvent::create(eventType, true, false, document()->defaultView(), 0), oldFocusedNode));
2774 }
2775
2776 void Node::dispatchFocusOutEvent(const AtomicString& eventType, PassRefPtr<Node> newFocusedNode)
2777 {
2778     ASSERT(!eventDispatchForbidden());
2779     ASSERT(eventType == eventNames().focusoutEvent || eventType == eventNames().DOMFocusOutEvent);
2780     dispatchScopedEventDispatchMediator(FocusOutEventDispatchMediator::create(UIEvent::create(eventType, true, false, document()->defaultView(), 0), newFocusedNode));
2781 }
2782
2783 void Node::dispatchDOMActivateEvent(int detail, PassRefPtr<Event> underlyingEvent)
2784 {
2785     ASSERT(!eventDispatchForbidden());
2786     RefPtr<UIEvent> event = UIEvent::create(eventNames().DOMActivateEvent, true, true, document()->defaultView(), detail);
2787     event->setUnderlyingEvent(underlyingEvent);
2788     dispatchScopedEvent(event.release());
2789 }
2790
2791 bool Node::dispatchKeyEvent(const PlatformKeyboardEvent& event)
2792 {
2793     return EventDispatcher::dispatchEvent(this, KeyboardEventDispatchMediator::create(KeyboardEvent::create(event, document()->defaultView())));
2794 }
2795
2796 bool Node::dispatchMouseEvent(const PlatformMouseEvent& event, const AtomicString& eventType,
2797     int detail, Node* relatedTarget)
2798 {
2799     return EventDispatcher::dispatchEvent(this, MouseEventDispatchMediator::create(MouseEvent::create(eventType, document()->defaultView(), event, detail, relatedTarget)));
2800 }
2801
2802 void Node::dispatchSimulatedClick(PassRefPtr<Event> event, bool sendMouseEvents, bool showPressedLook)
2803 {
2804     EventDispatcher::dispatchSimulatedClick(this, event, sendMouseEvents, showPressedLook);
2805 }
2806
2807 bool Node::dispatchBeforeLoadEvent(const String& sourceURL)
2808 {
2809     if (!document()->hasListenerType(Document::BEFORELOAD_LISTENER))
2810         return true;
2811
2812     RefPtr<Node> protector(this);
2813     RefPtr<BeforeLoadEvent> beforeLoadEvent = BeforeLoadEvent::create(sourceURL);
2814     dispatchEvent(beforeLoadEvent.get());
2815     return !beforeLoadEvent->defaultPrevented();
2816 }
2817
2818 bool Node::dispatchWheelEvent(const PlatformWheelEvent& event)
2819 {
2820     return EventDispatcher::dispatchEvent(this, WheelEventDispatchMediator::create(event, document()->defaultView()));
2821 }
2822
2823 void Node::dispatchFocusEvent(PassRefPtr<Node> oldFocusedNode)
2824 {
2825     if (document()->page())
2826         document()->page()->chrome()->client()->elementDidFocus(this);
2827     
2828     EventDispatcher::dispatchEvent(this, FocusEventDispatchMediator::create(oldFocusedNode));
2829 }
2830
2831 void Node::dispatchBlurEvent(PassRefPtr<Node> newFocusedNode)
2832 {
2833     if (document()->page())
2834         document()->page()->chrome()->client()->elementDidBlur(this);
2835
2836     EventDispatcher::dispatchEvent(this, BlurEventDispatchMediator::create(newFocusedNode));
2837 }
2838
2839 void Node::dispatchChangeEvent()
2840 {
2841     dispatchEvent(Event::create(eventNames().changeEvent, true, false));
2842 }
2843
2844 void Node::dispatchInputEvent()
2845 {
2846     dispatchEvent(Event::create(eventNames().inputEvent, true, false));
2847 }
2848
2849 bool Node::disabled() const
2850 {
2851     return false;
2852 }
2853
2854 void Node::defaultEventHandler(Event* event)
2855 {
2856     if (event->target() != this)
2857         return;
2858     const AtomicString& eventType = event->type();
2859     if (eventType == eventNames().keydownEvent || eventType == eventNames().keypressEvent) {
2860         if (event->isKeyboardEvent())
2861             if (Frame* frame = document()->frame())
2862                 frame->eventHandler()->defaultKeyboardEventHandler(static_cast<KeyboardEvent*>(event));
2863     } else if (eventType == eventNames().clickEvent) {
2864         int detail = event->isUIEvent() ? static_cast<UIEvent*>(event)->detail() : 0;
2865         dispatchDOMActivateEvent(detail, event);
2866 #if ENABLE(CONTEXT_MENUS)
2867     } else if (eventType == eventNames().contextmenuEvent) {
2868         if (Frame* frame = document()->frame())
2869             if (Page* page = frame->page())
2870                 page->contextMenuController()->handleContextMenuEvent(event);
2871 #endif
2872     } else if (eventType == eventNames().textInputEvent) {
2873         if (event->hasInterface(eventNames().interfaceForTextEvent))
2874             if (Frame* frame = document()->frame())
2875                 frame->eventHandler()->defaultTextInputEventHandler(static_cast<TextEvent*>(event));
2876 #if ENABLE(PAN_SCROLLING)
2877     } else if (eventType == eventNames().mousedownEvent && event->isMouseEvent()) {
2878         MouseEvent* mouseEvent = static_cast<MouseEvent*>(event);
2879         if (mouseEvent->button() == MiddleButton) {
2880             if (enclosingLinkEventParentOrSelf())
2881                 return;
2882
2883             RenderObject* renderer = this->renderer();
2884             while (renderer && (!renderer->isBox() || !toRenderBox(renderer)->canBeScrolledAndHasScrollableArea()))
2885                 renderer = renderer->parent();
2886
2887             if (renderer) {
2888                 if (Frame* frame = document()->frame())
2889                     frame->eventHandler()->startPanScrolling(renderer);
2890             }
2891         }
2892 #endif
2893     } else if (eventType == eventNames().mousewheelEvent && event->hasInterface(eventNames().interfaceForWheelEvent)) {
2894         WheelEvent* wheelEvent = static_cast<WheelEvent*>(event);
2895         
2896         // If we don't have a renderer, send the wheel event to the first node we find with a renderer.
2897         // This is needed for <option> and <optgroup> elements so that <select>s get a wheel scroll.
2898         Node* startNode = this;
2899         while (startNode && !startNode->renderer())
2900             startNode = startNode->parentOrHostNode();
2901         
2902         if (startNode && startNode->renderer())
2903             if (Frame* frame = document()->frame())
2904                 frame->eventHandler()->defaultWheelEventHandler(startNode, wheelEvent);
2905     } else if (event->type() == eventNames().webkitEditableContentChangedEvent) {
2906         dispatchInputEvent();
2907     }
2908 }
2909
2910 #if ENABLE(MICRODATA)
2911 DOMSettableTokenList* Node::itemProp()
2912 {
2913     return ensureRareData()->itemProp();
2914 }
2915
2916 void Node::setItemProp(const String& value)
2917 {
2918     ensureRareData()->setItemProp(value);
2919 }
2920
2921 DOMSettableTokenList* Node::itemRef()
2922 {
2923     return ensureRareData()->itemRef();
2924 }
2925
2926 void Node::setItemRef(const String& value)
2927 {
2928     ensureRareData()->setItemRef(value);
2929 }
2930
2931 DOMSettableTokenList* Node::itemType()
2932 {
2933     return ensureRareData()->itemType();
2934 }
2935
2936 void Node::setItemType(const String& value)
2937 {
2938     ensureRareData()->setItemType(value);
2939 }
2940
2941 HTMLPropertiesCollection* Node::properties()
2942 {
2943     return ensureRareData()->properties(this);
2944 }
2945 #endif
2946
2947 void NodeRareData::createNodeLists(Node* node)
2948 {
2949     ASSERT(node);
2950     setNodeLists(NodeListsNodeData::create());
2951     if (TreeScope* treeScope = node->treeScope())
2952         treeScope->addNodeListCache();
2953 }
2954
2955 void NodeRareData::clearChildNodeListCache()
2956 {
2957     if (m_childNodeList)
2958         m_childNodeList->invalidateCache();
2959 }
2960
2961 } // namespace WebCore
2962
2963 #ifndef NDEBUG
2964
2965 void showTree(const WebCore::Node* node)
2966 {
2967     if (node)
2968         node->showTreeForThis();
2969 }
2970
2971 #endif