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