d2f61c077586de0286190d27bddf45000d40e619
[WebKit-https.git] / WebCore / dom / Document.cpp
1 /**
2  * This file is part of the DOM implementation for KDE.
3  *
4  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
5  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
6  *           (C) 2001 Dirk Mueller (mueller@kde.org)
7  * Copyright (C) 2004, 2005, 2006 Apple Computer, Inc.
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., 59 Temple Place - Suite 330,
22  * Boston, MA 02111-1307, USA.
23  */
24
25 #include "config.h"
26 #include "Document.h"
27
28 #include "AXObjectCache.h"
29 #include "CDATASection.h"
30 #include "CSSStyleSheet.h"
31 #include "CSSValueKeywords.h"
32 #include "Comment.h"
33 #include "DOMImplementation.h"
34 #include "Decoder.h"
35 #include "DocLoader.h"
36 #include "DocumentFragment.h"
37 #include "DocumentType.h"
38 #include "EditingText.h"
39 #include "EntityReference.h"
40 #include "Event.h"
41 #include "EventListener.h"
42 #include "EventNames.h"
43 #include "ExceptionCode.h"
44 #include "Frame.h"
45 #include "FrameTree.h"
46 #include "HTMLBodyElement.h"
47 #include "HTMLDocument.h"
48 #include "HTMLElementFactory.h"
49 #include "HTMLImageLoader.h"
50 #include "HTMLInputElement.h"
51 #include "HTMLLinkElement.h"
52 #include "HTMLMapElement.h"
53 #include "HTMLNameCollection.h"
54 #include "HTMLNames.h"
55 #include "HTMLStyleElement.h"
56 #include "JSEditor.h"
57 #include "KeyboardEvent.h"
58 #include "Logging.h"
59 #include "MouseEvent.h"
60 #include "MouseEventWithHitTestResults.h"
61 #include "MutationEvent.h"
62 #include "NameNodeList.h"
63 #include "NodeFilter.h"
64 #include "NodeIterator.h"
65 #include "PlatformKeyboardEvent.h"
66 #include "ProcessingInstruction.h"
67 #include "RegisteredEventListener.h"
68 #include "RegularExpression.h"
69 #include "RenderArena.h"
70 #include "RenderView.h"
71 #include "RenderWidget.h"
72 #include "SegmentedString.h"
73 #include "SelectionController.h"
74 #include "StringHash.h"
75 #include "StyleSheetList.h"
76 #include "SystemTime.h"
77 #include "TextIterator.h"
78 #include "TreeWalker.h"
79 #include "UIEvent.h"
80 #include "csshelper.h"
81 #include "cssstyleselector.h"
82 #include "kjs_binding.h"
83 #include "kjs_proxy.h"
84 #include "XMLTokenizer.h"
85 #include "xmlhttprequest.h"
86
87 #ifdef XPATH_SUPPORT
88 #include "XPathEvaluator.h"
89 #include "XPathExpression.h"
90 #include "XPathNSResolver.h"
91 #include "XPathResult.h"
92 #endif
93
94 #ifdef XSLT_SUPPORT
95 #include "XSLTProcessor.h"
96 #endif
97
98 #ifdef XBL_SUPPORT
99 #include "XBLBindingManager.h"
100 #endif
101
102 #ifdef SVG_SUPPORT
103 #include "SVGDocumentExtensions.h"
104 #include "SVGElementFactory.h"
105 #include "SVGZoomEvent.h"
106 #include "SVGStyleElement.h"
107 #include "KSVGTimeScheduler.h"
108 #endif
109
110 using namespace std;
111
112 namespace WebCore {
113
114 using namespace EventNames;
115 using namespace HTMLNames;
116
117 // #define INSTRUMENT_LAYOUT_SCHEDULING 1
118
119 // This amount of time must have elapsed before we will even consider scheduling a layout without a delay.
120 // FIXME: For faster machines this value can really be lowered to 200.  250 is adequate, but a little high
121 // for dual G5s. :)
122 const int cLayoutScheduleThreshold = 250;
123
124 // Use 1 to represent the document's default form.
125 HTMLFormElement* const defaultForm = (HTMLFormElement*) 1;
126
127 // Golden ratio - arbitrary start value to avoid mapping all 0's to all 0's
128 static const unsigned PHI = 0x9e3779b9U;
129
130 // DOM Level 2 says (letters added):
131 //
132 // a) Name start characters must have one of the categories Ll, Lu, Lo, Lt, Nl.
133 // b) Name characters other than Name-start characters must have one of the categories Mc, Me, Mn, Lm, or Nd.
134 // c) Characters in the compatibility area (i.e. with character code greater than #xF900 and less than #xFFFE) are not allowed in XML names.
135 // d) Characters which have a font or compatibility decomposition (i.e. those with a "compatibility formatting tag" in field 5 of the database -- marked by field 5 beginning with a "<") are not allowed.
136 // e) The following characters are treated as name-start characters rather than name characters, because the property file classifies them as Alphabetic: [#x02BB-#x02C1], #x0559, #x06E5, #x06E6.
137 // f) Characters #x20DD-#x20E0 are excluded (in accordance with Unicode, section 5.14).
138 // g) Character #x00B7 is classified as an extender, because the property list so identifies it.
139 // h) Character #x0387 is added as a name character, because #x00B7 is its canonical equivalent.
140 // i) Characters ':' and '_' are allowed as name-start characters.
141 // j) Characters '-' and '.' are allowed as name characters.
142 //
143 // It also contains complete tables. If we decide it's better, we could include those instead of the following code.
144
145 static inline bool isValidNameStart(UChar32 c)
146 {
147     // rule (e) above
148     if ((c >= 0x02BB && c <= 0x02C1) || c == 0x559 || c == 0x6E5 || c == 0x6E6)
149         return true;
150
151     // rule (i) above
152     if (c == ':' || c == '_')
153         return true;
154
155     // rules (a) and (f) above
156     const uint32_t nameStartMask = U_GC_LL_MASK | U_GC_LU_MASK | U_GC_LO_MASK | U_GC_LT_MASK | U_GC_NL_MASK;
157     if (!(U_GET_GC_MASK(c) & nameStartMask))
158         return false;
159
160     // rule (c) above
161     if (c >= 0xF900 && c < 0xFFFE)
162         return false;
163
164     // rule (d) above
165     UDecompositionType decompType = static_cast<UDecompositionType>(u_getIntPropertyValue(c, UCHAR_DECOMPOSITION_TYPE));
166     if (decompType == U_DT_FONT || decompType == U_DT_COMPAT)
167         return false;
168
169     return true;
170 }
171
172 static inline bool isValidNamePart(UChar32 c)
173 {
174     // rules (a), (e), and (i) above
175     if (isValidNameStart(c))
176         return true;
177
178     // rules (g) and (h) above
179     if (c == 0x00B7 || c == 0x0387)
180         return true;
181
182     // rule (j) above
183     if (c == '-' || c == '.')
184         return true;
185
186     // rules (b) and (f) above
187     const uint32_t otherNamePartMask = U_GC_MC_MASK | U_GC_ME_MASK | U_GC_MN_MASK | U_GC_LM_MASK | U_GC_ND_MASK;
188     if (!(U_GET_GC_MASK(c) & otherNamePartMask))
189         return false;
190
191     // rule (c) above
192     if (c >= 0xF900 && c < 0xFFFE)
193         return false;
194
195     // rule (d) above
196     UDecompositionType decompType = static_cast<UDecompositionType>(u_getIntPropertyValue(c, UCHAR_DECOMPOSITION_TYPE));
197     if (decompType == U_DT_FONT || decompType == U_DT_COMPAT)
198         return false;
199
200     return true;
201 }
202
203 DeprecatedPtrList<Document> * Document::changedDocuments = 0;
204
205 // FrameView might be 0
206 Document::Document(DOMImplementation* impl, FrameView *v)
207     : ContainerNode(0)
208     , m_implementation(impl)
209     , m_domtree_version(0)
210     , m_styleSheets(new StyleSheetList)
211     , m_title("")
212     , m_titleSetExplicitly(false)
213     , m_imageLoadEventTimer(this, &Document::imageLoadEventTimerFired)
214 #ifdef XBL_SUPPORT
215     , m_bindingManager(new XBLBindingManager(this))
216 #endif
217 #ifdef XSLT_SUPPORT
218     , m_transformSource(0)
219 #endif
220     , m_savedRenderer(0)
221     , m_passwordFields(0)
222     , m_secureForms(0)
223     , m_designMode(inherit)
224     , m_selfOnlyRefCount(0)
225 #ifdef SVG_SUPPORT
226     , m_svgExtensions(0)
227 #endif
228 #if __APPLE__
229     , m_hasDashboardRegions(false)
230     , m_dashboardRegionsDirty(false)
231 #endif
232     , m_accessKeyMapValid(false)
233     , m_createRenderers(true)
234     , m_inPageCache(false)
235 {
236     m_document.resetSkippingRef(this);
237
238     m_printing = false;
239
240     m_view = v;
241     m_renderArena = 0;
242
243     m_axObjectCache = 0;
244     
245     m_docLoader = new DocLoader(v ? v->frame() : 0, this);
246
247     visuallyOrdered = false;
248     m_loadingSheet = false;
249     m_bParsing = false;
250     m_docChanged = false;
251     m_tokenizer = 0;
252
253     pMode = Strict;
254     hMode = XHtml;
255     m_textColor = Color::black;
256     m_listenerTypes = 0;
257     m_inDocument = true;
258     m_styleSelectorDirty = false;
259     m_inStyleRecalc = false;
260     m_closeAfterStyleRecalc = false;
261     m_usesDescendantRules = false;
262     m_usesSiblingRules = false;
263
264     m_styleSelector = new CSSStyleSelector(this, m_usersheet, m_styleSheets.get(), !inCompatMode());
265     m_pendingStylesheets = 0;
266     m_ignorePendingStylesheets = false;
267     m_pendingSheetLayout = NoLayoutWithPendingSheets;
268
269     m_cssTarget = 0;
270
271     resetLinkColor();
272     resetVisitedLinkColor();
273     resetActiveLinkColor();
274
275     m_processingLoadEvent = false;
276     m_startTime = currentTime();
277     m_overMinimumLayoutThreshold = false;
278     
279     m_jsEditor = 0;
280
281     static int docID = 0;
282     m_docID = docID++;
283 }
284
285 void Document::removedLastRef()
286 {
287     if (m_selfOnlyRefCount) {
288         // if removing a child removes the last self-only ref, we don't
289         // want the document to be destructed until after
290         // removeAllChildren returns, so we guard ourselves with an
291         // extra self-only ref
292
293         DocPtr<Document> guard(this);
294
295         // we must make sure not to be retaining any of our children through
296         // these extra pointers or we will create a reference cycle
297         m_docType = 0;
298         m_focusNode = 0;
299         m_hoverNode = 0;
300         m_activeNode = 0;
301         m_titleElement = 0;
302         m_documentElement = 0;
303
304         removeAllChildren();
305
306         deleteAllValues(m_markers);
307         m_markers.clear();
308
309         delete m_tokenizer;
310         m_tokenizer = 0;
311     } else
312         delete this;
313 }
314
315 Document::~Document()
316 {
317     assert(!renderer());
318     assert(!m_inPageCache);
319     assert(m_savedRenderer == 0);
320
321 #ifdef SVG_SUPPORT
322     delete m_svgExtensions;
323 #endif
324
325     XMLHttpRequest::detachRequests(this);
326     KJS::ScriptInterpreter::forgetAllDOMNodesForDocument(this);
327
328     if (m_docChanged && changedDocuments)
329         changedDocuments->remove(this);
330     delete m_tokenizer;
331     m_document.resetSkippingRef(0);
332     delete m_styleSelector;
333     delete m_docLoader;
334     
335     if (m_renderArena) {
336         delete m_renderArena;
337         m_renderArena = 0;
338     }
339
340 #ifdef XSLT_SUPPORT
341     xmlFreeDoc((xmlDocPtr)m_transformSource);
342 #endif
343
344 #ifdef XBL_SUPPORT
345     delete m_bindingManager;
346 #endif
347
348     deleteAllValues(m_markers);
349
350     if (m_axObjectCache) {
351         delete m_axObjectCache;
352         m_axObjectCache = 0;
353     }
354     m_decoder = 0;
355     
356     if (m_jsEditor) {
357         delete m_jsEditor;
358         m_jsEditor = 0;
359     }
360     
361     deleteAllValues(m_selectedRadioButtons);
362 }
363
364 void Document::resetLinkColor()
365 {
366     m_linkColor = Color(0, 0, 238);
367 }
368
369 void Document::resetVisitedLinkColor()
370 {
371     m_visitedLinkColor = Color(85, 26, 139);    
372 }
373
374 void Document::resetActiveLinkColor()
375 {
376     m_activeLinkColor.setNamedColor("red");
377 }
378
379 void Document::setDocType(PassRefPtr<DocumentType> docType)
380 {
381     m_docType = docType;
382 }
383
384 DocumentType *Document::doctype() const
385 {
386     return m_docType.get();
387 }
388
389 DOMImplementation* Document::implementation() const
390 {
391     return m_implementation.get();
392 }
393
394 void Document::childrenChanged()
395 {
396     // invalidate the document element we have cached in case it was replaced
397     m_documentElement = 0;
398 }
399
400 Element* Document::documentElement() const
401 {
402     if (!m_documentElement) {
403         Node* n = firstChild();
404         while (n && !n->isElementNode())
405             n = n->nextSibling();
406         m_documentElement = static_cast<Element*>(n);
407     }
408
409     return m_documentElement.get();
410 }
411
412 PassRefPtr<Element> Document::createElement(const String &name, ExceptionCode& ec)
413 {
414     return createElementNS(nullAtom, name, ec);
415 }
416
417 PassRefPtr<DocumentFragment> Document::createDocumentFragment()
418 {
419     return new DocumentFragment(document());
420 }
421
422 PassRefPtr<Text> Document::createTextNode(const String &data)
423 {
424     return new Text(this, data);
425 }
426
427 PassRefPtr<Comment> Document::createComment (const String &data)
428 {
429     return new Comment(this, data);
430 }
431
432 PassRefPtr<CDATASection> Document::createCDATASection(const String &data, ExceptionCode& ec)
433 {
434     if (isHTMLDocument()) {
435         ec = NOT_SUPPORTED_ERR;
436         return 0;
437     }
438     return new CDATASection(this, data);
439 }
440
441 PassRefPtr<ProcessingInstruction> Document::createProcessingInstruction(const String &target, const String &data, ExceptionCode& ec)
442 {
443     if (!isValidName(target)) {
444         ec = INVALID_CHARACTER_ERR;
445         return 0;
446     }
447     if (isHTMLDocument()) {
448         ec = NOT_SUPPORTED_ERR;
449         return 0;
450     }
451     return new ProcessingInstruction(this, target, data);
452 }
453
454 PassRefPtr<EntityReference> Document::createEntityReference(const String &name, ExceptionCode& ec)
455 {
456     if (!isValidName(name)) {
457         ec = INVALID_CHARACTER_ERR;
458         return 0;
459     }
460     if (isHTMLDocument()) {
461         ec = NOT_SUPPORTED_ERR;
462         return 0;
463     }
464     return new EntityReference(this, name.impl());
465 }
466
467 PassRefPtr<EditingText> Document::createEditingTextNode(const String &text)
468 {
469     return new EditingText(this, text);
470 }
471
472 PassRefPtr<CSSStyleDeclaration> Document::createCSSStyleDeclaration()
473 {
474     return new CSSMutableStyleDeclaration;
475 }
476
477 PassRefPtr<Node> Document::importNode(Node* importedNode, bool deep, ExceptionCode& ec)
478 {
479     ec = 0;
480     
481     if (!importedNode) {
482         ec = NOT_SUPPORTED_ERR;
483         return 0;
484     }
485
486     switch (importedNode->nodeType()) {
487         case TEXT_NODE:
488             return createTextNode(importedNode->nodeValue());
489         case CDATA_SECTION_NODE:
490             return createCDATASection(importedNode->nodeValue(), ec);
491         case ENTITY_REFERENCE_NODE:
492             return createEntityReference(importedNode->nodeName(), ec);
493         case PROCESSING_INSTRUCTION_NODE:
494             return createProcessingInstruction(importedNode->nodeName(), importedNode->nodeValue(), ec);
495         case COMMENT_NODE:
496             return createComment(importedNode->nodeValue());
497         case ELEMENT_NODE: {
498             Element *oldElement = static_cast<Element *>(importedNode);
499             RefPtr<Element> newElement = createElementNS(oldElement->namespaceURI(), oldElement->tagQName().toString(), ec);
500                         
501             if (ec != 0)
502                 return 0;
503
504             NamedAttrMap* attrs = oldElement->attributes(true);
505             if (attrs) {
506                 unsigned length = attrs->length();
507                 for (unsigned i = 0; i < length; i++) {
508                     Attribute* attr = attrs->attributeItem(i);
509                     newElement->setAttribute(attr->name(), attr->value().impl(), ec);
510                     if (ec != 0)
511                         return 0;
512                 }
513             }
514
515             newElement->copyNonAttributeProperties(oldElement);
516
517             if (deep) {
518                 for (Node* oldChild = oldElement->firstChild(); oldChild; oldChild = oldChild->nextSibling()) {
519                     RefPtr<Node> newChild = importNode(oldChild, true, ec);
520                     if (ec != 0)
521                         return 0;
522                     newElement->appendChild(newChild.release(), ec);
523                     if (ec != 0)
524                         return 0;
525                 }
526             }
527
528             return newElement.release();
529         }
530         case ATTRIBUTE_NODE:
531         case ENTITY_NODE:
532         case DOCUMENT_NODE:
533         case DOCUMENT_TYPE_NODE:
534         case DOCUMENT_FRAGMENT_NODE:
535         case NOTATION_NODE:
536         case XPATH_NAMESPACE_NODE:
537             break;
538     }
539
540     ec = NOT_SUPPORTED_ERR;
541     return 0;
542 }
543
544
545 PassRefPtr<Node> Document::adoptNode(PassRefPtr<Node> source, ExceptionCode& ec)
546 {
547     if (!source) {
548         ec = NOT_SUPPORTED_ERR;
549         return 0;
550     }
551     
552     switch (source->nodeType()) {
553         case ENTITY_NODE:
554         case NOTATION_NODE:
555         case DOCUMENT_NODE:
556         case DOCUMENT_TYPE_NODE:
557         case XPATH_NAMESPACE_NODE:
558             ec = NOT_SUPPORTED_ERR;
559             return 0;            
560         case ATTRIBUTE_NODE: {                   
561             Attr* attr = static_cast<Attr*>(source.get());
562             if (attr->ownerElement())
563                 attr->ownerElement()->removeAttributeNode(attr, ec);
564             attr->m_specified = true;
565             break;
566         }       
567         default:
568             if (source->parentNode())
569                 source->parentNode()->removeChild(source.get(), ec);
570     }
571                 
572     for (Node* node = source.get(); node; node = node->traverseNextNode(source.get())) {
573         KJS::ScriptInterpreter::updateDOMNodeDocument(node, node->document(), this);
574         node->setDocument(this);
575     }
576
577     return source;
578 }
579
580 PassRefPtr<Element> Document::createElementNS(const String &_namespaceURI, const String &qualifiedName, ExceptionCode& ec)
581 {
582     // FIXME: We'd like a faster code path that skips this check for calls from inside the engine where the name is known to be valid.
583     String prefix, localName;
584     if (!parseQualifiedName(qualifiedName, prefix, localName)) {
585         ec = INVALID_CHARACTER_ERR;
586         return 0;
587     }
588
589     RefPtr<Element> e;
590     QualifiedName qName = QualifiedName(AtomicString(prefix), AtomicString(localName), AtomicString(_namespaceURI));
591     
592     // FIXME: Use registered namespaces and look up in a hash to find the right factory.
593     if (_namespaceURI == xhtmlNamespaceURI) {
594         e = HTMLElementFactory::createHTMLElement(qName.localName(), this, 0, false);
595         if (e && !prefix.isNull()) {
596             e->setPrefix(qName.prefix(), ec);
597             if (ec)
598                 return 0;
599         }
600     }
601 #ifdef SVG_SUPPORT
602     else if (_namespaceURI == SVGNames::svgNamespaceURI)
603         e = SVGElementFactory::createSVGElement(qName, this, false);
604 #endif
605     
606     if (!e)
607         e = new Element(qName, document());
608     
609     return e.release();
610 }
611
612 Element *Document::getElementById(const AtomicString& elementId) const
613 {
614     if (elementId.length() == 0)
615         return 0;
616
617     Element *element = m_elementsById.get(elementId.impl());
618     if (element)
619         return element;
620         
621     if (m_duplicateIds.contains(elementId.impl())) {
622         for (Node *n = traverseNextNode(); n != 0; n = n->traverseNextNode()) {
623             if (n->isElementNode()) {
624                 element = static_cast<Element*>(n);
625                 if (element->hasID() && element->getAttribute(idAttr) == elementId) {
626                     m_duplicateIds.remove(elementId.impl());
627                     m_elementsById.set(elementId.impl(), element);
628                     return element;
629                 }
630             }
631         }
632     }
633     return 0;
634 }
635
636 String Document::readyState() const
637 {
638     if (Frame* f = frame()) {
639         if (f->isComplete()) 
640             return "complete";
641         if (parsing()) 
642             return "loading";
643       return "loaded";
644       // FIXME: What does "interactive" mean?
645       // FIXME: Missing support for "uninitialized".
646     }
647     return String();
648 }
649
650 String Document::inputEncoding() const
651 {
652     if (Decoder* d = decoder())
653         return d->encoding().name();
654     return String();
655 }
656
657 String Document::defaultCharset() const
658 {
659     if (Frame* f = frame())
660         return f->settings()->encoding();
661     return String();
662 }
663
664 void Document::setCharset(const String& charset)
665 {
666     if (!decoder())
667         return;
668     decoder()->setEncoding(charset, Decoder::UserChosenEncoding);
669 }
670
671 Element* Document::elementFromPoint(int x, int y) const
672 {
673     if (!renderer())
674         return 0;
675
676     RenderObject::NodeInfo nodeInfo(true, true);
677     renderer()->layer()->hitTest(nodeInfo, IntPoint(x, y)); 
678
679     Node* n = nodeInfo.innerNode();
680     while (n && !n->isElementNode())
681         n = n->parentNode();
682     if (n)
683         n = n->shadowAncestorNode();
684     return static_cast<Element*>(n);
685 }
686
687 void Document::addElementById(const AtomicString& elementId, Element* element)
688 {
689     if (!m_elementsById.contains(elementId.impl()))
690         m_elementsById.set(elementId.impl(), element);
691     else
692         m_duplicateIds.add(elementId.impl());
693 }
694
695 void Document::removeElementById(const AtomicString& elementId, Element* element)
696 {
697     if (m_elementsById.get(elementId.impl()) == element)
698         m_elementsById.remove(elementId.impl());
699     else
700         m_duplicateIds.remove(elementId.impl());
701 }
702
703 Element* Document::getElementByAccessKey(const String& key) const
704 {
705     if (key.isEmpty())
706         return 0;
707     if (!m_accessKeyMapValid) {
708         for (Node* n = firstChild(); n; n = n->traverseNextNode()) {
709             if (!n->isElementNode())
710                 continue;
711             Element* element = static_cast<Element*>(n);
712             const AtomicString& accessKey = element->getAttribute(accesskeyAttr);
713             if (!accessKey.isEmpty())
714                 m_elementsByAccessKey.set(accessKey.impl(), element);
715         }
716         m_accessKeyMapValid = true;
717     }
718     return m_elementsByAccessKey.get(key.impl());
719 }
720
721 void Document::updateTitle()
722 {
723     if (Frame* f = frame())
724         f->setTitle(m_title);
725 }
726
727 void Document::setTitle(const String& title, Node* titleElement)
728 {
729     if (!titleElement) {
730         // Title set by JavaScript -- overrides any title elements.
731         m_titleSetExplicitly = true;
732         m_titleElement = 0;
733     } else if (titleElement != m_titleElement) {
734         if (m_titleElement)
735             // Only allow the first title element to change the title -- others have no effect.
736             return;
737         m_titleElement = titleElement;
738     }
739
740     if (m_title == title)
741         return;
742
743     m_title = title;
744     updateTitle();
745 }
746
747 void Document::removeTitle(Node* titleElement)
748 {
749     if (m_titleElement != titleElement)
750         return;
751
752     // FIXME: Ideally we might want this to search for the first remaining title element, and use it.
753     m_titleElement = 0;
754
755     if (!m_title.isEmpty()) {
756         m_title = "";
757         updateTitle();
758     }
759 }
760
761 String Document::nodeName() const
762 {
763     return "#document";
764 }
765
766 Node::NodeType Document::nodeType() const
767 {
768     return DOCUMENT_NODE;
769 }
770
771 Frame* Document::frame() const 
772 {
773     return m_view ? m_view->frame() : 0; 
774 }
775
776 PassRefPtr<Range> Document::createRange()
777 {
778     return new Range(this);
779 }
780
781 PassRefPtr<NodeIterator> Document::createNodeIterator(Node* root, unsigned whatToShow, 
782     PassRefPtr<NodeFilter> filter, bool expandEntityReferences, ExceptionCode& ec)
783 {
784     if (!root) {
785         ec = NOT_SUPPORTED_ERR;
786         return 0;
787     }
788     return new NodeIterator(root, whatToShow, filter, expandEntityReferences);
789 }
790
791 PassRefPtr<TreeWalker> Document::createTreeWalker(Node *root, unsigned whatToShow, 
792     PassRefPtr<NodeFilter> filter, bool expandEntityReferences, ExceptionCode& ec)
793 {
794     if (!root) {
795         ec = NOT_SUPPORTED_ERR;
796         return 0;
797     }
798     return new TreeWalker(root, whatToShow, filter, expandEntityReferences);
799 }
800
801 void Document::setDocumentChanged(bool b)
802 {
803     if (b) {
804         if (!m_docChanged) {
805             if (!changedDocuments)
806                 changedDocuments = new DeprecatedPtrList<Document>;
807             changedDocuments->append(this);
808         }
809         if (m_accessKeyMapValid) {
810             m_accessKeyMapValid = false;
811             m_elementsByAccessKey.clear();
812         }
813     } else {
814         if (m_docChanged && changedDocuments)
815             changedDocuments->remove(this);
816     }
817
818     m_docChanged = b;
819 }
820
821 void Document::recalcStyle(StyleChange change)
822 {
823     if (m_inStyleRecalc)
824         return; // Guard against re-entrancy. -dwh
825         
826     m_inStyleRecalc = true;
827     
828     ASSERT(!renderer() || renderArena());
829     if (!renderer() || !renderArena())
830         goto bail_out;
831
832     if (change == Force) {
833         RenderStyle* oldStyle = renderer()->style();
834         if (oldStyle)
835             oldStyle->ref();
836         RenderStyle* _style = new (m_renderArena) RenderStyle();
837         _style->ref();
838         _style->setDisplay(BLOCK);
839         _style->setVisuallyOrdered(visuallyOrdered);
840         // ### make the font stuff _really_ work!!!!
841
842         FontDescription fontDescription;
843         fontDescription.setUsePrinterFont(printing());
844         if (m_view) {
845             const Settings *settings = m_view->frame()->settings();
846             if (printing() && !settings->shouldPrintBackgrounds())
847                 _style->setForceBackgroundsToWhite(true);
848             const AtomicString& stdfont = settings->stdFontName();
849             if (!stdfont.isEmpty()) {
850                 fontDescription.firstFamily().setFamily(stdfont);
851                 fontDescription.firstFamily().appendFamily(0);
852             }
853             fontDescription.setKeywordSize(CSS_VAL_MEDIUM - CSS_VAL_XX_SMALL + 1);
854             m_styleSelector->setFontSize(fontDescription, m_styleSelector->fontSizeForKeyword(CSS_VAL_MEDIUM, inCompatMode(), false));
855         }
856
857         _style->setFontDescription(fontDescription);
858         _style->font().update();
859         if (inCompatMode())
860             _style->setHtmlHacks(true); // enable html specific rendering tricks
861
862         StyleChange ch = diff(_style, oldStyle);
863         if (renderer() && ch != NoChange)
864             renderer()->setStyle(_style);
865         if (change != Force)
866             change = ch;
867
868         _style->deref(m_renderArena);
869         if (oldStyle)
870             oldStyle->deref(m_renderArena);
871     }
872
873     for (Node* n = fastFirstChild(); n; n = n->nextSibling())
874         if (change >= Inherit || n->hasChangedChild() || n->changed())
875             n->recalcStyle(change);
876
877     if (changed() && m_view)
878         m_view->layout();
879
880 bail_out:
881     setChanged(false);
882     setHasChangedChild(false);
883     setDocumentChanged(false);
884     
885     m_inStyleRecalc = false;
886     
887     // If we wanted to emit the implicitClose() during recalcStyle, do so now that we're finished.
888     if (m_closeAfterStyleRecalc) {
889         m_closeAfterStyleRecalc = false;
890         implicitClose();
891     }
892 }
893
894 void Document::updateRendering()
895 {
896     if (hasChangedChild())
897         recalcStyle(NoChange);
898 }
899
900 void Document::updateDocumentsRendering()
901 {
902     if (!changedDocuments)
903         return;
904
905     while (Document* doc = changedDocuments->take()) {
906         doc->m_docChanged = false;
907         doc->updateRendering();
908     }
909 }
910
911 void Document::updateLayout()
912 {
913     // FIXME: Dave Hyatt's pretty sure we can remove this because layout calls recalcStyle as needed.
914     updateRendering();
915
916     // Only do a layout if changes have occurred that make it necessary.      
917     if (m_view && renderer() && (m_view->layoutPending() || renderer()->needsLayout()))
918         m_view->layout();
919 }
920
921 // FIXME: This is a bad idea and needs to be removed eventually.
922 // Other browsers load stylesheets before they continue parsing the web page.
923 // Since we don't, we can run JavaScript code that needs answers before the
924 // stylesheets are loaded. Doing a layout ignoring the pending stylesheets
925 // lets us get reasonable answers. The long term solution to this problem is
926 // to instead suspend JavaScript execution.
927 void Document::updateLayoutIgnorePendingStylesheets()
928 {
929     bool oldIgnore = m_ignorePendingStylesheets;
930     
931     if (!haveStylesheetsLoaded()) {
932         m_ignorePendingStylesheets = true;
933         // FIXME: We are willing to attempt to suppress painting with outdated style info only once.  Our assumption is that it would be
934         // dangerous to try to stop it a second time, after page content has already been loaded and displayed
935         // with accurate style information.  (Our suppression involves blanking the whole page at the
936         // moment.  If it were more refined, we might be able to do something better.)
937         // It's worth noting though that this entire method is a hack, since what we really want to do is
938         // suspend JS instead of doing a layout with inaccurate information.
939         if (m_pendingSheetLayout == NoLayoutWithPendingSheets)
940             m_pendingSheetLayout = DidLayoutWithPendingSheets;
941         updateStyleSelector();    
942     }
943
944     updateLayout();
945
946     m_ignorePendingStylesheets = oldIgnore;
947 }
948
949 void Document::attach()
950 {
951     assert(!attached());
952     assert(!m_inPageCache);
953
954     if (!m_renderArena)
955         m_renderArena = new RenderArena();
956     
957     // Create the rendering tree
958     setRenderer(new (m_renderArena) RenderView(this, m_view));
959
960     recalcStyle(Force);
961
962     RenderObject* render = renderer();
963     setRenderer(0);
964
965     ContainerNode::attach();
966
967     setRenderer(render);
968 }
969
970 void Document::detach()
971 {
972     RenderObject* render = renderer();
973
974     // indicate destruction mode,  i.e. attached() but renderer == 0
975     setRenderer(0);
976     
977     if (m_inPageCache) {
978         if (render)
979             axObjectCache()->remove(render);
980         return;
981     }
982
983     // Empty out these lists as a performance optimization, since detaching
984     // all the individual render objects will cause all the RenderImage
985     // objects to remove themselves from the lists.
986     m_imageLoadEventDispatchSoonList.clear();
987     m_imageLoadEventDispatchingList.clear();
988     
989     m_hoverNode = 0;
990     m_focusNode = 0;
991     m_activeNode = 0;
992
993     ContainerNode::detach();
994
995     if (render)
996         render->destroy();
997
998     m_view = 0;
999     
1000     if (m_renderArena) {
1001         delete m_renderArena;
1002         m_renderArena = 0;
1003     }
1004 }
1005
1006 void Document::removeAllEventListenersFromAllNodes()
1007 {
1008     m_windowEventListeners.clear();
1009     removeAllDisconnectedNodeEventListeners();
1010     for (Node *n = this; n; n = n->traverseNextNode()) {
1011         if (!n->isEventTargetNode())
1012             continue;
1013         EventTargetNodeCast(n)->removeAllEventListeners();
1014     }
1015 }
1016
1017 void Document::registerDisconnectedNodeWithEventListeners(Node* node)
1018 {
1019     m_disconnectedNodesWithEventListeners.add(node);
1020 }
1021
1022 void Document::unregisterDisconnectedNodeWithEventListeners(Node* node)
1023 {
1024     m_disconnectedNodesWithEventListeners.remove(node);
1025 }
1026
1027 void Document::removeAllDisconnectedNodeEventListeners()
1028 {
1029     HashSet<Node*>::iterator end = m_disconnectedNodesWithEventListeners.end();
1030     for (HashSet<Node*>::iterator i = m_disconnectedNodesWithEventListeners.begin(); i != end; ++i)
1031         EventTargetNodeCast(*i)->removeAllEventListeners();
1032     m_disconnectedNodesWithEventListeners.clear();
1033 }
1034
1035 AXObjectCache* Document::axObjectCache() const
1036 {
1037     // The only document that actually has a AXObjectCache is the top-level
1038     // document.  This is because we need to be able to get from any WebCoreAXObject
1039     // to any other WebCoreAXObject on the same page.  Using a single cache allows
1040     // lookups across nested webareas (i.e. multiple documents).
1041     
1042     if (m_axObjectCache) {
1043         // return already known top-level cache
1044         if (!ownerElement())
1045             return m_axObjectCache;
1046         
1047         // In some pages with frames, the cache is created before the sub-webarea is
1048         // inserted into the tree.  Here, we catch that case and just toss the old
1049         // cache and start over.
1050         delete m_axObjectCache;
1051         m_axObjectCache = 0;
1052     }
1053
1054     // ask the top-level document for its cache
1055     Document* doc = topDocument();
1056     if (doc != this)
1057         return doc->axObjectCache();
1058     
1059     // this is the top-level document, so install a new cache
1060     m_axObjectCache = new AXObjectCache;
1061     return m_axObjectCache;
1062 }
1063
1064 void Document::setVisuallyOrdered()
1065 {
1066     visuallyOrdered = true;
1067     if (renderer())
1068         renderer()->style()->setVisuallyOrdered(true);
1069 }
1070
1071 void Document::updateSelection()
1072 {
1073     if (!renderer())
1074         return;
1075     
1076     RenderView *canvas = static_cast<RenderView*>(renderer());
1077     Selection selection = frame()->selectionController()->selection();
1078         
1079     if (!selection.isRange())
1080         canvas->clearSelection();
1081     else {
1082         // Use the rightmost candidate for the start of the selection, and the leftmost candidate for the end of the selection.
1083         // Example: foo <a>bar</a>.  Imagine that a line wrap occurs after 'foo', and that 'bar' is selected.   If we pass [foo, 3]
1084         // as the start of the selection, the selection painting code will think that content on the line containing 'foo' is selected
1085         // and will fill the gap before 'bar'.
1086         Position startPos = selection.visibleStart().deepEquivalent();
1087         if (startPos.downstream().inRenderedContent())
1088             startPos = startPos.downstream();
1089         Position endPos = selection.visibleEnd().deepEquivalent();
1090         if (endPos.upstream().inRenderedContent())
1091             endPos = endPos.upstream();
1092         
1093         // We can get into a state where the selection endpoints map to the same VisiblePosition when a selection is deleted
1094         // because we don't yet notify the SelectionController of text removal.
1095         if (startPos.isNotNull() && endPos.isNotNull() && selection.visibleStart() != selection.visibleEnd()) {
1096             RenderObject *startRenderer = startPos.node()->renderer();
1097             RenderObject *endRenderer = endPos.node()->renderer();
1098             static_cast<RenderView*>(renderer())->setSelection(startRenderer, startPos.offset(), endRenderer, endPos.offset());
1099         }
1100     }
1101     
1102 #if __APPLE__
1103     // FIXME: We shouldn't post this AX notification here since updateSelection() is called far to often: every time Safari gains
1104     // or loses focus, and once for every low level change to the selection during an editing operation.
1105     // FIXME: We no longer blow away the selection before starting an editing operation, so the isNotNull checks below are no 
1106     // longer a correct way to check for user-level selection changes.
1107     if (AXObjectCache::accessibilityEnabled() && selection.start().isNotNull() && selection.end().isNotNull()) {
1108         axObjectCache()->postNotification(selection.start().node()->renderer(), "AXSelectedTextChanged");
1109     }
1110 #endif
1111 }
1112
1113 Tokenizer *Document::createTokenizer()
1114 {
1115     return newXMLTokenizer(this, m_view);
1116 }
1117
1118 void Document::open()
1119 {
1120     // This is work that we should probably do in clear(), but we can't have it
1121     // happen when implicitOpen() is called unless we reorganize Frame code.
1122     if (Document *parent = parentDocument()) {
1123         setURL(parent->baseURL());
1124         setBaseURL(parent->baseURL());
1125     }
1126     else
1127         setURL(DeprecatedString());
1128         
1129
1130     if ((frame() && frame()->isLoadingMainResource()) || (tokenizer() && tokenizer()->executingScript()))
1131         return;
1132
1133     implicitOpen();
1134
1135     if (frame())
1136         frame()->didExplicitOpen();
1137 }
1138
1139 void Document::cancelParsing()
1140 {
1141     if (m_tokenizer) {
1142         // We have to clear the tokenizer to avoid possibly triggering
1143         // the onload handler when closing as a side effect of a cancel-style
1144         // change, such as opening a new document or closing the window while
1145         // still parsing
1146         delete m_tokenizer;
1147         m_tokenizer = 0;
1148         close();
1149     }
1150 }
1151
1152 void Document::implicitOpen()
1153 {
1154     cancelParsing();
1155
1156     clear();
1157     m_tokenizer = createTokenizer();
1158     setParsing(true);
1159 }
1160
1161 HTMLElement* Document::body()
1162 {
1163     Node *de = documentElement();
1164     if (!de)
1165         return 0;
1166     
1167     // try to prefer a FRAMESET element over BODY
1168     Node* body = 0;
1169     for (Node* i = de->firstChild(); i; i = i->nextSibling()) {
1170         if (i->hasTagName(framesetTag))
1171             return static_cast<HTMLElement*>(i);
1172         
1173         if (i->hasTagName(bodyTag))
1174             body = i;
1175     }
1176     return static_cast<HTMLElement *>(body);
1177 }
1178
1179 void Document::close()
1180 {
1181     if (frame())
1182         frame()->endIfNotLoading();
1183     implicitClose();
1184 }
1185
1186 void Document::implicitClose()
1187 {
1188     // If we're in the middle of recalcStyle, we need to defer the close until the style information is accurate and all elements are re-attached.
1189     if (m_inStyleRecalc) {
1190         m_closeAfterStyleRecalc = true;
1191         return;
1192     }
1193
1194     bool wasLocationChangePending = frame() && frame()->isScheduledLocationChangePending();
1195     bool doload = !parsing() && m_tokenizer && !m_processingLoadEvent && !wasLocationChangePending;
1196     
1197     if (!doload)
1198         return;
1199
1200     m_processingLoadEvent = true;
1201
1202     // We have to clear the tokenizer, in case someone document.write()s from the
1203     // onLoad event handler, as in Radar 3206524.
1204     delete m_tokenizer;
1205     m_tokenizer = 0;
1206
1207     // Create a body element if we don't already have one.
1208     // In the case of Radar 3758785, the window.onload was set in some javascript, but never fired because there was no body.  
1209     // This behavior now matches Firefox and IE.
1210     HTMLElement *body = this->body();
1211     if (!body && isHTMLDocument()) {
1212         Node *de = documentElement();
1213         if (de) {
1214             body = new HTMLBodyElement(this);
1215             ExceptionCode ec = 0;
1216             de->appendChild(body, ec);
1217             if (ec != 0)
1218                 body = 0;
1219         }
1220     }
1221     
1222     dispatchImageLoadEventsNow();
1223     this->dispatchWindowEvent(loadEvent, false, false);
1224     if (Frame *p = frame())
1225         p->handledOnloadEvents();
1226 #ifdef INSTRUMENT_LAYOUT_SCHEDULING
1227     if (!ownerElement())
1228         printf("onload fired at %d\n", elapsedTime());
1229 #endif
1230
1231     m_processingLoadEvent = false;
1232
1233     // Make sure both the initial layout and reflow happen after the onload
1234     // fires. This will improve onload scores, and other browsers do it.
1235     // If they wanna cheat, we can too. -dwh
1236
1237     if (frame() && frame()->isScheduledLocationChangePending() && elapsedTime() < cLayoutScheduleThreshold) {
1238         // Just bail out. Before or during the onload we were shifted to another page.
1239         // The old i-Bench suite does this. When this happens don't bother painting or laying out.        
1240         view()->unscheduleRelayout();
1241         return;
1242     }
1243
1244     if (frame())
1245         frame()->checkEmitLoadEvent();
1246
1247     // Now do our painting/layout, but only if we aren't in a subframe or if we're in a subframe
1248     // that has been sized already.  Otherwise, our view size would be incorrect, so doing any 
1249     // layout/painting now would be pointless.
1250     if (!ownerElement() || (ownerElement()->renderer() && !ownerElement()->renderer()->needsLayout())) {
1251         updateRendering();
1252         
1253         // Always do a layout after loading if needed.
1254         if (view() && renderer() && (!renderer()->firstChild() || renderer()->needsLayout()))
1255             view()->layout();
1256     }
1257 #if __APPLE__
1258     if (renderer() && AXObjectCache::accessibilityEnabled())
1259         axObjectCache()->postNotificationToElement(renderer(), "AXLoadComplete");
1260 #endif
1261
1262 #ifdef SVG_SUPPORT
1263     // FIXME: Officially, time 0 is when the outermost <svg> receives its
1264     // SVGLoad event, but we don't implement those yet.  This is close enough
1265     // for now.  In some cases we should have fired earlier.
1266     if (svgExtensions())
1267         accessSVGExtensions()->startAnimations();
1268 #endif
1269 }
1270
1271 void Document::setParsing(bool b)
1272 {
1273     m_bParsing = b;
1274     if (!m_bParsing && view())
1275         view()->scheduleRelayout();
1276
1277 #ifdef INSTRUMENT_LAYOUT_SCHEDULING
1278     if (!ownerElement() && !m_bParsing)
1279         printf("Parsing finished at %d\n", elapsedTime());
1280 #endif
1281 }
1282
1283 bool Document::shouldScheduleLayout()
1284 {
1285     // We can update layout if:
1286     // (a) we actually need a layout
1287     // (b) our stylesheets are all loaded
1288     // (c) we have a <body>
1289     return (renderer() && renderer()->needsLayout() && haveStylesheetsLoaded() &&
1290             documentElement() && documentElement()->renderer() &&
1291             (!documentElement()->hasTagName(htmlTag) || body()));
1292 }
1293
1294 int Document::minimumLayoutDelay()
1295 {
1296     if (m_overMinimumLayoutThreshold)
1297         return 0;
1298     
1299     int elapsed = elapsedTime();
1300     m_overMinimumLayoutThreshold = elapsed > cLayoutScheduleThreshold;
1301     
1302     // We'll want to schedule the timer to fire at the minimum layout threshold.
1303     return max(0, cLayoutScheduleThreshold - elapsed);
1304 }
1305
1306 int Document::elapsedTime() const
1307 {
1308     return static_cast<int>((currentTime() - m_startTime) * 1000);
1309 }
1310
1311 void Document::write(const DeprecatedString& text)
1312 {
1313     write(String(text));
1314 }
1315
1316 void Document::write(const String& text)
1317 {
1318 #ifdef INSTRUMENT_LAYOUT_SCHEDULING
1319     if (!ownerElement())
1320         printf("Beginning a document.write at %d\n", elapsedTime());
1321 #endif
1322     
1323     if (!m_tokenizer) {
1324         open();
1325         assert(m_tokenizer);
1326         if (!m_tokenizer)
1327             return;
1328         write(DeprecatedString("<html>"));
1329     }
1330     m_tokenizer->write(text, false);
1331     
1332 #ifdef INSTRUMENT_LAYOUT_SCHEDULING
1333     if (!ownerElement())
1334         printf("Ending a document.write at %d\n", elapsedTime());
1335 #endif    
1336 }
1337
1338 void Document::writeln(const String &text)
1339 {
1340     write(text);
1341     write(String("\n"));
1342 }
1343
1344 void Document::finishParsing()
1345 {
1346 #ifdef INSTRUMENT_LAYOUT_SCHEDULING
1347     if (!ownerElement())
1348         printf("Received all data at %d\n", elapsedTime());
1349 #endif
1350     
1351     // Let the tokenizer go through as much data as it can.  There will be three possible outcomes after
1352     // finish() is called:
1353     // (1) All remaining data is parsed, document isn't loaded yet
1354     // (2) All remaining data is parsed, document is loaded, tokenizer gets deleted
1355     // (3) Data is still remaining to be parsed.
1356     if (m_tokenizer)
1357         m_tokenizer->finish();
1358 }
1359
1360 void Document::clear()
1361 {
1362     delete m_tokenizer;
1363     m_tokenizer = 0;
1364
1365     removeChildren();
1366
1367     RegisteredEventListenerList::iterator end = m_windowEventListeners.end();
1368     for (RegisteredEventListenerList::iterator it = m_windowEventListeners.begin(); it != end; ++it)
1369         m_windowEventListeners.remove(it);
1370 }
1371
1372 void Document::setURL(const DeprecatedString& url)
1373 {
1374     m_url = url;
1375     if (m_styleSelector)
1376         m_styleSelector->setEncodedURL(m_url);
1377 }
1378
1379 void Document::setStyleSheet(const String &url, const String &sheet)
1380 {
1381     m_sheet = new CSSStyleSheet(this, url);
1382     m_sheet->parseString(sheet);
1383     m_loadingSheet = false;
1384
1385     updateStyleSelector();
1386 }
1387
1388 void Document::setUserStyleSheet(const String& sheet)
1389 {
1390     if (m_usersheet != sheet) {
1391         m_usersheet = sheet;
1392         updateStyleSelector();
1393     }
1394 }
1395
1396 CSSStyleSheet* Document::elementSheet()
1397 {
1398     if (!m_elemSheet)
1399         m_elemSheet = new CSSStyleSheet(this, baseURL());
1400     return m_elemSheet.get();
1401 }
1402
1403 void Document::determineParseMode(const String&)
1404 {
1405     // For XML documents use strict parse mode.
1406     // HTML overrides this method to determine the parse mode.
1407     pMode = Strict;
1408     hMode = XHtml;
1409 }
1410
1411 Node *Document::nextFocusNode(Node *fromNode)
1412 {
1413     unsigned short fromTabIndex;
1414
1415     if (!fromNode) {
1416         // No starting node supplied; begin with the top of the document
1417         Node *n;
1418
1419         int lowestTabIndex = 65535;
1420         for (n = this; n != 0; n = n->traverseNextNode()) {
1421             if (n->isKeyboardFocusable()) {
1422                 if ((n->tabIndex() > 0) && (n->tabIndex() < lowestTabIndex))
1423                     lowestTabIndex = n->tabIndex();
1424             }
1425         }
1426
1427         if (lowestTabIndex == 65535)
1428             lowestTabIndex = 0;
1429
1430         // Go to the first node in the document that has the desired tab index
1431         for (n = this; n != 0; n = n->traverseNextNode()) {
1432             if (n->isKeyboardFocusable() && (n->tabIndex() == lowestTabIndex))
1433                 return n;
1434         }
1435
1436         return 0;
1437     }
1438     else {
1439         fromTabIndex = fromNode->tabIndex();
1440     }
1441
1442     if (fromTabIndex == 0) {
1443         // Just need to find the next selectable node after fromNode (in document order) that doesn't have a tab index
1444         Node *n = fromNode->traverseNextNode();
1445         while (n && !(n->isKeyboardFocusable() && n->tabIndex() == 0))
1446             n = n->traverseNextNode();
1447         return n;
1448     }
1449     else {
1450         // Find the lowest tab index out of all the nodes except fromNode, that is greater than or equal to fromNode's
1451         // tab index. For nodes with the same tab index as fromNode, we are only interested in those that come after
1452         // fromNode in document order.
1453         // If we don't find a suitable tab index, the next focus node will be one with a tab index of 0.
1454         unsigned short lowestSuitableTabIndex = 65535;
1455         Node *n;
1456
1457         bool reachedFromNode = false;
1458         for (n = this; n != 0; n = n->traverseNextNode()) {
1459             if (n->isKeyboardFocusable() &&
1460                 ((reachedFromNode && (n->tabIndex() >= fromTabIndex)) ||
1461                  (!reachedFromNode && (n->tabIndex() > fromTabIndex))) &&
1462                 (n->tabIndex() < lowestSuitableTabIndex) &&
1463                 (n != fromNode)) {
1464
1465                 // We found a selectable node with a tab index at least as high as fromNode's. Keep searching though,
1466                 // as there may be another node which has a lower tab index but is still suitable for use.
1467                 lowestSuitableTabIndex = n->tabIndex();
1468             }
1469
1470             if (n == fromNode)
1471                 reachedFromNode = true;
1472         }
1473
1474         if (lowestSuitableTabIndex == 65535) {
1475             // No next node with a tab index -> just take first node with tab index of 0
1476             Node *n = this;
1477             while (n && !(n->isKeyboardFocusable() && n->tabIndex() == 0))
1478                 n = n->traverseNextNode();
1479             return n;
1480         }
1481
1482         // Search forwards from fromNode
1483         for (n = fromNode->traverseNextNode(); n != 0; n = n->traverseNextNode()) {
1484             if (n->isKeyboardFocusable() && (n->tabIndex() == lowestSuitableTabIndex))
1485                 return n;
1486         }
1487
1488         // The next node isn't after fromNode, start from the beginning of the document
1489         for (n = this; n != fromNode; n = n->traverseNextNode()) {
1490             if (n->isKeyboardFocusable() && (n->tabIndex() == lowestSuitableTabIndex))
1491                 return n;
1492         }
1493
1494         assert(false); // should never get here
1495         return 0;
1496     }
1497 }
1498
1499 Node *Document::previousFocusNode(Node *fromNode)
1500 {
1501     Node *lastNode = this;
1502     while (lastNode->lastChild())
1503         lastNode = lastNode->lastChild();
1504
1505     if (!fromNode) {
1506         // No starting node supplied; begin with the very last node in the document
1507         Node *n;
1508
1509         int highestTabIndex = 0;
1510         for (n = lastNode; n != 0; n = n->traversePreviousNode()) {
1511             if (n->isKeyboardFocusable()) {
1512                 if (n->tabIndex() == 0)
1513                     return n;
1514                 else if (n->tabIndex() > highestTabIndex)
1515                     highestTabIndex = n->tabIndex();
1516             }
1517         }
1518
1519         // No node with a tab index of 0; just go to the last node with the highest tab index
1520         for (n = lastNode; n != 0; n = n->traversePreviousNode()) {
1521             if (n->isKeyboardFocusable() && (n->tabIndex() == highestTabIndex))
1522                 return n;
1523         }
1524
1525         return 0;
1526     }
1527     else {
1528         unsigned short fromTabIndex = fromNode->tabIndex();
1529
1530         if (fromTabIndex == 0) {
1531             // Find the previous selectable node before fromNode (in document order) that doesn't have a tab index
1532             Node *n = fromNode->traversePreviousNode();
1533             while (n && !(n->isKeyboardFocusable() && n->tabIndex() == 0))
1534                 n = n->traversePreviousNode();
1535             if (n)
1536                 return n;
1537
1538             // No previous nodes with a 0 tab index, go to the last node in the document that has the highest tab index
1539             int highestTabIndex = 0;
1540             for (n = this; n != 0; n = n->traverseNextNode()) {
1541                 if (n->isKeyboardFocusable() && (n->tabIndex() > highestTabIndex))
1542                     highestTabIndex = n->tabIndex();
1543             }
1544
1545             if (highestTabIndex == 0)
1546                 return 0;
1547
1548             for (n = lastNode; n != 0; n = n->traversePreviousNode()) {
1549                 if (n->isKeyboardFocusable() && (n->tabIndex() == highestTabIndex))
1550                     return n;
1551             }
1552
1553             assert(false); // should never get here
1554             return 0;
1555         }
1556         else {
1557             // Find the lowest tab index out of all the nodes except fromNode, that is less than or equal to fromNode's
1558             // tab index. For nodes with the same tab index as fromNode, we are only interested in those before
1559             // fromNode.
1560             // If we don't find a suitable tab index, then there will be no previous focus node.
1561             unsigned short highestSuitableTabIndex = 0;
1562             Node *n;
1563
1564             bool reachedFromNode = false;
1565             for (n = this; n != 0; n = n->traverseNextNode()) {
1566                 if (n->isKeyboardFocusable() &&
1567                     ((!reachedFromNode && (n->tabIndex() <= fromTabIndex)) ||
1568                      (reachedFromNode && (n->tabIndex() < fromTabIndex)))  &&
1569                     (n->tabIndex() > highestSuitableTabIndex) &&
1570                     (n != fromNode)) {
1571
1572                     // We found a selectable node with a tab index no higher than fromNode's. Keep searching though, as
1573                     // there may be another node which has a higher tab index but is still suitable for use.
1574                     highestSuitableTabIndex = n->tabIndex();
1575                 }
1576
1577                 if (n == fromNode)
1578                     reachedFromNode = true;
1579             }
1580
1581             if (highestSuitableTabIndex == 0) {
1582                 // No previous node with a tab index. Since the order specified by HTML is nodes with tab index > 0
1583                 // first, this means that there is no previous node.
1584                 return 0;
1585             }
1586
1587             // Search backwards from fromNode
1588             for (n = fromNode->traversePreviousNode(); n != 0; n = n->traversePreviousNode()) {
1589                 if (n->isKeyboardFocusable() && (n->tabIndex() == highestSuitableTabIndex))
1590                     return n;
1591             }
1592             // The previous node isn't before fromNode, start from the end of the document
1593             for (n = lastNode; n != fromNode; n = n->traversePreviousNode()) {
1594                 if (n->isKeyboardFocusable() && (n->tabIndex() == highestSuitableTabIndex))
1595                     return n;
1596             }
1597
1598             assert(false); // should never get here
1599             return 0;
1600         }
1601     }
1602 }
1603
1604 int Document::nodeAbsIndex(Node *node)
1605 {
1606     assert(node->document() == this);
1607
1608     int absIndex = 0;
1609     for (Node *n = node; n && n != this; n = n->traversePreviousNode())
1610         absIndex++;
1611     return absIndex;
1612 }
1613
1614 Node *Document::nodeWithAbsIndex(int absIndex)
1615 {
1616     Node *n = this;
1617     for (int i = 0; n && (i < absIndex); i++) {
1618         n = n->traverseNextNode();
1619     }
1620     return n;
1621 }
1622
1623 void Document::processHttpEquiv(const String &equiv, const String &content)
1624 {
1625     assert(!equiv.isNull() && !content.isNull());
1626
1627     Frame *frame = this->frame();
1628
1629     if (equalIgnoringCase(equiv, "default-style")) {
1630         // The preferred style set has been overridden as per section 
1631         // 14.3.2 of the HTML4.0 specification.  We need to update the
1632         // sheet used variable and then update our style selector. 
1633         // For more info, see the test at:
1634         // http://www.hixie.ch/tests/evil/css/import/main/preferred.html
1635         // -dwh
1636         m_selectedStylesheetSet = content;
1637         m_preferredStylesheetSet = content;
1638         updateStyleSelector();
1639     } else if (equalIgnoringCase(equiv, "refresh")) {
1640         // get delay and url
1641         DeprecatedString str = content.stripWhiteSpace().deprecatedString();
1642         int pos = str.find(RegularExpression("[;,]"));
1643         if (pos == -1)
1644             pos = str.find(RegularExpression("[ \t]"));
1645
1646         if (pos == -1) // There can be no url (David)
1647         {
1648             bool ok = false;
1649             int delay = 0;
1650             delay = str.toInt(&ok);
1651             // We want a new history item if the refresh timeout > 1 second
1652             if (ok && frame)
1653                 frame->scheduleRedirection(delay, frame->url().url(), delay <= 1);
1654         } else {
1655             double delay = 0;
1656             bool ok = false;
1657             delay = str.left(pos).stripWhiteSpace().toDouble(&ok);
1658
1659             pos++;
1660             while(pos < (int)str.length() && str[pos].isSpace()) pos++;
1661             str = str.mid(pos);
1662             if (str.find("url", 0,  false) == 0)
1663                 str = str.mid(3);
1664             str = str.stripWhiteSpace();
1665             if (str.length() && str[0] == '=')
1666                 str = str.mid(1).stripWhiteSpace();
1667             str = parseURL(String(str)).deprecatedString();
1668             if (ok && frame)
1669                 // We want a new history item if the refresh timeout > 1 second
1670                 frame->scheduleRedirection(delay, completeURL(str), delay <= 1);
1671         }
1672     } else if (equalIgnoringCase(equiv, "expires")) {
1673         String str = content.stripWhiteSpace();
1674         time_t expire_date = str.toInt();
1675         if (m_docLoader)
1676             m_docLoader->setExpireDate(expire_date);
1677     } else if ((equalIgnoringCase(equiv, "pragma") || equalIgnoringCase(equiv, "cache-control")) && frame) {
1678         DeprecatedString str = content.deprecatedString().lower().stripWhiteSpace();
1679         KURL url = frame->url();
1680     } else if (equalIgnoringCase(equiv, "set-cookie")) {
1681         // ### FIXME: make setCookie work on XML documents too; e.g. in case of <html:meta .....>
1682         if (isHTMLDocument())
1683             static_cast<HTMLDocument *>(this)->setCookie(content);
1684     }
1685 }
1686
1687 MouseEventWithHitTestResults Document::prepareMouseEvent(bool readonly, bool active, bool mouseMove,
1688                                                          const IntPoint& point, const PlatformMouseEvent& event)
1689 {
1690     if (!renderer())
1691         return MouseEventWithHitTestResults(event, 0, false);
1692
1693     assert(renderer()->isRenderView());
1694     RenderObject::NodeInfo renderInfo(readonly, active, mouseMove);
1695     renderer()->layer()->hitTest(renderInfo, point);
1696
1697     if (!readonly)
1698         updateRendering();
1699
1700     bool isOverLink = renderInfo.URLElement() && !renderInfo.URLElement()->getAttribute(hrefAttr).isNull();
1701     return MouseEventWithHitTestResults(event, renderInfo.innerNode(), isOverLink);
1702 }
1703
1704 // DOM Section 1.1.1
1705 bool Document::childTypeAllowed(NodeType type)
1706 {
1707     switch (type) {
1708         case ATTRIBUTE_NODE:
1709         case CDATA_SECTION_NODE:
1710         case DOCUMENT_FRAGMENT_NODE:
1711         case DOCUMENT_NODE:
1712         case ENTITY_NODE:
1713         case ENTITY_REFERENCE_NODE:
1714         case NOTATION_NODE:
1715         case TEXT_NODE:
1716         case XPATH_NAMESPACE_NODE:
1717             return false;
1718         case COMMENT_NODE:
1719         case PROCESSING_INSTRUCTION_NODE:
1720             return true;
1721         case DOCUMENT_TYPE_NODE:
1722         case ELEMENT_NODE:
1723             // Documents may contain no more than one of each of these.
1724             // (One Element and one DocumentType.)
1725             for (Node* c = firstChild(); c; c = c->nextSibling())
1726                 if (c->nodeType() == type)
1727                     return false;
1728             return true;
1729     }
1730     return false;
1731 }
1732
1733 PassRefPtr<Node> Document::cloneNode(bool /*deep*/)
1734 {
1735     // Spec says cloning Document nodes is "implementation dependent"
1736     // so we do not support it...
1737     return 0;
1738 }
1739
1740 StyleSheetList* Document::styleSheets()
1741 {
1742     return m_styleSheets.get();
1743 }
1744
1745 String Document::preferredStylesheetSet() const
1746 {
1747     return m_preferredStylesheetSet;
1748 }
1749
1750 String Document::selectedStylesheetSet() const
1751 {
1752     return m_selectedStylesheetSet;
1753 }
1754
1755 void Document::setSelectedStylesheetSet(const String& aString)
1756 {
1757     m_selectedStylesheetSet = aString;
1758     updateStyleSelector();
1759     if (renderer())
1760         renderer()->repaint();
1761 }
1762
1763 // This method is called whenever a top-level stylesheet has finished loading.
1764 void Document::stylesheetLoaded()
1765 {
1766     // Make sure we knew this sheet was pending, and that our count isn't out of sync.
1767     assert(m_pendingStylesheets > 0);
1768
1769     m_pendingStylesheets--;
1770     
1771 #ifdef INSTRUMENT_LAYOUT_SCHEDULING
1772     if (!ownerElement())
1773         printf("Stylesheet loaded at time %d. %d stylesheets still remain.\n", elapsedTime(), m_pendingStylesheets);
1774 #endif
1775
1776     updateStyleSelector();    
1777 }
1778
1779 void Document::updateStyleSelector()
1780 {
1781     // Don't bother updating, since we haven't loaded all our style info yet.
1782     if (!haveStylesheetsLoaded())
1783         return;
1784
1785     if (didLayoutWithPendingStylesheets() && m_pendingStylesheets <= 0) {
1786         m_pendingSheetLayout = IgnoreLayoutWithPendingSheets;
1787         if (renderer())
1788             renderer()->repaint();
1789     }
1790
1791 #ifdef INSTRUMENT_LAYOUT_SCHEDULING
1792     if (!ownerElement())
1793         printf("Beginning update of style selector at time %d.\n", elapsedTime());
1794 #endif
1795
1796     recalcStyleSelector();
1797     recalcStyle(Force);
1798
1799 #ifdef INSTRUMENT_LAYOUT_SCHEDULING
1800     if (!ownerElement())
1801         printf("Finished update of style selector at time %d\n", elapsedTime());
1802 #endif
1803
1804     if (renderer()) {
1805         renderer()->setNeedsLayoutAndMinMaxRecalc();
1806         if (view())
1807             view()->scheduleRelayout();
1808     }
1809 }
1810
1811
1812 DeprecatedStringList Document::availableStyleSheets() const
1813 {
1814     return m_availableSheets;
1815 }
1816
1817 void Document::recalcStyleSelector()
1818 {
1819     if (!renderer() || !attached())
1820         return;
1821
1822     DeprecatedPtrList<StyleSheet> oldStyleSheets = m_styleSheets->styleSheets;
1823     m_styleSheets->styleSheets.clear();
1824     m_availableSheets.clear();
1825     Node *n;
1826     for (n = this; n; n = n->traverseNextNode()) {
1827         StyleSheet *sheet = 0;
1828
1829         if (n->nodeType() == PROCESSING_INSTRUCTION_NODE)
1830         {
1831             // Processing instruction (XML documents only)
1832             ProcessingInstruction* pi = static_cast<ProcessingInstruction*>(n);
1833             sheet = pi->sheet();
1834 #ifdef XSLT_SUPPORT
1835             // Don't apply XSL transforms to already transformed documents -- <rdar://problem/4132806>
1836             if (pi->isXSL() && !transformSourceDocument()) {
1837                 // Don't apply XSL transforms until loading is finished.
1838                 if (!parsing())
1839                     applyXSLTransform(pi);
1840                 return;
1841             }
1842 #endif
1843             if (!sheet && !pi->localHref().isEmpty())
1844             {
1845                 // Processing instruction with reference to an element in this document - e.g.
1846                 // <?xml-stylesheet href="#mystyle">, with the element
1847                 // <foo id="mystyle">heading { color: red; }</foo> at some location in
1848                 // the document
1849                 Element* elem = getElementById(pi->localHref().impl());
1850                 if (elem) {
1851                     String sheetText("");
1852                     Node *c;
1853                     for (c = elem->firstChild(); c; c = c->nextSibling()) {
1854                         if (c->nodeType() == TEXT_NODE || c->nodeType() == CDATA_SECTION_NODE)
1855                             sheetText += c->nodeValue();
1856                     }
1857
1858                     CSSStyleSheet *cssSheet = new CSSStyleSheet(this);
1859                     cssSheet->parseString(sheetText);
1860                     pi->setStyleSheet(cssSheet);
1861                     sheet = cssSheet;
1862                 }
1863             }
1864
1865         }
1866         else if (n->isHTMLElement() && (n->hasTagName(linkTag) || n->hasTagName(styleTag))) {
1867             HTMLElement *e = static_cast<HTMLElement *>(n);
1868             DeprecatedString title = e->getAttribute(titleAttr).deprecatedString();
1869             bool enabledViaScript = false;
1870             if (e->hasLocalName(linkTag)) {
1871                 // <LINK> element
1872                 HTMLLinkElement* l = static_cast<HTMLLinkElement*>(n);
1873                 if (l->isLoading() || l->isDisabled())
1874                     continue;
1875                 if (!l->sheet())
1876                     title = DeprecatedString::null;
1877                 enabledViaScript = l->isEnabledViaScript();
1878             }
1879
1880             // Get the current preferred styleset.  This is the
1881             // set of sheets that will be enabled.
1882             if (e->hasLocalName(linkTag))
1883                 sheet = static_cast<HTMLLinkElement*>(n)->sheet();
1884             else
1885                 // <STYLE> element
1886                 sheet = static_cast<HTMLStyleElement*>(n)->sheet();
1887
1888             // Check to see if this sheet belongs to a styleset
1889             // (thus making it PREFERRED or ALTERNATE rather than
1890             // PERSISTENT).
1891             if (!enabledViaScript && !title.isEmpty()) {
1892                 // Yes, we have a title.
1893                 if (m_preferredStylesheetSet.isEmpty()) {
1894                     // No preferred set has been established.  If
1895                     // we are NOT an alternate sheet, then establish
1896                     // us as the preferred set.  Otherwise, just ignore
1897                     // this sheet.
1898                     DeprecatedString rel = e->getAttribute(relAttr).deprecatedString();
1899                     if (e->hasLocalName(styleTag) || !rel.contains("alternate"))
1900                         m_preferredStylesheetSet = m_selectedStylesheetSet = title;
1901                 }
1902                       
1903                 if (!m_availableSheets.contains(title))
1904                     m_availableSheets.append(title);
1905                 
1906                 if (title != m_preferredStylesheetSet)
1907                     sheet = 0;
1908             }
1909         }
1910 #ifdef SVG_SUPPORT
1911         else if (n->isSVGElement() && n->hasTagName(SVGNames::styleTag)) {
1912             DeprecatedString title;
1913             // <STYLE> element
1914             SVGStyleElement *s = static_cast<SVGStyleElement*>(n);
1915             if (!s->isLoading()) {
1916                 sheet = s->sheet();
1917                 if(sheet)
1918                     title = s->getAttribute(SVGNames::titleAttr).deprecatedString();
1919             }
1920
1921             if (!title.isEmpty() && m_preferredStylesheetSet.isEmpty())
1922                 m_preferredStylesheetSet = m_selectedStylesheetSet = title;
1923
1924             if (!title.isEmpty()) {
1925                 if (title != m_preferredStylesheetSet)
1926                     sheet = 0; // don't use it
1927
1928                 title = title.replace('&', "&&");
1929
1930                 if (!m_availableSheets.contains(title))
1931                     m_availableSheets.append(title);
1932             }
1933        }
1934 #endif
1935
1936         if (sheet) {
1937             sheet->ref();
1938             m_styleSheets->styleSheets.append(sheet);
1939         }
1940     
1941         // For HTML documents, stylesheets are not allowed within/after the <BODY> tag. So we
1942         // can stop searching here.
1943         if (isHTMLDocument() && n->hasTagName(bodyTag))
1944             break;
1945     }
1946
1947     // De-reference all the stylesheets in the old list
1948     DeprecatedPtrListIterator<StyleSheet> it(oldStyleSheets);
1949     for (; it.current(); ++it)
1950         it.current()->deref();
1951
1952     // Create a new style selector
1953     delete m_styleSelector;
1954     String usersheet = m_usersheet;
1955     if (m_view && m_view->mediaType() == "print")
1956         usersheet += m_printSheet;
1957     m_styleSelector = new CSSStyleSelector(this, usersheet, m_styleSheets.get(), !inCompatMode());
1958     m_styleSelector->setEncodedURL(m_url);
1959     m_styleSelectorDirty = false;
1960 }
1961
1962 void Document::setHoverNode(PassRefPtr<Node> newHoverNode)
1963 {
1964     m_hoverNode = newHoverNode;
1965 }
1966
1967 void Document::setActiveNode(PassRefPtr<Node> newActiveNode)
1968 {
1969     m_activeNode = newActiveNode;
1970 }
1971
1972 void Document::hoveredNodeDetached(Node* node)
1973 {
1974     if (!m_hoverNode || (node != m_hoverNode && (!m_hoverNode->isTextNode() || node != m_hoverNode->parent())))
1975         return;
1976
1977     m_hoverNode = node->parent();
1978     while (m_hoverNode && !m_hoverNode->renderer())
1979         m_hoverNode = m_hoverNode->parent();
1980     if (view())
1981         view()->scheduleHoverStateUpdate();
1982 }
1983
1984 void Document::activeChainNodeDetached(Node* node)
1985 {
1986     if (!m_activeNode || (node != m_activeNode && (!m_activeNode->isTextNode() || node != m_activeNode->parent())))
1987         return;
1988
1989     m_activeNode = node->parent();
1990     while (m_activeNode && !m_activeNode->renderer())
1991         m_activeNode = m_activeNode->parent();
1992 }
1993
1994 bool Document::relinquishesEditingFocus(Node *node)
1995 {
1996     assert(node);
1997     assert(node->isContentEditable());
1998
1999     Node *root = node->rootEditableElement();
2000     if (!frame() || !root)
2001         return false;
2002
2003     return frame()->shouldEndEditing(rangeOfContents(root).get());
2004 }
2005
2006 bool Document::acceptsEditingFocus(Node *node)
2007 {
2008     assert(node);
2009     assert(node->isContentEditable());
2010
2011     Node *root = node->rootEditableElement();
2012     if (!frame() || !root)
2013         return false;
2014
2015     return frame()->shouldBeginEditing(rangeOfContents(root).get());
2016 }
2017
2018 void Document::didBeginEditing()
2019 {
2020     if (!frame())
2021         return;
2022     
2023     frame()->didBeginEditing();
2024 }
2025
2026 void Document::didEndEditing()
2027 {
2028     if (!frame())
2029         return;
2030     
2031     frame()->didEndEditing();
2032 }
2033
2034 #if __APPLE__
2035 const Vector<DashboardRegionValue>& Document::dashboardRegions() const
2036 {
2037     return m_dashboardRegions;
2038 }
2039
2040 void Document::setDashboardRegions(const Vector<DashboardRegionValue>& regions)
2041 {
2042     m_dashboardRegions = regions;
2043     setDashboardRegionsDirty(false);
2044 }
2045 #endif
2046
2047 static Widget *widgetForNode(Node *focusNode)
2048 {
2049     if (!focusNode)
2050         return 0;
2051     RenderObject *renderer = focusNode->renderer();
2052     if (!renderer || !renderer->isWidget())
2053         return 0;
2054     return static_cast<RenderWidget*>(renderer)->widget();
2055 }
2056
2057 bool Document::setFocusNode(PassRefPtr<Node> newFocusNode)
2058 {    
2059     // Make sure newFocusNode is actually in this document
2060     if (newFocusNode && (newFocusNode->document() != this))
2061         return true;
2062
2063     if (m_focusNode == newFocusNode)
2064         return true;
2065
2066     if (m_focusNode && m_focusNode.get() == m_focusNode->rootEditableElement() && !relinquishesEditingFocus(m_focusNode.get()))
2067         return false;
2068         
2069     bool focusChangeBlocked = false;
2070     RefPtr<Node> oldFocusNode = m_focusNode;
2071     m_focusNode = 0;
2072     clearSelectionIfNeeded(newFocusNode.get());
2073
2074     // Remove focus from the existing focus node (if any)
2075     if (oldFocusNode && !oldFocusNode->m_inDetach) { 
2076         if (oldFocusNode->active())
2077             oldFocusNode->setActive(false);
2078
2079         oldFocusNode->setFocus(false);
2080                 
2081         // Dispatch a change event for text fields or textareas that have been edited
2082         RenderObject *r = static_cast<RenderObject*>(oldFocusNode.get()->renderer());
2083         if (r && (r->isTextArea() || r->isTextField()) && r->isEdited()) {
2084             EventTargetNodeCast(oldFocusNode.get())->dispatchHTMLEvent(changeEvent, true, false);
2085             if ((r = static_cast<RenderObject*>(oldFocusNode.get()->renderer())))
2086                 r->setEdited(false);
2087         }
2088
2089         // Dispatch the blur event and let the node do any other blur related activities (important for text fields)
2090         EventTargetNodeCast(oldFocusNode.get())->dispatchBlurEvent();
2091
2092         if (m_focusNode) {
2093             // handler shifted focus
2094             focusChangeBlocked = true;
2095             newFocusNode = 0;
2096         }
2097         clearSelectionIfNeeded(newFocusNode.get());
2098         EventTargetNodeCast(oldFocusNode.get())->dispatchUIEvent(DOMFocusOutEvent);
2099         if (m_focusNode) {
2100             // handler shifted focus
2101             focusChangeBlocked = true;
2102             newFocusNode = 0;
2103         }
2104         clearSelectionIfNeeded(newFocusNode.get());
2105         if ((oldFocusNode.get() == this) && oldFocusNode->hasOneRef())
2106             return true;
2107             
2108         if (oldFocusNode.get() == oldFocusNode->rootEditableElement())
2109             didEndEditing();
2110     }
2111
2112     if (newFocusNode) {
2113         if (newFocusNode == newFocusNode->rootEditableElement() && !acceptsEditingFocus(newFocusNode.get())) {
2114             // delegate blocks focus change
2115             focusChangeBlocked = true;
2116             goto SetFocusNodeDone;
2117         }
2118         // Set focus on the new node
2119         m_focusNode = newFocusNode.get();
2120
2121         // Dispatch the focus event and let the node do any other focus related activities (important for text fields)
2122         EventTargetNodeCast(m_focusNode.get())->dispatchFocusEvent();
2123
2124         if (m_focusNode != newFocusNode) {
2125             // handler shifted focus
2126             focusChangeBlocked = true;
2127             goto SetFocusNodeDone;
2128         }
2129         EventTargetNodeCast(m_focusNode.get())->dispatchUIEvent(DOMFocusInEvent);
2130         if (m_focusNode != newFocusNode) { 
2131             // handler shifted focus
2132             focusChangeBlocked = true;
2133             goto SetFocusNodeDone;
2134         }
2135         m_focusNode->setFocus();
2136         
2137         if (m_focusNode.get() == m_focusNode->rootEditableElement())
2138             didBeginEditing();
2139         
2140         // eww, I suck. set the qt focus correctly
2141         // ### find a better place in the code for this
2142         if (view()) {
2143             Widget *focusWidget = widgetForNode(m_focusNode.get());
2144             if (focusWidget) {
2145                 // Make sure a widget has the right size before giving it focus.
2146                 // Otherwise, we are testing edge cases of the Widget code.
2147                 // Specifically, in WebCore this does not work well for text fields.
2148                 updateLayout();
2149                 // Re-get the widget in case updating the layout changed things.
2150                 focusWidget = widgetForNode(m_focusNode.get());
2151             }
2152             if (focusWidget)
2153                 focusWidget->setFocus();
2154             else
2155                 view()->setFocus();
2156         }
2157    }
2158
2159 #if __APPLE__
2160     if (!focusChangeBlocked && m_focusNode && AXObjectCache::accessibilityEnabled())
2161         axObjectCache()->handleFocusedUIElementChanged();
2162 #endif
2163
2164 SetFocusNodeDone:
2165     updateRendering();
2166     return !focusChangeBlocked;
2167 }
2168
2169 void Document::clearSelectionIfNeeded(Node *newFocusNode)
2170 {
2171     if (!frame())
2172         return;
2173
2174     // Clear the selection when changing the focus node to null or to a node that is not 
2175     // contained by the current selection.
2176     Node *startContainer = frame()->selectionController()->start().node();
2177     if (!newFocusNode || (startContainer && startContainer != newFocusNode && !(startContainer->isDescendantOf(newFocusNode)) && startContainer->shadowAncestorNode() != newFocusNode))
2178         frame()->selectionController()->clear();
2179 }
2180
2181 void Document::setCSSTarget(Node* n)
2182 {
2183     if (m_cssTarget)
2184         m_cssTarget->setChanged();
2185     m_cssTarget = n;
2186     if (n)
2187         n->setChanged();
2188 }
2189
2190 Node* Document::getCSSTarget() const
2191 {
2192     return m_cssTarget;
2193 }
2194
2195 void Document::attachNodeIterator(NodeIterator *ni)
2196 {
2197     m_nodeIterators.append(ni);
2198 }
2199
2200 void Document::detachNodeIterator(NodeIterator *ni)
2201 {
2202     m_nodeIterators.remove(ni);
2203 }
2204
2205 void Document::notifyBeforeNodeRemoval(Node *n)
2206 {
2207     if (Frame* f = frame()) {
2208         f->selectionController()->nodeWillBeRemoved(n);
2209         f->dragCaretController()->nodeWillBeRemoved(n);
2210     }
2211     DeprecatedPtrListIterator<NodeIterator> it(m_nodeIterators);
2212     for (; it.current(); ++it)
2213         it.current()->notifyBeforeNodeRemoval(n);
2214 }
2215
2216 DOMWindow* Document::defaultView() const
2217 {
2218     if (!frame())
2219         return 0;
2220     
2221     return frame()->domWindow();
2222 }
2223
2224 PassRefPtr<Event> Document::createEvent(const String &eventType, ExceptionCode& ec)
2225 {
2226     if (eventType == "UIEvents" || eventType == "UIEvent")
2227         return new UIEvent();
2228     if (eventType == "MouseEvents" || eventType == "MouseEvent")
2229         return new MouseEvent();
2230     if (eventType == "MutationEvents" || eventType == "MutationEvent")
2231         return new MutationEvent();
2232     if (eventType == "KeyboardEvents" || eventType == "KeyboardEvent")
2233         return new KeyboardEvent();
2234     if (eventType == "HTMLEvents" || eventType == "Event" || eventType == "Events")
2235         return new Event();
2236 #ifdef SVG_SUPPORT
2237     if (eventType == "SVGEvents")
2238         return new Event();
2239     if (eventType == "SVGZoomEvents")
2240         return new SVGZoomEvent();
2241 #endif
2242     ec = NOT_SUPPORTED_ERR;
2243     return 0;
2244 }
2245
2246 CSSStyleDeclaration *Document::getOverrideStyle(Element */*elt*/, const String &/*pseudoElt*/)
2247 {
2248     return 0; // ###
2249 }
2250
2251 void Document::handleWindowEvent(Event *evt, bool useCapture)
2252 {
2253     if (m_windowEventListeners.isEmpty())
2254         return;
2255         
2256     // if any html event listeners are registered on the window, then dispatch them here
2257     RegisteredEventListenerList listenersCopy = m_windowEventListeners;
2258     RegisteredEventListenerList::iterator it = listenersCopy.begin();
2259     
2260     for (; it != listenersCopy.end(); ++it)
2261         if ((*it)->eventType() == evt->type() && (*it)->useCapture() == useCapture && !(*it)->removed()) 
2262             (*it)->listener()->handleEvent(evt, true);
2263 }
2264
2265
2266 void Document::defaultEventHandler(Event *evt)
2267 {
2268     // handle accesskey
2269     if (evt->type() == keydownEvent) {
2270         KeyboardEvent* kevt = static_cast<KeyboardEvent *>(evt);
2271         if (kevt->ctrlKey()) {
2272             const PlatformKeyboardEvent* ev = kevt->keyEvent();
2273             String key = (ev ? ev->unmodifiedText() : kevt->keyIdentifier()).lower();
2274             Element* elem = getElementByAccessKey(key);
2275             if (elem) {
2276                 elem->accessKeyAction(false);
2277                 evt->setDefaultHandled();
2278             }
2279         }
2280     }
2281 }
2282
2283 void Document::setHTMLWindowEventListener(const AtomicString &eventType, PassRefPtr<EventListener> listener)
2284 {
2285     // If we already have it we don't want removeWindowEventListener to delete it
2286     removeHTMLWindowEventListener(eventType);
2287     if (listener)
2288         addWindowEventListener(eventType, listener, false);
2289 }
2290
2291 EventListener *Document::getHTMLWindowEventListener(const AtomicString &eventType)
2292 {
2293     RegisteredEventListenerList::iterator it = m_windowEventListeners.begin();
2294        for (; it != m_windowEventListeners.end(); ++it)
2295         if ( (*it)->eventType() == eventType && (*it)->listener()->isHTMLEventListener())
2296             return (*it)->listener();
2297     return 0;
2298 }
2299
2300 void Document::removeHTMLWindowEventListener(const AtomicString &eventType)
2301 {
2302     RegisteredEventListenerList::iterator it = m_windowEventListeners.begin();
2303     for (; it != m_windowEventListeners.end(); ++it)
2304         if ( (*it)->eventType() == eventType && (*it)->listener()->isHTMLEventListener()) {
2305             m_windowEventListeners.remove(it);
2306             return;
2307         }
2308 }
2309
2310 void Document::addWindowEventListener(const AtomicString &eventType, PassRefPtr<EventListener> listener, bool useCapture)
2311 {
2312     // Remove existing identical listener set with identical arguments.
2313     // The DOM 2 spec says that "duplicate instances are discarded" in this case.
2314     removeWindowEventListener(eventType, listener.get(), useCapture);
2315     m_windowEventListeners.append(new RegisteredEventListener(eventType, listener, useCapture));
2316 }
2317
2318 void Document::removeWindowEventListener(const AtomicString &eventType, EventListener *listener, bool useCapture)
2319 {
2320     RegisteredEventListener rl(eventType, listener, useCapture);
2321     RegisteredEventListenerList::iterator it = m_windowEventListeners.begin();
2322     for (; it != m_windowEventListeners.end(); ++it)
2323         if (*(*it) == rl) {
2324             m_windowEventListeners.remove(it);
2325             return;
2326         }
2327 }
2328
2329 bool Document::hasWindowEventListener(const AtomicString &eventType)
2330 {
2331     RegisteredEventListenerList::iterator it = m_windowEventListeners.begin();
2332     for (; it != m_windowEventListeners.end(); ++it)
2333         if ((*it)->eventType() == eventType) {
2334             return true;
2335         }
2336     return false;
2337 }
2338
2339 PassRefPtr<EventListener> Document::createHTMLEventListener(const String& functionName, const String& code, Node *node)
2340 {
2341     if (Frame* frm = frame())
2342         if (KJSProxy* proxy = frm->jScript())
2343             return proxy->createHTMLEventHandler(functionName, code, node);
2344     return 0;
2345 }
2346
2347 void Document::setHTMLWindowEventListener(const AtomicString& eventType, Attribute* attr)
2348 {
2349     setHTMLWindowEventListener(eventType,
2350         createHTMLEventListener(attr->localName().domString(), attr->value(), 0));
2351 }
2352
2353 void Document::dispatchImageLoadEventSoon(HTMLImageLoader *image)
2354 {
2355     m_imageLoadEventDispatchSoonList.append(image);
2356     if (!m_imageLoadEventTimer.isActive())
2357         m_imageLoadEventTimer.startOneShot(0);
2358 }
2359
2360 void Document::removeImage(HTMLImageLoader* image)
2361 {
2362     // Remove instances of this image from both lists.
2363     // Use loops because we allow multiple instances to get into the lists.
2364     while (m_imageLoadEventDispatchSoonList.removeRef(image)) { }
2365     while (m_imageLoadEventDispatchingList.removeRef(image)) { }
2366     if (m_imageLoadEventDispatchSoonList.isEmpty())
2367         m_imageLoadEventTimer.stop();
2368 }
2369
2370 void Document::dispatchImageLoadEventsNow()
2371 {
2372     // need to avoid re-entering this function; if new dispatches are
2373     // scheduled before the parent finishes processing the list, they
2374     // will set a timer and eventually be processed
2375     if (!m_imageLoadEventDispatchingList.isEmpty()) {
2376         return;
2377     }
2378
2379     m_imageLoadEventTimer.stop();
2380     
2381     m_imageLoadEventDispatchingList = m_imageLoadEventDispatchSoonList;
2382     m_imageLoadEventDispatchSoonList.clear();
2383     for (DeprecatedPtrListIterator<HTMLImageLoader> it(m_imageLoadEventDispatchingList); it.current();) {
2384         HTMLImageLoader* image = it.current();
2385         // Must advance iterator *before* dispatching call.
2386         // Otherwise, it might be advanced automatically if dispatching the call had a side effect
2387         // of destroying the current HTMLImageLoader, and then we would advance past the *next* item,
2388         // missing one altogether.
2389         ++it;
2390         image->dispatchLoadEvent();
2391     }
2392     m_imageLoadEventDispatchingList.clear();
2393 }
2394
2395 void Document::imageLoadEventTimerFired(Timer<Document>*)
2396 {
2397     dispatchImageLoadEventsNow();
2398 }
2399
2400 Element *Document::ownerElement() const
2401 {
2402     if (!frame())
2403         return 0;
2404     return frame()->ownerElement();
2405 }
2406
2407 String Document::referrer() const
2408 {
2409     if (frame())
2410         return frame()->incomingReferrer();
2411     
2412     return String();
2413 }
2414
2415 String Document::domain() const
2416 {
2417     if (m_domain.isEmpty()) // not set yet (we set it on demand to save time and space)
2418         m_domain = KURL(URL()).host(); // Initially set to the host
2419     return m_domain;
2420 }
2421
2422 void Document::setDomain(const String &newDomain, bool force /*=false*/)
2423 {
2424     if (force) {
2425         m_domain = newDomain;
2426         return;
2427     }
2428     if (m_domain.isEmpty()) // not set yet (we set it on demand to save time and space)
2429         m_domain = KURL(URL()).host(); // Initially set to the host
2430
2431     // Both NS and IE specify that changing the domain is only allowed when
2432     // the new domain is a suffix of the old domain.
2433     int oldLength = m_domain.length();
2434     int newLength = newDomain.length();
2435     if (newLength < oldLength) // e.g. newDomain=kde.org (7) and m_domain=www.kde.org (11)
2436     {
2437         String test = m_domain.copy();
2438         if (test[oldLength - newLength - 1] == '.') // Check that it's a subdomain, not e.g. "de.org"
2439         {
2440             test.remove(0, oldLength - newLength); // now test is "kde.org" from m_domain
2441             if (test == newDomain)                 // and we check that it's the same thing as newDomain
2442                 m_domain = newDomain;
2443         }
2444     }
2445 }
2446
2447 bool Document::isValidName(const String &name)
2448 {
2449     const UChar* s = reinterpret_cast<const UChar*>(name.characters());
2450     unsigned length = name.length();
2451
2452     if (length == 0)
2453         return false;
2454
2455     unsigned i = 0;
2456
2457     UChar32 c;
2458     U16_NEXT(s, i, length, c)
2459     if (!isValidNameStart(c))
2460         return false;
2461
2462     while (i < length) {
2463         U16_NEXT(s, i, length, c)
2464         if (!isValidNamePart(c))
2465             return false;
2466     }
2467
2468     return true;
2469 }
2470
2471 bool Document::parseQualifiedName(const String &qualifiedName, String &prefix, String &localName)
2472 {
2473     unsigned length = qualifiedName.length();
2474
2475     if (length == 0)
2476         return false;
2477
2478     bool nameStart = true;
2479     bool sawColon = false;
2480     int colonPos = 0;
2481
2482     const UChar* s = reinterpret_cast<const UChar*>(qualifiedName.characters());
2483     for (unsigned i = 0; i < length;) {
2484         UChar32 c;
2485         U16_NEXT(s, i, length, c)
2486         if (c == ':') {
2487             if (sawColon)
2488                 return false; // multiple colons: not allowed
2489             nameStart = true;
2490             sawColon = true;
2491             colonPos = i - 1;
2492         } else if (nameStart) {
2493             if (!isValidNameStart(c))
2494                 return false;
2495             nameStart = false;
2496         } else {
2497             if (!isValidNamePart(c))
2498                 return false;
2499         }
2500     }
2501
2502     if (!sawColon) {
2503         prefix = String();
2504         localName = qualifiedName.copy();
2505     } else {
2506         prefix = qualifiedName.substring(0, colonPos);
2507         localName = qualifiedName.substring(colonPos + 1, length - (colonPos + 1));
2508     }
2509
2510     return true;
2511 }
2512
2513 void Document::addImageMap(HTMLMapElement* imageMap)
2514 {
2515     // Add the image map, unless there's already another with that name.
2516     // "First map wins" is the rule other browsers seem to implement.
2517     m_imageMapsByName.add(imageMap->getName().impl(), imageMap);
2518 }
2519
2520 void Document::removeImageMap(HTMLMapElement* imageMap)
2521 {
2522     // Remove the image map by name.
2523     // But don't remove some other image map that just happens to have the same name.
2524     // FIXME: Use a HashCountedSet as we do for IDs to find the first remaining map
2525     // once a map has been removed.
2526     const AtomicString& name = imageMap->getName();
2527     ImageMapsByName::iterator it = m_imageMapsByName.find(name.impl());
2528     if (it != m_imageMapsByName.end() && it->second == imageMap)
2529         m_imageMapsByName.remove(it);
2530 }
2531
2532 HTMLMapElement *Document::getImageMap(const String& URL) const
2533 {
2534     if (URL.isNull())
2535         return 0;
2536     int hashPos = URL.find('#');
2537     AtomicString name = (hashPos < 0 ? URL : URL.substring(hashPos + 1)).impl();
2538     return m_imageMapsByName.get(name.impl());
2539 }
2540
2541 void Document::setDecoder(Decoder *decoder)
2542 {
2543     m_decoder = decoder;
2544 }
2545
2546 UChar Document::backslashAsCurrencySymbol() const
2547 {
2548     if (!m_decoder)
2549         return '\\';
2550     return m_decoder->encoding().backslashAsCurrencySymbol();
2551 }
2552
2553 DeprecatedString Document::completeURL(const DeprecatedString &URL)
2554 {
2555     // If both the URL and base URL are empty, like they are for documents
2556     // created using DOMImplementation::createDocument, just return the passed in URL.
2557     // (We do this because URL() returns "about:blank" for empty URLs.
2558     if (m_url.isEmpty() && m_baseURL.isEmpty())
2559         return URL;
2560     
2561     if (!m_decoder)
2562         return KURL(baseURL(), URL).url();
2563     return KURL(baseURL(), URL, m_decoder->encoding()).url();
2564 }
2565
2566 String Document::completeURL(const String &URL)
2567 {
2568     if (URL.isNull())
2569         return URL;
2570     return completeURL(URL.deprecatedString());
2571 }
2572
2573 bool Document::inPageCache()
2574 {
2575     return m_inPageCache;
2576 }
2577
2578 void Document::setInPageCache(bool flag)
2579 {
2580     if (m_inPageCache == flag)
2581         return;
2582
2583     m_inPageCache = flag;
2584     if (flag) {
2585         ASSERT(m_savedRenderer == 0);
2586         m_savedRenderer = renderer();
2587         if (m_view)
2588             m_view->resetScrollBars();
2589     } else {
2590         ASSERT(renderer() == 0 || renderer() == m_savedRenderer);
2591         ASSERT(m_renderArena);
2592         setRenderer(m_savedRenderer);
2593         m_savedRenderer = 0;
2594     }
2595 }
2596
2597 void Document::passwordFieldAdded()
2598 {
2599     m_passwordFields++;
2600 }
2601
2602 void Document::passwordFieldRemoved()
2603 {
2604     assert(m_passwordFields > 0);
2605     m_passwordFields--;
2606 }
2607
2608 bool Document::hasPasswordField() const
2609 {
2610     return m_passwordFields > 0;
2611 }
2612
2613 void Document::secureFormAdded()
2614 {
2615     m_secureForms++;
2616 }
2617
2618 void Document::secureFormRemoved()
2619 {
2620     assert(m_secureForms > 0);
2621     m_secureForms--;
2622 }
2623
2624 bool Document::hasSecureForm() const
2625 {
2626     return m_secureForms > 0;
2627 }
2628
2629 void Document::setShouldCreateRenderers(bool f)
2630 {
2631     m_createRenderers = f;
2632 }
2633
2634 bool Document::shouldCreateRenderers()
2635 {
2636     return m_createRenderers;
2637 }
2638
2639 String Document::toString() const
2640 {
2641     String result;
2642
2643     for (Node *child = firstChild(); child != NULL; child = child->nextSibling()) {
2644         result += child->toString();
2645     }
2646
2647     return result;
2648 }
2649
2650 // Support for Javascript execCommand, and related methods
2651
2652 JSEditor *Document::jsEditor()
2653 {
2654     if (!m_jsEditor)
2655         m_jsEditor = new JSEditor(this);
2656     return m_jsEditor;
2657 }
2658
2659 bool Document::execCommand(const String &command, bool userInterface, const String &value)
2660 {
2661     return jsEditor()->execCommand(command, userInterface, value);
2662 }
2663
2664 bool Document::queryCommandEnabled(const String &command)
2665 {
2666     return jsEditor()->queryCommandEnabled(command);
2667 }
2668
2669 bool Document::queryCommandIndeterm(const String &command)
2670 {
2671     return jsEditor()->queryCommandIndeterm(command);
2672 }
2673
2674 bool Document::queryCommandState(const String &command)
2675 {
2676     return jsEditor()->queryCommandState(command);
2677 }
2678
2679 bool Document::queryCommandSupported(const String &command)
2680 {
2681     return jsEditor()->queryCommandSupported(command);
2682 }
2683
2684 String Document::queryCommandValue(const String &command)
2685 {
2686     return jsEditor()->queryCommandValue(command);
2687 }
2688
2689 static IntRect placeholderRectForMarker(void)
2690 {
2691     return IntRect(-1,-1,-1,-1);
2692 }
2693
2694 void Document::addMarker(Range *range, DocumentMarker::MarkerType type)
2695 {
2696     // Use a TextIterator to visit the potentially multiple nodes the range covers.
2697     for (TextIterator markedText(range); !markedText.atEnd(); markedText.advance()) {
2698         RefPtr<Range> textPiece = markedText.range();
2699         int exception = 0;
2700         DocumentMarker marker = {type, textPiece->startOffset(exception), textPiece->endOffset(exception)};
2701         addMarker(textPiece->startContainer(exception), marker);
2702     }
2703 }
2704
2705 void Document::removeMarkers(Range *range, DocumentMarker::MarkerType markerType)
2706 {
2707     // Use a TextIterator to visit the potentially multiple nodes the range covers.
2708     for (TextIterator markedText(range); !markedText.atEnd(); markedText.advance()) {
2709         RefPtr<Range> textPiece = markedText.range();
2710         int exception = 0;
2711         unsigned startOffset = textPiece->startOffset(exception);
2712         unsigned length = textPiece->endOffset(exception) - startOffset + 1;
2713         removeMarkers(textPiece->startContainer(exception), startOffset, length, markerType);
2714     }
2715 }
2716
2717 // Markers are stored in order sorted by their location.  They do not overlap each other, as currently
2718 // required by the drawing code in RenderText.cpp.
2719
2720 void Document::addMarker(Node *node, DocumentMarker newMarker) 
2721 {
2722     assert(newMarker.endOffset >= newMarker.startOffset);
2723     if (newMarker.endOffset == newMarker.startOffset)
2724         return;
2725     
2726     MarkerMapVectorPair* vectorPair = m_markers.get(node);
2727     
2728     if (!vectorPair) {
2729         vectorPair = new MarkerMapVectorPair;
2730         vectorPair->first.append(newMarker);
2731         vectorPair->second.append(placeholderRectForMarker());
2732         m_markers.set(node, vectorPair);
2733     } else {
2734         Vector<DocumentMarker>& markers = vectorPair->first;
2735         Vector<IntRect>& rects = vectorPair->second;
2736         ASSERT(markers.size() == rects.size());
2737         Vector<DocumentMarker>::iterator it;
2738         for (it = markers.begin(); it != markers.end();) {
2739             DocumentMarker marker = *it;
2740             
2741             if (newMarker.endOffset < marker.startOffset+1) {
2742                 // This is the first marker that is completely after newMarker, and disjoint from it.
2743                 // We found our insertion point.\10
2744                 break;
2745             } else if (newMarker.startOffset > marker.endOffset) {
2746                 // maker is before newMarker, and disjoint from it.  Keep scanning.
2747                 it++;
2748             } else if (newMarker == marker) {
2749                 // already have this one, NOP
2750                 return;
2751             } else {
2752                 // marker and newMarker intersect or touch - merge them into newMarker
2753                 newMarker.startOffset = min(newMarker.startOffset, marker.startOffset);
2754                 newMarker.endOffset = max(newMarker.endOffset, marker.endOffset);
2755                 // remove old one, we'll add newMarker later
2756                 unsigned removalIndex = it - markers.begin();
2757                 markers.remove(removalIndex);
2758                 rects.remove(removalIndex);
2759                 // it points to the next marker to consider
2760             }
2761         }
2762         // at this point it points to the node before which we want to insert
2763         unsigned insertionIndex = it - markers.begin();
2764         markers.insert(insertionIndex, newMarker);
2765         rects.insert(insertionIndex, placeholderRectForMarker());
2766     }
2767     
2768     // repaint the affected node
2769     if (node->renderer())
2770         node->renderer()->repaint();
2771 }
2772
2773 // copies markers from srcNode to dstNode, applying the specified shift delta to the copies.  The shift is
2774 // useful if, e.g., the caller has created the dstNode from a non-prefix substring of the srcNode.
2775 void Document::copyMarkers(Node *srcNode, unsigned startOffset, int length, Node *dstNode, int delta, DocumentMarker::MarkerType markerType)
2776 {
2777     if (length <= 0)
2778         return;
2779     
2780     MarkerMapVectorPair* vectorPair = m_markers.get(srcNode);
2781     if (!vectorPair)
2782         return;
2783
2784     ASSERT(vectorPair->first.size() == vectorPair->second.size());
2785
2786     bool docDirty = false;
2787     unsigned endOffset = startOffset + length - 1;
2788     Vector<DocumentMarker>::iterator it;
2789     Vector<DocumentMarker>& markers = vectorPair->first;
2790     for (it = markers.begin(); it != markers.end(); ++it) {
2791         DocumentMarker marker = *it;
2792
2793         // stop if we are now past the specified range
2794         if (marker.startOffset > endOffset)
2795             break;
2796         
2797         // skip marker that is before the specified range or is the wrong type
2798         if (marker.endOffset < startOffset || (marker.type != markerType && markerType != DocumentMarker::AllMarkers))
2799             continue;
2800
2801         // pin the marker to the specified range and apply the shift delta
2802         docDirty = true;
2803         if (marker.startOffset < startOffset)
2804             marker.startOffset = startOffset;
2805         if (marker.endOffset > endOffset)
2806             marker.endOffset = endOffset;
2807         marker.startOffset += delta;
2808         marker.endOffset += delta;
2809         
2810         addMarker(dstNode, marker);
2811     }
2812     
2813     // repaint the affected node
2814     if (docDirty && dstNode->renderer())
2815         dstNode->renderer()->repaint();
2816 }
2817
2818 void Document::removeMarkers(Node *node, unsigned startOffset, int length, DocumentMarker::MarkerType markerType)
2819 {
2820     if (length <= 0)
2821         return;
2822
2823     MarkerMapVectorPair* vectorPair = m_markers.get(node);
2824     if (!vectorPair)
2825         return;
2826
2827     Vector<DocumentMarker>& markers = vectorPair->first;
2828     Vector<IntRect>& rects = vectorPair->second;
2829     ASSERT(markers.size() == rects.size());
2830     bool docDirty = false;
2831     unsigned endOffset = startOffset + length - 1;
2832     Vector<DocumentMarker>::iterator it;
2833     for (it = markers.begin(); it < markers.end();) {
2834         DocumentMarker marker = *it;
2835
2836         // markers are returned in order, so stop if we are now past the specified range
2837         if (marker.startOffset > endOffset)
2838             break;
2839         
2840         // skip marker that is wrong type or before target
2841         if (marker.endOffset < startOffset || (marker.type != markerType && markerType != DocumentMarker::AllMarkers)) {
2842             it++;
2843             continue;
2844         }
2845
2846         // at this point we know that marker and target intersect in some way
2847         docDirty = true;
2848
2849         // pitch the old marker and any associated rect
2850         unsigned removalIndex = it - markers.begin();
2851         markers.remove(removalIndex);
2852         rects.remove(removalIndex);
2853         // it now points to the next node
2854         
2855         // add either of the resulting slices that are left after removing target
2856         if (startOffset > marker.startOffset) {
2857             DocumentMarker newLeft = marker;
2858             newLeft.endOffset = startOffset;
2859             unsigned insertionIndex = it - markers.begin();
2860             markers.insert(insertionIndex, newLeft);
2861             rects.insert(insertionIndex, placeholderRectForMarker());
2862             // it now points to the newly-inserted node, but we want to skip that one
2863             it++;
2864         }
2865         if (marker.endOffset > endOffset) {
2866             DocumentMarker newRight = marker;
2867             newRight.startOffset = endOffset;
2868             unsigned insertionIndex = it - markers.begin();
2869             markers.insert(insertionIndex, newRight);
2870             rects.insert(insertionIndex, placeholderRectForMarker());
2871             // it now points to the newly-inserted node, but we want to skip that one
2872             it++;
2873         }
2874     }
2875
2876     if (markers.isEmpty()) {
2877         ASSERT(rects.isEmpty());
2878         m_markers.remove(node);
2879         delete vectorPair;
2880     }
2881
2882     // repaint the affected node
2883     if (docDirty && node->renderer())
2884         node->renderer()->repaint();
2885 }
2886
2887 Vector<DocumentMarker> Document::markersForNode(Node* node)
2888 {
2889     MarkerMapVectorPair* vectorPair = m_markers.get(node);
2890     if (vectorPair)
2891         return vectorPair->first;
2892     return Vector<DocumentMarker>();
2893 }
2894
2895 Vector<IntRect> Document::renderedRectsForMarkers(DocumentMarker::MarkerType markerType)
2896 {
2897     Vector<IntRect> result;
2898     
2899     // outer loop: process each node
2900     MarkerMap::iterator end = m_markers.end();
2901     for (MarkerMap::iterator nodeIterator = m_markers.begin(); nodeIterator != end; ++nodeIterator) {
2902         // inner loop; process each marker in this node
2903         MarkerMapVectorPair* vectorPair = nodeIterator->second;
2904         Vector<DocumentMarker>& markers = vectorPair->first;
2905         Vector<IntRect>& rects = vectorPair->second;
2906         ASSERT(markers.size() == rects.size());
2907         unsigned markerCount = markers.size();
2908         for (unsigned markerIndex = 0; markerIndex < markerCount; ++markerIndex) {
2909             DocumentMarker marker = markers[markerIndex];
2910             
2911             // skip marker that is wrong type
2912             if (marker.type != markerType && markerType != DocumentMarker::AllMarkers)
2913                 continue;
2914             
2915             IntRect r = rects[markerIndex];
2916             // skip placeholder rects
2917             if (r == placeholderRectForMarker())
2918                 continue;
2919
2920             result.append(r);
2921         }
2922     }
2923     
2924     return result;
2925 }
2926
2927
2928 void Document::removeMarkers(Node* node)
2929 {
2930     MarkerMap::iterator i = m_markers.find(node);
2931     if (i != m_markers.end()) {
2932         delete i->second;
2933         m_markers.remove(i);
2934         if (RenderObject* renderer = node->renderer())
2935             renderer->repaint();
2936     }
2937 }
2938
2939 void Document::removeMarkers(DocumentMarker::MarkerType markerType)
2940 {
2941     // outer loop: process each markered node in the document
2942     MarkerMap markerMapCopy = m_markers;
2943     MarkerMap::iterator end = markerMapCopy.end();
2944     for (MarkerMap::iterator i = markerMapCopy.begin(); i != end; ++i) {
2945         Node* node = i->first.get();
2946         bool nodeNeedsRepaint = false;
2947
2948         // inner loop: process each marker in the current node
2949         MarkerMapVectorPair* vectorPair = i->second;
2950         Vector<DocumentMarker>& markers = vectorPair->first;
2951         Vector<IntRect>& rects = vectorPair->second;
2952         ASSERT(markers.size() == rects.size());
2953         Vector<DocumentMarker>::iterator markerIterator;
2954         for (markerIterator = markers.begin(); markerIterator != markers.end();) {
2955             DocumentMarker marker = *markerIterator;
2956
2957             // skip nodes that are not of the specified type
2958             if (marker.type != markerType && markerType != DocumentMarker::AllMarkers) {
2959                 ++markerIterator;
2960                 continue;
2961             }
2962
2963             // pitch the old marker
2964             markers.remove(markerIterator - markers.begin());
2965             rects.remove(markerIterator - markers.begin());
2966             nodeNeedsRepaint = true;
2967             // markerIterator now points to the next node
2968         }
2969
2970         // Redraw the node if it changed. Do this before the node is removed from m_markers, since 
2971         // m_markers might contain the last reference to the node.
2972         if (nodeNeedsRepaint) {
2973             RenderObject* renderer = node->renderer();
2974             if (renderer)
2975                 renderer->repaint();
2976         }
2977
2978         // delete the node's list if it is now empty
2979         if (markers.isEmpty()) {
2980             ASSERT(rects.isEmpty());
2981             m_markers.remove(node);
2982             delete vectorPair;
2983         }
2984     }
2985 }
2986
2987 void Document::repaintMarkers(DocumentMarker::MarkerType markerType)
2988 {
2989     // outer loop: process each markered node in the document
2990     MarkerMap::iterator end = m_markers.end();
2991     for (MarkerMap::iterator i = m_markers.begin(); i != end; ++i) {
2992         Node* node = i->first.get();
2993         
2994         // inner loop: process each marker in the current node
2995         MarkerMapVectorPair* vectorPair = i->second;
2996         Vector<DocumentMarker>& markers = vectorPair->first;
2997         Vector<DocumentMarker>::iterator markerIterator;
2998         bool nodeNeedsRepaint = false;
2999         for (markerIterator = markers.begin(); markerIterator != markers.end(); ++markerIterator) {
3000             DocumentMarker marker = *markerIterator;
3001             
3002             // skip nodes that are not of the specified type
3003             if (marker.type == markerType || markerType == DocumentMarker::AllMarkers) {
3004                 nodeNeedsRepaint = true;
3005                 break;
3006             }
3007         }
3008         
3009         if (!nodeNeedsRepaint)
3010             continue;
3011         
3012         // cause the node to be redrawn
3013         if (RenderObject* renderer = node->renderer())
3014             renderer->repaint();
3015     }
3016 }
3017
3018 void Document::setRenderedRectForMarker(Node* node, DocumentMarker marker, const IntRect& r)
3019 {
3020     MarkerMapVectorPair* vectorPair = m_markers.get(node);
3021     if (!vectorPair) {
3022         ASSERT_NOT_REACHED(); // shouldn't be trying to set the rect for a marker we don't already know about
3023         return;
3024     }
3025     
3026     Vector<DocumentMarker>& markers = vectorPair->first;
3027     ASSERT(markers.size() == vectorPair->second.size());
3028     unsigned markerCount = markers.size();
3029     for (unsigned markerIndex = 0; markerIndex < markerCount; ++markerIndex) {
3030         DocumentMarker m = markers[markerIndex];
3031         if (m == marker) {
3032             vectorPair->second[markerIndex] = r;
3033             return;
3034         }
3035     }
3036     
3037     ASSERT_NOT_REACHED(); // shouldn't be trying to set the rect for a marker we don't already know about
3038 }
3039
3040 void Document::invalidateRenderedRectsForMarkersInRect(const IntRect& r)
3041 {
3042     // outer loop: process each markered node in the document
3043     MarkerMap::iterator end = m_markers.end();
3044     for (MarkerMap::iterator i = m_markers.begin(); i != end; ++i) {
3045         
3046         // inner loop: process each rect in the current node
3047         MarkerMapVectorPair* vectorPair = i->second;
3048         Vector<IntRect>& rects = vectorPair->second;
3049         
3050         unsigned rectCount = rects.size();
3051         for (unsigned rectIndex = 0; rectIndex < rectCount; ++rectIndex)
3052             if (rects[rectIndex].intersects(r))
3053                 rects[rectIndex] = placeholderRectForMarker();
3054     }
3055 }
3056
3057 void Document::shiftMarkers(Node *node, unsigned startOffset, int delta, DocumentMarker::MarkerType markerType)
3058 {
3059     MarkerMapVectorPair* vectorPair = m_markers.get(node);
3060     if (!vectorPair)
3061         return;
3062     
3063     Vector<DocumentMarker>& markers = vectorPair->first;
3064     Vector<IntRect>& rects = vectorPair->second;
3065     ASSERT(markers.size() == rects.size());
3066     
3067     bool docDirty = false;
3068     Vector<DocumentMarker>::iterator it;
3069     for (it = markers.begin(); it != markers.end(); ++it) {
3070         DocumentMarker &marker = *it;
3071         if (marker.startOffset >= startOffset && (markerType == DocumentMarker::AllMarkers || marker.type == markerType)) {
3072             assert((int)marker.startOffset + delta >= 0);
3073             marker.startOffset += delta;
3074             marker.endOffset += delta;
3075             docDirty = true;
3076             
3077             // Marker moved, so previously-computed rendered rectangle is now invalid
3078             rects[it - markers.begin()] = placeholderRectForMarker();
3079         }
3080     }
3081     
3082     // repaint the affected node
3083     if (docDirty && node->renderer())
3084         node->renderer()->repaint();
3085 }
3086
3087 #ifdef XSLT_SUPPORT
3088
3089 void Document::applyXSLTransform(ProcessingInstruction* pi)
3090 {
3091     RefPtr<XSLTProcessor> processor = new XSLTProcessor;
3092     processor->setXSLStylesheet(static_cast<XSLStyleSheet*>(pi->sheet()));
3093     
3094     DeprecatedString resultMIMEType;
3095     DeprecatedString newSource;
3096     DeprecatedString resultEncoding;
3097     if (!processor->transformToString(this, resultMIMEType, newSource, resultEncoding))
3098         return;
3099     // FIXME: If the transform failed we should probably report an error (like Mozilla does).
3100     processor->createDocumentFromSource(newSource, resultEncoding, resultMIMEType, this, view());
3101 }
3102
3103 #endif
3104
3105 void Document::setDesignMode(InheritedBool value)
3106 {
3107     m_designMode = value;
3108 }
3109
3110 Document::InheritedBool Document::getDesignMode() const
3111 {
3112     return m_designMode;
3113 }
3114
3115 bool Document::inDesignMode() const
3116 {
3117     for (const Document* d = this; d; d = d->parentDocument()) {
3118         if (d->m_designMode != inherit)
3119             return d->m_designMode;
3120     }
3121     return false;
3122 }
3123
3124 Document *Document::parentDocument() const
3125 {
3126     Frame *childPart = frame();
3127     if (!childPart)
3128         return 0;
3129     Frame *parent = childPart->tree()->parent();
3130     if (!parent)
3131         return 0;
3132     return parent->document();
3133 }
3134
3135 Document *Document::topDocument() const
3136 {
3137     Document *doc = const_cast<Document *>(this);
3138     Element *element;
3139     while ((element = doc->ownerElement()) != 0)
3140         doc = element->document();
3141     
3142     return doc;
3143 }
3144
3145 PassRefPtr<Attr> Document::createAttributeNS(const String &namespaceURI, const String &qualifiedName, ExceptionCode& ec)
3146 {
3147     if (qualifiedName.isNull()) {
3148         ec = NAMESPACE_ERR;
3149         return 0;
3150     }
3151
3152     String localName = qualifiedName;
3153     String prefix;
3154     int colonpos;
3155     if ((colonpos = qualifiedName.find(':')) >= 0) {
3156         prefix = qualifiedName.copy();
3157         localName = qualifiedName.copy();
3158         prefix.truncate(colonpos);
3159         localName.remove(0, colonpos+1);
3160     }
3161
3162     if (!isValidName(localName)) {
3163         ec = INVALID_CHARACTER_ERR;
3164         return 0;
3165     }
3166     
3167     // FIXME: Assume this is a mapped attribute, since createAttribute isn't namespace-aware.  There's no harm to XML
3168     // documents if we're wrong.
3169     return new Attr(0, this, new MappedAttribute(QualifiedName(prefix.impl(), 
3170                                                                        localName.impl(),
3171                                                                        namespaceURI.impl()), String("").impl()));
3172 }
3173
3174 #ifdef SVG_SUPPORT
3175 const SVGDocumentExtensions* Document::svgExtensions()
3176 {
3177     return m_svgExtensions;
3178 }
3179
3180 SVGDocumentExtensions* Document::accessSVGExtensions()
3181 {
3182     if (!m_svgExtensions)
3183         m_svgExtensions = new SVGDocumentExtensions(this);
3184     return m_svgExtensions;
3185 }
3186 #endif
3187
3188 void Document::radioButtonChecked(HTMLInputElement *caller, HTMLFormElement *form)
3189 {
3190     // Without a name, there is no group.
3191     if (caller->name().isEmpty())
3192         return;
3193     if (!form)
3194         form = defaultForm;
3195     // Uncheck the currently selected item
3196     NameToInputMap* formRadioButtons = m_selectedRadioButtons.get(form);
3197     if (!formRadioButtons) {
3198         formRadioButtons = new NameToInputMap;
3199         m_selectedRadioButtons.set(form, formRadioButtons);
3200     }
3201     
3202     HTMLInputElement* currentCheckedRadio = formRadioButtons->get(caller->name().impl());
3203     if (currentCheckedRadio && currentCheckedRadio != caller)
3204         currentCheckedRadio->setChecked(false);
3205
3206     formRadioButtons->set(caller->name().impl(), caller);
3207 }
3208
3209 HTMLInputElement* Document::checkedRadioButtonForGroup(AtomicStringImpl* name, HTMLFormElement *form)
3210 {
3211     if (!form)
3212         form = defaultForm;
3213     NameToInputMap* formRadioButtons = m_selectedRadioButtons.get(form);
3214     if (!formRadioButtons)
3215         return 0;
3216     
3217     return formRadioButtons->get(name);
3218 }
3219
3220 void Document::removeRadioButtonGroup(AtomicStringImpl* name, HTMLFormElement *form)
3221 {
3222     if (!form)
3223         form = defaultForm;
3224     NameToInputMap* formRadioButtons = m_selectedRadioButtons.get(form);
3225     if (formRadioButtons) {
3226         formRadioButtons->remove(name);
3227         if (formRadioButtons->isEmpty()) {
3228             m_selectedRadioButtons.remove(form);
3229             delete formRadioButtons;
3230         }
3231     }
3232 }
3233
3234 PassRefPtr<HTMLCollection> Document::images()
3235 {
3236     return new HTMLCollection(this, HTMLCollection::DocImages);
3237 }
3238
3239 PassRefPtr<HTMLCollection> Document::applets()
3240 {
3241     return new HTMLCollection(this, HTMLCollection::DocApplets);
3242 }
3243
3244 PassRefPtr<HTMLCollection> Document::embeds()
3245 {
3246     return new HTMLCollection(this, HTMLCollection::DocEmbeds);
3247 }
3248
3249 PassRefPtr<HTMLCollection> Document::objects()
3250 {
3251     return new HTMLCollection(this, HTMLCollection::DocObjects);
3252 }
3253
3254 PassRefPtr<HTMLCollection> Document::scripts()
3255 {
3256     return new HTMLCollection(this, HTMLCollection::DocScripts);
3257 }
3258
3259 PassRefPtr<HTMLCollection> Document::links()
3260 {
3261     return new HTMLCollection(this, HTMLCollection::DocLinks);
3262 }
3263
3264 PassRefPtr<HTMLCollection> Document::forms()
3265 {
3266     return new HTMLCollection(this, HTMLCollection::DocForms);
3267 }
3268
3269 PassRefPtr<HTMLCollection> Document::anchors()
3270 {
3271     return new HTMLCollection(this, HTMLCollection::DocAnchors);
3272 }
3273
3274 PassRefPtr<HTMLCollection> Document::all()
3275 {
3276     return new HTMLCollection(this, HTMLCollection::DocAll);
3277 }
3278
3279 PassRefPtr<HTMLCollection> Document::windowNamedItems(const String &name)
3280 {
3281     return new HTMLNameCollection(this, HTMLCollection::WindowNamedItems, name);
3282 }
3283
3284 PassRefPtr<HTMLCollection> Document::documentNamedItems(const String &name)
3285 {
3286     return new HTMLNameCollection(this, HTMLCollection::DocumentNamedItems, name);
3287 }
3288
3289 HTMLCollection::CollectionInfo* Document::nameCollectionInfo(HTMLCollection::Type type, const String& name)
3290 {
3291     HashMap<AtomicStringImpl*, HTMLCollection::CollectionInfo>& map = m_nameCollectionInfo[type - HTMLCollection::UnnamedCollectionTypes];
3292     
3293     AtomicString atomicName(name);
3294     
3295     HashMap<AtomicStringImpl*, HTMLCollection::CollectionInfo>::iterator iter = map.find(atomicName.impl());
3296     if (iter == map.end())
3297         iter = map.add(atomicName.impl(), HTMLCollection::CollectionInfo()).first;
3298     
3299     return &iter->second;
3300 }
3301
3302 PassRefPtr<NameNodeList> Document::getElementsByName(const String &elementName)
3303 {
3304     return new NameNodeList(this, elementName);
3305 }
3306
3307 void Document::finishedParsing()
3308 {
3309     setParsing(false);
3310     if (Frame* f = frame())
3311         f->finishedParsing();
3312 }
3313
3314 Vector<String> Document::formElementsState() const
3315 {
3316     Vector<String> stateVector;
3317     stateVector.reserveCapacity(m_formElementsWithState.size() * 3);
3318     typedef HashSet<HTMLGenericFormElement*>::const_iterator Iterator;
3319     Iterator end = m_formElementsWithState.end();
3320     for (Iterator it = m_formElementsWithState.begin(); it != end; ++it) {
3321         HTMLGenericFormElement* e = *it;
3322         stateVector.append(e->name().domString());
3323         stateVector.append(e->type().domString());
3324         stateVector.append(e->stateValue());
3325     }
3326     return stateVector;
3327 }
3328
3329 #ifdef XPATH_SUPPORT
3330
3331 PassRefPtr<XPathExpression> Document::createExpression(const String& expression,
3332                                                        XPathNSResolver* resolver,
3333                                                        ExceptionCode& ec)
3334 {
3335     if (!m_xpathEvaluator)
3336         m_xpathEvaluator = new XPathEvaluator;
3337     return m_xpathEvaluator->createExpression(expression, resolver, ec);
3338 }
3339
3340 PassRefPtr<XPathNSResolver> Document::createNSResolver(Node* nodeResolver)
3341 {
3342     if (!m_xpathEvaluator)
3343         m_xpathEvaluator = new XPathEvaluator;
3344     return m_xpathEvaluator->createNSResolver(nodeResolver);
3345 }
3346
3347 PassRefPtr<XPathResult> Document::evaluate(const String& expression,
3348                                            Node* contextNode,
3349                                            XPathNSResolver* resolver,
3350                                            unsigned short type,
3351                                            XPathResult* result,
3352                                            ExceptionCode& ec)
3353 {
3354     if (!m_xpathEvaluator)
3355         m_xpathEvaluator = new XPathEvaluator;
3356     return m_xpathEvaluator->evaluate(expression, contextNode, resolver, type, result, ec);
3357 }
3358
3359 #endif // XPATH_SUPPORT
3360
3361 void Document::setStateForNewFormElements(const Vector<String>& stateVector)
3362 {
3363     // Walk the state vector backwards so that the value to use for each
3364     // name/type pair first is the one at the end of each individual vector
3365     // in the FormElementStateMap. We're using them like stacks.
3366     typedef FormElementStateMap::iterator Iterator;
3367     m_formElementsWithState.clear();
3368     for (size_t i = stateVector.size() / 3 * 3; i; i -= 3) {
3369         AtomicString a = stateVector[i - 3];
3370         AtomicString b = stateVector[i - 2];
3371         const String& c = stateVector[i - 1];
3372         FormElementKey key(a.impl(), b.impl());
3373         Iterator it = m_stateForNewFormElements.find(key);
3374         if (it != m_stateForNewFormElements.end())
3375             it->second.append(c);
3376         else {
3377             Vector<String> v(1);
3378             v[0] = c;
3379             m_stateForNewFormElements.set(key, v);
3380         }
3381     }
3382 }
3383
3384 bool Document::hasStateForNewFormElements() const
3385 {
3386     return !m_stateForNewFormElements.isEmpty();
3387 }
3388
3389 bool Document::takeStateForFormElement(AtomicStringImpl* name, AtomicStringImpl* type, String& state)
3390 {
3391     typedef FormElementStateMap::iterator Iterator;
3392     Iterator it = m_stateForNewFormElements.find(FormElementKey(name, type));
3393     if (it == m_stateForNewFormElements.end())
3394         return false;
3395     ASSERT(it->second.size());
3396     state = it->second.last();
3397     if (it->second.size() > 1)
3398         it->second.removeLast();
3399     else
3400         m_stateForNewFormElements.remove(it);
3401     return true;
3402 }
3403
3404 FormElementKey::FormElementKey(AtomicStringImpl* name, AtomicStringImpl* type)
3405     : m_name(name), m_type(type)
3406 {
3407     ref();
3408 }
3409
3410 FormElementKey::~FormElementKey()
3411 {
3412     deref();
3413 }
3414
3415 FormElementKey::FormElementKey(const FormElementKey& other)
3416     : m_name(other.name()), m_type(other.type())
3417 {
3418     ref();
3419 }
3420
3421 FormElementKey& FormElementKey::operator=(const FormElementKey& other)
3422 {
3423     other.ref();
3424     deref();
3425     m_name = other.name();
3426     m_type = other.type();
3427     return *this;
3428 }
3429
3430 void FormElementKey::ref() const
3431 {
3432     if (name() && name() != HashTraits<AtomicStringImpl*>::deletedValue())
3433         name()->ref();
3434     if (type())
3435         type()->ref();
3436 }
3437
3438 void FormElementKey::deref() const
3439 {
3440     if (name() && name() != HashTraits<AtomicStringImpl*>::deletedValue())
3441         name()->deref();
3442     if (type())
3443         type()->deref();
3444 }
3445
3446 unsigned FormElementKeyHash::hash(const FormElementKey& k)
3447 {
3448     ASSERT(sizeof(k) % (sizeof(uint16_t) * 2) == 0);
3449
3450     unsigned l = sizeof(k) / (sizeof(uint16_t) * 2);
3451     const uint16_t* s = reinterpret_cast<const uint16_t*>(&k);
3452     uint32_t hash = PHI;
3453
3454     // Main loop
3455     for (; l > 0; l--) {
3456         hash += s[0];
3457         uint32_t tmp = (s[1] << 11) ^ hash;
3458         hash = (hash << 16) ^ tmp;
3459         s += 2;
3460         hash += hash >> 11;
3461     }
3462         
3463     // Force "avalanching" of final 127 bits
3464     hash ^= hash << 3;
3465     hash += hash >> 5;
3466     hash ^= hash << 2;
3467     hash += hash >> 15;
3468     hash ^= hash << 10;
3469
3470     // this avoids ever returning a hash code of 0, since that is used to
3471     // signal "hash not computed yet", using a value that is likely to be
3472     // effectively the same as 0 when the low bits are masked
3473     if (hash == 0)
3474         hash = 0x80000000;
3475
3476     return hash;
3477 }
3478
3479 FormElementKey FormElementKeyHashTraits::deletedValue()
3480 {
3481     return HashTraits<AtomicStringImpl*>::deletedValue();
3482 }
3483
3484
3485 String Document::iconURL()
3486 {
3487     return m_iconURL;
3488 }
3489
3490 void Document::setIconURL(const String& iconURL, const String& type)
3491 {
3492     // FIXME - <rdar://problem/4727645> - At some point in the future, we might actually honor the "type" 
3493     if (m_iconURL.isEmpty())
3494         m_iconURL = iconURL;
3495     else if (!type.isEmpty())
3496         m_iconURL = iconURL;
3497 }
3498
3499 }