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