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