ac0afc9e3664d0754981fa28c81ef06d2de06228
[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 "InspectorInstrumentation.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 "TagNodeList.h"
76 #include "Text.h"
77 #include "TextEvent.h"
78 #include "UIEvent.h"
79 #include "UIEventWithKeyState.h"
80 #include "WebKitAnimationEvent.h"
81 #include "WebKitTransitionEvent.h"
82 #include "WheelEvent.h"
83 #include "XMLNames.h"
84 #include "htmlediting.h"
85 #include <wtf/HashSet.h>
86 #include <wtf/PassOwnPtr.h>
87 #include <wtf/RefCountedLeakCounter.h>
88 #include <wtf/UnusedParam.h>
89 #include <wtf/text/CString.h>
90 #include <wtf/text/StringBuilder.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 (ContainerNode* p = parentNode(); p && !p->childNeedsStyleRecalc(); p = p->parentNode())
728         p->setChildNeedsStyleRecalc();
729     
730     if (document()->childNeedsStyleRecalc())
731         document()->scheduleStyleRecalc();
732 }
733
734 void Node::refEventTarget()
735 {
736     ref();
737 }
738
739 void Node::derefEventTarget()
740 {
741     deref();
742 }
743
744 void Node::setNeedsStyleRecalc(StyleChangeType changeType)
745 {
746     ASSERT(changeType != NoStyleChange);
747     if (!attached()) // changed compared to what?
748         return;
749
750     StyleChangeType existingChangeType = styleChangeType();
751     if (changeType > existingChangeType)
752         setStyleChange(changeType);
753
754     if (existingChangeType == NoStyleChange)
755         markAncestorsWithChildNeedsStyleRecalc();
756 }
757
758 void Node::lazyAttach(ShouldSetAttached shouldSetAttached)
759 {
760     for (Node* n = this; n; n = n->traverseNextNode(this)) {
761         if (n->firstChild())
762             n->setChildNeedsStyleRecalc();
763         n->setStyleChange(FullStyleChange);
764         if (shouldSetAttached == SetAttached)
765             n->setAttached();
766     }
767     markAncestorsWithChildNeedsStyleRecalc();
768 }
769
770 void Node::setFocus(bool b)
771
772     if (b || hasRareData())
773         ensureRareData()->setFocused(b);
774 }
775
776 bool Node::rareDataFocused() const
777 {
778     ASSERT(hasRareData());
779     return rareData()->isFocused();
780 }
781
782 bool Node::supportsFocus() const
783 {
784     return hasRareData() && rareData()->tabIndexSetExplicitly();
785 }
786     
787 bool Node::isFocusable() const
788 {
789     if (!inDocument() || !supportsFocus())
790         return false;
791     
792     if (renderer())
793         ASSERT(!renderer()->needsLayout());
794     else
795         // If the node is in a display:none tree it might say it needs style recalc but
796         // the whole document is actually up to date.
797         ASSERT(!document()->childNeedsStyleRecalc());
798     
799     // FIXME: Even if we are not visible, we might have a child that is visible.
800     // Hyatt wants to fix that some day with a "has visible content" flag or the like.
801     if (!renderer() || renderer()->style()->visibility() != VISIBLE)
802         return false;
803
804     return true;
805 }
806
807 bool Node::isKeyboardFocusable(KeyboardEvent*) const
808 {
809     return isFocusable() && tabIndex() >= 0;
810 }
811
812 bool Node::isMouseFocusable() const
813 {
814     return isFocusable();
815 }
816
817 unsigned Node::nodeIndex() const
818 {
819     Node *_tempNode = previousSibling();
820     unsigned count=0;
821     for ( count=0; _tempNode; count++ )
822         _tempNode = _tempNode->previousSibling();
823     return count;
824 }
825
826 void Node::registerDynamicNodeList(DynamicNodeList* list)
827 {
828     NodeRareData* data = ensureRareData();
829     if (!data->nodeLists()) {
830         data->setNodeLists(NodeListsNodeData::create());
831         document()->addNodeListCache();
832     } else if (!m_document || !m_document->hasNodeListCaches()) {
833         // We haven't been receiving notifications while there were no registered lists, so the cache is invalid now.
834         data->nodeLists()->invalidateCaches();
835     }
836
837     if (list->hasOwnCaches())
838         data->nodeLists()->m_listsWithCaches.add(list);
839 }
840
841 void Node::unregisterDynamicNodeList(DynamicNodeList* list)
842 {
843     ASSERT(rareData());
844     ASSERT(rareData()->nodeLists());
845     if (list->hasOwnCaches()) {
846         NodeRareData* data = rareData();
847         data->nodeLists()->m_listsWithCaches.remove(list);
848         if (data->nodeLists()->isEmpty()) {
849             data->clearNodeLists();
850             if (document())
851                 document()->removeNodeListCache();
852         }
853     }
854 }
855
856 void Node::notifyLocalNodeListsAttributeChanged()
857 {
858     if (!hasRareData())
859         return;
860     NodeRareData* data = rareData();
861     if (!data->nodeLists())
862         return;
863
864     if (!isAttributeNode())
865         data->nodeLists()->invalidateCachesThatDependOnAttributes();
866     else
867         data->nodeLists()->invalidateCaches();
868
869     if (data->nodeLists()->isEmpty()) {
870         data->clearNodeLists();
871         document()->removeNodeListCache();
872     }
873 }
874
875 void Node::notifyNodeListsAttributeChanged()
876 {
877     for (Node *n = this; n; n = n->parentNode())
878         n->notifyLocalNodeListsAttributeChanged();
879 }
880
881 void Node::notifyLocalNodeListsChildrenChanged()
882 {
883     if (!hasRareData())
884         return;
885     NodeRareData* data = rareData();
886     if (!data->nodeLists())
887         return;
888
889     data->nodeLists()->invalidateCaches();
890
891     NodeListsNodeData::NodeListSet::iterator end = data->nodeLists()->m_listsWithCaches.end();
892     for (NodeListsNodeData::NodeListSet::iterator i = data->nodeLists()->m_listsWithCaches.begin(); i != end; ++i)
893         (*i)->invalidateCache();
894
895     if (data->nodeLists()->isEmpty()) {
896         data->clearNodeLists();
897         document()->removeNodeListCache();
898     }
899 }
900
901 void Node::notifyNodeListsChildrenChanged()
902 {
903     for (Node* n = this; n; n = n->parentNode())
904         n->notifyLocalNodeListsChildrenChanged();
905 }
906
907 void Node::notifyLocalNodeListsLabelChanged()
908 {
909     if (!hasRareData())
910         return;
911     NodeRareData* data = rareData();
912     if (!data->nodeLists())
913         return;
914
915     if (data->nodeLists()->m_labelsNodeListCache)
916         data->nodeLists()->m_labelsNodeListCache->invalidateCache();
917 }
918
919 void Node::removeCachedClassNodeList(ClassNodeList* list, const String& className)
920 {
921     ASSERT(rareData());
922     ASSERT(rareData()->nodeLists());
923     ASSERT_UNUSED(list, list->hasOwnCaches());
924
925     NodeListsNodeData* data = rareData()->nodeLists();
926     ASSERT_UNUSED(list, list == data->m_classNodeListCache.get(className));
927     data->m_classNodeListCache.remove(className);
928 }
929
930 void Node::removeCachedNameNodeList(NameNodeList* list, const String& nodeName)
931 {
932     ASSERT(rareData());
933     ASSERT(rareData()->nodeLists());
934     ASSERT_UNUSED(list, list->hasOwnCaches());
935
936     NodeListsNodeData* data = rareData()->nodeLists();
937     ASSERT_UNUSED(list, list == data->m_nameNodeListCache.get(nodeName));
938     data->m_nameNodeListCache.remove(nodeName);
939 }
940
941 void Node::removeCachedTagNodeList(TagNodeList* list, const QualifiedName& name)
942 {
943     ASSERT(rareData());
944     ASSERT(rareData()->nodeLists());
945     ASSERT_UNUSED(list, list->hasOwnCaches());
946
947     NodeListsNodeData* data = rareData()->nodeLists();
948     ASSERT_UNUSED(list, list == data->m_tagNodeListCache.get(name.impl()));
949     data->m_tagNodeListCache.remove(name.impl());
950 }
951
952 void Node::removeCachedLabelsNodeList(DynamicNodeList* list)
953 {
954     ASSERT(rareData());
955     ASSERT(rareData()->nodeLists());
956     ASSERT_UNUSED(list, list->hasOwnCaches());
957     
958     NodeListsNodeData* data = rareData()->nodeLists();
959     data->m_labelsNodeListCache = 0;
960 }
961
962 Node *Node::traverseNextNode(const Node *stayWithin) const
963 {
964     if (firstChild())
965         return firstChild();
966     if (this == stayWithin)
967         return 0;
968     if (nextSibling())
969         return nextSibling();
970     const Node *n = this;
971     while (n && !n->nextSibling() && (!stayWithin || n->parentNode() != stayWithin))
972         n = n->parentNode();
973     if (n)
974         return n->nextSibling();
975     return 0;
976 }
977
978 Node *Node::traverseNextSibling(const Node *stayWithin) const
979 {
980     if (this == stayWithin)
981         return 0;
982     if (nextSibling())
983         return nextSibling();
984     const Node *n = this;
985     while (n && !n->nextSibling() && (!stayWithin || n->parentNode() != stayWithin))
986         n = n->parentNode();
987     if (n)
988         return n->nextSibling();
989     return 0;
990 }
991
992 Node* Node::traverseNextNodePostOrder() const
993 {
994     Node* next = nextSibling();
995     if (!next)
996         return parentNode();
997     while (Node* firstChild = next->firstChild())
998         next = firstChild;
999     return next;
1000 }
1001
1002 Node *Node::traversePreviousNode(const Node *stayWithin) const
1003 {
1004     if (this == stayWithin)
1005         return 0;
1006     if (previousSibling()) {
1007         Node *n = previousSibling();
1008         while (n->lastChild())
1009             n = n->lastChild();
1010         return n;
1011     }
1012     return parentNode();
1013 }
1014
1015 Node *Node::traversePreviousNodePostOrder(const Node *stayWithin) const
1016 {
1017     if (lastChild())
1018         return lastChild();
1019     if (this == stayWithin)
1020         return 0;
1021     if (previousSibling())
1022         return previousSibling();
1023     const Node *n = this;
1024     while (n && !n->previousSibling() && (!stayWithin || n->parentNode() != stayWithin))
1025         n = n->parentNode();
1026     if (n)
1027         return n->previousSibling();
1028     return 0;
1029 }
1030
1031 Node* Node::traversePreviousSiblingPostOrder(const Node* stayWithin) const
1032 {
1033     if (this == stayWithin)
1034         return 0;
1035     if (previousSibling())
1036         return previousSibling();
1037     const Node *n = this;
1038     while (n && !n->previousSibling() && (!stayWithin || n->parentNode() != stayWithin))
1039         n = n->parentNode();
1040     if (n)
1041         return n->previousSibling();
1042     return 0;
1043 }
1044
1045 void Node::checkSetPrefix(const AtomicString& prefix, ExceptionCode& ec)
1046 {
1047     // Perform error checking as required by spec for setting Node.prefix. Used by
1048     // Element::setPrefix() and Attr::setPrefix()
1049
1050     // FIXME: Implement support for INVALID_CHARACTER_ERR: Raised if the specified prefix contains an illegal character.
1051     
1052     if (isReadOnlyNode()) {
1053         ec = NO_MODIFICATION_ALLOWED_ERR;
1054         return;
1055     }
1056
1057     // FIXME: Raise NAMESPACE_ERR if prefix is malformed per the Namespaces in XML specification.
1058
1059     const AtomicString& nodeNamespaceURI = namespaceURI();
1060     if ((nodeNamespaceURI.isEmpty() && !prefix.isEmpty())
1061         || (prefix == xmlAtom && nodeNamespaceURI != XMLNames::xmlNamespaceURI)) {
1062         ec = NAMESPACE_ERR;
1063         return;
1064     }
1065     // Attribute-specific checks are in Attr::setPrefix().
1066 }
1067
1068 static bool isChildTypeAllowed(Node* newParent, Node* child)
1069 {
1070     if (child->nodeType() != Node::DOCUMENT_FRAGMENT_NODE) {
1071         if (!newParent->childTypeAllowed(child->nodeType()))
1072             return false;
1073     }
1074     
1075     for (Node *n = child->firstChild(); n; n = n->nextSibling()) {
1076         if (!newParent->childTypeAllowed(n->nodeType()))
1077             return false;
1078     }
1079
1080     return true;
1081 }
1082
1083 bool Node::canReplaceChild(Node* newChild, Node*)
1084 {
1085     return isChildTypeAllowed(this, newChild);
1086 }
1087
1088 static void checkAcceptChild(Node* newParent, Node* newChild, ExceptionCode& ec)
1089 {
1090     // Perform error checking as required by spec for adding a new child. Used by replaceChild().
1091     
1092     // Not mentioned in spec: throw NOT_FOUND_ERR if newChild is null
1093     if (!newChild) {
1094         ec = NOT_FOUND_ERR;
1095         return;
1096     }
1097     
1098     // NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly
1099     if (newParent->isReadOnlyNode()) {
1100         ec = NO_MODIFICATION_ALLOWED_ERR;
1101         return;
1102     }
1103     
1104     // WRONG_DOCUMENT_ERR: Raised if newChild was created from a different document than the one that
1105     // created this node.
1106     // We assume that if newChild is a DocumentFragment, all children are created from the same document
1107     // as the fragment itself (otherwise they could not have been added as children)
1108     if (newChild->document() != newParent->document() && newChild->inDocument()) {
1109         // but if the child is not in a document yet then loosen the
1110         // restriction, so that e.g. creating an element with the Option()
1111         // constructor and then adding it to a different document works,
1112         // as it does in Mozilla and Mac IE.
1113         ec = WRONG_DOCUMENT_ERR;
1114         return;
1115     }
1116     
1117     // HIERARCHY_REQUEST_ERR: Raised if this node is of a type that does not allow children of the type of the
1118     // newChild node, or if the node to append is one of this node's ancestors.
1119
1120     // check for ancestor/same node
1121     if (newChild == newParent || newParent->isDescendantOf(newChild)) {
1122         ec = HIERARCHY_REQUEST_ERR;
1123         return;
1124     }
1125 }
1126
1127 static void transferOwnerDocument(Document* newDocument, Node* root)
1128 {
1129     // FIXME: To match Gecko, we should do this for nodes that are already in the document as well.
1130     if (root->document() != newDocument && !root->inDocument()) {
1131         for (Node* node = root; node; node = node->traverseNextNode(root))
1132             node->setDocument(newDocument);
1133     }
1134 }
1135
1136 void Node::checkReplaceChild(Node* newChild, Node* oldChild, ExceptionCode& ec)
1137 {
1138     checkAcceptChild(this, newChild, ec);
1139     if (ec)
1140         return;
1141
1142     if (!canReplaceChild(newChild, oldChild)) {
1143         ec = HIERARCHY_REQUEST_ERR;
1144         return;
1145     }
1146
1147     transferOwnerDocument(document(), newChild);
1148 }
1149
1150 void Node::checkAddChild(Node *newChild, ExceptionCode& ec)
1151 {
1152     checkAcceptChild(this, newChild, ec);
1153     if (ec)
1154         return;
1155     
1156     if (!isChildTypeAllowed(this, newChild)) {
1157         ec = HIERARCHY_REQUEST_ERR;
1158         return;
1159     }
1160
1161     transferOwnerDocument(document(), newChild);
1162 }
1163
1164 bool Node::isDescendantOf(const Node *other) const
1165 {
1166     // Return true if other is an ancestor of this, otherwise false
1167     if (!other)
1168         return false;
1169     for (const ContainerNode* n = parentNode(); n; n = n->parentNode()) {
1170         if (n == other)
1171             return true;
1172     }
1173     return false;
1174 }
1175
1176 bool Node::contains(const Node* node) const
1177 {
1178     if (!node)
1179         return false;
1180     return this == node || node->isDescendantOf(this);
1181 }
1182
1183 void Node::attach()
1184 {
1185     ASSERT(!attached());
1186     ASSERT(!renderer() || (renderer()->style() && renderer()->parent()));
1187
1188     // If this node got a renderer it may be the previousRenderer() of sibling text nodes and thus affect the
1189     // result of Text::rendererIsNeeded() for those nodes.
1190     if (renderer()) {
1191         for (Node* next = nextSibling(); next; next = next->nextSibling()) {
1192             if (next->renderer())
1193                 break;
1194             if (!next->attached())
1195                 break;  // Assume this means none of the following siblings are attached.
1196             if (next->isTextNode())
1197                 next->createRendererIfNeeded();
1198         }
1199     }
1200
1201     setAttached();
1202     clearNeedsStyleRecalc();
1203 }
1204
1205 void Node::willRemove()
1206 {
1207 }
1208
1209 void Node::detach()
1210 {
1211     setFlag(InDetachFlag);
1212
1213     if (renderer())
1214         renderer()->destroy();
1215     setRenderer(0);
1216
1217     Document* doc = document();
1218     if (hovered())
1219         doc->hoveredNodeDetached(this);
1220     if (inActiveChain())
1221         doc->activeChainNodeDetached(this);
1222
1223     clearFlag(IsActiveFlag);
1224     clearFlag(IsHoveredFlag);
1225     clearFlag(InActiveChainFlag);
1226     clearFlag(IsAttachedFlag);
1227
1228     clearFlag(InDetachFlag);
1229 }
1230
1231 Node *Node::previousEditable() const
1232 {
1233     Node *node = previousLeafNode();
1234     while (node) {
1235         if (node->isContentEditable())
1236             return node;
1237         node = node->previousLeafNode();
1238     }
1239     return 0;
1240 }
1241
1242 Node *Node::nextEditable() const
1243 {
1244     Node *node = nextLeafNode();
1245     while (node) {
1246         if (node->isContentEditable())
1247             return node;
1248         node = node->nextLeafNode();
1249     }
1250     return 0;
1251 }
1252
1253 RenderObject * Node::previousRenderer()
1254 {
1255     for (Node *n = previousSibling(); n; n = n->previousSibling()) {
1256         if (n->renderer())
1257             return n->renderer();
1258     }
1259     return 0;
1260 }
1261
1262 RenderObject * Node::nextRenderer()
1263 {
1264     // Avoid an O(n^2) problem with this function by not checking for nextRenderer() when the parent element hasn't even 
1265     // been attached yet.
1266     if (parent() && !parent()->attached())
1267         return 0;
1268
1269     for (Node *n = nextSibling(); n; n = n->nextSibling()) {
1270         if (n->renderer())
1271             return n->renderer();
1272     }
1273     return 0;
1274 }
1275
1276 // FIXME: This code is used by editing.  Seems like it could move over there and not pollute Node.
1277 Node *Node::previousNodeConsideringAtomicNodes() const
1278 {
1279     if (previousSibling()) {
1280         Node *n = previousSibling();
1281         while (!isAtomicNode(n) && n->lastChild())
1282             n = n->lastChild();
1283         return n;
1284     }
1285     else if (parentNode()) {
1286         return parentNode();
1287     }
1288     else {
1289         return 0;
1290     }
1291 }
1292
1293 Node *Node::nextNodeConsideringAtomicNodes() const
1294 {
1295     if (!isAtomicNode(this) && firstChild())
1296         return firstChild();
1297     if (nextSibling())
1298         return nextSibling();
1299     const Node *n = this;
1300     while (n && !n->nextSibling())
1301         n = n->parentNode();
1302     if (n)
1303         return n->nextSibling();
1304     return 0;
1305 }
1306
1307 Node *Node::previousLeafNode() const
1308 {
1309     Node *node = previousNodeConsideringAtomicNodes();
1310     while (node) {
1311         if (isAtomicNode(node))
1312             return node;
1313         node = node->previousNodeConsideringAtomicNodes();
1314     }
1315     return 0;
1316 }
1317
1318 Node *Node::nextLeafNode() const
1319 {
1320     Node *node = nextNodeConsideringAtomicNodes();
1321     while (node) {
1322         if (isAtomicNode(node))
1323             return node;
1324         node = node->nextNodeConsideringAtomicNodes();
1325     }
1326     return 0;
1327 }
1328
1329 void Node::createRendererIfNeeded()
1330 {
1331     if (!document()->shouldCreateRenderers())
1332         return;
1333
1334     ASSERT(!renderer());
1335     
1336     ContainerNode* parent = parentNode();    
1337     ASSERT(parent);
1338     
1339     RenderObject* parentRenderer = parent->renderer();
1340     if (parentRenderer && parentRenderer->canHaveChildren()
1341 #if ENABLE(SVG) || ENABLE(XHTMLMP)
1342         && parent->childShouldCreateRenderer(this)
1343 #endif
1344         ) {
1345         RefPtr<RenderStyle> style = styleForRenderer();
1346         if (rendererIsNeeded(style.get())) {
1347             if (RenderObject* r = createRenderer(document()->renderArena(), style.get())) {
1348                 if (!parentRenderer->isChildAllowed(r, style.get()))
1349                     r->destroy();
1350                 else {
1351                     setRenderer(r);
1352                     renderer()->setAnimatableStyle(style.release());
1353                     parentRenderer->addChild(renderer(), nextRenderer());
1354                 }
1355             }
1356         }
1357     }
1358 }
1359
1360 PassRefPtr<RenderStyle> Node::styleForRenderer()
1361 {
1362     if (isElementNode()) {
1363         bool allowSharing = true;
1364 #if ENABLE(XHTMLMP)
1365         // noscript needs the display property protected - it's a special case
1366         allowSharing = localName() != HTMLNames::noscriptTag.localName();
1367 #endif
1368         return document()->styleSelector()->styleForElement(static_cast<Element*>(this), 0, allowSharing);
1369     }
1370     return parentNode() && parentNode()->renderer() ? parentNode()->renderer()->style() : 0;
1371 }
1372
1373 bool Node::rendererIsNeeded(RenderStyle *style)
1374 {
1375     return (document()->documentElement() == this) || (style->display() != NONE);
1376 }
1377
1378 RenderObject* Node::createRenderer(RenderArena*, RenderStyle*)
1379 {
1380     ASSERT(false);
1381     return 0;
1382 }
1383     
1384 RenderStyle* Node::nonRendererRenderStyle() const
1385
1386     return 0; 
1387 }   
1388
1389 void Node::setRenderStyle(PassRefPtr<RenderStyle> s)
1390 {
1391     if (m_renderer)
1392         m_renderer->setAnimatableStyle(s); 
1393 }
1394
1395 RenderStyle* Node::virtualComputedStyle(PseudoId pseudoElementSpecifier)
1396 {
1397     return parent() ? parent()->computedStyle(pseudoElementSpecifier) : 0;
1398 }
1399
1400 int Node::maxCharacterOffset() const
1401 {
1402     ASSERT_NOT_REACHED();
1403     return 0;
1404 }
1405
1406 // FIXME: Shouldn't these functions be in the editing code?  Code that asks questions about HTML in the core DOM class
1407 // is obviously misplaced.
1408 bool Node::canStartSelection() const
1409 {
1410     if (isContentEditable())
1411         return true;
1412
1413     if (renderer()) {
1414         RenderStyle* style = renderer()->style();
1415         // We allow selections to begin within an element that has -webkit-user-select: none set,
1416         // but if the element is draggable then dragging should take priority over selection.
1417         if (style->userDrag() == DRAG_ELEMENT && style->userSelect() == SELECT_NONE)
1418             return false;
1419     }
1420     return parent() ? parent()->canStartSelection() : true;
1421 }
1422
1423 Node* Node::shadowAncestorNode()
1424 {
1425 #if ENABLE(SVG)
1426     // SVG elements living in a shadow tree only occur when <use> created them.
1427     // For these cases we do NOT want to return the shadowParentNode() here
1428     // but the actual shadow tree element - as main difference to the HTML forms
1429     // shadow tree concept. (This function _could_ be made virtual - opinions?)
1430     if (isSVGElement())
1431         return this;
1432 #endif
1433
1434     Node* root = shadowTreeRootNode();
1435     if (root)
1436         return root->shadowParentNode();
1437     return this;
1438 }
1439
1440 Node* Node::shadowTreeRootNode()
1441 {
1442     Node* root = this;
1443     while (root) {
1444         if (root->isShadowNode())
1445             return root;
1446         root = root->parentNode();
1447     }
1448     return 0;
1449 }
1450
1451 bool Node::isInShadowTree()
1452 {
1453     for (Node* n = this; n; n = n->parentNode())
1454         if (n->isShadowNode())
1455             return true;
1456     return false;
1457 }
1458
1459 bool Node::isBlockFlow() const
1460 {
1461     return renderer() && renderer()->isBlockFlow();
1462 }
1463
1464 bool Node::isBlockFlowOrBlockTable() const
1465 {
1466     return renderer() && (renderer()->isBlockFlow() || (renderer()->isTable() && !renderer()->isInline()));
1467 }
1468
1469 bool Node::isEditableBlock() const
1470 {
1471     return isContentEditable() && isBlockFlow();
1472 }
1473
1474 Element *Node::enclosingBlockFlowElement() const
1475 {
1476     Node *n = const_cast<Node *>(this);
1477     if (isBlockFlow())
1478         return static_cast<Element *>(n);
1479
1480     while (1) {
1481         n = n->parentNode();
1482         if (!n)
1483             break;
1484         if (n->isBlockFlow() || n->hasTagName(bodyTag))
1485             return static_cast<Element *>(n);
1486     }
1487     return 0;
1488 }
1489
1490 Element *Node::enclosingInlineElement() const
1491 {
1492     Node *n = const_cast<Node *>(this);
1493     Node *p;
1494
1495     while (1) {
1496         p = n->parentNode();
1497         if (!p || p->isBlockFlow() || p->hasTagName(bodyTag))
1498             return static_cast<Element *>(n);
1499         // Also stop if any previous sibling is a block
1500         for (Node *sibling = n->previousSibling(); sibling; sibling = sibling->previousSibling()) {
1501             if (sibling->isBlockFlow())
1502                 return static_cast<Element *>(n);
1503         }
1504         n = p;
1505     }
1506     ASSERT_NOT_REACHED();
1507     return 0;
1508 }
1509
1510 Element* Node::rootEditableElement() const
1511 {
1512     Element* result = 0;
1513     for (Node* n = const_cast<Node*>(this); n && n->isContentEditable(); n = n->parentNode()) {
1514         if (n->isElementNode())
1515             result = static_cast<Element*>(n);
1516         if (n->hasTagName(bodyTag))
1517             break;
1518     }
1519     return result;
1520 }
1521
1522 bool Node::inSameContainingBlockFlowElement(Node *n)
1523 {
1524     return n ? enclosingBlockFlowElement() == n->enclosingBlockFlowElement() : false;
1525 }
1526
1527 // FIXME: End of obviously misplaced HTML editing functions.  Try to move these out of Node.
1528
1529 PassRefPtr<NodeList> Node::getElementsByTagName(const AtomicString& name)
1530 {
1531     return getElementsByTagNameNS(starAtom, name);
1532 }
1533  
1534 PassRefPtr<NodeList> Node::getElementsByTagNameNS(const AtomicString& namespaceURI, const AtomicString& localName)
1535 {
1536     if (localName.isNull())
1537         return 0;
1538     
1539     NodeRareData* data = ensureRareData();
1540     if (!data->nodeLists()) {
1541         data->setNodeLists(NodeListsNodeData::create());
1542         document()->addNodeListCache();
1543     }
1544
1545     String name = localName;
1546     if (document()->isHTMLDocument())
1547         name = localName.lower();
1548     
1549     AtomicString localNameAtom = name;
1550         
1551     pair<NodeListsNodeData::TagNodeListCache::iterator, bool> result = data->nodeLists()->m_tagNodeListCache.add(QualifiedName(nullAtom, localNameAtom, namespaceURI).impl(), 0);
1552     if (!result.second)
1553         return PassRefPtr<TagNodeList>(result.first->second);
1554     
1555     RefPtr<TagNodeList> list = TagNodeList::create(this, namespaceURI.isEmpty() ? nullAtom : namespaceURI, localNameAtom);
1556     result.first->second = list.get();
1557     return list.release();
1558 }
1559
1560 PassRefPtr<NodeList> Node::getElementsByName(const String& elementName)
1561 {
1562     NodeRareData* data = ensureRareData();
1563     if (!data->nodeLists()) {
1564         data->setNodeLists(NodeListsNodeData::create());
1565         document()->addNodeListCache();
1566     }
1567
1568     pair<NodeListsNodeData::NameNodeListCache::iterator, bool> result = data->nodeLists()->m_nameNodeListCache.add(elementName, 0);
1569     if (!result.second)
1570         return PassRefPtr<NodeList>(result.first->second);
1571
1572     RefPtr<NameNodeList> list = NameNodeList::create(this, elementName);
1573     result.first->second = list.get();
1574     return list.release();
1575 }
1576
1577 PassRefPtr<NodeList> Node::getElementsByClassName(const String& classNames)
1578 {
1579     NodeRareData* data = ensureRareData();
1580     if (!data->nodeLists()) {
1581         data->setNodeLists(NodeListsNodeData::create());
1582         document()->addNodeListCache();
1583     }
1584
1585     pair<NodeListsNodeData::ClassNodeListCache::iterator, bool> result = data->nodeLists()->m_classNodeListCache.add(classNames, 0);
1586     if (!result.second)
1587         return PassRefPtr<NodeList>(result.first->second);
1588
1589     RefPtr<ClassNodeList> list = ClassNodeList::create(this, classNames);
1590     result.first->second = list.get();
1591     return list.release();
1592 }
1593
1594 PassRefPtr<Element> Node::querySelector(const String& selectors, ExceptionCode& ec)
1595 {
1596     if (selectors.isEmpty()) {
1597         ec = SYNTAX_ERR;
1598         return 0;
1599     }
1600     bool strictParsing = !document()->inQuirksMode();
1601     CSSParser p(strictParsing);
1602
1603     CSSSelectorList querySelectorList;
1604     p.parseSelector(selectors, document(), querySelectorList);
1605
1606     if (!querySelectorList.first()) {
1607         ec = SYNTAX_ERR;
1608         return 0;
1609     }
1610
1611     // throw a NAMESPACE_ERR if the selector includes any namespace prefixes.
1612     if (querySelectorList.selectorsNeedNamespaceResolution()) {
1613         ec = NAMESPACE_ERR;
1614         return 0;
1615     }
1616
1617     CSSStyleSelector::SelectorChecker selectorChecker(document(), strictParsing);
1618
1619     // FIXME: we could also optimize for the the [id="foo"] case
1620     if (strictParsing && inDocument() && querySelectorList.hasOneSelector() && querySelectorList.first()->m_match == CSSSelector::Id) {
1621         Element* element = document()->getElementById(querySelectorList.first()->m_value);
1622         if (element && (isDocumentNode() || element->isDescendantOf(this)) && selectorChecker.checkSelector(querySelectorList.first(), element))
1623             return element;
1624         return 0;
1625     }
1626
1627     // FIXME: We can speed this up by implementing caching similar to the one use by getElementById
1628     for (Node* n = firstChild(); n; n = n->traverseNextNode(this)) {
1629         if (n->isElementNode()) {
1630             Element* element = static_cast<Element*>(n);
1631             for (CSSSelector* selector = querySelectorList.first(); selector; selector = CSSSelectorList::next(selector)) {
1632                 if (selectorChecker.checkSelector(selector, element))
1633                     return element;
1634             }
1635         }
1636     }
1637     
1638     return 0;
1639 }
1640
1641 PassRefPtr<NodeList> Node::querySelectorAll(const String& selectors, ExceptionCode& ec)
1642 {
1643     if (selectors.isEmpty()) {
1644         ec = SYNTAX_ERR;
1645         return 0;
1646     }
1647     bool strictParsing = !document()->inQuirksMode();
1648     CSSParser p(strictParsing);
1649
1650     CSSSelectorList querySelectorList;
1651     p.parseSelector(selectors, document(), querySelectorList);
1652
1653     if (!querySelectorList.first()) {
1654         ec = SYNTAX_ERR;
1655         return 0;
1656     }
1657
1658     // Throw a NAMESPACE_ERR if the selector includes any namespace prefixes.
1659     if (querySelectorList.selectorsNeedNamespaceResolution()) {
1660         ec = NAMESPACE_ERR;
1661         return 0;
1662     }
1663
1664     return createSelectorNodeList(this, querySelectorList);
1665 }
1666
1667 Document *Node::ownerDocument() const
1668 {
1669     Document *doc = document();
1670     return doc == this ? 0 : doc;
1671 }
1672
1673 KURL Node::baseURI() const
1674 {
1675     return parentNode() ? parentNode()->baseURI() : KURL();
1676 }
1677
1678 bool Node::isEqualNode(Node* other) const
1679 {
1680     if (!other)
1681         return false;
1682     
1683     NodeType nodeType = this->nodeType();
1684     if (nodeType != other->nodeType())
1685         return false;
1686     
1687     if (nodeName() != other->nodeName())
1688         return false;
1689     
1690     if (localName() != other->localName())
1691         return false;
1692     
1693     if (namespaceURI() != other->namespaceURI())
1694         return false;
1695     
1696     if (prefix() != other->prefix())
1697         return false;
1698     
1699     if (nodeValue() != other->nodeValue())
1700         return false;
1701     
1702     NamedNodeMap* attributes = this->attributes();
1703     NamedNodeMap* otherAttributes = other->attributes();
1704     
1705     if (!attributes && otherAttributes)
1706         return false;
1707     
1708     if (attributes && !attributes->mapsEquivalent(otherAttributes))
1709         return false;
1710     
1711     Node* child = firstChild();
1712     Node* otherChild = other->firstChild();
1713     
1714     while (child) {
1715         if (!child->isEqualNode(otherChild))
1716             return false;
1717         
1718         child = child->nextSibling();
1719         otherChild = otherChild->nextSibling();
1720     }
1721     
1722     if (otherChild)
1723         return false;
1724     
1725     if (nodeType == DOCUMENT_TYPE_NODE) {
1726         const DocumentType* documentTypeThis = static_cast<const DocumentType*>(this);
1727         const DocumentType* documentTypeOther = static_cast<const DocumentType*>(other);
1728         
1729         if (documentTypeThis->publicId() != documentTypeOther->publicId())
1730             return false;
1731
1732         if (documentTypeThis->systemId() != documentTypeOther->systemId())
1733             return false;
1734
1735         if (documentTypeThis->internalSubset() != documentTypeOther->internalSubset())
1736             return false;
1737
1738         NamedNodeMap* entities = documentTypeThis->entities();
1739         NamedNodeMap* otherEntities = documentTypeOther->entities();
1740         if (!entities && otherEntities)
1741             return false;
1742         if (entities && !entities->mapsEquivalent(otherEntities))
1743             return false;
1744
1745         NamedNodeMap* notations = documentTypeThis->notations();
1746         NamedNodeMap* otherNotations = documentTypeOther->notations();
1747         if (!notations && otherNotations)
1748             return false;
1749         if (notations && !notations->mapsEquivalent(otherNotations))
1750             return false;
1751     }
1752     
1753     return true;
1754 }
1755
1756 bool Node::isDefaultNamespace(const AtomicString& namespaceURIMaybeEmpty) const
1757 {
1758     const AtomicString& namespaceURI = namespaceURIMaybeEmpty.isEmpty() ? nullAtom : namespaceURIMaybeEmpty;
1759
1760     switch (nodeType()) {
1761         case ELEMENT_NODE: {
1762             const Element* elem = static_cast<const Element*>(this);
1763             
1764             if (elem->prefix().isNull())
1765                 return elem->namespaceURI() == namespaceURI;
1766
1767             if (elem->hasAttributes()) {
1768                 NamedNodeMap* attrs = elem->attributes();
1769                 
1770                 for (unsigned i = 0; i < attrs->length(); i++) {
1771                     Attribute* attr = attrs->attributeItem(i);
1772                     
1773                     if (attr->localName() == xmlnsAtom)
1774                         return attr->value() == namespaceURI;
1775                 }
1776             }
1777
1778             if (Element* ancestor = ancestorElement())
1779                 return ancestor->isDefaultNamespace(namespaceURI);
1780
1781             return false;
1782         }
1783         case DOCUMENT_NODE:
1784             if (Element* de = static_cast<const Document*>(this)->documentElement())
1785                 return de->isDefaultNamespace(namespaceURI);
1786             return false;
1787         case ENTITY_NODE:
1788         case NOTATION_NODE:
1789         case DOCUMENT_TYPE_NODE:
1790         case DOCUMENT_FRAGMENT_NODE:
1791             return false;
1792         case ATTRIBUTE_NODE: {
1793             const Attr* attr = static_cast<const Attr*>(this);
1794             if (attr->ownerElement())
1795                 return attr->ownerElement()->isDefaultNamespace(namespaceURI);
1796             return false;
1797         }
1798         default:
1799             if (Element* ancestor = ancestorElement())
1800                 return ancestor->isDefaultNamespace(namespaceURI);
1801             return false;
1802     }
1803 }
1804
1805 String Node::lookupPrefix(const AtomicString &namespaceURI) const
1806 {
1807     // Implemented according to
1808     // http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/namespaces-algorithms.html#lookupNamespacePrefixAlgo
1809     
1810     if (namespaceURI.isEmpty())
1811         return String();
1812     
1813     switch (nodeType()) {
1814         case ELEMENT_NODE:
1815             return lookupNamespacePrefix(namespaceURI, static_cast<const Element *>(this));
1816         case DOCUMENT_NODE:
1817             if (Element* de = static_cast<const Document*>(this)->documentElement())
1818                 return de->lookupPrefix(namespaceURI);
1819             return String();
1820         case ENTITY_NODE:
1821         case NOTATION_NODE:
1822         case DOCUMENT_FRAGMENT_NODE:
1823         case DOCUMENT_TYPE_NODE:
1824             return String();
1825         case ATTRIBUTE_NODE: {
1826             const Attr *attr = static_cast<const Attr *>(this);
1827             if (attr->ownerElement())
1828                 return attr->ownerElement()->lookupPrefix(namespaceURI);
1829             return String();
1830         }
1831         default:
1832             if (Element* ancestor = ancestorElement())
1833                 return ancestor->lookupPrefix(namespaceURI);
1834             return String();
1835     }
1836 }
1837
1838 String Node::lookupNamespaceURI(const String &prefix) const
1839 {
1840     // Implemented according to
1841     // http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/namespaces-algorithms.html#lookupNamespaceURIAlgo
1842     
1843     if (!prefix.isNull() && prefix.isEmpty())
1844         return String();
1845     
1846     switch (nodeType()) {
1847         case ELEMENT_NODE: {
1848             const Element *elem = static_cast<const Element *>(this);
1849             
1850             if (!elem->namespaceURI().isNull() && elem->prefix() == prefix)
1851                 return elem->namespaceURI();
1852             
1853             if (elem->hasAttributes()) {
1854                 NamedNodeMap *attrs = elem->attributes();
1855                 
1856                 for (unsigned i = 0; i < attrs->length(); i++) {
1857                     Attribute *attr = attrs->attributeItem(i);
1858                     
1859                     if (attr->prefix() == xmlnsAtom && attr->localName() == prefix) {
1860                         if (!attr->value().isEmpty())
1861                             return attr->value();
1862                         
1863                         return String();
1864                     } else if (attr->localName() == xmlnsAtom && prefix.isNull()) {
1865                         if (!attr->value().isEmpty())
1866                             return attr->value();
1867                         
1868                         return String();
1869                     }
1870                 }
1871             }
1872             if (Element* ancestor = ancestorElement())
1873                 return ancestor->lookupNamespaceURI(prefix);
1874             return String();
1875         }
1876         case DOCUMENT_NODE:
1877             if (Element* de = static_cast<const Document*>(this)->documentElement())
1878                 return de->lookupNamespaceURI(prefix);
1879             return String();
1880         case ENTITY_NODE:
1881         case NOTATION_NODE:
1882         case DOCUMENT_TYPE_NODE:
1883         case DOCUMENT_FRAGMENT_NODE:
1884             return String();
1885         case ATTRIBUTE_NODE: {
1886             const Attr *attr = static_cast<const Attr *>(this);
1887             
1888             if (attr->ownerElement())
1889                 return attr->ownerElement()->lookupNamespaceURI(prefix);
1890             else
1891                 return String();
1892         }
1893         default:
1894             if (Element* ancestor = ancestorElement())
1895                 return ancestor->lookupNamespaceURI(prefix);
1896             return String();
1897     }
1898 }
1899
1900 String Node::lookupNamespacePrefix(const AtomicString &_namespaceURI, const Element *originalElement) const
1901 {
1902     if (_namespaceURI.isNull())
1903         return String();
1904             
1905     if (originalElement->lookupNamespaceURI(prefix()) == _namespaceURI)
1906         return prefix();
1907     
1908     if (hasAttributes()) {
1909         NamedNodeMap *attrs = attributes();
1910         
1911         for (unsigned i = 0; i < attrs->length(); i++) {
1912             Attribute *attr = attrs->attributeItem(i);
1913             
1914             if (attr->prefix() == xmlnsAtom &&
1915                 attr->value() == _namespaceURI &&
1916                 originalElement->lookupNamespaceURI(attr->localName()) == _namespaceURI)
1917                 return attr->localName();
1918         }
1919     }
1920     
1921     if (Element* ancestor = ancestorElement())
1922         return ancestor->lookupNamespacePrefix(_namespaceURI, originalElement);
1923     return String();
1924 }
1925
1926 static void appendTextContent(const Node* node, bool convertBRsToNewlines, bool& isNullString, StringBuilder& content)
1927 {
1928     switch (node->nodeType()) {
1929     case Node::TEXT_NODE:
1930     case Node::CDATA_SECTION_NODE:
1931     case Node::COMMENT_NODE:
1932         isNullString = false;
1933         content.append(static_cast<const CharacterData*>(node)->data());
1934         break;
1935
1936     case Node::PROCESSING_INSTRUCTION_NODE:
1937         isNullString = false;
1938         content.append(static_cast<const ProcessingInstruction*>(node)->data());
1939         break;
1940     
1941     case Node::ELEMENT_NODE:
1942         if (node->hasTagName(brTag) && convertBRsToNewlines) {
1943             isNullString = false;
1944             content.append('\n');
1945             break;
1946         }
1947     // Fall through.
1948     case Node::ATTRIBUTE_NODE:
1949     case Node::ENTITY_NODE:
1950     case Node::ENTITY_REFERENCE_NODE:
1951     case Node::DOCUMENT_FRAGMENT_NODE:
1952         isNullString = false;
1953         for (Node* child = node->firstChild(); child; child = child->nextSibling()) {
1954             if (child->nodeType() == Node::COMMENT_NODE || child->nodeType() == Node::PROCESSING_INSTRUCTION_NODE)
1955                 continue;
1956             appendTextContent(child, convertBRsToNewlines, isNullString, content);
1957         }
1958         break;
1959
1960     case Node::DOCUMENT_NODE:
1961     case Node::DOCUMENT_TYPE_NODE:
1962     case Node::NOTATION_NODE:
1963     case Node::XPATH_NAMESPACE_NODE:
1964         break;
1965     }
1966 }
1967
1968 String Node::textContent(bool convertBRsToNewlines) const
1969 {
1970     StringBuilder content;
1971     bool isNullString = true;
1972     appendTextContent(this, convertBRsToNewlines, isNullString, content);
1973     return isNullString ? String() : content.toString();
1974 }
1975
1976 void Node::setTextContent(const String& text, ExceptionCode& ec)
1977 {           
1978     switch (nodeType()) {
1979         case TEXT_NODE:
1980         case CDATA_SECTION_NODE:
1981         case COMMENT_NODE:
1982         case PROCESSING_INSTRUCTION_NODE:
1983             setNodeValue(text, ec);
1984             return;
1985         case ELEMENT_NODE:
1986         case ATTRIBUTE_NODE:
1987         case ENTITY_NODE:
1988         case ENTITY_REFERENCE_NODE:
1989         case DOCUMENT_FRAGMENT_NODE: {
1990             ContainerNode* container = toContainerNode(this);
1991             container->removeChildren();
1992             if (!text.isEmpty())
1993                 container->appendChild(document()->createTextNode(text), ec);
1994             return;
1995         }
1996         case DOCUMENT_NODE:
1997         case DOCUMENT_TYPE_NODE:
1998         case NOTATION_NODE:
1999         case XPATH_NAMESPACE_NODE:
2000             // Do nothing.
2001             return;
2002     }
2003     ASSERT_NOT_REACHED();
2004 }
2005
2006 Element* Node::ancestorElement() const
2007 {
2008     // In theory, there can be EntityReference nodes between elements, but this is currently not supported.
2009     for (ContainerNode* n = parentNode(); n; n = n->parentNode()) {
2010         if (n->isElementNode())
2011             return static_cast<Element*>(n);
2012     }
2013     return 0;
2014 }
2015
2016 bool Node::offsetInCharacters() const
2017 {
2018     return false;
2019 }
2020
2021 unsigned short Node::compareDocumentPosition(Node* otherNode)
2022 {
2023     // It is not clear what should be done if |otherNode| is 0.
2024     if (!otherNode)
2025         return DOCUMENT_POSITION_DISCONNECTED;
2026
2027     if (otherNode == this)
2028         return DOCUMENT_POSITION_EQUIVALENT;
2029     
2030     Attr* attr1 = nodeType() == ATTRIBUTE_NODE ? static_cast<Attr*>(this) : 0;
2031     Attr* attr2 = otherNode->nodeType() == ATTRIBUTE_NODE ? static_cast<Attr*>(otherNode) : 0;
2032     
2033     Node* start1 = attr1 ? attr1->ownerElement() : this;
2034     Node* start2 = attr2 ? attr2->ownerElement() : otherNode;
2035     
2036     // If either of start1 or start2 is null, then we are disconnected, since one of the nodes is
2037     // an orphaned attribute node.
2038     if (!start1 || !start2)
2039         return DOCUMENT_POSITION_DISCONNECTED | DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC;
2040
2041     Vector<Node*, 16> chain1;
2042     Vector<Node*, 16> chain2;
2043     if (attr1)
2044         chain1.append(attr1);
2045     if (attr2)
2046         chain2.append(attr2);
2047     
2048     if (attr1 && attr2 && start1 == start2 && start1) {
2049         // We are comparing two attributes on the same node.  Crawl our attribute map
2050         // and see which one we hit first.
2051         NamedNodeMap* map = attr1->ownerElement()->attributes(true);
2052         unsigned length = map->length();
2053         for (unsigned i = 0; i < length; ++i) {
2054             // If neither of the two determining nodes is a child node and nodeType is the same for both determining nodes, then an 
2055             // implementation-dependent order between the determining nodes is returned. This order is stable as long as no nodes of
2056             // the same nodeType are inserted into or removed from the direct container. This would be the case, for example, 
2057             // when comparing two attributes of the same element, and inserting or removing additional attributes might change 
2058             // the order between existing attributes.
2059             Attribute* attr = map->attributeItem(i);
2060             if (attr1->attr() == attr)
2061                 return DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC | DOCUMENT_POSITION_FOLLOWING;
2062             if (attr2->attr() == attr)
2063                 return DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC | DOCUMENT_POSITION_PRECEDING;
2064         }
2065         
2066         ASSERT_NOT_REACHED();
2067         return DOCUMENT_POSITION_DISCONNECTED;
2068     }
2069
2070     // If one node is in the document and the other is not, we must be disconnected.
2071     // If the nodes have different owning documents, they must be disconnected.  Note that we avoid
2072     // comparing Attr nodes here, since they return false from inDocument() all the time (which seems like a bug).
2073     if (start1->inDocument() != start2->inDocument() ||
2074         start1->document() != start2->document())
2075         return DOCUMENT_POSITION_DISCONNECTED | DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC;
2076
2077     // We need to find a common ancestor container, and then compare the indices of the two immediate children.
2078     Node* current;
2079     for (current = start1; current; current = current->parentNode())
2080         chain1.append(current);
2081     for (current = start2; current; current = current->parentNode())
2082         chain2.append(current);
2083    
2084     // Walk the two chains backwards and look for the first difference.
2085     unsigned index1 = chain1.size();
2086     unsigned index2 = chain2.size();
2087     for (unsigned i = min(index1, index2); i; --i) {
2088         Node* child1 = chain1[--index1];
2089         Node* child2 = chain2[--index2];
2090         if (child1 != child2) {
2091             // If one of the children is an attribute, it wins.
2092             if (child1->nodeType() == ATTRIBUTE_NODE)
2093                 return DOCUMENT_POSITION_FOLLOWING;
2094             if (child2->nodeType() == ATTRIBUTE_NODE)
2095                 return DOCUMENT_POSITION_PRECEDING;
2096             
2097             if (!child2->nextSibling())
2098                 return DOCUMENT_POSITION_FOLLOWING;
2099             if (!child1->nextSibling())
2100                 return DOCUMENT_POSITION_PRECEDING;
2101
2102             // Otherwise we need to see which node occurs first.  Crawl backwards from child2 looking for child1.
2103             for (Node* child = child2->previousSibling(); child; child = child->previousSibling()) {
2104                 if (child == child1)
2105                     return DOCUMENT_POSITION_FOLLOWING;
2106             }
2107             return DOCUMENT_POSITION_PRECEDING;
2108         }
2109     }
2110     
2111     // There was no difference between the two parent chains, i.e., one was a subset of the other.  The shorter
2112     // chain is the ancestor.
2113     return index1 < index2 ? 
2114                DOCUMENT_POSITION_FOLLOWING | DOCUMENT_POSITION_CONTAINED_BY :
2115                DOCUMENT_POSITION_PRECEDING | DOCUMENT_POSITION_CONTAINS;
2116 }
2117
2118 FloatPoint Node::convertToPage(const FloatPoint& p) const
2119 {
2120     // If there is a renderer, just ask it to do the conversion
2121     if (renderer())
2122         return renderer()->localToAbsolute(p, false, true);
2123     
2124     // Otherwise go up the tree looking for a renderer
2125     Element *parent = ancestorElement();
2126     if (parent)
2127         return parent->convertToPage(p);
2128
2129     // No parent - no conversion needed
2130     return p;
2131 }
2132
2133 FloatPoint Node::convertFromPage(const FloatPoint& p) const
2134 {
2135     // If there is a renderer, just ask it to do the conversion
2136     if (renderer())
2137         return renderer()->absoluteToLocal(p, false, true);
2138
2139     // Otherwise go up the tree looking for a renderer
2140     Element *parent = ancestorElement();
2141     if (parent)
2142         return parent->convertFromPage(p);
2143
2144     // No parent - no conversion needed
2145     return p;
2146 }
2147
2148 #ifndef NDEBUG
2149
2150 static void appendAttributeDesc(const Node* node, String& string, const QualifiedName& name, const char* attrDesc)
2151 {
2152     if (node->isElementNode()) {
2153         String attr = static_cast<const Element*>(node)->getAttribute(name);
2154         if (!attr.isEmpty()) {
2155             string += attrDesc;
2156             string += attr;
2157         }
2158     }
2159 }
2160
2161 void Node::showNode(const char* prefix) const
2162 {
2163     if (!prefix)
2164         prefix = "";
2165     if (isTextNode()) {
2166         String value = nodeValue();
2167         value.replace('\\', "\\\\");
2168         value.replace('\n', "\\n");
2169         fprintf(stderr, "%s%s\t%p \"%s\"\n", prefix, nodeName().utf8().data(), this, value.utf8().data());
2170     } else {
2171         String attrs = "";
2172         appendAttributeDesc(this, attrs, classAttr, " CLASS=");
2173         appendAttributeDesc(this, attrs, styleAttr, " STYLE=");
2174         fprintf(stderr, "%s%s\t%p%s\n", prefix, nodeName().utf8().data(), this, attrs.utf8().data());
2175     }
2176 }
2177
2178 void Node::showTreeForThis() const
2179 {
2180     showTreeAndMark(this, "*");
2181 }
2182
2183 void Node::showTreeAndMark(const Node* markedNode1, const char* markedLabel1, const Node* markedNode2, const char * markedLabel2) const
2184 {
2185     const Node* rootNode;
2186     const Node* node = this;
2187     while (node->parentNode() && !node->hasTagName(bodyTag))
2188         node = node->parentNode();
2189     rootNode = node;
2190         
2191     for (node = rootNode; node; node = node->traverseNextNode()) {
2192         if (node == markedNode1)
2193             fprintf(stderr, "%s", markedLabel1);
2194         if (node == markedNode2)
2195             fprintf(stderr, "%s", markedLabel2);
2196                         
2197         for (const Node* tmpNode = node; tmpNode && tmpNode != rootNode; tmpNode = tmpNode->parentNode())
2198             fprintf(stderr, "\t");
2199         node->showNode();
2200     }
2201 }
2202
2203 void Node::formatForDebugger(char* buffer, unsigned length) const
2204 {
2205     String result;
2206     String s;
2207     
2208     s = nodeName();
2209     if (s.length() == 0)
2210         result += "<none>";
2211     else
2212         result += s;
2213           
2214     strncpy(buffer, result.utf8().data(), length - 1);
2215 }
2216
2217 #endif
2218
2219 // --------
2220
2221 void NodeListsNodeData::invalidateCaches()
2222 {
2223     m_childNodeListCaches->reset();
2224
2225     if (m_labelsNodeListCache)
2226         m_labelsNodeListCache->invalidateCache();
2227     TagNodeListCache::const_iterator tagCacheEnd = m_tagNodeListCache.end();
2228     for (TagNodeListCache::const_iterator it = m_tagNodeListCache.begin(); it != tagCacheEnd; ++it)
2229         it->second->invalidateCache();
2230     invalidateCachesThatDependOnAttributes();
2231 }
2232
2233 void NodeListsNodeData::invalidateCachesThatDependOnAttributes()
2234 {
2235     ClassNodeListCache::iterator classCacheEnd = m_classNodeListCache.end();
2236     for (ClassNodeListCache::iterator it = m_classNodeListCache.begin(); it != classCacheEnd; ++it)
2237         it->second->invalidateCache();
2238
2239     NameNodeListCache::iterator nameCacheEnd = m_nameNodeListCache.end();
2240     for (NameNodeListCache::iterator it = m_nameNodeListCache.begin(); it != nameCacheEnd; ++it)
2241         it->second->invalidateCache();
2242     if (m_labelsNodeListCache)
2243         m_labelsNodeListCache->invalidateCache();
2244 }
2245
2246 bool NodeListsNodeData::isEmpty() const
2247 {
2248     if (!m_listsWithCaches.isEmpty())
2249         return false;
2250
2251     if (m_childNodeListCaches->refCount())
2252         return false;
2253     
2254     TagNodeListCache::const_iterator tagCacheEnd = m_tagNodeListCache.end();
2255     for (TagNodeListCache::const_iterator it = m_tagNodeListCache.begin(); it != tagCacheEnd; ++it) {
2256         if (it->second->refCount())
2257             return false;
2258     }
2259
2260     ClassNodeListCache::const_iterator classCacheEnd = m_classNodeListCache.end();
2261     for (ClassNodeListCache::const_iterator it = m_classNodeListCache.begin(); it != classCacheEnd; ++it) {
2262         if (it->second->refCount())
2263             return false;
2264     }
2265
2266     NameNodeListCache::const_iterator nameCacheEnd = m_nameNodeListCache.end();
2267     for (NameNodeListCache::const_iterator it = m_nameNodeListCache.begin(); it != nameCacheEnd; ++it) {
2268         if (it->second->refCount())
2269             return false;
2270     }
2271
2272     if (m_labelsNodeListCache)
2273         return false;
2274
2275     return true;
2276 }
2277
2278 void Node::getSubresourceURLs(ListHashSet<KURL>& urls) const
2279 {
2280     addSubresourceAttributeURLs(urls);
2281 }
2282
2283 ContainerNode* Node::eventParentNode()
2284 {
2285     return parentNode();
2286 }
2287
2288 Node* Node::enclosingLinkEventParentOrSelf()
2289 {
2290     for (Node* node = this; node; node = node->eventParentNode()) {
2291         // For imagemaps, the enclosing link node is the associated area element not the image itself.
2292         // So we don't let images be the enclosingLinkNode, even though isLink sometimes returns true
2293         // for them.
2294         if (node->isLink() && !node->hasTagName(imgTag))
2295             return node;
2296     }
2297
2298     return 0;
2299 }
2300
2301 // --------
2302
2303 ScriptExecutionContext* Node::scriptExecutionContext() const
2304 {
2305     return document();
2306 }
2307
2308 void Node::insertedIntoDocument()
2309 {
2310     setInDocument();
2311 }
2312
2313 void Node::removedFromDocument()
2314 {
2315     clearInDocument();
2316 }
2317
2318 void Node::willMoveToNewOwnerDocument()
2319 {
2320     ASSERT(!willMoveToNewOwnerDocumentWasCalled);
2321     setWillMoveToNewOwnerDocumentWasCalled(true);
2322 }
2323
2324 void Node::didMoveToNewOwnerDocument()
2325 {
2326     ASSERT(!didMoveToNewOwnerDocumentWasCalled);
2327     setDidMoveToNewOwnerDocumentWasCalled(true);
2328 }
2329
2330 #if ENABLE(SVG)
2331 static inline HashSet<SVGElementInstance*> instancesForSVGElement(Node* node)
2332 {
2333     HashSet<SVGElementInstance*> instances;
2334  
2335     ASSERT(node);
2336     if (!node->isSVGElement() || node->shadowTreeRootNode())
2337         return HashSet<SVGElementInstance*>();
2338
2339     SVGElement* element = static_cast<SVGElement*>(node);
2340     if (!element->isStyled())
2341         return HashSet<SVGElementInstance*>();
2342
2343     SVGStyledElement* styledElement = static_cast<SVGStyledElement*>(element);
2344     ASSERT(!styledElement->instanceUpdatesBlocked());
2345
2346     return styledElement->instancesForElement();
2347 }
2348 #endif
2349
2350 static inline bool tryAddEventListener(Node* targetNode, const AtomicString& eventType, PassRefPtr<EventListener> listener, bool useCapture)
2351 {
2352     if (!targetNode->EventTarget::addEventListener(eventType, listener, useCapture))
2353         return false;
2354
2355     if (Document* document = targetNode->document())
2356         document->addListenerTypeIfNeeded(eventType);
2357
2358     return true;
2359 }
2360
2361 bool Node::addEventListener(const AtomicString& eventType, PassRefPtr<EventListener> listener, bool useCapture)
2362 {
2363 #if !ENABLE(SVG)
2364     return tryAddEventListener(this, eventType, listener, useCapture);
2365 #else
2366     if (!isSVGElement())
2367         return tryAddEventListener(this, eventType, listener, useCapture);
2368
2369     HashSet<SVGElementInstance*> instances = instancesForSVGElement(this);
2370     if (instances.isEmpty())
2371         return tryAddEventListener(this, eventType, listener, useCapture);
2372
2373     RefPtr<EventListener> listenerForRegularTree = listener;
2374     RefPtr<EventListener> listenerForShadowTree = listenerForRegularTree;
2375
2376     // Add event listener to regular DOM element
2377     if (!tryAddEventListener(this, eventType, listenerForRegularTree.release(), useCapture))
2378         return false;
2379
2380     // Add event listener to all shadow tree DOM element instances
2381     const HashSet<SVGElementInstance*>::const_iterator end = instances.end();
2382     for (HashSet<SVGElementInstance*>::const_iterator it = instances.begin(); it != end; ++it) {
2383         ASSERT((*it)->shadowTreeElement());
2384         ASSERT((*it)->correspondingElement() == this);
2385
2386         RefPtr<EventListener> listenerForCurrentShadowTreeElement = listenerForShadowTree;
2387         bool result = tryAddEventListener((*it)->shadowTreeElement(), eventType, listenerForCurrentShadowTreeElement.release(), useCapture);
2388         ASSERT_UNUSED(result, result);
2389     }
2390
2391     return true;
2392 #endif
2393 }
2394
2395 static inline bool tryRemoveEventListener(Node* targetNode, const AtomicString& eventType, EventListener* listener, bool useCapture)
2396 {
2397     if (!targetNode->EventTarget::removeEventListener(eventType, listener, useCapture))
2398         return false;
2399
2400     // FIXME: Notify Document that the listener has vanished. We need to keep track of a number of
2401     // listeners for each type, not just a bool - see https://bugs.webkit.org/show_bug.cgi?id=33861
2402
2403     return true;
2404 }
2405
2406 bool Node::removeEventListener(const AtomicString& eventType, EventListener* listener, bool useCapture)
2407 {
2408 #if !ENABLE(SVG)
2409     return tryRemoveEventListener(this, eventType, listener, useCapture);
2410 #else
2411     if (!isSVGElement())
2412         return tryRemoveEventListener(this, eventType, listener, useCapture);
2413
2414     HashSet<SVGElementInstance*> instances = instancesForSVGElement(this);
2415     if (instances.isEmpty())
2416         return tryRemoveEventListener(this, eventType, listener, useCapture);
2417
2418     // EventTarget::removeEventListener creates a PassRefPtr around the given EventListener
2419     // object when creating a temporary RegisteredEventListener object used to look up the
2420     // event listener in a cache. If we want to be able to call removeEventListener() multiple
2421     // times on different nodes, we have to delay its immediate destruction, which would happen
2422     // after the first call below.
2423     RefPtr<EventListener> protector(listener);
2424
2425     // Remove event listener from regular DOM element
2426     if (!tryRemoveEventListener(this, eventType, listener, useCapture))
2427         return false;
2428
2429     // Remove event listener from all shadow tree DOM element instances
2430     const HashSet<SVGElementInstance*>::const_iterator end = instances.end();
2431     for (HashSet<SVGElementInstance*>::const_iterator it = instances.begin(); it != end; ++it) {
2432         ASSERT((*it)->correspondingElement() == this);
2433
2434         SVGElement* shadowTreeElement = (*it)->shadowTreeElement();
2435         ASSERT(shadowTreeElement);
2436
2437         if (tryRemoveEventListener(shadowTreeElement, eventType, listener, useCapture))
2438             continue;
2439
2440         // This case can only be hit for event listeners created from markup
2441         ASSERT(listener->wasCreatedFromMarkup());
2442
2443         // If the event listener 'listener' has been created from markup and has been fired before
2444         // then JSLazyEventListener::parseCode() has been called and m_jsFunction of that listener
2445         // has been created (read: it's not 0 anymore). During shadow tree creation, the event
2446         // listener DOM attribute has been cloned, and another event listener has been setup in
2447         // the shadow tree. If that event listener has not been used yet, m_jsFunction is still 0,
2448         // and tryRemoveEventListener() above will fail. Work around that very seldom problem.
2449         EventTargetData* data = shadowTreeElement->eventTargetData();
2450         ASSERT(data);
2451
2452         EventListenerMap::iterator result = data->eventListenerMap.find(eventType);
2453         ASSERT(result != data->eventListenerMap.end());
2454
2455         EventListenerVector* entry = result->second;
2456         ASSERT(entry);
2457
2458         unsigned int index = 0;
2459         bool foundListener = false;
2460
2461         EventListenerVector::iterator end = entry->end();
2462         for (EventListenerVector::iterator it = entry->begin(); it != end; ++it) {
2463             if (!(*it).listener->wasCreatedFromMarkup()) {
2464                 ++index;
2465                 continue;
2466             }
2467
2468             foundListener = true;
2469             entry->remove(index);
2470             break;
2471         }
2472
2473         ASSERT(foundListener);
2474
2475         if (entry->isEmpty()) {                
2476             delete entry;
2477             data->eventListenerMap.remove(result);
2478         }
2479     }
2480
2481     return true;
2482 #endif
2483 }
2484
2485 EventTargetData* Node::eventTargetData()
2486 {
2487     return hasRareData() ? rareData()->eventTargetData() : 0;
2488 }
2489
2490 EventTargetData* Node::ensureEventTargetData()
2491 {
2492     return ensureRareData()->ensureEventTargetData();
2493 }
2494
2495 #if USE(JSC)
2496
2497 template <class NodeListMap>
2498 void markNodeLists(const NodeListMap& map, JSC::MarkStack& markStack, JSC::JSGlobalData& globalData)
2499 {
2500     for (typename NodeListMap::const_iterator it = map.begin(); it != map.end(); ++it)
2501         markDOMObjectWrapper(markStack, globalData, it->second);
2502 }
2503
2504 void Node::markCachedNodeListsSlow(JSC::MarkStack& markStack, JSC::JSGlobalData& globalData)
2505 {
2506     NodeListsNodeData* nodeLists = rareData()->nodeLists();
2507     if (!nodeLists)
2508         return;
2509
2510     markNodeLists(nodeLists->m_classNodeListCache, markStack, globalData);
2511     markNodeLists(nodeLists->m_nameNodeListCache, markStack, globalData);
2512     markNodeLists(nodeLists->m_tagNodeListCache, markStack, globalData);
2513 }
2514
2515 #endif
2516
2517 void Node::handleLocalEvents(Event* event)
2518 {
2519     if (!hasRareData() || !rareData()->eventTargetData())
2520         return;
2521
2522     if (disabled() && event->isMouseEvent())
2523         return;
2524
2525     fireEventListeners(event);
2526 }
2527
2528 #if ENABLE(SVG)
2529 static inline SVGElementInstance* eventTargetAsSVGElementInstance(Node* referenceNode)
2530 {
2531     ASSERT(referenceNode);
2532     if (!referenceNode->isSVGElement())
2533         return 0;
2534
2535     // Spec: The event handling for the non-exposed tree works as if the referenced element had been textually included
2536     // as a deeply cloned child of the 'use' element, except that events are dispatched to the SVGElementInstance objects
2537     for (Node* n = referenceNode; n; n = n->parentNode()) {
2538         if (!n->isShadowNode() || !n->isSVGElement())
2539             continue;
2540
2541         ContainerNode* shadowTreeParentElement = n->shadowParentNode();
2542         ASSERT(shadowTreeParentElement->hasTagName(SVGNames::useTag));
2543
2544         if (SVGElementInstance* instance = static_cast<SVGUseElement*>(shadowTreeParentElement)->instanceForShadowTreeElement(referenceNode))
2545             return instance;
2546     }
2547
2548     return 0;
2549 }
2550 #endif
2551
2552 static inline EventTarget* eventTargetRespectingSVGTargetRules(Node* referenceNode)
2553 {
2554     ASSERT(referenceNode);
2555
2556 #if ENABLE(SVG)
2557     if (SVGElementInstance* instance = eventTargetAsSVGElementInstance(referenceNode)) {
2558         ASSERT(instance->shadowTreeElement() == referenceNode);
2559         return instance;
2560     }
2561 #endif
2562
2563     return referenceNode;
2564 }
2565
2566 void Node::eventAncestors(Vector<RefPtr<ContainerNode> > &ancestors)
2567 {
2568     if (inDocument()) {
2569         for (ContainerNode* ancestor = eventParentNode(); ancestor; ancestor = ancestor->eventParentNode()) {
2570 #if ENABLE(SVG)
2571             // Skip <use> shadow tree elements.
2572             if (ancestor->isSVGElement() && ancestor->isShadowNode())
2573                 continue;
2574 #endif
2575             ancestors.append(ancestor);
2576         }
2577     }
2578 }
2579
2580 bool Node::dispatchEvent(PassRefPtr<Event> prpEvent)
2581 {
2582     RefPtr<EventTarget> protect = this;
2583     RefPtr<Event> event = prpEvent;
2584
2585     event->setTarget(eventTargetRespectingSVGTargetRules(this));
2586
2587     RefPtr<FrameView> view = document()->view();
2588     return dispatchGenericEvent(event.release());
2589 }
2590
2591 bool Node::dispatchGenericEvent(PassRefPtr<Event> prpEvent)
2592 {
2593     RefPtr<Event> event(prpEvent);
2594
2595     ASSERT(!eventDispatchForbidden());
2596     ASSERT(event->target());
2597     ASSERT(!event->type().isNull()); // JavaScript code can create an event with an empty name, but not null.
2598
2599     // Make a vector of ancestors to send the event to.
2600     // If the node is not in a document just send the event to it.
2601     // Be sure to ref all of nodes since event handlers could result in the last reference going away.
2602     RefPtr<Node> thisNode(this);
2603     Vector<RefPtr<ContainerNode> > ancestors;
2604     eventAncestors(ancestors);
2605
2606     // Set up a pointer to indicate whether / where to dispatch window events.
2607     // We don't dispatch load events to the window. That quirk was originally
2608     // added because Mozilla doesn't propagate load events to the window object.
2609     DOMWindow* targetForWindowEvents = 0;
2610     if (event->type() != eventNames().loadEvent) {
2611         Node* topLevelContainer = ancestors.isEmpty() ? this : ancestors.last().get();
2612         if (topLevelContainer->isDocumentNode())
2613             targetForWindowEvents = static_cast<Document*>(topLevelContainer)->domWindow();
2614     }
2615
2616     InspectorInstrumentationCookie cookie = InspectorInstrumentation::willDispatchEvent(document(), *event, targetForWindowEvents, this, ancestors);
2617
2618     // Give the target node a chance to do some work before DOM event handlers get a crack.
2619     void* data = preDispatchEventHandler(event.get());
2620     if (event->propagationStopped())
2621         goto doneDispatching;
2622
2623     // Trigger capturing event handlers, starting at the top and working our way down.
2624     event->setEventPhase(Event::CAPTURING_PHASE);
2625
2626     if (targetForWindowEvents) {
2627         event->setCurrentTarget(targetForWindowEvents);
2628         targetForWindowEvents->fireEventListeners(event.get());
2629         if (event->propagationStopped())
2630             goto doneDispatching;
2631     }
2632     for (size_t i = ancestors.size(); i; --i) {
2633         ContainerNode* ancestor = ancestors[i - 1].get();
2634         event->setCurrentTarget(eventTargetRespectingSVGTargetRules(ancestor));
2635         ancestor->handleLocalEvents(event.get());
2636         if (event->propagationStopped())
2637             goto doneDispatching;
2638     }
2639
2640     event->setEventPhase(Event::AT_TARGET);
2641
2642     event->setCurrentTarget(eventTargetRespectingSVGTargetRules(this));
2643     handleLocalEvents(event.get());
2644     if (event->propagationStopped())
2645         goto doneDispatching;
2646
2647     if (event->bubbles() && !event->cancelBubble()) {
2648         // Trigger bubbling event handlers, starting at the bottom and working our way up.
2649         event->setEventPhase(Event::BUBBLING_PHASE);
2650
2651         size_t size = ancestors.size();
2652         for (size_t i = 0; i < size; ++i) {
2653             ContainerNode* ancestor = ancestors[i].get();
2654             event->setCurrentTarget(eventTargetRespectingSVGTargetRules(ancestor));
2655             ancestor->handleLocalEvents(event.get());
2656             if (event->propagationStopped() || event->cancelBubble())
2657                 goto doneDispatching;
2658         }
2659         if (targetForWindowEvents) {
2660             event->setCurrentTarget(targetForWindowEvents);
2661             targetForWindowEvents->fireEventListeners(event.get());
2662             if (event->propagationStopped() || event->cancelBubble())
2663                 goto doneDispatching;
2664         }
2665     }
2666
2667 doneDispatching:
2668     event->setCurrentTarget(0);
2669     event->setEventPhase(0);
2670
2671     // Pass the data from the preDispatchEventHandler to the postDispatchEventHandler.
2672     postDispatchEventHandler(event.get(), data);
2673
2674     // Call default event handlers. While the DOM does have a concept of preventing
2675     // default handling, the detail of which handlers are called is an internal
2676     // implementation detail and not part of the DOM.
2677     if (!event->defaultPrevented() && !event->defaultHandled()) {
2678         // Non-bubbling events call only one default event handler, the one for the target.
2679         defaultEventHandler(event.get());
2680         ASSERT(!event->defaultPrevented());
2681         if (event->defaultHandled())
2682             goto doneWithDefault;
2683         // For bubbling events, call default event handlers on the same targets in the
2684         // same order as the bubbling phase.
2685         if (event->bubbles()) {
2686             size_t size = ancestors.size();
2687             for (size_t i = 0; i < size; ++i) {
2688                 ContainerNode* ancestor = ancestors[i].get();
2689                 ancestor->defaultEventHandler(event.get());
2690                 ASSERT(!event->defaultPrevented());
2691                 if (event->defaultHandled())
2692                     goto doneWithDefault;
2693             }
2694         }
2695     }
2696
2697 doneWithDefault:
2698
2699     InspectorInstrumentation::didDispatchEvent(cookie);
2700
2701     return !event->defaultPrevented();
2702 }
2703
2704 void Node::dispatchSubtreeModifiedEvent()
2705 {
2706     ASSERT(!eventDispatchForbidden());
2707     
2708     document()->incDOMTreeVersion();
2709
2710     notifyNodeListsAttributeChanged(); // FIXME: Can do better some day. Really only care about the name attribute changing.
2711     
2712     if (!document()->hasListenerType(Document::DOMSUBTREEMODIFIED_LISTENER))
2713         return;
2714
2715     dispatchEvent(MutationEvent::create(eventNames().DOMSubtreeModifiedEvent, true));
2716 }
2717
2718 void Node::dispatchUIEvent(const AtomicString& eventType, int detail, PassRefPtr<Event> underlyingEvent)
2719 {
2720     ASSERT(!eventDispatchForbidden());
2721     ASSERT(eventType == eventNames().focusinEvent || eventType == eventNames().focusoutEvent || 
2722            eventType == eventNames().DOMFocusInEvent || eventType == eventNames().DOMFocusOutEvent || eventType == eventNames().DOMActivateEvent);
2723     
2724     bool cancelable = eventType == eventNames().DOMActivateEvent;
2725     
2726     RefPtr<UIEvent> event = UIEvent::create(eventType, true, cancelable, document()->defaultView(), detail);
2727     event->setUnderlyingEvent(underlyingEvent);
2728     dispatchEvent(event.release());
2729 }
2730
2731 bool Node::dispatchKeyEvent(const PlatformKeyboardEvent& key)
2732 {
2733     RefPtr<KeyboardEvent> keyboardEvent = KeyboardEvent::create(key, document()->defaultView());
2734     bool r = dispatchEvent(keyboardEvent);
2735     
2736     // we want to return false if default is prevented (already taken care of)
2737     // or if the element is default-handled by the DOM. Otherwise we let it just
2738     // let it get handled by AppKit 
2739     if (keyboardEvent->defaultHandled())
2740         r = false;
2741     
2742     return r;
2743 }
2744
2745 bool Node::dispatchMouseEvent(const PlatformMouseEvent& event, const AtomicString& eventType,
2746     int detail, Node* relatedTarget)
2747 {
2748     ASSERT(!eventDispatchForbidden());
2749     
2750     IntPoint contentsPos;
2751     if (FrameView* view = document()->view())
2752         contentsPos = view->windowToContents(event.pos());
2753
2754     short button = event.button();
2755
2756     ASSERT(event.eventType() == MouseEventMoved || button != NoButton);
2757     
2758     return dispatchMouseEvent(eventType, button, detail,
2759         contentsPos.x(), contentsPos.y(), event.globalX(), event.globalY(),
2760         event.ctrlKey(), event.altKey(), event.shiftKey(), event.metaKey(),
2761         false, relatedTarget, 0);
2762 }
2763
2764 void Node::dispatchSimulatedMouseEvent(const AtomicString& eventType,
2765     PassRefPtr<Event> underlyingEvent)
2766 {
2767     ASSERT(!eventDispatchForbidden());
2768
2769     bool ctrlKey = false;
2770     bool altKey = false;
2771     bool shiftKey = false;
2772     bool metaKey = false;
2773     if (UIEventWithKeyState* keyStateEvent = findEventWithKeyState(underlyingEvent.get())) {
2774         ctrlKey = keyStateEvent->ctrlKey();
2775         altKey = keyStateEvent->altKey();
2776         shiftKey = keyStateEvent->shiftKey();
2777         metaKey = keyStateEvent->metaKey();
2778     }
2779
2780     // Like Gecko, we just pass 0 for everything when we make a fake mouse event.
2781     // Internet Explorer instead gives the current mouse position and state.
2782     dispatchMouseEvent(eventType, 0, 0, 0, 0, 0, 0,
2783         ctrlKey, altKey, shiftKey, metaKey, true, 0, underlyingEvent);
2784 }
2785
2786 void Node::dispatchSimulatedClick(PassRefPtr<Event> event, bool sendMouseEvents, bool showPressedLook)
2787 {
2788     if (!gNodesDispatchingSimulatedClicks)
2789         gNodesDispatchingSimulatedClicks = new HashSet<Node*>;
2790     else if (gNodesDispatchingSimulatedClicks->contains(this))
2791         return;
2792     
2793     gNodesDispatchingSimulatedClicks->add(this);
2794     
2795     // send mousedown and mouseup before the click, if requested
2796     if (sendMouseEvents)
2797         dispatchSimulatedMouseEvent(eventNames().mousedownEvent, event.get());
2798     setActive(true, showPressedLook);
2799     if (sendMouseEvents)
2800         dispatchSimulatedMouseEvent(eventNames().mouseupEvent, event.get());
2801     setActive(false);
2802
2803     // always send click
2804     dispatchSimulatedMouseEvent(eventNames().clickEvent, event);
2805     
2806     gNodesDispatchingSimulatedClicks->remove(this);
2807 }
2808
2809 bool Node::dispatchMouseEvent(const AtomicString& eventType, int button, int detail,
2810     int pageX, int pageY, int screenX, int screenY,
2811     bool ctrlKey, bool altKey, bool shiftKey, bool metaKey, 
2812     bool isSimulated, Node* relatedTargetArg, PassRefPtr<Event> underlyingEvent)
2813 {
2814     ASSERT(!eventDispatchForbidden());
2815     if (disabled()) // Don't even send DOM events for disabled controls..
2816         return true;
2817     
2818     if (eventType.isEmpty())
2819         return false; // Shouldn't happen.
2820     
2821     // Dispatching the first event can easily result in this node being destroyed.
2822     // Since we dispatch up to three events here, we need to make sure we're referenced
2823     // so the pointer will be good for the two subsequent ones.
2824     RefPtr<Node> protect(this);
2825     
2826     bool cancelable = eventType != eventNames().mousemoveEvent;
2827     
2828     bool swallowEvent = false;
2829     
2830     // Attempting to dispatch with a non-EventTarget relatedTarget causes the relatedTarget to be silently ignored.
2831     RefPtr<Node> relatedTarget = relatedTargetArg;
2832
2833     int adjustedPageX = pageX;
2834     int adjustedPageY = pageY;
2835     if (Frame* frame = document()->frame()) {
2836         float pageZoom = frame->pageZoomFactor();
2837         if (pageZoom != 1.0f) {
2838             // Adjust our pageX and pageY to account for the page zoom.
2839             adjustedPageX = lroundf(pageX / pageZoom);
2840             adjustedPageY = lroundf(pageY / pageZoom);
2841         }
2842     }
2843
2844     RefPtr<MouseEvent> mouseEvent = MouseEvent::create(eventType,
2845         true, cancelable, document()->defaultView(),
2846         detail, screenX, screenY, adjustedPageX, adjustedPageY,
2847         ctrlKey, altKey, shiftKey, metaKey, button,
2848         relatedTarget, 0, isSimulated);
2849     mouseEvent->setUnderlyingEvent(underlyingEvent.get());
2850     mouseEvent->setAbsoluteLocation(IntPoint(pageX, pageY));
2851     
2852     dispatchEvent(mouseEvent);
2853     bool defaultHandled = mouseEvent->defaultHandled();
2854     bool defaultPrevented = mouseEvent->defaultPrevented();
2855     if (defaultHandled || defaultPrevented)
2856         swallowEvent = true;
2857     
2858     // Special case: If it's a double click event, we also send the dblclick event. This is not part
2859     // of the DOM specs, but is used for compatibility with the ondblclick="" attribute.  This is treated
2860     // as a separate event in other DOM-compliant browsers like Firefox, and so we do the same.
2861     if (eventType == eventNames().clickEvent && detail == 2) {
2862         RefPtr<Event> doubleClickEvent = MouseEvent::create(eventNames().dblclickEvent,
2863             true, cancelable, document()->defaultView(),
2864             detail, screenX, screenY, adjustedPageX, adjustedPageY,
2865             ctrlKey, altKey, shiftKey, metaKey, button,
2866             relatedTarget, 0, isSimulated);
2867         doubleClickEvent->setUnderlyingEvent(underlyingEvent.get());
2868         if (defaultHandled)
2869             doubleClickEvent->setDefaultHandled();
2870         dispatchEvent(doubleClickEvent);
2871         if (doubleClickEvent->defaultHandled() || doubleClickEvent->defaultPrevented())
2872             swallowEvent = true;
2873     }
2874
2875     return swallowEvent;
2876 }
2877
2878 void Node::dispatchWheelEvent(PlatformWheelEvent& e)
2879 {
2880     ASSERT(!eventDispatchForbidden());
2881     if (e.deltaX() == 0 && e.deltaY() == 0)
2882         return;
2883     
2884     FrameView* view = document()->view();
2885     if (!view)
2886         return;
2887     
2888     IntPoint pos = view->windowToContents(e.pos());
2889
2890     int adjustedPageX = pos.x();
2891     int adjustedPageY = pos.y();
2892     if (Frame* frame = document()->frame()) {
2893         float pageZoom = frame->pageZoomFactor();
2894         if (pageZoom != 1.0f) {
2895             // Adjust our pageX and pageY to account for the page zoom.
2896             adjustedPageX = lroundf(pos.x() / pageZoom);
2897             adjustedPageY = lroundf(pos.y() / pageZoom);
2898         }
2899     }
2900     
2901     WheelEvent::Granularity granularity;
2902     switch (e.granularity()) {
2903     case ScrollByPageWheelEvent:
2904         granularity = WheelEvent::Page;
2905         break;
2906     case ScrollByPixelWheelEvent:
2907     default:
2908         granularity = WheelEvent::Pixel;
2909         break;
2910     }
2911     
2912     RefPtr<WheelEvent> we = WheelEvent::create(e.wheelTicksX(), e.wheelTicksY(), e.deltaX(), e.deltaY(), granularity,
2913         document()->defaultView(), e.globalX(), e.globalY(), adjustedPageX, adjustedPageY,
2914         e.ctrlKey(), e.altKey(), e.shiftKey(), e.metaKey());
2915
2916     we->setAbsoluteLocation(IntPoint(pos.x(), pos.y()));
2917
2918     if (!dispatchEvent(we) || we->defaultHandled())
2919         e.accept();
2920
2921     we.release();
2922 }
2923
2924 void Node::dispatchFocusEvent()
2925 {
2926     dispatchEvent(Event::create(eventNames().focusEvent, false, false));
2927 }
2928
2929 void Node::dispatchBlurEvent()
2930 {
2931     dispatchEvent(Event::create(eventNames().blurEvent, false, false));
2932 }
2933
2934 bool Node::disabled() const
2935 {
2936     return false;
2937 }
2938
2939 void Node::defaultEventHandler(Event* event)
2940 {
2941     if (event->target() != this)
2942         return;
2943     const AtomicString& eventType = event->type();
2944     if (eventType == eventNames().keydownEvent || eventType == eventNames().keypressEvent) {
2945         if (event->isKeyboardEvent())
2946             if (Frame* frame = document()->frame())
2947                 frame->eventHandler()->defaultKeyboardEventHandler(static_cast<KeyboardEvent*>(event));
2948     } else if (eventType == eventNames().clickEvent) {
2949         int detail = event->isUIEvent() ? static_cast<UIEvent*>(event)->detail() : 0;
2950         dispatchUIEvent(eventNames().DOMActivateEvent, detail, event);
2951 #if ENABLE(CONTEXT_MENUS)
2952     } else if (eventType == eventNames().contextmenuEvent) {
2953         if (Frame* frame = document()->frame())
2954             if (Page* page = frame->page())
2955                 page->contextMenuController()->handleContextMenuEvent(event);
2956 #endif
2957     } else if (eventType == eventNames().textInputEvent) {
2958         if (event->isTextEvent())
2959             if (Frame* frame = document()->frame())
2960                 frame->eventHandler()->defaultTextInputEventHandler(static_cast<TextEvent*>(event));
2961 #if ENABLE(PAN_SCROLLING)
2962     } else if (eventType == eventNames().mousedownEvent) {
2963         MouseEvent* mouseEvent = static_cast<MouseEvent*>(event);
2964         if (mouseEvent->button() == MiddleButton) {
2965             if (enclosingLinkEventParentOrSelf())
2966                 return;
2967
2968             RenderObject* renderer = this->renderer();
2969             while (renderer && (!renderer->isBox() || !toRenderBox(renderer)->canBeScrolledAndHasScrollableArea()))
2970                 renderer = renderer->parent();
2971
2972             if (renderer) {
2973                 if (Frame* frame = document()->frame())
2974                     frame->eventHandler()->startPanScrolling(renderer);
2975             }
2976         }
2977 #endif
2978     } else if (eventType == eventNames().mousewheelEvent && event->isWheelEvent()) {
2979         WheelEvent* wheelEvent = static_cast<WheelEvent*>(event);
2980         
2981         // If we don't have a renderer, send the wheel event to the first node we find with a renderer.
2982         // This is needed for <option> and <optgroup> elements so that <select>s get a wheel scroll.
2983         Node* startNode = this;
2984         while (startNode && !startNode->renderer())
2985             startNode = startNode->parent();
2986         
2987         if (startNode && startNode->renderer())
2988             if (Frame* frame = document()->frame())
2989                 frame->eventHandler()->defaultWheelEventHandler(startNode, wheelEvent);
2990     } else if (event->type() == eventNames().webkitEditableContentChangedEvent) {
2991         dispatchEvent(Event::create(eventNames().inputEvent, true, false));
2992     }
2993 }
2994
2995 } // namespace WebCore
2996
2997 #ifndef NDEBUG
2998
2999 void showTree(const WebCore::Node* node)
3000 {
3001     if (node)
3002         node->showTreeForThis();
3003 }
3004
3005 #endif