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