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