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