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