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