dd835e4e7dfd6a20778dc8dc4ca1633d71b5bd2e
[WebKit-https.git] / 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 Apple Inc. All rights reserved.
6  * Copyright (C) 2007 Trolltech ASA
7  *
8  * This library is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Library General Public
10  * License as published by the Free Software Foundation; either
11  * version 2 of the License, or (at your option) any later version.
12  *
13  * This library is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * Library General Public License for more details.
17  *
18  * You should have received a copy of the GNU Library General Public License
19  * along with this library; see the file COPYING.LIB.  If not, write to
20  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
21  * Boston, MA 02110-1301, USA.
22  */
23
24 #include "config.h"
25 #include "Node.h"
26
27 #include "CSSParser.h"
28 #include "CSSRule.h"
29 #include "CSSRuleList.h"
30 #include "CSSSelector.h"
31 #include "CSSStyleRule.h"
32 #include "CSSStyleSelector.h"
33 #include "CSSStyleSheet.h"
34 #include "CString.h"
35 #include "ChildNodeList.h"
36 #include "ClassNodeList.h"
37 #include "DOMImplementation.h"
38 #include "Document.h"
39 #include "DynamicNodeList.h"
40 #include "Element.h"
41 #include "ExceptionCode.h"
42 #include "Frame.h"
43 #include "HTMLNames.h"
44 #include "HTMLNames.h"
45 #include "KURL.h"
46 #include "Logging.h"
47 #include "NameNodeList.h"
48 #include "NamedAttrMap.h"
49 #include "RenderObject.h"
50 #include "SelectorNodeList.h"
51 #include "TagNodeList.h"
52 #include "Text.h"
53 #include "TextStream.h"
54 #include "XMLNames.h"
55 #include "htmlediting.h"
56 #include "kjs_binding.h"
57
58 namespace WebCore {
59
60 using namespace HTMLNames;
61
62 typedef HashSet<DynamicNodeList*> NodeListSet;
63 struct NodeListsNodeData {
64     NodeListSet m_listsToNotify;
65     DynamicNodeList::Caches m_childNodeListCaches;
66     HashMap<String, DynamicNodeList::Caches> m_classNodeListCaches;
67     HashMap<String, DynamicNodeList::Caches> m_nameNodeListCaches;
68 };
69
70 bool Node::isSupported(const String& feature, const String& version)
71 {
72     return DOMImplementation::instance()->hasFeature(feature, version);
73 }
74
75 #ifndef NDEBUG
76 WTFLogChannel LogWebCoreNodeLeaks =  { 0x00000000, "", WTFLogChannelOn };
77
78 struct NodeCounter {
79     static unsigned count; 
80
81     ~NodeCounter() 
82     { 
83         if (count) 
84             LOG(WebCoreNodeLeaks, "LEAK: %u Node\n", count); 
85     }
86 };
87 unsigned NodeCounter::count = 0;
88 static NodeCounter nodeCounter;
89
90 static bool shouldIgnoreLeaks = false;
91 static HashSet<Node*> ignoreSet;
92 #endif
93
94 void Node::startIgnoringLeaks()
95 {
96 #ifndef NDEBUG
97     shouldIgnoreLeaks = true;
98 #endif
99 }
100
101 void Node::stopIgnoringLeaks()
102 {
103 #ifndef NDEBUG
104     shouldIgnoreLeaks = false;
105 #endif
106 }
107
108 Node::Node(Document *doc)
109     : m_document(doc),
110       m_previous(0),
111       m_next(0),
112       m_renderer(0),
113       m_tabIndex(0),
114       m_hasId(false),
115       m_hasClass(false),
116       m_attached(false),
117       m_styleChange(NoStyleChange),
118       m_hasChangedChild(false),
119       m_inDocument(false),
120       m_isLink(false),
121       m_attrWasSpecifiedOrElementHasRareData(false),
122       m_focused(false),
123       m_active(false),
124       m_hovered(false),
125       m_inActiveChain(false),
126       m_inDetach(false),
127       m_dispatchingSimulatedEvent(false),
128       m_inSubtreeMark(false)
129 {
130 #ifndef NDEBUG
131     if (shouldIgnoreLeaks)
132         ignoreSet.add(this);
133     else
134         ++NodeCounter::count;
135 #endif
136 }
137
138 void Node::setDocument(Document* doc)
139 {
140     if (inDocument() || m_document == doc)
141         return;
142
143     willMoveToNewOwnerDocument();
144
145     {
146         KJS::JSLock lock;
147         KJS::ScriptInterpreter::updateDOMNodeDocument(this, m_document.get(), doc);
148     }    
149     m_document = doc;
150
151     didMoveToNewOwnerDocument();
152 }
153
154 Node::~Node()
155 {
156 #ifndef NDEBUG
157     HashSet<Node*>::iterator it = ignoreSet.find(this);
158     if (it != ignoreSet.end())
159         ignoreSet.remove(it);
160     else
161         --NodeCounter::count;
162 #endif
163     if (renderer())
164         detach();
165
166     if (m_previous)
167         m_previous->setNextSibling(0);
168     if (m_next)
169         m_next->setPreviousSibling(0);
170 }
171
172 String Node::nodeValue() const
173 {
174   return String();
175 }
176
177 void Node::setNodeValue(const String& /*nodeValue*/, ExceptionCode& ec)
178 {
179     // NO_MODIFICATION_ALLOWED_ERR: Raised when the node is readonly
180     if (isReadOnlyNode()) {
181         ec = NO_MODIFICATION_ALLOWED_ERR;
182         return;
183     }
184
185     // by default nodeValue is null, so setting it has no effect
186 }
187
188 PassRefPtr<NodeList> Node::childNodes()
189 {
190     if (!m_nodeLists)
191         m_nodeLists.set(new NodeListsNodeData);
192
193     return new ChildNodeList(this, &m_nodeLists->m_childNodeListCaches);
194 }
195
196 Node* Node::virtualFirstChild() const
197 {
198     return 0;
199 }
200
201 Node* Node::virtualLastChild() const
202 {
203     return 0;
204 }
205
206 Node *Node::lastDescendant() const
207 {
208     Node *n = const_cast<Node *>(this);
209     while (n && n->lastChild())
210         n = n->lastChild();
211     return n;
212 }
213
214 Node* Node::firstDescendant() const
215 {
216     Node *n = const_cast<Node *>(this);
217     while (n && n->firstChild())
218         n = n->firstChild();
219     return n;
220 }
221
222 bool Node::insertBefore(PassRefPtr<Node>, Node*, ExceptionCode& ec)
223 {
224     ec = HIERARCHY_REQUEST_ERR;
225     return false;
226 }
227
228 bool Node::replaceChild(PassRefPtr<Node>, Node*, ExceptionCode& ec)
229 {
230     ec = HIERARCHY_REQUEST_ERR;
231     return false;
232 }
233
234 bool Node::removeChild(Node*, ExceptionCode& ec)
235 {
236     ec = NOT_FOUND_ERR;
237     return false;
238 }
239
240 bool Node::appendChild(PassRefPtr<Node>, ExceptionCode& ec)
241 {
242     ec = HIERARCHY_REQUEST_ERR;
243     return false;
244 }
245
246 void Node::remove(ExceptionCode& ec)
247 {
248     ref();
249     if (Node *p = parentNode())
250         p->removeChild(this, ec);
251     else
252         ec = HIERARCHY_REQUEST_ERR;
253     deref();
254 }
255
256 bool Node::hasChildNodes(  ) const
257 {
258   return false;
259 }
260
261 void Node::normalize ()
262 {
263     ExceptionCode ec = 0;
264     Node *child = firstChild();
265
266     if (isElementNode()) {
267         // Normalize any attribute children we might have 
268         Element *element = static_cast<Element *>(this);
269         NamedAttrMap *attrMap = element->attributes();
270         
271         if (attrMap) {
272             unsigned numAttrs = attrMap->length();
273             
274             for (unsigned i = 0; i < numAttrs; i++) {
275                 Attribute *attribute = attrMap->attributeItem(i);
276                 Attr *attr = attribute->attr();
277                 
278                 if (attr)
279                     attr->normalize();
280             }
281         }
282     }
283     
284     // Recursively go through the subtree beneath us, normalizing all nodes. In the case
285     // where there are two adjacent text nodes, they are merged together
286     while (child) {
287         Node *nextChild = child->nextSibling();
288
289         if (nextChild && child->nodeType() == TEXT_NODE && nextChild->nodeType() == TEXT_NODE) {
290             // Current child and the next one are both text nodes... merge them
291             Text *currentText = static_cast<Text*>(child);
292             Text *nextText = static_cast<Text*>(nextChild);
293
294             currentText->appendData(nextText->data(),ec);
295             if (ec)
296                 return;
297
298             nextChild->remove(ec);
299             if (ec)
300                 return;
301         }
302         else {
303             child->normalize();
304             child = nextChild;
305         }
306     }
307     
308     // Check if we have a single empty text node left and remove it if so
309     child = firstChild();
310     if (child && !child->nextSibling() && child->isTextNode()) {
311         Text *text = static_cast<Text*>(child);
312         if (text->data().isEmpty())
313             child->remove(ec);
314     }
315 }
316
317 const AtomicString& Node::prefix() const
318 {
319     // For nodes other than elements and attributes, the prefix is always null
320     return nullAtom;
321 }
322
323 void Node::setPrefix(const AtomicString& /*prefix*/, ExceptionCode& ec)
324 {
325     // The spec says that for nodes other than elements and attributes, prefix is always null.
326     // It does not say what to do when the user tries to set the prefix on another type of
327     // node, however Mozilla throws a NAMESPACE_ERR exception.
328     ec = NAMESPACE_ERR;
329 }
330
331 const AtomicString& Node::localName() const
332 {
333     return emptyAtom;
334 }
335
336 const AtomicString& Node::namespaceURI() const
337 {
338     return nullAtom;
339 }
340
341 ContainerNode* Node::addChild(PassRefPtr<Node>)
342 {
343     return 0;
344 }
345
346 bool Node::isContentEditable() const
347 {
348     return parent() && parent()->isContentEditable();
349 }
350
351 bool Node::isContentRichlyEditable() const
352 {
353     return parent() && parent()->isContentRichlyEditable();
354 }
355
356 bool Node::shouldUseInputMethod() const
357 {
358     return isContentEditable();
359 }
360
361 IntRect Node::getRect() const
362 {
363     int _x, _y;
364     if (renderer() && renderer()->absolutePosition(_x, _y))
365         return IntRect( _x, _y, renderer()->width(), renderer()->height() + renderer()->borderTopExtra() + renderer()->borderBottomExtra());
366
367     return IntRect();
368 }
369
370 void Node::setChanged(StyleChangeType changeType)
371 {
372     if ((changeType != NoStyleChange) && !attached()) // changed compared to what?
373         return;
374
375     if (!(changeType == InlineStyleChange && m_styleChange == FullStyleChange))
376         m_styleChange = changeType;
377
378     if (m_styleChange != NoStyleChange) {
379         for (Node* p = parentNode(); p; p = p->parentNode())
380             p->setHasChangedChild(true);
381         document()->setDocumentChanged(true);
382     }
383 }
384
385 bool Node::isFocusable() const
386 {
387     return false;
388 }
389
390 bool Node::isKeyboardFocusable(KeyboardEvent*) const
391 {
392     return isFocusable();
393 }
394
395 bool Node::isMouseFocusable() const
396 {
397     return isFocusable();
398 }
399
400 unsigned Node::nodeIndex() const
401 {
402     Node *_tempNode = previousSibling();
403     unsigned count=0;
404     for( count=0; _tempNode; count++ )
405         _tempNode = _tempNode->previousSibling();
406     return count;
407 }
408
409 void Node::registerDynamicNodeList(DynamicNodeList* list)
410 {
411     if (!m_nodeLists)
412         m_nodeLists.set(new NodeListsNodeData);
413     else if (!m_document->hasNodeLists())
414         // We haven't been receiving notifications while there were no registered lists, so the cache is invalid now.
415         m_nodeLists->m_childNodeListCaches.reset();
416
417     if (list->needsNotifications())
418         m_nodeLists->m_listsToNotify.add(list);
419     m_document->addNodeList();
420 }
421
422 void Node::unregisterDynamicNodeList(DynamicNodeList* list)
423 {
424     ASSERT(m_nodeLists);
425     m_document->removeNodeList();
426     if (list->needsNotifications())
427         m_nodeLists->m_listsToNotify.remove(list);
428 }
429
430 void Node::notifyLocalNodeListsAttributeChanged()
431 {
432     if (!m_nodeLists)
433         return;
434
435     NodeListSet::iterator end = m_nodeLists->m_listsToNotify.end();
436     for (NodeListSet::iterator i = m_nodeLists->m_listsToNotify.begin(); i != end; ++i)
437         (*i)->rootNodeAttributeChanged();
438 }
439
440 void Node::notifyNodeListsAttributeChanged()
441 {
442     for (Node *n = this; n; n = n->parentNode())
443         n->notifyLocalNodeListsAttributeChanged();
444 }
445
446 void Node::notifyLocalNodeListsChildrenChanged()
447 {
448     if (!m_nodeLists)
449         return;
450
451     m_nodeLists->m_childNodeListCaches.reset();
452
453     NodeListSet::iterator end = m_nodeLists->m_listsToNotify.end();
454     for (NodeListSet::iterator i = m_nodeLists->m_listsToNotify.begin(); i != end; ++i)
455         (*i)->rootNodeChildrenChanged();
456 }
457
458 void Node::notifyNodeListsChildrenChanged()
459 {
460     for (Node *n = this; n; n = n->parentNode())
461         n->notifyLocalNodeListsChildrenChanged();
462 }
463
464 unsigned Node::childNodeCount() const
465 {
466     return 0;
467 }
468
469 Node *Node::childNode(unsigned /*index*/) const
470 {
471     return 0;
472 }
473
474 Node *Node::traverseNextNode(const Node *stayWithin) const
475 {
476     if (firstChild()) {
477         ASSERT(!stayWithin || firstChild()->isDescendantOf(stayWithin));
478         return firstChild();
479     }
480     if (this == stayWithin)
481         return 0;
482     if (nextSibling()) {
483         ASSERT(!stayWithin || nextSibling()->isDescendantOf(stayWithin));
484         return nextSibling();
485     }
486     const Node *n = this;
487     while (n && !n->nextSibling() && (!stayWithin || n->parentNode() != stayWithin))
488         n = n->parentNode();
489     if (n) {
490         ASSERT(!stayWithin || !n->nextSibling() || n->nextSibling()->isDescendantOf(stayWithin));
491         return n->nextSibling();
492     }
493     return 0;
494 }
495
496 Node *Node::traverseNextSibling(const Node *stayWithin) const
497 {
498     if (this == stayWithin)
499         return 0;
500     if (nextSibling()) {
501         ASSERT(!stayWithin || nextSibling()->isDescendantOf(stayWithin));
502         return nextSibling();
503     }
504     const Node *n = this;
505     while (n && !n->nextSibling() && (!stayWithin || n->parentNode() != stayWithin))
506         n = n->parentNode();
507     if (n) {
508         ASSERT(!stayWithin || !n->nextSibling() || n->nextSibling()->isDescendantOf(stayWithin));
509         return n->nextSibling();
510     }
511     return 0;
512 }
513
514 Node *Node::traversePreviousNode(const Node *stayWithin) const
515 {
516     if (this == stayWithin)
517         return 0;
518     if (previousSibling()) {
519         Node *n = previousSibling();
520         while (n->lastChild())
521             n = n->lastChild();
522         return n;
523     }
524     return parentNode();
525 }
526
527 Node *Node::traversePreviousNodePostOrder(const Node *stayWithin) const
528 {
529     if (lastChild()) {
530         ASSERT(!stayWithin || lastChild()->isDescendantOf(stayWithin));
531         return lastChild();
532     }
533     if (this == stayWithin)
534         return 0;
535     if (previousSibling()) {
536         ASSERT(!stayWithin || previousSibling()->isDescendantOf(stayWithin));
537         return previousSibling();
538     }
539     const Node *n = this;
540     while (n && !n->previousSibling() && (!stayWithin || n->parentNode() != stayWithin))
541         n = n->parentNode();
542     if (n) {
543         ASSERT(!stayWithin || !n->previousSibling() || n->previousSibling()->isDescendantOf(stayWithin));
544         return n->previousSibling();
545     }
546     return 0;
547 }
548
549 void Node::checkSetPrefix(const AtomicString &_prefix, ExceptionCode& ec)
550 {
551     // Perform error checking as required by spec for setting Node.prefix. Used by
552     // Element::setPrefix() and Attr::setPrefix()
553
554     // FIXME: Implement support for INVALID_CHARACTER_ERR: Raised if the specified prefix contains an illegal character.
555     
556     // NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.
557     if (isReadOnlyNode()) {
558         ec = NO_MODIFICATION_ALLOWED_ERR;
559         return;
560     }
561
562     // FIXME: Implement NAMESPACE_ERR: - Raised if the specified prefix is malformed
563     // We have to comment this out, since it's used for attributes and tag names, and we've only
564     // switched one over.
565     /*
566     // - if the namespaceURI of this node is null,
567     // - if the specified prefix is "xml" and the namespaceURI of this node is different from
568     //   "http://www.w3.org/XML/1998/namespace",
569     // - if this node is an attribute and the specified prefix is "xmlns" and
570     //   the namespaceURI of this node is different from "http://www.w3.org/2000/xmlns/",
571     // - or if this node is an attribute and the qualifiedName of this node is "xmlns" [Namespaces].
572     if ((namespacePart(id()) == noNamespace && id() > ID_LAST_TAG) ||
573         (_prefix == "xml" && String(document()->namespaceURI(id())) != "http://www.w3.org/XML/1998/namespace")) {
574         ec = NAMESPACE_ERR;
575         return;
576     }*/
577 }
578
579 bool Node::canReplaceChild(Node* newChild, Node* oldChild)
580 {
581     if (newChild->nodeType() != DOCUMENT_FRAGMENT_NODE) {
582         if (!childTypeAllowed(newChild->nodeType()))
583             return false;
584     }
585     else {
586         for (Node *n = newChild->firstChild(); n; n = n->nextSibling()) {
587             if (!childTypeAllowed(n->nodeType())) 
588                 return false;
589         }
590     }
591     
592     return true;
593 }
594
595 void Node::checkReplaceChild(Node* newChild, Node* oldChild, ExceptionCode& ec)
596 {
597     // Perform error checking as required by spec for adding a new child. Used by
598     // appendChild(), replaceChild() and insertBefore()
599     
600     // Not mentioned in spec: throw NOT_FOUND_ERR if newChild is null
601     if (!newChild) {
602         ec = NOT_FOUND_ERR;
603         return;
604     }
605     
606     // NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly
607     if (isReadOnlyNode()) {
608         ec = NO_MODIFICATION_ALLOWED_ERR;
609         return;
610     }
611     
612     bool shouldAdoptChild = false;
613     
614     // WRONG_DOCUMENT_ERR: Raised if newChild was created from a different document than the one that
615     // created this node.
616     // We assume that if newChild is a DocumentFragment, all children are created from the same document
617     // as the fragment itself (otherwise they could not have been added as children)
618     if (newChild->document() != document()) {
619         // but if the child is not in a document yet then loosen the
620         // restriction, so that e.g. creating an element with the Option()
621         // constructor and then adding it to a different document works,
622         // as it does in Mozilla and Mac IE.
623         if (!newChild->inDocument()) {
624             shouldAdoptChild = true;
625         } else {
626             ec = WRONG_DOCUMENT_ERR;
627             return;
628         }
629     }
630     
631     // HIERARCHY_REQUEST_ERR: Raised if this node is of a type that does not allow children of the type of the
632     // newChild node, or if the node to append is one of this node's ancestors.
633     
634     // check for ancestor/same node
635     if (newChild == this || isDescendantOf(newChild)) {
636         ec = HIERARCHY_REQUEST_ERR;
637         return;
638     }
639     
640     if (!canReplaceChild(newChild, oldChild)) {
641         ec = HIERARCHY_REQUEST_ERR;
642         return;
643     }
644        
645     // change the document pointer of newChild and all of its children to be the new document
646     if (shouldAdoptChild)
647         for (Node* node = newChild; node; node = node->traverseNextNode(newChild))
648             node->setDocument(document());
649 }
650
651 void Node::checkAddChild(Node *newChild, ExceptionCode& ec)
652 {
653     // Perform error checking as required by spec for adding a new child. Used by
654     // appendChild(), replaceChild() and insertBefore()
655
656     // Not mentioned in spec: throw NOT_FOUND_ERR if newChild is null
657     if (!newChild) {
658         ec = NOT_FOUND_ERR;
659         return;
660     }
661
662     // NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly
663     if (isReadOnlyNode()) {
664         ec = NO_MODIFICATION_ALLOWED_ERR;
665         return;
666     }
667
668     bool shouldAdoptChild = false;
669
670     // WRONG_DOCUMENT_ERR: Raised if newChild was created from a different document than the one that
671     // created this node.
672     // We assume that if newChild is a DocumentFragment, all children are created from the same document
673     // as the fragment itself (otherwise they could not have been added as children)
674     if (newChild->document() != document()) {
675         // but if the child is not in a document yet then loosen the
676         // restriction, so that e.g. creating an element with the Option()
677         // constructor and then adding it to a different document works,
678         // as it does in Mozilla and Mac IE.
679         if (!newChild->inDocument()) {
680             shouldAdoptChild = true;
681         } else {
682             ec = WRONG_DOCUMENT_ERR;
683             return;
684         }
685     }
686
687     // HIERARCHY_REQUEST_ERR: Raised if this node is of a type that does not allow children of the type of the
688     // newChild node, or if the node to append is one of this node's ancestors.
689
690     // check for ancestor/same node
691     if (newChild == this || isDescendantOf(newChild)) {
692         ec = HIERARCHY_REQUEST_ERR;
693         return;
694     }
695     
696     if (newChild->nodeType() != DOCUMENT_FRAGMENT_NODE) {
697         if (!childTypeAllowed(newChild->nodeType())) {
698             ec = HIERARCHY_REQUEST_ERR;
699             return;
700         }
701     }
702     else {
703         for (Node *n = newChild->firstChild(); n; n = n->nextSibling()) {
704             if (!childTypeAllowed(n->nodeType())) {
705                 ec = HIERARCHY_REQUEST_ERR;
706                 return;
707             }
708         }
709     }
710     
711     // change the document pointer of newChild and all of its children to be the new document
712     if (shouldAdoptChild)
713         for (Node* node = newChild; node; node = node->traverseNextNode(newChild))
714             node->setDocument(document());
715 }
716
717 bool Node::isDescendantOf(const Node *other) const
718 {
719     // Return true if other is an ancestor of this, otherwise false
720     if (!other)
721         return false;
722     for (const Node *n = parentNode(); n; n = n->parentNode()) {
723         if (n == other)
724             return true;
725     }
726     return false;
727 }
728
729 bool Node::childAllowed( Node *newChild )
730 {
731     return childTypeAllowed(newChild->nodeType());
732 }
733
734 Node::StyleChange Node::diff( RenderStyle *s1, RenderStyle *s2 ) const
735 {
736     // FIXME: The behavior of this function is just totally wrong.  It doesn't handle
737     // explicit inheritance of non-inherited properties and so you end up not re-resolving
738     // style in cases where you need to.
739     StyleChange ch = NoInherit;
740     EDisplay display1 = s1 ? s1->display() : NONE;
741     bool fl1 = s1 && s1->hasPseudoStyle(RenderStyle::FIRST_LETTER);
742     EDisplay display2 = s2 ? s2->display() : NONE;
743     bool fl2 = s2 && s2->hasPseudoStyle(RenderStyle::FIRST_LETTER);
744         
745     if (display1 != display2 || fl1 != fl2 || (s1 && s2 && !s1->contentDataEquivalent(s2)))
746         ch = Detach;
747     else if (!s1 || !s2)
748         ch = Inherit;
749     else if (*s1 == *s2)
750         ch = NoChange;
751     else if (s1->inheritedNotEqual(s2))
752         ch = Inherit;
753     
754     // If the pseudoStyles have changed, we want any StyleChange that is not NoChange
755     // because setStyle will do the right thing with anything else.
756     if (ch == NoChange && s1->hasPseudoStyle(RenderStyle::BEFORE)) {
757         RenderStyle* ps2 = s2->getPseudoStyle(RenderStyle::BEFORE);
758         if (!ps2)
759             ch = NoInherit;
760         else {
761             RenderStyle* ps1 = s1->getPseudoStyle(RenderStyle::BEFORE);
762             ch = ps1 && *ps1 == *ps2 ? NoChange : NoInherit;
763         }
764     }
765     if (ch == NoChange && s1->hasPseudoStyle(RenderStyle::AFTER)) {
766         RenderStyle* ps2 = s2->getPseudoStyle(RenderStyle::AFTER);
767         if (!ps2)
768             ch = NoInherit;
769         else {
770             RenderStyle* ps1 = s1->getPseudoStyle(RenderStyle::AFTER);
771             ch = ps2 && *ps1 == *ps2 ? NoChange : NoInherit;
772         }
773     }
774     
775     return ch;
776 }
777
778 #ifndef NDEBUG
779 void Node::dump(TextStream* stream, DeprecatedString ind) const
780 {
781     if (m_hasId) { *stream << " hasId"; }
782     if (m_hasClass) { *stream << " hasClass"; }
783     if (m_focused) { *stream << " focused"; }
784     if (m_active) { *stream << " active"; }
785
786     *stream << " tabIndex=" << m_tabIndex;
787     *stream << endl;
788
789     for (Node* child = firstChild(); child; child = child->nextSibling()) {
790         *stream << ind << child->nodeName() << ": ";
791         child->dump(stream, ind + "  ");
792     }
793 }
794 #endif
795
796 void Node::attach()
797 {
798     ASSERT(!attached());
799     ASSERT(!renderer() || (renderer()->style() && renderer()->parent()));
800
801     // If this node got a renderer it may be the previousRenderer() of sibling text nodes and thus affect the
802     // result of Text::rendererIsNeeded() for those nodes.
803     if (renderer()) {
804         for (Node* next = nextSibling(); next; next = next->nextSibling()) {
805             if (next->renderer())
806                 break;
807             if (!next->attached())
808                 break;  // Assume this means none of the following siblings are attached.
809             if (next->isTextNode())
810                 next->createRendererIfNeeded();
811         }
812     }
813
814     m_attached = true;
815 }
816
817 void Node::willRemove()
818 {
819 }
820
821 void Node::detach()
822 {
823     m_inDetach = true;
824
825     if (renderer())
826         renderer()->destroy();
827     setRenderer(0);
828
829     Document* doc = document();
830     if (m_hovered)
831         doc->hoveredNodeDetached(this);
832     if (m_inActiveChain)
833         doc->activeChainNodeDetached(this);
834
835     m_active = false;
836     m_hovered = false;
837     m_inActiveChain = false;
838     m_attached = false;
839     m_inDetach = false;
840 }
841
842 void Node::insertedIntoDocument()
843 {
844     setInDocument(true);
845     insertedIntoTree(false);
846 }
847
848 void Node::removedFromDocument()
849 {
850     setInDocument(false);
851     removedFromTree(false);
852 }
853
854 void Node::childrenChanged()
855 {
856 }
857
858 bool Node::isReadOnlyNode()
859 {
860     // Entity & Entity Reference nodes and their descendants are read-only
861     Node *n = this;
862     while (n) {
863         if (n->nodeType() == ENTITY_NODE || n->nodeType() == ENTITY_REFERENCE_NODE)
864             return true;
865         n = n->parentNode();
866     }
867     return false;
868 }
869
870 Node *Node::previousEditable() const
871 {
872     Node *node = previousLeafNode();
873     while (node) {
874         if (node->isContentEditable())
875             return node;
876         node = node->previousLeafNode();
877     }
878     return 0;
879 }
880
881 // Offset specifies the child node to start at.  If it is past
882 // the last child, it specifies to start at next sibling.
883 Node *Node::nextEditable(int offset) const
884 {
885     ASSERT(offset>=0);
886     Node *node;
887     if (hasChildNodes())
888         node = (offset >= (int)childNodeCount()) ? nextSibling() : childNode(offset)->nextLeafNode();
889     else
890         node = nextLeafNode();
891     while (node) {
892         if (node->isContentEditable())
893             return node;
894         node = node->nextLeafNode();
895     }
896     return 0;
897 }
898
899 Node *Node::nextEditable() const
900 {
901     Node *node = nextLeafNode();
902     while (node) {
903         if (node->isContentEditable())
904             return node;
905         node = node->nextLeafNode();
906     }
907     return 0;
908 }
909
910 RenderObject * Node::previousRenderer()
911 {
912     for (Node *n = previousSibling(); n; n = n->previousSibling()) {
913         if (n->renderer())
914             return n->renderer();
915     }
916     return 0;
917 }
918
919 RenderObject * Node::nextRenderer()
920 {
921     // Avoid an O(n^2) problem with this function by not checking for nextRenderer() when the parent element hasn't even 
922     // been attached yet.
923     if (parent() && !parent()->attached())
924         return 0;
925
926     for (Node *n = nextSibling(); n; n = n->nextSibling()) {
927         if (n->renderer())
928             return n->renderer();
929     }
930     return 0;
931 }
932
933 // FIXME: This code is used by editing.  Seems like it could move over there and not pollute Node.
934 Node *Node::previousNodeConsideringAtomicNodes() const
935 {
936     if (previousSibling()) {
937         Node *n = previousSibling();
938         while (!isAtomicNode(n) && n->lastChild())
939             n = n->lastChild();
940         return n;
941     }
942     else if (parentNode()) {
943         return parentNode();
944     }
945     else {
946         return 0;
947     }
948 }
949
950 Node *Node::nextNodeConsideringAtomicNodes() const
951 {
952     if (!isAtomicNode(this) && firstChild())
953         return firstChild();
954     if (nextSibling())
955         return nextSibling();
956     const Node *n = this;
957     while (n && !n->nextSibling())
958         n = n->parentNode();
959     if (n)
960         return n->nextSibling();
961     return 0;
962 }
963
964 Node *Node::previousLeafNode() const
965 {
966     Node *node = previousNodeConsideringAtomicNodes();
967     while (node) {
968         if (isAtomicNode(node))
969             return node;
970         node = node->previousNodeConsideringAtomicNodes();
971     }
972     return 0;
973 }
974
975 Node *Node::nextLeafNode() const
976 {
977     Node *node = nextNodeConsideringAtomicNodes();
978     while (node) {
979         if (isAtomicNode(node))
980             return node;
981         node = node->nextNodeConsideringAtomicNodes();
982     }
983     return 0;
984 }
985
986 void Node::createRendererIfNeeded()
987 {
988     if (!document()->shouldCreateRenderers())
989         return;
990
991     ASSERT(!renderer());
992     
993     Node *parent = parentNode();    
994     ASSERT(parent);
995     
996     RenderObject *parentRenderer = parent->renderer();
997     if (parentRenderer && parentRenderer->canHaveChildren()
998 #if ENABLE(SVG)
999         && parent->childShouldCreateRenderer(this)
1000 #endif
1001         ) {
1002         RenderStyle* style = styleForRenderer(parentRenderer);
1003         if (rendererIsNeeded(style)) {
1004             if (RenderObject* r = createRenderer(document()->renderArena(), style)) {
1005                 if (!parentRenderer->isChildAllowed(r, style))
1006                     r->destroy();
1007                 else {
1008                     setRenderer(r);
1009                     renderer()->setAnimatableStyle(style);
1010                     parentRenderer->addChild(renderer(), nextRenderer());
1011                 }
1012             }
1013         }
1014         style->deref(document()->renderArena());
1015     }
1016 }
1017
1018 RenderStyle *Node::styleForRenderer(RenderObject *parent)
1019 {
1020     RenderStyle *style = parent->style();
1021     style->ref();
1022     return style;
1023 }
1024
1025 bool Node::rendererIsNeeded(RenderStyle *style)
1026 {
1027     return (document()->documentElement() == this) || (style->display() != NONE);
1028 }
1029
1030 RenderObject *Node::createRenderer(RenderArena *arena, RenderStyle *style)
1031 {
1032     ASSERT(false);
1033     return 0;
1034 }
1035
1036 RenderStyle* Node::renderStyle() const
1037
1038     return m_renderer ? m_renderer->style() : 0; 
1039 }
1040
1041 void Node::setRenderStyle(RenderStyle* s)
1042 {
1043     if (m_renderer)
1044         m_renderer->setAnimatableStyle(s); 
1045 }
1046
1047 RenderStyle* Node::computedStyle()
1048 {
1049     return parent() ? parent()->computedStyle() : 0;
1050 }
1051
1052 int Node::maxCharacterOffset() const
1053 {
1054     ASSERT_NOT_REACHED();
1055     return 0;
1056 }
1057
1058 // FIXME: Shouldn't these functions be in the editing code?  Code that asks questions about HTML in the core DOM class
1059 // is obviously misplaced.
1060 bool Node::canStartSelection() const
1061 {
1062     if (isContentEditable())
1063         return true;
1064     return parent() ? parent()->canStartSelection() : true;
1065 }
1066
1067 Node* Node::shadowAncestorNode()
1068 {
1069 #if ENABLE(SVG)
1070     // SVG elements living in a shadow tree only occour when <use> created them.
1071     // For these cases we do NOT want to return the shadowParentNode() here
1072     // but the actual shadow tree element - as main difference to the HTML forms
1073     // shadow tree concept. (This function _could_ be made virtual - opinions?)
1074     if (isSVGElement())
1075         return this;
1076 #endif
1077
1078     Node *n = this;    
1079     while (n) {
1080         if (n->isShadowNode())
1081             return n->shadowParentNode();
1082         n = n->parentNode();
1083     } 
1084     return this;
1085 }
1086
1087 bool Node::isBlockFlow() const
1088 {
1089     return renderer() && renderer()->isBlockFlow();
1090 }
1091
1092 bool Node::isBlockFlowOrBlockTable() const
1093 {
1094     return renderer() && (renderer()->isBlockFlow() || renderer()->isTable() && !renderer()->isInline());
1095 }
1096
1097 bool Node::isEditableBlock() const
1098 {
1099     return isContentEditable() && isBlockFlow();
1100 }
1101
1102 Element *Node::enclosingBlockFlowOrTableElement() const
1103 {
1104     Node *n = const_cast<Node *>(this);
1105     if (isBlockFlowOrBlockTable())
1106         return static_cast<Element *>(n);
1107
1108     while (1) {
1109         n = n->parentNode();
1110         if (!n)
1111             break;
1112         if (n->isBlockFlowOrBlockTable() || n->hasTagName(bodyTag))
1113             return static_cast<Element *>(n);
1114     }
1115     return 0;
1116 }
1117
1118 Element *Node::enclosingBlockFlowElement() const
1119 {
1120     Node *n = const_cast<Node *>(this);
1121     if (isBlockFlow())
1122         return static_cast<Element *>(n);
1123
1124     while (1) {
1125         n = n->parentNode();
1126         if (!n)
1127             break;
1128         if (n->isBlockFlow() || n->hasTagName(bodyTag))
1129             return static_cast<Element *>(n);
1130     }
1131     return 0;
1132 }
1133
1134 Element *Node::enclosingInlineElement() const
1135 {
1136     Node *n = const_cast<Node *>(this);
1137     Node *p;
1138
1139     while (1) {
1140         p = n->parentNode();
1141         if (!p || p->isBlockFlow() || p->hasTagName(bodyTag))
1142             return static_cast<Element *>(n);
1143         // Also stop if any previous sibling is a block
1144         for (Node *sibling = n->previousSibling(); sibling; sibling = sibling->previousSibling()) {
1145             if (sibling->isBlockFlow())
1146                 return static_cast<Element *>(n);
1147         }
1148         n = p;
1149     }
1150     ASSERT_NOT_REACHED();
1151     return 0;
1152 }
1153
1154 Element* Node::rootEditableElement() const
1155 {
1156     Element* result = 0;
1157     for (Node* n = const_cast<Node*>(this); n && n->isContentEditable(); n = n->parentNode()) {
1158         if (n->isElementNode())
1159             result = static_cast<Element*>(n);
1160         if (n->hasTagName(bodyTag))
1161             break;
1162     }
1163     return result;
1164 }
1165
1166 bool Node::inSameContainingBlockFlowElement(Node *n)
1167 {
1168     return n ? enclosingBlockFlowElement() == n->enclosingBlockFlowElement() : false;
1169 }
1170
1171 // FIXME: End of obviously misplaced HTML editing functions.  Try to move these out of Node.
1172
1173 PassRefPtr<NodeList> Node::getElementsByTagName(const String& name)
1174 {
1175     return getElementsByTagNameNS("*", name);
1176 }
1177  
1178 PassRefPtr<NodeList> Node::getElementsByTagNameNS(const String& namespaceURI, const String& localName)
1179 {
1180     if (localName.isNull())
1181         return 0;
1182
1183     String name = localName;
1184     if (document()->isHTMLDocument())
1185         name = localName.lower();
1186     return new TagNodeList(this, namespaceURI.isEmpty() ? nullAtom : AtomicString(namespaceURI), name);
1187 }
1188
1189 PassRefPtr<NodeList> Node::getElementsByName(const String& elementName)
1190 {
1191     if (!m_nodeLists)
1192         m_nodeLists.set(new NodeListsNodeData);
1193
1194     return new NameNodeList(this, elementName, &m_nodeLists->m_nameNodeListCaches.add(elementName, DynamicNodeList::Caches()).first->second);
1195 }
1196
1197 PassRefPtr<NodeList> Node::getElementsByClassName(const String& classNames)
1198 {
1199     if (!m_nodeLists)
1200         m_nodeLists.set(new NodeListsNodeData);
1201
1202     return new ClassNodeList(this, classNames, &m_nodeLists->m_classNodeListCaches.add(classNames, DynamicNodeList::Caches()).first->second);
1203 }
1204
1205 PassRefPtr<Element> Node::querySelector(const String& selectors, ExceptionCode& ec)
1206 {
1207     if (selectors.isNull() || selectors.isEmpty()) {
1208         ec = SYNTAX_ERR;
1209         return 0;
1210     }
1211     CSSStyleSheet tempStyleSheet(document());
1212     CSSParser p(true);
1213     RefPtr<CSSRule> rule = p.parseRule(&tempStyleSheet, selectors + "{}");
1214     if (!rule || !rule->isStyleRule()) {
1215         ec = SYNTAX_ERR;
1216         return 0;
1217     }
1218
1219     CSSStyleSelector* styleSelector = document()->styleSelector();
1220     CSSSelector* querySelector = static_cast<CSSStyleRule*>(rule.get())->selector();
1221     
1222     // FIXME: We can speed this up by implementing caching similar to the one use by getElementById
1223     for (Node *n = traverseNextNode(); n; n = n->traverseNextNode()) {
1224         if (n->isElementNode()) {
1225             Element* element = static_cast<Element*>(n);
1226             styleSelector->initElementAndPseudoState(element);
1227             for (CSSSelector* selector = querySelector; selector; selector = selector->next()) {
1228                 if (styleSelector->checkSelector(selector))
1229                     return element;
1230             }
1231         }
1232     }
1233     
1234     return 0;
1235 }
1236
1237 PassRefPtr<NodeList> Node::querySelectorAll(const String& selectors, ExceptionCode& ec)
1238 {
1239     if (selectors.isNull() || selectors.isEmpty()) {
1240         ec = SYNTAX_ERR;
1241         return 0;
1242     }
1243     CSSStyleSheet tempStyleSheet(document());
1244     CSSParser p(true);
1245     RefPtr<CSSRule> rule = p.parseRule(&tempStyleSheet, selectors + "{}");
1246     if (!rule || !rule->isStyleRule()) {
1247         ec = SYNTAX_ERR;
1248         return 0;
1249     }
1250     
1251     SelectorNodeList* resultList = new SelectorNodeList(this, static_cast<CSSStyleRule*>(rule.get())->selector());
1252
1253     return resultList;
1254 }
1255
1256 Document *Node::ownerDocument() const
1257 {
1258     Document *doc = document();
1259     return doc == this ? 0 : doc;
1260 }
1261
1262 bool Node::hasAttributes() const
1263 {
1264     return false;
1265 }
1266
1267 NamedAttrMap *Node::attributes() const
1268 {
1269     return 0;
1270 }
1271
1272 String Node::baseURI() const
1273 {
1274     Node* parent = parentNode();
1275     if (parent)
1276         return parent->baseURI();
1277
1278     return String();
1279 }
1280
1281 bool Node::isEqualNode(Node *other) const
1282 {
1283     if (!other)
1284         return false;
1285     
1286     if (nodeType() != other->nodeType())
1287         return false;
1288     
1289     if (nodeName() != other->nodeName())
1290         return false;
1291     
1292     if (localName() != other->localName())
1293         return false;
1294     
1295     if (namespaceURI() != other->namespaceURI())
1296         return false;
1297     
1298     if (prefix() != other->prefix())
1299         return false;
1300     
1301     if (nodeValue() != other->nodeValue())
1302         return false;
1303     
1304     NamedAttrMap *attrs = attributes();
1305     NamedAttrMap *otherAttrs = other->attributes();
1306     
1307     if (!attrs && otherAttrs)
1308         return false;
1309     
1310     if (attrs && !attrs->mapsEquivalent(otherAttrs))
1311         return false;
1312     
1313     Node *child = firstChild();
1314     Node *otherChild = other->firstChild();
1315     
1316     while (child) {
1317         if (!child->isEqualNode(otherChild))
1318             return false;
1319         
1320         child = child->nextSibling();
1321         otherChild = otherChild->nextSibling();
1322     }
1323     
1324     if (otherChild)
1325         return false;
1326     
1327     // FIXME: For DocumentType nodes we should check equality on
1328     // the entities and notations NamedNodeMaps as well.
1329     
1330     return true;
1331 }
1332
1333 bool Node::isDefaultNamespace(const String &namespaceURI) const
1334 {
1335     // Implemented according to
1336     // http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/namespaces-algorithms.html#isDefaultNamespaceAlgo
1337     
1338     switch (nodeType()) {
1339         case ELEMENT_NODE: {
1340             const Element *elem = static_cast<const Element *>(this);
1341             
1342             if (elem->prefix().isNull())
1343                 return elem->namespaceURI() == namespaceURI;
1344
1345             if (elem->hasAttributes()) {
1346                 NamedAttrMap *attrs = elem->attributes();
1347                 
1348                 for (unsigned i = 0; i < attrs->length(); i++) {
1349                     Attribute *attr = attrs->attributeItem(i);
1350                     
1351                     if (attr->localName() == "xmlns")
1352                         return attr->value() == namespaceURI;
1353                 }
1354             }
1355
1356             if (Element* ancestor = ancestorElement())
1357                 return ancestor->isDefaultNamespace(namespaceURI);
1358
1359             return false;
1360         }
1361         case DOCUMENT_NODE:
1362             return static_cast <const Document *>(this)->documentElement()->isDefaultNamespace(namespaceURI);
1363         case ENTITY_NODE:
1364         case NOTATION_NODE:
1365         case DOCUMENT_TYPE_NODE:
1366         case DOCUMENT_FRAGMENT_NODE:
1367             return false;
1368         case ATTRIBUTE_NODE: {
1369             const Attr *attr = static_cast<const Attr *>(this);
1370             if (attr->ownerElement())
1371                 return attr->ownerElement()->isDefaultNamespace(namespaceURI);
1372             return false;
1373         }
1374         default:
1375             if (Element* ancestor = ancestorElement())
1376                 return ancestor->isDefaultNamespace(namespaceURI);
1377             return false;
1378     }
1379 }
1380
1381 String Node::lookupPrefix(const String &namespaceURI) const
1382 {
1383     // Implemented according to
1384     // http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/namespaces-algorithms.html#lookupNamespacePrefixAlgo
1385     
1386     if (namespaceURI.isEmpty())
1387         return String();
1388     
1389     switch (nodeType()) {
1390         case ELEMENT_NODE:
1391             return lookupNamespacePrefix(namespaceURI, static_cast<const Element *>(this));
1392         case DOCUMENT_NODE:
1393             return static_cast<const Document *>(this)->documentElement()->lookupPrefix(namespaceURI);
1394         case ENTITY_NODE:
1395         case NOTATION_NODE:
1396         case DOCUMENT_FRAGMENT_NODE:
1397         case DOCUMENT_TYPE_NODE:
1398             return String();
1399         case ATTRIBUTE_NODE: {
1400             const Attr *attr = static_cast<const Attr *>(this);
1401             if (attr->ownerElement())
1402                 return attr->ownerElement()->lookupPrefix(namespaceURI);
1403             return String();
1404         }
1405         default:
1406             if (Element* ancestor = ancestorElement())
1407                 return ancestor->lookupPrefix(namespaceURI);
1408             return String();
1409     }
1410 }
1411
1412 String Node::lookupNamespaceURI(const String &prefix) const
1413 {
1414     // Implemented according to
1415     // http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/namespaces-algorithms.html#lookupNamespaceURIAlgo
1416     
1417     if (!prefix.isNull() && prefix.isEmpty())
1418         return String();
1419     
1420     switch (nodeType()) {
1421         case ELEMENT_NODE: {
1422             const Element *elem = static_cast<const Element *>(this);
1423             
1424             if (!elem->namespaceURI().isNull() && elem->prefix() == prefix)
1425                 return elem->namespaceURI();
1426             
1427             if (elem->hasAttributes()) {
1428                 NamedAttrMap *attrs = elem->attributes();
1429                 
1430                 for (unsigned i = 0; i < attrs->length(); i++) {
1431                     Attribute *attr = attrs->attributeItem(i);
1432                     
1433                     if (attr->prefix() == "xmlns" && attr->localName() == prefix) {
1434                         if (!attr->value().isEmpty())
1435                             return attr->value();
1436                         
1437                         return String();
1438                     } else if (attr->localName() == "xmlns" && prefix.isNull()) {
1439                         if (!attr->value().isEmpty())
1440                             return attr->value();
1441                         
1442                         return String();
1443                     }
1444                 }
1445             }
1446             if (Element* ancestor = ancestorElement())
1447                 return ancestor->lookupNamespaceURI(prefix);
1448             return String();
1449         }
1450         case DOCUMENT_NODE:
1451             return static_cast<const Document *>(this)->documentElement()->lookupNamespaceURI(prefix);
1452         case ENTITY_NODE:
1453         case NOTATION_NODE:
1454         case DOCUMENT_TYPE_NODE:
1455         case DOCUMENT_FRAGMENT_NODE:
1456             return String();
1457         case ATTRIBUTE_NODE: {
1458             const Attr *attr = static_cast<const Attr *>(this);
1459             
1460             if (attr->ownerElement())
1461                 return attr->ownerElement()->lookupNamespaceURI(prefix);
1462             else
1463                 return String();
1464         }
1465         default:
1466             if (Element* ancestor = ancestorElement())
1467                 return ancestor->lookupNamespaceURI(prefix);
1468             return String();
1469     }
1470 }
1471
1472 String Node::lookupNamespacePrefix(const String &_namespaceURI, const Element *originalElement) const
1473 {
1474     if (_namespaceURI.isNull())
1475         return String();
1476             
1477     if (originalElement->lookupNamespaceURI(prefix()) == _namespaceURI)
1478         return prefix();
1479     
1480     if (hasAttributes()) {
1481         NamedAttrMap *attrs = attributes();
1482         
1483         for (unsigned i = 0; i < attrs->length(); i++) {
1484             Attribute *attr = attrs->attributeItem(i);
1485             
1486             if (attr->prefix() == "xmlns" &&
1487                 attr->value() == _namespaceURI &&
1488                 originalElement->lookupNamespaceURI(attr->localName()) == _namespaceURI)
1489                 return attr->localName();
1490         }
1491     }
1492     
1493     if (Element* ancestor = ancestorElement())
1494         return ancestor->lookupNamespacePrefix(_namespaceURI, originalElement);
1495     return String();
1496 }
1497
1498 String Node::textContent(bool convertBRsToNewlines) const
1499 {
1500     switch (nodeType()) {
1501         case TEXT_NODE:
1502         case CDATA_SECTION_NODE:
1503         case COMMENT_NODE:
1504         case PROCESSING_INSTRUCTION_NODE:
1505             return nodeValue();
1506         
1507         case ELEMENT_NODE:
1508             if (hasTagName(brTag) && 
1509                 convertBRsToNewlines)
1510                 return "\n";
1511         case ATTRIBUTE_NODE:
1512         case ENTITY_NODE:
1513         case ENTITY_REFERENCE_NODE:
1514         case DOCUMENT_FRAGMENT_NODE: {
1515             String s = "";
1516         
1517             for (Node *child = firstChild(); child; child = child->nextSibling()) {
1518                 if (child->nodeType() == COMMENT_NODE || child->nodeType() == PROCESSING_INSTRUCTION_NODE)
1519                     continue;
1520             
1521                 s += child->textContent(convertBRsToNewlines);
1522             }
1523         
1524             return s;
1525         }
1526         
1527         case DOCUMENT_NODE:
1528         case DOCUMENT_TYPE_NODE:
1529         case NOTATION_NODE:
1530         default:
1531             return String();            
1532     }
1533 }
1534
1535 void Node::setTextContent(const String &text, ExceptionCode& ec)
1536 {           
1537     switch (nodeType()) {
1538         case TEXT_NODE:
1539         case CDATA_SECTION_NODE:
1540         case COMMENT_NODE:
1541         case PROCESSING_INSTRUCTION_NODE:
1542             setNodeValue(text, ec);
1543             break;
1544         case ELEMENT_NODE:
1545         case ATTRIBUTE_NODE:
1546         case ENTITY_NODE:
1547         case ENTITY_REFERENCE_NODE:
1548         case DOCUMENT_FRAGMENT_NODE: {
1549             ContainerNode *container = static_cast<ContainerNode *>(this);
1550             
1551             container->removeChildren();
1552             
1553             if (!text.isEmpty())
1554                 appendChild(document()->createTextNode(text), ec);
1555             break;
1556         }
1557         case DOCUMENT_NODE:
1558         case DOCUMENT_TYPE_NODE:
1559         case NOTATION_NODE:
1560         default:
1561             // Do nothing
1562             break;
1563     }
1564 }
1565
1566 Element* Node::ancestorElement() const
1567 {
1568     // In theory, there can be EntityReference nodes between elements, but this is currently not supported.
1569     for (Node* n = parentNode(); n; n = n->parentNode()) {
1570         if (n->isElementNode())
1571             return static_cast<Element*>(n);
1572     }
1573     return 0;
1574 }
1575
1576 bool Node::offsetInCharacters() const
1577 {
1578     return false;
1579 }
1580
1581 #ifndef NDEBUG
1582
1583 static void appendAttributeDesc(const Node* node, String& string, const QualifiedName& name, const char* attrDesc)
1584 {
1585     if (node->isElementNode()) {
1586         String attr = static_cast<const Element*>(node)->getAttribute(name);
1587         if (!attr.isEmpty()) {
1588             string += attrDesc;
1589             string += attr;
1590         }
1591     }
1592 }
1593
1594 void Node::showNode(const char* prefix) const
1595 {
1596     if (!prefix)
1597         prefix = "";
1598     if (isTextNode()) {
1599         String value = nodeValue();
1600         value.replace('\\', "\\\\");
1601         value.replace('\n', "\\n");
1602         fprintf(stderr, "%s%s\t%p \"%s\"\n", prefix, nodeName().utf8().data(), this, value.utf8().data());
1603     } else {
1604         String attrs = "";
1605         appendAttributeDesc(this, attrs, classAttr, " CLASS=");
1606         appendAttributeDesc(this, attrs, styleAttr, " STYLE=");
1607         fprintf(stderr, "%s%s\t%p%s\n", prefix, nodeName().utf8().data(), this, attrs.utf8().data());
1608     }
1609 }
1610
1611 void Node::showTreeForThis() const
1612 {
1613     showTreeAndMark(this, "*");
1614 }
1615
1616 void Node::showTreeAndMark(const Node* markedNode1, const char* markedLabel1, const Node* markedNode2, const char * markedLabel2) const
1617 {
1618     const Node* rootNode;
1619     const Node* node = this;
1620     while (node->parentNode() && !node->hasTagName(bodyTag))
1621         node = node->parentNode();
1622     rootNode = node;
1623         
1624     for (node = rootNode; node; node = node->traverseNextNode()) {
1625         if (node == markedNode1)
1626             fprintf(stderr, "%s", markedLabel1);
1627         if (node == markedNode2)
1628             fprintf(stderr, "%s", markedLabel2);
1629                         
1630         for (const Node* tmpNode = node; tmpNode && tmpNode != rootNode; tmpNode = tmpNode->parentNode())
1631             fprintf(stderr, "\t");
1632         node->showNode();
1633     }
1634 }
1635
1636 void Node::formatForDebugger(char* buffer, unsigned length) const
1637 {
1638     String result;
1639     String s;
1640     
1641     s = nodeName();
1642     if (s.length() == 0)
1643         result += "<none>";
1644     else
1645         result += s;
1646           
1647     strncpy(buffer, result.utf8().data(), length - 1);
1648 }
1649
1650 #endif
1651
1652 }
1653
1654 #ifndef NDEBUG
1655
1656 void showTree(const WebCore::Node* node)
1657 {
1658     if (node)
1659         node->showTreeForThis();
1660 }
1661
1662 #endif