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