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