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