Source/WebCore/dom/Node.cpp

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