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