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