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