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