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