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