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