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