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