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