Make some things that return never-null pointers return references instead.
[WebKit-https.git] / Source / 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, 2011, 2012, 2013 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, 2011, 2012 Google Inc. All rights reserved.
9  * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)
10  * Copyright (C) Research In Motion Limited 2010-2011. All rights reserved.
11  *
12  * This library is free software; you can redistribute it and/or
13  * modify it under the terms of the GNU Library General Public
14  * License as published by the Free Software Foundation; either
15  * version 2 of the License, or (at your option) any later version.
16  *
17  * This library is distributed in the hope that it will be useful,
18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
20  * Library General Public License for more details.
21  *
22  * You should have received a copy of the GNU Library General Public License
23  * along with this library; see the file COPYING.LIB.  If not, write to
24  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
25  * Boston, MA 02110-1301, USA.
26  */
27
28 #include "config.h"
29 #include "Document.h"
30
31 #include "AXObjectCache.h"
32 #include "AnimationController.h"
33 #include "Attr.h"
34 #include "Attribute.h"
35 #include "CDATASection.h"
36 #include "CSSStyleDeclaration.h"
37 #include "CSSStyleSheet.h"
38 #include "CachedCSSStyleSheet.h"
39 #include "CachedResourceLoader.h"
40 #include "Chrome.h"
41 #include "ChromeClient.h"
42 #include "Comment.h"
43 #include "ContentSecurityPolicy.h"
44 #include "ContextFeatures.h"
45 #include "CookieJar.h"
46 #include "CustomElementConstructor.h"
47 #include "CustomElementRegistry.h"
48 #include "DOMImplementation.h"
49 #include "DOMNamedFlowCollection.h"
50 #include "DOMWindow.h"
51 #include "DateComponents.h"
52 #include "Dictionary.h"
53 #include "DocumentEventQueue.h"
54 #include "DocumentFragment.h"
55 #include "DocumentLoader.h"
56 #include "DocumentMarkerController.h"
57 #include "DocumentSharedObjectPool.h"
58 #include "DocumentStyleSheetCollection.h"
59 #include "DocumentType.h"
60 #include "Editor.h"
61 #include "Element.h"
62 #include "ElementShadow.h"
63 #include "EntityReference.h"
64 #include "Event.h"
65 #include "EventFactory.h"
66 #include "EventHandler.h"
67 #include "EventListener.h"
68 #include "EventNames.h"
69 #include "ExceptionCode.h"
70 #include "FontLoader.h"
71 #include "FormController.h"
72 #include "Frame.h"
73 #include "FrameLoader.h"
74 #include "FrameLoaderClient.h"
75 #include "FrameView.h"
76 #include "HashChangeEvent.h"
77 #include "HistogramSupport.h"
78 #include "History.h"
79 #include "HTMLAllCollection.h"
80 #include "HTMLAnchorElement.h"
81 #include "HTMLCanvasElement.h"
82 #include "HTMLCollection.h"
83 #include "HTMLDocument.h"
84 #include "HTMLElementFactory.h"
85 #include "HTMLFormControlElement.h"
86 #include "HTMLFrameOwnerElement.h"
87 #include "HTMLHeadElement.h"
88 #include "HTMLIFrameElement.h"
89 #include "HTMLLinkElement.h"
90 #include "HTMLNameCollection.h"
91 #include "HTMLNames.h"
92 #include "HTMLParserIdioms.h"
93 #include "HTMLPlugInElement.h"
94 #include "HTMLScriptElement.h"
95 #include "HTMLStyleElement.h"
96 #include "HTMLTitleElement.h"
97 #include "HTTPParsers.h"
98 #include "HitTestRequest.h"
99 #include "HitTestResult.h"
100 #include "IconController.h"
101 #include "ImageLoader.h"
102 #include "InspectorCounters.h"
103 #include "InspectorInstrumentation.h"
104 #include "Language.h"
105 #include "Logging.h"
106 #include "MediaCanStartListener.h"
107 #include "MediaQueryList.h"
108 #include "MediaQueryMatcher.h"
109 #include "MouseEventWithHitTestResults.h"
110 #include "NameNodeList.h"
111 #include "NamedFlowCollection.h"
112 #include "NestingLevelIncrementer.h"
113 #include "NodeFilter.h"
114 #include "NodeIterator.h"
115 #include "NodeRareData.h"
116 #include "NodeTraversal.h"
117 #include "NodeWithIndex.h"
118 #include "Page.h"
119 #include "PageConsole.h"
120 #include "PageGroup.h"
121 #include "PageTransitionEvent.h"
122 #include "PlatformLocale.h"
123 #include "PlugInsResources.h"
124 #include "PluginDocument.h"
125 #include "PointerLockController.h"
126 #include "PopStateEvent.h"
127 #include "ProcessingInstruction.h"
128 #include "QualifiedName.h"
129 #include "RenderArena.h"
130 #include "RenderView.h"
131 #include "RenderWidget.h"
132 #include "ResourceLoader.h"
133 #include "RuntimeEnabledFeatures.h"
134 #include "SchemeRegistry.h"
135 #include "ScopedEventQueue.h"
136 #include "ScriptCallStack.h"
137 #include "ScriptController.h"
138 #include "ScriptRunner.h"
139 #include "ScriptSourceCode.h"
140 #include "ScriptValue.h"
141 #include "ScrollingCoordinator.h"
142 #include "SecurityOrigin.h"
143 #include "SecurityPolicy.h"
144 #include "SegmentedString.h"
145 #include "SelectorQuery.h"
146 #include "Settings.h"
147 #include "ShadowRoot.h"
148 #include "StylePropertySet.h"
149 #include "StyleResolveForDocument.h"
150 #include "StyleResolver.h"
151 #include "StyleSheetContents.h"
152 #include "StyleSheetList.h"
153 #include "TextResourceDecoder.h"
154 #include "Timer.h"
155 #include "TransformSource.h"
156 #include "TreeWalker.h"
157 #include "VisitedLinkState.h"
158 #include "XMLDocumentParser.h"
159 #include "XMLNSNames.h"
160 #include "XMLNames.h"
161 #include "XPathEvaluator.h"
162 #include "XPathExpression.h"
163 #include "XPathNSResolver.h"
164 #include "XPathResult.h"
165 #include "htmlediting.h"
166 #include <wtf/CurrentTime.h>
167 #include <wtf/MainThread.h>
168 #include <wtf/PassRefPtr.h>
169 #include <wtf/text/StringBuffer.h>
170
171 #if USE(ACCELERATED_COMPOSITING)
172 #include "RenderLayerCompositor.h"
173 #endif
174
175 #if ENABLE(SHARED_WORKERS)
176 #include "SharedWorkerRepository.h"
177 #endif
178
179 #if ENABLE(XSLT)
180 #include "XSLTProcessor.h"
181 #endif
182
183 #if ENABLE(SVG)
184 #include "SVGDocumentExtensions.h"
185 #include "SVGElementFactory.h"
186 #include "SVGNames.h"
187 #include "SVGSVGElement.h"
188 #endif
189
190 #if ENABLE(TOUCH_EVENTS)
191 #include "TouchList.h"
192 #endif
193
194 #if ENABLE(MATHML)
195 #include "MathMLElement.h"
196 #include "MathMLElementFactory.h"
197 #include "MathMLNames.h"
198 #endif
199
200 #if ENABLE(FULLSCREEN_API)
201 #include "RenderFullScreen.h"
202 #endif
203
204 #if ENABLE(REQUEST_ANIMATION_FRAME)
205 #include "RequestAnimationFrameCallback.h"
206 #include "ScriptedAnimationController.h"
207 #endif
208
209 #if ENABLE(TEXT_AUTOSIZING)
210 #include "TextAutosizer.h"
211 #endif
212
213 #if ENABLE(CSP_NEXT)
214 #include "DOMSecurityPolicy.h"
215 #endif
216
217 #if ENABLE(VIDEO_TRACK)
218 #include "CaptionUserPreferences.h"
219 #endif
220
221 using namespace std;
222 using namespace WTF;
223 using namespace Unicode;
224
225 namespace WebCore {
226
227 using namespace HTMLNames;
228
229 // #define INSTRUMENT_LAYOUT_SCHEDULING 1
230
231 static const unsigned cMaxWriteRecursionDepth = 21;
232
233 // This amount of time must have elapsed before we will even consider scheduling a layout without a delay.
234 // FIXME: For faster machines this value can really be lowered to 200.  250 is adequate, but a little high
235 // for dual G5s. :)
236 static const int cLayoutScheduleThreshold = 250;
237
238 // DOM Level 2 says (letters added):
239 //
240 // a) Name start characters must have one of the categories Ll, Lu, Lo, Lt, Nl.
241 // b) Name characters other than Name-start characters must have one of the categories Mc, Me, Mn, Lm, or Nd.
242 // c) Characters in the compatibility area (i.e. with character code greater than #xF900 and less than #xFFFE) are not allowed in XML names.
243 // 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.
244 // 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.
245 // f) Characters #x20DD-#x20E0 are excluded (in accordance with Unicode, section 5.14).
246 // g) Character #x00B7 is classified as an extender, because the property list so identifies it.
247 // h) Character #x0387 is added as a name character, because #x00B7 is its canonical equivalent.
248 // i) Characters ':' and '_' are allowed as name-start characters.
249 // j) Characters '-' and '.' are allowed as name characters.
250 //
251 // It also contains complete tables. If we decide it's better, we could include those instead of the following code.
252
253 static inline bool isValidNameStart(UChar32 c)
254 {
255     // rule (e) above
256     if ((c >= 0x02BB && c <= 0x02C1) || c == 0x559 || c == 0x6E5 || c == 0x6E6)
257         return true;
258
259     // rule (i) above
260     if (c == ':' || c == '_')
261         return true;
262
263     // rules (a) and (f) above
264     const uint32_t nameStartMask = Letter_Lowercase | Letter_Uppercase | Letter_Other | Letter_Titlecase | Number_Letter;
265     if (!(Unicode::category(c) & nameStartMask))
266         return false;
267
268     // rule (c) above
269     if (c >= 0xF900 && c < 0xFFFE)
270         return false;
271
272     // rule (d) above
273     DecompositionType decompType = decompositionType(c);
274     if (decompType == DecompositionFont || decompType == DecompositionCompat)
275         return false;
276
277     return true;
278 }
279
280 static inline bool isValidNamePart(UChar32 c)
281 {
282     // rules (a), (e), and (i) above
283     if (isValidNameStart(c))
284         return true;
285
286     // rules (g) and (h) above
287     if (c == 0x00B7 || c == 0x0387)
288         return true;
289
290     // rule (j) above
291     if (c == '-' || c == '.')
292         return true;
293
294     // rules (b) and (f) above
295     const uint32_t otherNamePartMask = Mark_NonSpacing | Mark_Enclosing | Mark_SpacingCombining | Letter_Modifier | Number_DecimalDigit;
296     if (!(Unicode::category(c) & otherNamePartMask))
297         return false;
298
299     // rule (c) above
300     if (c >= 0xF900 && c < 0xFFFE)
301         return false;
302
303     // rule (d) above
304     DecompositionType decompType = decompositionType(c);
305     if (decompType == DecompositionFont || decompType == DecompositionCompat)
306         return false;
307
308     return true;
309 }
310
311 static bool shouldInheritSecurityOriginFromOwner(const KURL& url)
312 {
313     // http://www.whatwg.org/specs/web-apps/current-work/#origin-0
314     //
315     // If a Document has the address "about:blank"
316     //     The origin of the Document is the origin it was assigned when its browsing context was created.
317     //
318     // Note: We generalize this to all "blank" URLs and invalid URLs because we
319     // treat all of these URLs as about:blank.
320     //
321     return url.isEmpty() || url.isBlankURL();
322 }
323
324 static Widget* widgetForNode(Node* focusedNode)
325 {
326     if (!focusedNode)
327         return 0;
328     RenderObject* renderer = focusedNode->renderer();
329     if (!renderer || !renderer->isWidget())
330         return 0;
331     return toRenderWidget(renderer)->widget();
332 }
333
334 static bool acceptsEditingFocus(Node* node)
335 {
336     ASSERT(node);
337     ASSERT(node->rendererIsEditable());
338
339     Node* root = node->rootEditableElement();
340     Frame* frame = node->document()->frame();
341     if (!frame || !root)
342         return false;
343
344     return frame->editor().shouldBeginEditing(rangeOfContents(root).get());
345 }
346
347 static bool canAccessAncestor(const SecurityOrigin* activeSecurityOrigin, Frame* targetFrame)
348 {
349     // targetFrame can be 0 when we're trying to navigate a top-level frame
350     // that has a 0 opener.
351     if (!targetFrame)
352         return false;
353
354     const bool isLocalActiveOrigin = activeSecurityOrigin->isLocal();
355     for (Frame* ancestorFrame = targetFrame; ancestorFrame; ancestorFrame = ancestorFrame->tree()->parent()) {
356         Document* ancestorDocument = ancestorFrame->document();
357         // FIXME: Should be an ASSERT? Frames should alway have documents.
358         if (!ancestorDocument)
359             return true;
360
361         const SecurityOrigin* ancestorSecurityOrigin = ancestorDocument->securityOrigin();
362         if (activeSecurityOrigin->canAccess(ancestorSecurityOrigin))
363             return true;
364         
365         // Allow file URL descendant navigation even when allowFileAccessFromFileURLs is false.
366         // FIXME: It's a bit strange to special-case local origins here. Should we be doing
367         // something more general instead?
368         if (isLocalActiveOrigin && ancestorSecurityOrigin->isLocal())
369             return true;
370     }
371
372     return false;
373 }
374
375 static void printNavigationErrorMessage(Frame* frame, const KURL& activeURL, const char* reason)
376 {
377     String message = "Unsafe JavaScript attempt to initiate navigation for frame with URL '" + frame->document()->url().string() + "' from frame with URL '" + activeURL.string() + "'. " + reason + "\n";
378
379     // FIXME: should we print to the console of the document performing the navigation instead?
380     frame->document()->domWindow()->printErrorMessage(message);
381 }
382
383 uint64_t Document::s_globalTreeVersion = 0;
384
385 static const double timeBeforeThrowingAwayStyleResolverAfterLastUseInSeconds = 30;
386
387 Document::Document(Frame* frame, const KURL& url, unsigned documentClasses)
388     : ContainerNode(0, CreateDocument)
389     , TreeScope(this)
390     , m_styleResolverThrowawayTimer(this, &Document::styleResolverThrowawayTimerFired, timeBeforeThrowingAwayStyleResolverAfterLastUseInSeconds)
391     , m_didCalculateStyleResolver(false)
392     , m_hasNodesWithPlaceholderStyle(false)
393     , m_needsNotifyRemoveAllPendingStylesheet(false)
394     , m_ignorePendingStylesheets(false)
395     , m_pendingSheetLayout(NoLayoutWithPendingSheets)
396     , m_frame(frame)
397     , m_activeParserCount(0)
398     , m_contextFeatures(ContextFeatures::defaultSwitch())
399     , m_wellFormed(false)
400     , m_printing(false)
401     , m_paginatedForScreen(false)
402     , m_ignoreAutofocus(false)
403     , m_compatibilityMode(NoQuirksMode)
404     , m_compatibilityModeLocked(false)
405     , m_textColor(Color::black)
406     , m_domTreeVersion(++s_globalTreeVersion)
407     , m_listenerTypes(0)
408     , m_mutationObserverTypes(0)
409     , m_styleSheetCollection(DocumentStyleSheetCollection::create(this))
410     , m_visitedLinkState(VisitedLinkState::create(this))
411     , m_visuallyOrdered(false)
412     , m_readyState(Complete)
413     , m_bParsing(false)
414     , m_optimizedStyleSheetUpdateTimer(this, &Document::optimizedStyleSheetUpdateTimerFired)
415     , m_styleRecalcTimer(this, &Document::styleRecalcTimerFired)
416     , m_pendingStyleRecalcShouldForce(false)
417     , m_inStyleRecalc(false)
418     , m_closeAfterStyleRecalc(false)
419     , m_gotoAnchorNeededAfterStylesheetsLoad(false)
420     , m_frameElementsShouldIgnoreScrolling(false)
421     , m_containsValidityStyleRules(false)
422     , m_updateFocusAppearanceRestoresSelection(false)
423     , m_ignoreDestructiveWriteCount(0)
424     , m_titleSetExplicitly(false)
425     , m_updateFocusAppearanceTimer(this, &Document::updateFocusAppearanceTimerFired)
426     , m_cssTarget(0)
427     , m_processingLoadEvent(false)
428     , m_loadEventFinished(false)
429     , m_startTime(currentTime())
430     , m_overMinimumLayoutThreshold(false)
431     , m_scriptRunner(ScriptRunner::create(this))
432     , m_xmlVersion(ASCIILiteral("1.0"))
433     , m_xmlStandalone(StandaloneUnspecified)
434     , m_hasXMLDeclaration(0)
435     , m_savedRenderer(0)
436     , m_designMode(inherit)
437 #if ENABLE(DASHBOARD_SUPPORT) || ENABLE(DRAGGABLE_REGION)
438     , m_hasAnnotatedRegions(false)
439     , m_annotatedRegionsDirty(false)
440 #endif
441     , m_createRenderers(true)
442     , m_inPageCache(false)
443     , m_accessKeyMapValid(false)
444     , m_documentClasses(documentClasses)
445     , m_isViewSource(false)
446     , m_sawElementsInKnownNamespaces(false)
447     , m_isSrcdocDocument(false)
448     , m_renderer(0)
449     , m_eventQueue(DocumentEventQueue::create(this))
450     , m_weakFactory(this)
451     , m_idAttributeName(idAttr)
452 #if ENABLE(FULLSCREEN_API)
453     , m_areKeysEnabledInFullScreen(0)
454     , m_fullScreenRenderer(0)
455     , m_fullScreenChangeDelayTimer(this, &Document::fullScreenChangeDelayTimerFired)
456     , m_isAnimatingFullScreen(false)
457 #endif
458     , m_loadEventDelayCount(0)
459     , m_loadEventDelayTimer(this, &Document::loadEventDelayTimerFired)
460     , m_referrerPolicy(ReferrerPolicyDefault)
461     , m_directionSetOnDocumentElement(false)
462     , m_writingModeSetOnDocumentElement(false)
463     , m_writeRecursionIsTooDeep(false)
464     , m_writeRecursionDepth(0)
465     , m_wheelEventHandlerCount(0)
466     , m_lastHandledUserGestureTimestamp(0)
467     , m_pendingTasksTimer(this, &Document::pendingTasksTimerFired)
468     , m_scheduledTasksAreSuspended(false)
469     , m_visualUpdatesAllowed(true)
470     , m_visualUpdatesSuppressionTimer(this, &Document::visualUpdatesSuppressionTimerFired)
471     , m_sharedObjectPoolClearTimer(this, &Document::sharedObjectPoolClearTimerFired)
472 #ifndef NDEBUG
473     , m_didDispatchViewportPropertiesChanged(false)
474 #endif
475 #if ENABLE(TEMPLATE_ELEMENT)
476     , m_templateDocumentHost(0)
477 #endif
478 #if ENABLE(FONT_LOAD_EVENTS)
479     , m_fontloader(0)
480 #endif
481     , m_didAssociateFormControlsTimer(this, &Document::didAssociateFormControlsTimerFired)
482     , m_hasInjectedPlugInsScript(false)
483 {
484     if (m_frame)
485         provideContextFeaturesToDocumentFrom(this, m_frame->page());
486
487     // We depend on the url getting immediately set in subframes, but we
488     // also depend on the url NOT getting immediately set in opened windows.
489     // See fast/dom/early-frame-url.html
490     // and fast/dom/location-new-window-no-crash.html, respectively.
491     // FIXME: Can/should we unify this behavior?
492     if ((frame && frame->ownerElement()) || !url.isEmpty())
493         setURL(url);
494
495     m_markers = adoptPtr(new DocumentMarkerController);
496
497     if (m_frame)
498         m_cachedResourceLoader = m_frame->loader()->activeDocumentLoader()->cachedResourceLoader();
499     if (!m_cachedResourceLoader)
500         m_cachedResourceLoader = CachedResourceLoader::create(0);
501     m_cachedResourceLoader->setDocument(this);
502
503 #if ENABLE(TEXT_AUTOSIZING)
504     m_textAutosizer = TextAutosizer::create(this);
505 #endif
506
507     resetLinkColor();
508     resetVisitedLinkColor();
509     resetActiveLinkColor();
510
511     initSecurityContext();
512     initDNSPrefetch();
513
514     for (unsigned i = 0; i < WTF_ARRAY_LENGTH(m_nodeListCounts); i++)
515         m_nodeListCounts[i] = 0;
516
517     InspectorCounters::incrementCounter(InspectorCounters::DocumentCounter);
518 }
519
520 static void histogramMutationEventUsage(const unsigned short& listenerTypes)
521 {
522     HistogramSupport::histogramEnumeration("DOMAPI.PerDocumentMutationEventUsage.DOMSubtreeModified", static_cast<bool>(listenerTypes & Document::DOMSUBTREEMODIFIED_LISTENER), 2);
523     HistogramSupport::histogramEnumeration("DOMAPI.PerDocumentMutationEventUsage.DOMNodeInserted", static_cast<bool>(listenerTypes & Document::DOMNODEINSERTED_LISTENER), 2);
524     HistogramSupport::histogramEnumeration("DOMAPI.PerDocumentMutationEventUsage.DOMNodeRemoved", static_cast<bool>(listenerTypes & Document::DOMNODEREMOVED_LISTENER), 2);
525     HistogramSupport::histogramEnumeration("DOMAPI.PerDocumentMutationEventUsage.DOMNodeRemovedFromDocument", static_cast<bool>(listenerTypes & Document::DOMNODEREMOVEDFROMDOCUMENT_LISTENER), 2);
526     HistogramSupport::histogramEnumeration("DOMAPI.PerDocumentMutationEventUsage.DOMNodeInsertedIntoDocument", static_cast<bool>(listenerTypes & Document::DOMNODEINSERTEDINTODOCUMENT_LISTENER), 2);
527     HistogramSupport::histogramEnumeration("DOMAPI.PerDocumentMutationEventUsage.DOMCharacterDataModified", static_cast<bool>(listenerTypes & Document::DOMCHARACTERDATAMODIFIED_LISTENER), 2);
528 }
529
530 #if ENABLE(FULLSCREEN_API)
531 static bool isAttributeOnAllOwners(const WebCore::QualifiedName& attribute, const WebCore::QualifiedName& prefixedAttribute, const HTMLFrameOwnerElement* owner)
532 {
533     if (!owner)
534         return true;
535     do {
536         if (!(owner->hasAttribute(attribute) || owner->hasAttribute(prefixedAttribute)))
537             return false;
538     } while ((owner = owner->document()->ownerElement()));
539     return true;
540 }
541 #endif
542
543 Document::~Document()
544 {
545     ASSERT(!renderer());
546     ASSERT(!m_inPageCache);
547     ASSERT(!m_savedRenderer);
548     ASSERT(m_ranges.isEmpty());
549     ASSERT(!m_styleRecalcTimer.isActive());
550     ASSERT(!m_parentTreeScope);
551     ASSERT(!hasGuardRefCount());
552
553 #if ENABLE(TEMPLATE_ELEMENT)
554     if (m_templateDocument)
555         m_templateDocument->setTemplateDocumentHost(0); // balanced in templateDocument().
556 #endif
557
558 #if ENABLE(TOUCH_EVENT_TRACKING)
559     if (Document* ownerDocument = this->ownerDocument())
560         ownerDocument->didRemoveEventTargetNode(this);
561 #endif
562     // FIXME: Should we reset m_domWindow when we detach from the Frame?
563     if (m_domWindow)
564         m_domWindow->resetUnlessSuspendedForPageCache();
565
566     m_scriptRunner.clear();
567
568     histogramMutationEventUsage(m_listenerTypes);
569
570     removeAllEventListeners();
571
572     // Currently we believe that Document can never outlive the parser.
573     // Although the Document may be replaced synchronously, DocumentParsers
574     // generally keep at least one reference to an Element which would in turn
575     // has a reference to the Document.  If you hit this ASSERT, then that
576     // assumption is wrong.  DocumentParser::detach() should ensure that even
577     // if the DocumentParser outlives the Document it won't cause badness.
578     ASSERT(!m_parser || m_parser->refCount() == 1);
579     detachParser();
580
581     m_renderArena.clear();
582
583     if (this == topDocument())
584         clearAXObjectCache();
585
586     m_decoder = 0;
587
588     if (m_styleSheetList)
589         m_styleSheetList->detachFromDocument();
590
591     m_styleSheetCollection.clear();
592
593     if (m_elemSheet)
594         m_elemSheet->clearOwnerNode();
595
596     clearStyleResolver(); // We need to destory CSSFontSelector before destroying m_cachedResourceLoader.
597
598     // It's possible for multiple Documents to end up referencing the same CachedResourceLoader (e.g., SVGImages
599     // load the initial empty document and the SVGDocument with the same DocumentLoader).
600     if (m_cachedResourceLoader->document() == this)
601         m_cachedResourceLoader->setDocument(0);
602     m_cachedResourceLoader.clear();
603
604     // We must call clearRareData() here since a Document class inherits TreeScope
605     // as well as Node. See a comment on TreeScope.h for the reason.
606     if (hasRareData())
607         clearRareData();
608
609     ASSERT(!m_listsInvalidatedAtDocument.size());
610
611     for (unsigned i = 0; i < WTF_ARRAY_LENGTH(m_nodeListCounts); i++)
612         ASSERT(!m_nodeListCounts[i]);
613
614     clearDocumentScope();
615
616     InspectorCounters::decrementCounter(InspectorCounters::DocumentCounter);
617 }
618
619 void Document::dispose()
620 {
621     ASSERT(!m_deletionHasBegun);
622     // We must make sure not to be retaining any of our children through
623     // these extra pointers or we will create a reference cycle.
624     m_docType = 0;
625     m_focusedElement = 0;
626     m_hoveredElement = 0;
627     m_activeElement = 0;
628     m_titleElement = 0;
629     m_documentElement = 0;
630     m_contextFeatures = ContextFeatures::defaultSwitch();
631     m_userActionElements.documentDidRemoveLastRef();
632 #if ENABLE(FULLSCREEN_API)
633     m_fullScreenElement = 0;
634     m_fullScreenElementStack.clear();
635 #endif
636
637     detachParser();
638
639 #if ENABLE(CUSTOM_ELEMENTS)
640     m_registry.clear();
641 #endif
642
643     // removeDetachedChildren() doesn't always unregister IDs,
644     // so tear down scope information upfront to avoid having stale references in the map.
645     destroyTreeScopeData();
646     removeDetachedChildren();
647     m_formController.clear();
648
649     m_markers->detach();
650
651     m_cssCanvasElements.clear();
652
653 #if ENABLE(REQUEST_ANIMATION_FRAME)
654     clearScriptedAnimationController();
655 #endif
656 }
657
658 Element* Document::getElementById(const AtomicString& id) const
659 {
660     return TreeScope::getElementById(id);
661 }
662
663 Element* Document::getElementByAccessKey(const String& key)
664 {
665     if (key.isEmpty())
666         return 0;
667     if (!m_accessKeyMapValid) {
668         buildAccessKeyMap(this);
669         m_accessKeyMapValid = true;
670     }
671     return m_elementsByAccessKey.get(key.impl());
672 }
673
674 void Document::buildAccessKeyMap(TreeScope* scope)
675 {
676     ASSERT(scope);
677     ContainerNode* rootNode = scope->rootNode();
678     for (Element* element = ElementTraversal::firstWithin(rootNode); element; element = ElementTraversal::next(element, rootNode)) {
679         const AtomicString& accessKey = element->getAttribute(accesskeyAttr);
680         if (!accessKey.isEmpty())
681             m_elementsByAccessKey.set(accessKey.impl(), element);
682
683         if (ShadowRoot* root = element->shadowRoot())
684             buildAccessKeyMap(root);
685     }
686 }
687
688 void Document::invalidateAccessKeyMap()
689 {
690     m_accessKeyMapValid = false;
691     m_elementsByAccessKey.clear();
692 }
693
694 SelectorQueryCache& Document::selectorQueryCache()
695 {
696     if (!m_selectorQueryCache)
697         m_selectorQueryCache = adoptPtr(new SelectorQueryCache());
698     return *m_selectorQueryCache;
699 }
700
701 MediaQueryMatcher& Document::mediaQueryMatcher()
702 {
703     if (!m_mediaQueryMatcher)
704         m_mediaQueryMatcher = MediaQueryMatcher::create(this);
705     return *m_mediaQueryMatcher;
706 }
707
708 void Document::setCompatibilityMode(CompatibilityMode mode)
709 {
710     if (m_compatibilityModeLocked || mode == m_compatibilityMode)
711         return;
712     bool wasInQuirksMode = inQuirksMode();
713     m_compatibilityMode = mode;
714
715     if (m_selectorQueryCache)
716         m_selectorQueryCache->invalidate();
717
718     if (inQuirksMode() != wasInQuirksMode) {
719         // All user stylesheets have to reparse using the different mode.
720         m_styleSheetCollection->clearPageUserSheet();
721         m_styleSheetCollection->invalidateInjectedStyleSheetCache();
722     }
723 }
724
725 String Document::compatMode() const
726 {
727     return inQuirksMode() ? "BackCompat" : "CSS1Compat";
728 }
729
730 void Document::resetLinkColor()
731 {
732     m_linkColor = Color(0, 0, 238);
733 }
734
735 void Document::resetVisitedLinkColor()
736 {
737     m_visitedLinkColor = Color(85, 26, 139);    
738 }
739
740 void Document::resetActiveLinkColor()
741 {
742     m_activeLinkColor.setNamedColor("red");
743 }
744
745 void Document::setDocType(PassRefPtr<DocumentType> docType)
746 {
747     // This should never be called more than once.
748     ASSERT(!m_docType || !docType);
749     m_docType = docType;
750     if (m_docType) {
751         this->adoptIfNeeded(m_docType.get());
752 #if ENABLE(LEGACY_VIEWPORT_ADAPTION)
753         if (m_docType->publicId().startsWith("-//wapforum//dtd xhtml mobile 1.", /* caseSensitive */ false))
754             processViewport("width=device-width, height=device-height", ViewportArguments::XHTMLMobileProfile);
755 #endif
756     }
757     // Doctype affects the interpretation of the stylesheets.
758     clearStyleResolver();
759 }
760
761 DOMImplementation* Document::implementation()
762 {
763     if (!m_implementation)
764         m_implementation = DOMImplementation::create(this);
765     return m_implementation.get();
766 }
767
768 bool Document::hasManifest() const
769 {
770     return documentElement() && documentElement()->hasTagName(htmlTag) && documentElement()->hasAttribute(manifestAttr);
771 }
772
773 void Document::childrenChanged(bool changedByParser, Node* beforeChange, Node* afterChange, int childCountDelta)
774 {
775     ContainerNode::childrenChanged(changedByParser, beforeChange, afterChange, childCountDelta);
776     
777     Element* newDocumentElement = ElementTraversal::firstWithin(this);
778     if (newDocumentElement == m_documentElement)
779         return;
780     m_documentElement = newDocumentElement;
781     // The root style used for media query matching depends on the document element.
782     clearStyleResolver();
783 }
784
785 PassRefPtr<Element> Document::createElement(const AtomicString& name, ExceptionCode& ec)
786 {
787     if (!isValidName(name)) {
788         ec = INVALID_CHARACTER_ERR;
789         return 0;
790     }
791
792     if (isXHTMLDocument())
793         return HTMLElementFactory::createHTMLElement(QualifiedName(nullAtom, name, xhtmlNamespaceURI), this, 0, false);
794
795     return createElement(QualifiedName(nullAtom, name, nullAtom), false);
796 }
797
798 #if ENABLE(CUSTOM_ELEMENTS)
799 PassRefPtr<Element> Document::createElement(const AtomicString& localName, const AtomicString& typeExtension, ExceptionCode& ec)
800 {
801     if (!isValidName(localName)) {
802         ec = INVALID_CHARACTER_ERR;
803         return 0;
804     }
805
806     if (m_registry) {
807         if (PassRefPtr<Element> created = m_registry->createElement(QualifiedName(nullAtom, localName, xhtmlNamespaceURI), typeExtension))
808             return created;
809     }
810
811     return setTypeExtension(createElement(localName, ec), typeExtension);
812 }
813
814 PassRefPtr<Element> Document::createElementNS(const AtomicString& namespaceURI, const String& qualifiedName, const AtomicString& typeExtension, ExceptionCode& ec)
815 {
816     String prefix, localName;
817     if (!parseQualifiedName(qualifiedName, prefix, localName, ec))
818         return 0;
819
820     QualifiedName qName(prefix, localName, namespaceURI);
821     if (!hasValidNamespaceForElements(qName)) {
822         ec = NAMESPACE_ERR;
823         return 0;
824     }
825
826     if (m_registry) {
827         if (PassRefPtr<Element> created = m_registry->createElement(qName, typeExtension))
828             return created;
829     }
830
831     return setTypeExtension(createElementNS(namespaceURI, qualifiedName, ec), typeExtension);
832 }
833
834 PassRefPtr<CustomElementConstructor> Document::registerElement(WebCore::ScriptState* state, const AtomicString& name, ExceptionCode& ec)
835 {
836     return registerElement(state, name, Dictionary(), ec);
837 }
838
839 PassRefPtr<CustomElementConstructor> Document::registerElement(WebCore::ScriptState* state, const AtomicString& name, const Dictionary& options, ExceptionCode& ec)
840 {
841     if (!isHTMLDocument() && !isXHTMLDocument()) {
842         ec = NOT_SUPPORTED_ERR;
843         return 0;
844     }
845
846     if (!m_registry)
847         m_registry = adoptRef(new CustomElementRegistry(this));
848     return m_registry->registerElement(state, name, options, ec);
849 }
850
851 void Document::didCreateCustomElement(Element* element, CustomElementConstructor* constructor)
852 {
853     // m_registry is cleared Document::dispose() and can be null here.
854     if (m_registry)
855         m_registry->didCreateElement(element);
856 }
857 #endif // ENABLE(CUSTOM_ELEMENTS)
858
859 PassRefPtr<DocumentFragment> Document::createDocumentFragment()
860 {
861     return DocumentFragment::create(document());
862 }
863
864 PassRefPtr<Text> Document::createTextNode(const String& data)
865 {
866     return Text::create(this, data);
867 }
868
869 PassRefPtr<Comment> Document::createComment(const String& data)
870 {
871     return Comment::create(this, data);
872 }
873
874 PassRefPtr<CDATASection> Document::createCDATASection(const String& data, ExceptionCode& ec)
875 {
876     if (isHTMLDocument()) {
877         ec = NOT_SUPPORTED_ERR;
878         return 0;
879     }
880     return CDATASection::create(this, data);
881 }
882
883 PassRefPtr<ProcessingInstruction> Document::createProcessingInstruction(const String& target, const String& data, ExceptionCode& ec)
884 {
885     if (!isValidName(target)) {
886         ec = INVALID_CHARACTER_ERR;
887         return 0;
888     }
889     if (isHTMLDocument()) {
890         ec = NOT_SUPPORTED_ERR;
891         return 0;
892     }
893     return ProcessingInstruction::create(this, target, data);
894 }
895
896 PassRefPtr<EntityReference> Document::createEntityReference(const String& name, ExceptionCode& ec)
897 {
898     if (!isValidName(name)) {
899         ec = INVALID_CHARACTER_ERR;
900         return 0;
901     }
902     if (isHTMLDocument()) {
903         ec = NOT_SUPPORTED_ERR;
904         return 0;
905     }
906     return EntityReference::create(this, name);
907 }
908
909 PassRefPtr<Text> Document::createEditingTextNode(const String& text)
910 {
911     return Text::createEditingText(this, text);
912 }
913
914 PassRefPtr<CSSStyleDeclaration> Document::createCSSStyleDeclaration()
915 {
916     return MutableStylePropertySet::create()->ensureCSSStyleDeclaration();
917 }
918
919 PassRefPtr<Node> Document::importNode(Node* importedNode, bool deep, ExceptionCode& ec)
920 {
921     ec = 0;
922     
923     if (!importedNode) {
924         ec = NOT_SUPPORTED_ERR;
925         return 0;
926     }
927
928     switch (importedNode->nodeType()) {
929     case TEXT_NODE:
930         return createTextNode(importedNode->nodeValue());
931     case CDATA_SECTION_NODE:
932         return createCDATASection(importedNode->nodeValue(), ec);
933     case ENTITY_REFERENCE_NODE:
934         return createEntityReference(importedNode->nodeName(), ec);
935     case PROCESSING_INSTRUCTION_NODE:
936         return createProcessingInstruction(importedNode->nodeName(), importedNode->nodeValue(), ec);
937     case COMMENT_NODE:
938         return createComment(importedNode->nodeValue());
939     case ELEMENT_NODE: {
940         Element* oldElement = toElement(importedNode);
941         // FIXME: The following check might be unnecessary. Is it possible that
942         // oldElement has mismatched prefix/namespace?
943         if (!hasValidNamespaceForElements(oldElement->tagQName())) {
944             ec = NAMESPACE_ERR;
945             return 0;
946         }
947         RefPtr<Element> newElement = createElement(oldElement->tagQName(), false);
948
949         newElement->cloneDataFromElement(*oldElement);
950
951         if (deep) {
952             for (Node* oldChild = oldElement->firstChild(); oldChild; oldChild = oldChild->nextSibling()) {
953                 RefPtr<Node> newChild = importNode(oldChild, true, ec);
954                 if (ec)
955                     return 0;
956                 newElement->appendChild(newChild.release(), ec);
957                 if (ec)
958                     return 0;
959             }
960         }
961
962         return newElement.release();
963     }
964     case ATTRIBUTE_NODE:
965         return Attr::create(this, QualifiedName(nullAtom, static_cast<Attr*>(importedNode)->name(), nullAtom), static_cast<Attr*>(importedNode)->value());
966     case DOCUMENT_FRAGMENT_NODE: {
967         if (importedNode->isShadowRoot()) {
968             // ShadowRoot nodes should not be explicitly importable.
969             // Either they are imported along with their host node, or created implicitly.
970             break;
971         }
972         DocumentFragment* oldFragment = static_cast<DocumentFragment*>(importedNode);
973         RefPtr<DocumentFragment> newFragment = createDocumentFragment();
974         if (deep) {
975             for (Node* oldChild = oldFragment->firstChild(); oldChild; oldChild = oldChild->nextSibling()) {
976                 RefPtr<Node> newChild = importNode(oldChild, true, ec);
977                 if (ec)
978                     return 0;
979                 newFragment->appendChild(newChild.release(), ec);
980                 if (ec)
981                     return 0;
982             }
983         }
984         
985         return newFragment.release();
986     }
987     case ENTITY_NODE:
988     case NOTATION_NODE:
989         // 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.
990         // Ability to add these imported nodes to a DocumentType will be considered for addition to a future release of the DOM.
991     case DOCUMENT_NODE:
992     case DOCUMENT_TYPE_NODE:
993     case XPATH_NAMESPACE_NODE:
994         break;
995     }
996     ec = NOT_SUPPORTED_ERR;
997     return 0;
998 }
999
1000
1001 PassRefPtr<Node> Document::adoptNode(PassRefPtr<Node> source, ExceptionCode& ec)
1002 {
1003     if (!source) {
1004         ec = NOT_SUPPORTED_ERR;
1005         return 0;
1006     }
1007
1008     if (source->isReadOnlyNode()) {
1009         ec = NO_MODIFICATION_ALLOWED_ERR;
1010         return 0;
1011     }
1012
1013     EventQueueScope scope;
1014
1015     switch (source->nodeType()) {
1016     case ENTITY_NODE:
1017     case NOTATION_NODE:
1018     case DOCUMENT_NODE:
1019     case DOCUMENT_TYPE_NODE:
1020     case XPATH_NAMESPACE_NODE:
1021         ec = NOT_SUPPORTED_ERR;
1022         return 0;            
1023     case ATTRIBUTE_NODE: {                   
1024         Attr* attr = static_cast<Attr*>(source.get());
1025         if (attr->ownerElement())
1026             attr->ownerElement()->removeAttributeNode(attr, ec);
1027         attr->setSpecified(true);
1028         break;
1029     }       
1030     default:
1031         if (source->isShadowRoot()) {
1032             // ShadowRoot cannot disconnect itself from the host node.
1033             ec = HIERARCHY_REQUEST_ERR;
1034             return 0;
1035         }
1036
1037         if (source->isFrameOwnerElement()) {
1038             HTMLFrameOwnerElement* frameOwnerElement = toFrameOwnerElement(source.get());
1039             if (frame() && frame()->tree()->isDescendantOf(frameOwnerElement->contentFrame())) {
1040                 ec = HIERARCHY_REQUEST_ERR;
1041                 return 0;
1042             }
1043         }
1044         if (source->parentNode()) {
1045             source->parentNode()->removeChild(source.get(), ec);
1046             if (ec)
1047                 return 0;
1048         }
1049     }
1050
1051     this->adoptIfNeeded(source.get());
1052
1053     return source;
1054 }
1055
1056 bool Document::hasValidNamespaceForElements(const QualifiedName& qName)
1057 {
1058     // These checks are from DOM Core Level 2, createElementNS
1059     // http://www.w3.org/TR/DOM-Level-2-Core/core.html#ID-DocCrElNS
1060     if (!qName.prefix().isEmpty() && qName.namespaceURI().isNull()) // createElementNS(null, "html:div")
1061         return false;
1062     if (qName.prefix() == xmlAtom && qName.namespaceURI() != XMLNames::xmlNamespaceURI) // createElementNS("http://www.example.com", "xml:lang")
1063         return false;
1064
1065     // Required by DOM Level 3 Core and unspecified by DOM Level 2 Core:
1066     // http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core.html#ID-DocCrElNS
1067     // createElementNS("http://www.w3.org/2000/xmlns/", "foo:bar"), createElementNS(null, "xmlns:bar")
1068     if ((qName.prefix() == xmlnsAtom && qName.namespaceURI() != XMLNSNames::xmlnsNamespaceURI) || (qName.prefix() != xmlnsAtom && qName.namespaceURI() == XMLNSNames::xmlnsNamespaceURI))
1069         return false;
1070
1071     return true;
1072 }
1073
1074 bool Document::hasValidNamespaceForAttributes(const QualifiedName& qName)
1075 {
1076     // Spec: DOM Level 2 Core: http://www.w3.org/TR/DOM-Level-2-Core/core.html#ID-ElSetAttrNS
1077     if (qName.prefix().isEmpty() && qName.localName() == xmlnsAtom) {
1078         // Note: The case of an "xmlns" qualified name with a namespace of
1079         // xmlnsNamespaceURI is specifically allowed (See <http://www.w3.org/2000/xmlns/>).
1080         return qName.namespaceURI() == XMLNSNames::xmlnsNamespaceURI;
1081     }
1082     return hasValidNamespaceForElements(qName);
1083 }
1084
1085 // FIXME: This should really be in a possible ElementFactory class
1086 PassRefPtr<Element> Document::createElement(const QualifiedName& qName, bool createdByParser)
1087 {
1088     RefPtr<Element> e;
1089
1090     // FIXME: Use registered namespaces and look up in a hash to find the right factory.
1091     if (qName.namespaceURI() == xhtmlNamespaceURI)
1092         e = HTMLElementFactory::createHTMLElement(qName, this, 0, createdByParser);
1093 #if ENABLE(SVG)
1094     else if (qName.namespaceURI() == SVGNames::svgNamespaceURI)
1095         e = SVGElementFactory::createSVGElement(qName, this, createdByParser);
1096 #endif
1097 #if ENABLE(MATHML)
1098     else if (qName.namespaceURI() == MathMLNames::mathmlNamespaceURI)
1099         e = MathMLElementFactory::createMathMLElement(qName, this, createdByParser);
1100 #endif
1101
1102     if (e)
1103         m_sawElementsInKnownNamespaces = true;
1104     else
1105         e = Element::create(qName, document());
1106
1107     // <image> uses imgTag so we need a special rule.
1108     ASSERT((qName.matches(imageTag) && e->tagQName().matches(imgTag) && e->tagQName().prefix() == qName.prefix()) || qName == e->tagQName());
1109
1110     return e.release();
1111 }
1112
1113 bool Document::regionBasedColumnsEnabled() const
1114 {
1115     return settings() && settings()->regionBasedColumnsEnabled(); 
1116 }
1117
1118 bool Document::cssStickyPositionEnabled() const
1119 {
1120     return settings() && settings()->cssStickyPositionEnabled(); 
1121 }
1122
1123 bool Document::cssRegionsEnabled() const
1124 {
1125     return RuntimeEnabledFeatures::cssRegionsEnabled(); 
1126 }
1127
1128 bool Document::cssCompositingEnabled() const
1129 {
1130     return RuntimeEnabledFeatures::cssCompositingEnabled();
1131 }
1132
1133 bool Document::cssGridLayoutEnabled() const
1134 {
1135     return settings() && settings()->cssGridLayoutEnabled();
1136 }
1137
1138 #if ENABLE(CSS_REGIONS)
1139
1140 PassRefPtr<DOMNamedFlowCollection> Document::webkitGetNamedFlows()
1141 {
1142     if (!cssRegionsEnabled() || !renderer())
1143         return 0;
1144
1145     updateStyleIfNeeded();
1146
1147     return namedFlows()->createCSSOMSnapshot();
1148 }
1149
1150 #endif
1151
1152 NamedFlowCollection* Document::namedFlows()
1153 {
1154     if (!m_namedFlows)
1155         m_namedFlows = NamedFlowCollection::create(this);
1156
1157     return m_namedFlows.get();
1158 }
1159
1160 PassRefPtr<Element> Document::createElementNS(const String& namespaceURI, const String& qualifiedName, ExceptionCode& ec)
1161 {
1162     String prefix, localName;
1163     if (!parseQualifiedName(qualifiedName, prefix, localName, ec))
1164         return 0;
1165
1166     QualifiedName qName(prefix, localName, namespaceURI);
1167     if (!hasValidNamespaceForElements(qName)) {
1168         ec = NAMESPACE_ERR;
1169         return 0;
1170     }
1171
1172     return createElement(qName, false);
1173 }
1174
1175 String Document::readyState() const
1176 {
1177     DEFINE_STATIC_LOCAL(const String, loading, (ASCIILiteral("loading")));
1178     DEFINE_STATIC_LOCAL(const String, interactive, (ASCIILiteral("interactive")));
1179     DEFINE_STATIC_LOCAL(const String, complete, (ASCIILiteral("complete")));
1180
1181     switch (m_readyState) {
1182     case Loading:
1183         return loading;
1184     case Interactive:
1185         return interactive;
1186     case Complete:
1187         return complete;
1188     }
1189
1190     ASSERT_NOT_REACHED();
1191     return String();
1192 }
1193
1194 void Document::setReadyState(ReadyState readyState)
1195 {
1196     if (readyState == m_readyState)
1197         return;
1198
1199     switch (readyState) {
1200     case Loading:
1201         if (!m_documentTiming.domLoading)
1202             m_documentTiming.domLoading = monotonicallyIncreasingTime();
1203         break;
1204     case Interactive:
1205         if (!m_documentTiming.domInteractive)
1206             m_documentTiming.domInteractive = monotonicallyIncreasingTime();
1207         break;
1208     case Complete:
1209         if (!m_documentTiming.domComplete)
1210             m_documentTiming.domComplete = monotonicallyIncreasingTime();
1211         break;
1212     }
1213
1214     m_readyState = readyState;
1215     dispatchEvent(Event::create(eventNames().readystatechangeEvent, false, false));
1216     
1217     if (settings() && settings()->suppressesIncrementalRendering())
1218         setVisualUpdatesAllowed(readyState);
1219 }
1220
1221 void Document::setVisualUpdatesAllowed(ReadyState readyState)
1222 {
1223     ASSERT(settings() && settings()->suppressesIncrementalRendering());
1224     switch (readyState) {
1225     case Loading:
1226         ASSERT(!m_visualUpdatesSuppressionTimer.isActive());
1227         ASSERT(m_visualUpdatesAllowed);
1228         setVisualUpdatesAllowed(false);
1229         break;
1230     case Interactive:
1231         ASSERT(m_visualUpdatesSuppressionTimer.isActive() || m_visualUpdatesAllowed);
1232         break;
1233     case Complete:
1234         if (m_visualUpdatesSuppressionTimer.isActive()) {
1235             ASSERT(!m_visualUpdatesAllowed);
1236
1237             if (!view()->visualUpdatesAllowedByClient())
1238                 return;
1239
1240             setVisualUpdatesAllowed(true);
1241         } else
1242             ASSERT(m_visualUpdatesAllowed);
1243         break;
1244     }
1245 }
1246     
1247 void Document::setVisualUpdatesAllowed(bool visualUpdatesAllowed)
1248 {
1249     if (m_visualUpdatesAllowed == visualUpdatesAllowed)
1250         return;
1251
1252     m_visualUpdatesAllowed = visualUpdatesAllowed;
1253
1254     if (visualUpdatesAllowed)
1255         m_visualUpdatesSuppressionTimer.stop();
1256     else
1257         m_visualUpdatesSuppressionTimer.startOneShot(settings()->incrementalRenderingSuppressionTimeoutInSeconds());
1258
1259     if (!visualUpdatesAllowed)
1260         return;
1261
1262     FrameView* frameView = view();
1263     bool needsLayout = frameView && renderer() && (frameView->layoutPending() || renderer()->needsLayout());
1264     if (needsLayout)
1265         updateLayout();
1266
1267     if (Page* page = this->page()) {
1268         if (frame() == page->mainFrame())
1269             frameView->addPaintPendingMilestones(DidFirstPaintAfterSuppressedIncrementalRendering);
1270         if (page->requestedLayoutMilestones() & DidFirstLayoutAfterSuppressedIncrementalRendering)
1271             frame()->loader()->didLayout(DidFirstLayoutAfterSuppressedIncrementalRendering);
1272     }
1273
1274 #if USE(ACCELERATED_COMPOSITING)
1275     if (view())
1276         view()->updateCompositingLayersAfterLayout();
1277 #endif
1278
1279     if (RenderView* renderView = this->renderView())
1280         renderView->repaintViewAndCompositedLayers();
1281
1282     if (Frame* frame = this->frame())
1283         frame->loader()->forcePageTransitionIfNeeded();
1284 }
1285
1286 void Document::visualUpdatesSuppressionTimerFired(Timer<Document>*)
1287 {
1288     ASSERT(!m_visualUpdatesAllowed);
1289
1290     // If the client is extending the visual update suppression period explicitly, the
1291     // watchdog should not re-enable visual updates itself, but should wait for the client.
1292     if (!view()->visualUpdatesAllowedByClient())
1293         return;
1294
1295     setVisualUpdatesAllowed(true);
1296 }
1297
1298 void Document::setVisualUpdatesAllowedByClient(bool visualUpdatesAllowedByClient)
1299 {
1300     // We should only re-enable visual updates if ReadyState is Completed or the watchdog timer has fired,
1301     // both of which we can determine by looking at the timer.
1302
1303     if (visualUpdatesAllowedByClient && !m_visualUpdatesSuppressionTimer.isActive() && !visualUpdatesAllowed())
1304         setVisualUpdatesAllowed(true);
1305 }
1306
1307 String Document::encoding() const
1308 {
1309     if (TextResourceDecoder* d = decoder())
1310         return d->encoding().domName();
1311     return String();
1312 }
1313
1314 String Document::defaultCharset() const
1315 {
1316     if (Settings* settings = this->settings())
1317         return settings->defaultTextEncodingName();
1318     return String();
1319 }
1320
1321 void Document::setCharset(const String& charset)
1322 {
1323     if (!decoder())
1324         return;
1325     decoder()->setEncoding(charset, TextResourceDecoder::UserChosenEncoding);
1326 }
1327
1328 void Document::setContentLanguage(const String& language)
1329 {
1330     if (m_contentLanguage == language)
1331         return;
1332     m_contentLanguage = language;
1333
1334     // Recalculate style so language is used when selecting the initial font.
1335     styleResolverChanged(DeferRecalcStyle);
1336 }
1337
1338 void Document::setXMLVersion(const String& version, ExceptionCode& ec)
1339 {
1340     if (!implementation()->hasFeature("XML", String())) {
1341         ec = NOT_SUPPORTED_ERR;
1342         return;
1343     }
1344
1345     if (!XMLDocumentParser::supportsXMLVersion(version)) {
1346         ec = NOT_SUPPORTED_ERR;
1347         return;
1348     }
1349
1350     m_xmlVersion = version;
1351 }
1352
1353 void Document::setXMLStandalone(bool standalone, ExceptionCode& ec)
1354 {
1355     if (!implementation()->hasFeature("XML", String())) {
1356         ec = NOT_SUPPORTED_ERR;
1357         return;
1358     }
1359
1360     m_xmlStandalone = standalone ? Standalone : NotStandalone;
1361 }
1362
1363 void Document::setDocumentURI(const String& uri)
1364 {
1365     // This property is read-only from JavaScript, but writable from Objective-C.
1366     m_documentURI = uri;
1367     updateBaseURL();
1368 }
1369
1370 KURL Document::baseURI() const
1371 {
1372     return m_baseURL;
1373 }
1374
1375 void Document::setContent(const String& content)
1376 {
1377     open();
1378     // FIXME: This should probably use insert(), but that's (intentionally)
1379     // not implemented for the XML parser as it's normally synonymous with
1380     // document.write(). append() will end up yielding, but close() will
1381     // pump the tokenizer syncrhonously and finish the parse.
1382     m_parser->pinToMainThread();
1383     m_parser->append(content.impl());
1384     close();
1385 }
1386
1387 String Document::suggestedMIMEType() const
1388 {
1389     if (isXHTMLDocument())
1390         return "application/xhtml+xml";
1391     if (isSVGDocument())
1392         return "image/svg+xml";
1393     if (xmlStandalone())
1394         return "text/xml";
1395     if (isHTMLDocument())
1396         return "text/html";
1397
1398     if (DocumentLoader* documentLoader = loader())
1399         return documentLoader->responseMIMEType();
1400     return String();
1401 }
1402
1403 Element* Document::elementFromPoint(int x, int y) const
1404 {
1405     if (!renderer())
1406         return 0;
1407
1408     return TreeScope::elementFromPoint(x, y);
1409 }
1410
1411 PassRefPtr<Range> Document::caretRangeFromPoint(int x, int y)
1412 {
1413     if (!renderer())
1414         return 0;
1415     LayoutPoint localPoint;
1416     Node* node = nodeFromPoint(this, x, y, &localPoint);
1417     if (!node)
1418         return 0;
1419
1420     Node* shadowAncestorNode = ancestorInThisScope(node);
1421     if (shadowAncestorNode != node) {
1422         unsigned offset = shadowAncestorNode->nodeIndex();
1423         ContainerNode* container = shadowAncestorNode->parentNode();
1424         return Range::create(this, container, offset, container, offset);
1425     }
1426
1427     RenderObject* renderer = node->renderer();
1428     if (!renderer)
1429         return 0;
1430     VisiblePosition visiblePosition = renderer->positionForPoint(localPoint);
1431     if (visiblePosition.isNull())
1432         return 0;
1433
1434     Position rangeCompliantPosition = visiblePosition.deepEquivalent().parentAnchoredEquivalent();
1435     return Range::create(this, rangeCompliantPosition, rangeCompliantPosition);
1436 }
1437
1438 /*
1439  * Performs three operations:
1440  *  1. Convert control characters to spaces
1441  *  2. Trim leading and trailing spaces
1442  *  3. Collapse internal whitespace.
1443  */
1444 template <typename CharacterType>
1445 static inline StringWithDirection canonicalizedTitle(Document* document, const StringWithDirection& titleWithDirection)
1446 {
1447     const String& title = titleWithDirection.string();
1448     const CharacterType* characters = title.getCharacters<CharacterType>();
1449     unsigned length = title.length();
1450     unsigned i;
1451
1452     StringBuffer<CharacterType> buffer(length);
1453     unsigned builderIndex = 0;
1454
1455     // Skip leading spaces and leading characters that would convert to spaces
1456     for (i = 0; i < length; ++i) {
1457         CharacterType c = characters[i];
1458         if (!(c <= 0x20 || c == 0x7F))
1459             break;
1460     }
1461
1462     if (i == length)
1463         return StringWithDirection();
1464
1465     // Replace control characters with spaces, and backslashes with currency symbols, and collapse whitespace.
1466     bool previousCharWasWS = false;
1467     for (; i < length; ++i) {
1468         CharacterType c = characters[i];
1469         if (c <= 0x20 || c == 0x7F || (WTF::Unicode::category(c) & (WTF::Unicode::Separator_Line | WTF::Unicode::Separator_Paragraph))) {
1470             if (previousCharWasWS)
1471                 continue;
1472             buffer[builderIndex++] = ' ';
1473             previousCharWasWS = true;
1474         } else {
1475             buffer[builderIndex++] = c;
1476             previousCharWasWS = false;
1477         }
1478     }
1479
1480     // Strip trailing spaces
1481     while (builderIndex > 0) {
1482         --builderIndex;
1483         if (buffer[builderIndex] != ' ')
1484             break;
1485     }
1486
1487     if (!builderIndex && buffer[builderIndex] == ' ')
1488         return StringWithDirection();
1489
1490     buffer.shrink(builderIndex + 1);
1491
1492     // Replace the backslashes with currency symbols if the encoding requires it.
1493     document->displayBufferModifiedByEncoding(buffer.characters(), buffer.length());
1494     
1495     return StringWithDirection(String::adopt(buffer), titleWithDirection.direction());
1496 }
1497
1498 void Document::updateTitle(const StringWithDirection& title)
1499 {
1500     if (m_rawTitle == title)
1501         return;
1502
1503     m_rawTitle = title;
1504
1505     if (m_rawTitle.string().isEmpty())
1506         m_title = StringWithDirection();
1507     else {
1508         if (m_rawTitle.string().is8Bit())
1509             m_title = canonicalizedTitle<LChar>(this, m_rawTitle);
1510         else
1511             m_title = canonicalizedTitle<UChar>(this, m_rawTitle);
1512     }
1513     if (Frame* f = frame())
1514         f->loader()->setTitle(m_title);
1515 }
1516
1517 void Document::setTitle(const String& title)
1518 {
1519     // Title set by JavaScript -- overrides any title elements.
1520     m_titleSetExplicitly = true;
1521     if (!isHTMLDocument() && !isXHTMLDocument())
1522         m_titleElement = 0;
1523     else if (!m_titleElement) {
1524         if (HTMLElement* headElement = head()) {
1525             m_titleElement = createElement(titleTag, false);
1526             headElement->appendChild(m_titleElement, ASSERT_NO_EXCEPTION);
1527         }
1528     }
1529
1530     // The DOM API has no method of specifying direction, so assume LTR.
1531     updateTitle(StringWithDirection(title, LTR));
1532
1533     if (m_titleElement) {
1534         ASSERT(isHTMLTitleElement(m_titleElement.get()));
1535         if (isHTMLTitleElement(m_titleElement.get()))
1536             toHTMLTitleElement(m_titleElement.get())->setText(title);
1537     }
1538 }
1539
1540 void Document::setTitleElement(const StringWithDirection& title, Element* titleElement)
1541 {
1542     if (titleElement != m_titleElement) {
1543         if (m_titleElement || m_titleSetExplicitly)
1544             // Only allow the first title element to change the title -- others have no effect.
1545             return;
1546         m_titleElement = titleElement;
1547     }
1548
1549     updateTitle(title);
1550 }
1551
1552 void Document::removeTitle(Element* titleElement)
1553 {
1554     if (m_titleElement != titleElement)
1555         return;
1556
1557     m_titleElement = 0;
1558     m_titleSetExplicitly = false;
1559
1560     // Update title based on first title element in the head, if one exists.
1561     if (HTMLElement* headElement = head()) {
1562         for (Node* e = headElement->firstChild(); e; e = e->nextSibling())
1563             if (isHTMLTitleElement(e)) {
1564                 HTMLTitleElement* titleElement = toHTMLTitleElement(e);
1565                 setTitleElement(titleElement->textWithDirection(), titleElement);
1566                 break;
1567             }
1568     }
1569
1570     if (!m_titleElement)
1571         updateTitle(StringWithDirection());
1572 }
1573
1574 #if ENABLE(PAGE_VISIBILITY_API)
1575 PageVisibilityState Document::pageVisibilityState() const
1576 {
1577     // The visibility of the document is inherited from the visibility of the
1578     // page. If there is no page associated with the document, we will assume
1579     // that the page is hidden, as specified by the spec:
1580     // http://dvcs.w3.org/hg/webperf/raw-file/tip/specs/PageVisibility/Overview.html#dom-document-hidden
1581     if (!m_frame || !m_frame->page())
1582         return PageVisibilityStateHidden;
1583     return m_frame->page()->visibilityState();
1584 }
1585
1586 String Document::visibilityState() const
1587 {
1588     return pageVisibilityStateString(pageVisibilityState());
1589 }
1590
1591 bool Document::hidden() const
1592 {
1593     return pageVisibilityState() != PageVisibilityStateVisible;
1594 }
1595
1596 void Document::dispatchVisibilityStateChangeEvent()
1597 {
1598     dispatchEvent(Event::create(eventNames().visibilitychangeEvent, false, false));
1599 }
1600 #endif
1601
1602 #if ENABLE(CSP_NEXT)
1603 DOMSecurityPolicy* Document::securityPolicy()
1604 {
1605     if (!m_domSecurityPolicy)
1606         m_domSecurityPolicy = DOMSecurityPolicy::create(this);
1607     return m_domSecurityPolicy.get();
1608 }
1609 #endif
1610
1611 String Document::nodeName() const
1612 {
1613     return "#document";
1614 }
1615
1616 Node::NodeType Document::nodeType() const
1617 {
1618     return DOCUMENT_NODE;
1619 }
1620
1621 FormController& Document::formController()
1622 {
1623     if (!m_formController)
1624         m_formController = FormController::create();
1625     return *m_formController;
1626 }
1627
1628 Vector<String> Document::formElementsState() const
1629 {
1630     if (!m_formController)
1631         return Vector<String>();
1632     return m_formController->formElementsState();
1633 }
1634
1635 void Document::setStateForNewFormElements(const Vector<String>& stateVector)
1636 {
1637     if (!stateVector.size() && !m_formController)
1638         return;
1639     formController().setStateForNewFormElements(stateVector);
1640 }
1641
1642 FrameView* Document::view() const
1643 {
1644     return m_frame ? m_frame->view() : 0;
1645 }
1646
1647 Page* Document::page() const
1648 {
1649     return m_frame ? m_frame->page() : 0;    
1650 }
1651
1652 Settings* Document::settings() const
1653 {
1654     return m_frame ? m_frame->settings() : 0;
1655 }
1656
1657 PassRefPtr<Range> Document::createRange()
1658 {
1659     return Range::create(this);
1660 }
1661
1662 PassRefPtr<NodeIterator> Document::createNodeIterator(Node* root, unsigned whatToShow, 
1663     PassRefPtr<NodeFilter> filter, bool expandEntityReferences, ExceptionCode& ec)
1664 {
1665     if (!root) {
1666         ec = NOT_SUPPORTED_ERR;
1667         return 0;
1668     }
1669     return NodeIterator::create(root, whatToShow, filter, expandEntityReferences);
1670 }
1671
1672 PassRefPtr<TreeWalker> Document::createTreeWalker(Node* root, unsigned whatToShow, 
1673     PassRefPtr<NodeFilter> filter, bool expandEntityReferences, ExceptionCode& ec)
1674 {
1675     if (!root) {
1676         ec = NOT_SUPPORTED_ERR;
1677         return 0;
1678     }
1679     return TreeWalker::create(root, whatToShow, filter, expandEntityReferences);
1680 }
1681
1682 void Document::scheduleForcedStyleRecalc()
1683 {
1684     m_pendingStyleRecalcShouldForce = true;
1685     scheduleStyleRecalc();
1686 }
1687
1688 void Document::scheduleStyleRecalc()
1689 {
1690     if (shouldDisplaySeamlesslyWithParent()) {
1691         // When we're seamless, our parent document manages our style recalcs.
1692         ownerElement()->setNeedsStyleRecalc();
1693         ownerElement()->document()->scheduleStyleRecalc();
1694         return;
1695     }
1696
1697     if (m_styleRecalcTimer.isActive() || inPageCache())
1698         return;
1699
1700     ASSERT(childNeedsStyleRecalc() || m_pendingStyleRecalcShouldForce);
1701
1702     // FIXME: Why on earth is this here? This is clearly misplaced.
1703     invalidateAccessKeyMap();
1704     
1705     m_styleRecalcTimer.startOneShot(0);
1706
1707     InspectorInstrumentation::didScheduleStyleRecalculation(this);
1708 }
1709
1710 void Document::unscheduleStyleRecalc()
1711 {
1712     ASSERT(!childNeedsStyleRecalc());
1713
1714     m_styleRecalcTimer.stop();
1715     m_pendingStyleRecalcShouldForce = false;
1716 }
1717
1718 bool Document::hasPendingStyleRecalc() const
1719 {
1720     return m_styleRecalcTimer.isActive() && !m_inStyleRecalc;
1721 }
1722
1723 bool Document::hasPendingForcedStyleRecalc() const
1724 {
1725     return m_styleRecalcTimer.isActive() && m_pendingStyleRecalcShouldForce;
1726 }
1727
1728 void Document::styleRecalcTimerFired(Timer<Document>*)
1729 {
1730     updateStyleIfNeeded();
1731 }
1732
1733 bool Document::childNeedsAndNotInStyleRecalc()
1734 {
1735     return childNeedsStyleRecalc() && !m_inStyleRecalc;
1736 }
1737
1738 void Document::recalcStyle(Style::Change change)
1739 {
1740     // we should not enter style recalc while painting
1741     ASSERT(!view() || !view()->isPainting());
1742     if (view() && view()->isPainting())
1743         return;
1744     
1745     if (m_inStyleRecalc)
1746         return; // Guard against re-entrancy. -dwh
1747
1748     // FIXME: We should update style on our ancestor chain before proceeding (especially for seamless),
1749     // however doing so currently causes several tests to crash, as Frame::setDocument calls Document::attach
1750     // before setting the DOMWindow on the Frame, or the SecurityOrigin on the document. The attach, in turn
1751     // resolves style (here) and then when we resolve style on the parent chain, we may end up
1752     // re-attaching our containing iframe, which when asked HTMLFrameElementBase::isURLAllowed
1753     // hits a null-dereference due to security code always assuming the document has a SecurityOrigin.
1754
1755     m_styleSheetCollection->flushPendingUpdates();
1756
1757     InspectorInstrumentationCookie cookie = InspectorInstrumentation::willRecalculateStyle(this);
1758
1759     if (m_elemSheet && m_elemSheet->contents()->usesRemUnits())
1760         m_styleSheetCollection->setUsesRemUnit(true);
1761
1762     m_inStyleRecalc = true;
1763     {
1764         PostAttachCallbackDisabler disabler(this);
1765         WidgetHierarchyUpdatesSuspensionScope suspendWidgetHierarchyUpdates;
1766
1767         RefPtr<FrameView> frameView = view();
1768         if (frameView) {
1769             frameView->pauseScheduledEvents();
1770             frameView->beginDeferredRepaints();
1771         }
1772
1773         ASSERT(!renderer() || renderArena());
1774         if (!renderer() || !renderArena())
1775             goto bailOut;
1776
1777         if (m_pendingStyleRecalcShouldForce)
1778             change = Style::Force;
1779
1780         // Recalculating the root style (on the document) is not needed in the common case.
1781         if ((change == Style::Force) || (shouldDisplaySeamlesslyWithParent() && (change >= Style::Inherit))) {
1782             // style selector may set this again during recalc
1783             m_hasNodesWithPlaceholderStyle = false;
1784
1785             RefPtr<RenderStyle> documentStyle = Style::resolveForDocument(this);
1786
1787             Style::Change documentChange = Style::determineChange(documentStyle.get(), renderer()->style(), settings());
1788             if (documentChange != Style::NoChange)
1789                 renderer()->setStyle(documentStyle.release());
1790         }
1791
1792         for (Node* n = firstChild(); n; n = n->nextSibling()) {
1793             if (!n->isElementNode())
1794                 continue;
1795             Element* element = toElement(n);
1796             if (change >= Style::Inherit || element->childNeedsStyleRecalc() || element->needsStyleRecalc())
1797                 Style::resolveTree(element, change);
1798         }
1799
1800 #if USE(ACCELERATED_COMPOSITING)
1801         if (view())
1802             view()->updateCompositingLayersAfterStyleChange();
1803 #endif
1804
1805     bailOut:
1806         clearNeedsStyleRecalc();
1807         clearChildNeedsStyleRecalc();
1808         unscheduleStyleRecalc();
1809
1810         m_inStyleRecalc = false;
1811
1812         // Pseudo element removal and similar may only work with these flags still set. Reset them after the style recalc.
1813         if (m_styleResolver)
1814             m_styleSheetCollection->resetCSSFeatureFlags();
1815
1816         if (frameView) {
1817             frameView->resumeScheduledEvents();
1818             frameView->endDeferredRepaints();
1819         }
1820     }
1821
1822     // If we wanted to call implicitClose() during recalcStyle, do so now that we're finished.
1823     if (m_closeAfterStyleRecalc) {
1824         m_closeAfterStyleRecalc = false;
1825         implicitClose();
1826     }
1827
1828     InspectorInstrumentation::didRecalculateStyle(cookie);
1829
1830     // As a result of the style recalculation, the currently hovered element might have been
1831     // detached (for example, by setting display:none in the :hover style), schedule another mouseMove event
1832     // to check if any other elements ended up under the mouse pointer due to re-layout.
1833     if (m_hoveredElement && !m_hoveredElement->renderer() && frame())
1834         frame()->eventHandler()->dispatchFakeMouseMoveEventSoon();
1835 }
1836
1837 void Document::updateStyleIfNeeded()
1838 {
1839     ASSERT(isMainThread());
1840     ASSERT(!view() || (!view()->isInLayout() && !view()->isPainting()));
1841
1842     if (m_optimizedStyleSheetUpdateTimer.isActive())
1843         styleResolverChanged(RecalcStyleIfNeeded);
1844
1845     if ((!m_pendingStyleRecalcShouldForce && !childNeedsStyleRecalc()) || inPageCache())
1846         return;
1847
1848     AnimationUpdateBlock animationUpdateBlock(m_frame ? m_frame->animation() : 0);
1849     recalcStyle(Style::NoChange);
1850 }
1851
1852 void Document::updateLayout()
1853 {
1854     ASSERT(isMainThread());
1855
1856     FrameView* frameView = view();
1857     if (frameView && frameView->isInLayout()) {
1858         // View layout should not be re-entrant.
1859         ASSERT_NOT_REACHED();
1860         return;
1861     }
1862
1863     if (Element* oe = ownerElement())
1864         oe->document()->updateLayout();
1865
1866     updateStyleIfNeeded();
1867
1868     StackStats::LayoutCheckPoint layoutCheckPoint;
1869
1870     // Only do a layout if changes have occurred that make it necessary.      
1871     if (frameView && renderer() && (frameView->layoutPending() || renderer()->needsLayout()))
1872         frameView->layout();
1873 }
1874
1875 // FIXME: This is a bad idea and needs to be removed eventually.
1876 // Other browsers load stylesheets before they continue parsing the web page.
1877 // Since we don't, we can run JavaScript code that needs answers before the
1878 // stylesheets are loaded. Doing a layout ignoring the pending stylesheets
1879 // lets us get reasonable answers. The long term solution to this problem is
1880 // to instead suspend JavaScript execution.
1881 void Document::updateLayoutIgnorePendingStylesheets()
1882 {
1883     bool oldIgnore = m_ignorePendingStylesheets;
1884     
1885     if (!haveStylesheetsLoaded()) {
1886         m_ignorePendingStylesheets = true;
1887         // FIXME: We are willing to attempt to suppress painting with outdated style info only once.  Our assumption is that it would be
1888         // dangerous to try to stop it a second time, after page content has already been loaded and displayed
1889         // with accurate style information.  (Our suppression involves blanking the whole page at the
1890         // moment.  If it were more refined, we might be able to do something better.)
1891         // It's worth noting though that this entire method is a hack, since what we really want to do is
1892         // suspend JS instead of doing a layout with inaccurate information.
1893         HTMLElement* bodyElement = body();
1894         if (bodyElement && !bodyElement->renderer() && m_pendingSheetLayout == NoLayoutWithPendingSheets) {
1895             m_pendingSheetLayout = DidLayoutWithPendingSheets;
1896             styleResolverChanged(RecalcStyleImmediately);
1897         } else if (m_hasNodesWithPlaceholderStyle)
1898             // If new nodes have been added or style recalc has been done with style sheets still pending, some nodes 
1899             // may not have had their real style calculated yet. Normally this gets cleaned when style sheets arrive 
1900             // but here we need up-to-date style immediately.
1901             recalcStyle(Style::Force);
1902     }
1903
1904     updateLayout();
1905
1906     m_ignorePendingStylesheets = oldIgnore;
1907 }
1908
1909 PassRefPtr<RenderStyle> Document::styleForElementIgnoringPendingStylesheets(Element* element)
1910 {
1911     ASSERT_ARG(element, element->document() == this);
1912
1913     bool oldIgnore = m_ignorePendingStylesheets;
1914     m_ignorePendingStylesheets = true;
1915     RefPtr<RenderStyle> style = ensureStyleResolver().styleForElement(element, element->parentNode() ? element->parentNode()->computedStyle() : 0);
1916     m_ignorePendingStylesheets = oldIgnore;
1917     return style.release();
1918 }
1919
1920 PassRefPtr<RenderStyle> Document::styleForPage(int pageIndex)
1921 {
1922     RefPtr<RenderStyle> style = ensureStyleResolver().styleForPage(pageIndex);
1923     return style.release();
1924 }
1925
1926 bool Document::isPageBoxVisible(int pageIndex)
1927 {
1928     RefPtr<RenderStyle> style = styleForPage(pageIndex);
1929     return style->visibility() != HIDDEN; // display property doesn't apply to @page.
1930 }
1931
1932 void Document::pageSizeAndMarginsInPixels(int pageIndex, IntSize& pageSize, int& marginTop, int& marginRight, int& marginBottom, int& marginLeft)
1933 {
1934     RefPtr<RenderStyle> style = styleForPage(pageIndex);
1935     RenderView* view = renderView();
1936
1937     int width = pageSize.width();
1938     int height = pageSize.height();
1939     switch (style->pageSizeType()) {
1940     case PAGE_SIZE_AUTO:
1941         break;
1942     case PAGE_SIZE_AUTO_LANDSCAPE:
1943         if (width < height)
1944             std::swap(width, height);
1945         break;
1946     case PAGE_SIZE_AUTO_PORTRAIT:
1947         if (width > height)
1948             std::swap(width, height);
1949         break;
1950     case PAGE_SIZE_RESOLVED: {
1951         LengthSize size = style->pageSize();
1952         ASSERT(size.width().isFixed());
1953         ASSERT(size.height().isFixed());
1954         width = valueForLength(size.width(), 0, view);
1955         height = valueForLength(size.height(), 0, view);
1956         break;
1957     }
1958     default:
1959         ASSERT_NOT_REACHED();
1960     }
1961     pageSize = IntSize(width, height);
1962
1963     // The percentage is calculated with respect to the width even for margin top and bottom.
1964     // http://www.w3.org/TR/CSS2/box.html#margin-properties
1965     marginTop = style->marginTop().isAuto() ? marginTop : intValueForLength(style->marginTop(), width, view);
1966     marginRight = style->marginRight().isAuto() ? marginRight : intValueForLength(style->marginRight(), width, view);
1967     marginBottom = style->marginBottom().isAuto() ? marginBottom : intValueForLength(style->marginBottom(), width, view);
1968     marginLeft = style->marginLeft().isAuto() ? marginLeft : intValueForLength(style->marginLeft(), width, view);
1969 }
1970
1971 void Document::setIsViewSource(bool isViewSource)
1972 {
1973     m_isViewSource = isViewSource;
1974     if (!m_isViewSource)
1975         return;
1976
1977     setSecurityOrigin(SecurityOrigin::createUnique());
1978 }
1979
1980 void Document::createStyleResolver()
1981 {
1982     bool matchAuthorAndUserStyles = true;
1983     if (Settings* docSettings = settings())
1984         matchAuthorAndUserStyles = docSettings->authorAndUserStylesEnabled();
1985     m_styleResolver = adoptPtr(new StyleResolver(this, matchAuthorAndUserStyles));
1986     m_styleSheetCollection->combineCSSFeatureFlags();
1987 }
1988
1989 void Document::clearStyleResolver()
1990 {
1991     m_styleResolver.clear();
1992 }
1993
1994 void Document::attach(const AttachContext& context)
1995 {
1996     ASSERT(!attached());
1997     ASSERT(!m_inPageCache);
1998     ASSERT(!m_axObjectCache || this != topDocument());
1999
2000     if (!m_renderArena)
2001         m_renderArena = RenderArena::create();
2002     
2003     // Create the rendering tree
2004     setRenderer(new (m_renderArena.get()) RenderView(this));
2005 #if USE(ACCELERATED_COMPOSITING)
2006     renderView()->setIsInWindow(true);
2007 #endif
2008
2009     recalcStyle(Style::Force);
2010
2011     RenderObject* render = renderer();
2012     setRenderer(0);
2013
2014     ContainerNode::attach(context);
2015
2016     setRenderer(render);
2017 }
2018
2019 void Document::detach(const AttachContext& context)
2020 {
2021     ASSERT(attached());
2022     ASSERT(!m_inPageCache);
2023
2024 #if ENABLE(POINTER_LOCK)
2025     if (page())
2026         page()->pointerLockController()->documentDetached(this);
2027 #endif
2028
2029     if (this == topDocument())
2030         clearAXObjectCache();
2031
2032     stopActiveDOMObjects();
2033     m_eventQueue->close();
2034 #if ENABLE(FULLSCREEN_API)
2035     m_fullScreenChangeEventTargetQueue.clear();
2036     m_fullScreenErrorEventTargetQueue.clear();
2037 #endif
2038
2039 #if ENABLE(REQUEST_ANIMATION_FRAME)
2040     clearScriptedAnimationController();
2041 #endif
2042
2043     RenderObject* render = renderer();
2044
2045     documentWillBecomeInactive();
2046
2047 #if ENABLE(SHARED_WORKERS)
2048     SharedWorkerRepository::documentDetached(this);
2049 #endif
2050
2051     if (m_frame) {
2052         FrameView* view = m_frame->view();
2053         if (view)
2054             view->detachCustomScrollbars();
2055
2056     }
2057
2058     // indicate destruction mode,  i.e. attached() but renderer == 0
2059     setRenderer(0);
2060     
2061 #if ENABLE(FULLSCREEN_API)
2062     if (m_fullScreenRenderer)
2063         setFullScreenRenderer(0);
2064 #endif
2065
2066     m_hoveredElement = 0;
2067     m_focusedElement = 0;
2068     m_activeElement = 0;
2069
2070     ContainerNode::detach(context);
2071
2072     unscheduleStyleRecalc();
2073
2074     if (render)
2075         render->destroy();
2076
2077 #if ENABLE(TOUCH_EVENTS)
2078     if (m_touchEventTargets && m_touchEventTargets->size() && parentDocument())
2079         parentDocument()->didRemoveEventTargetNode(this);
2080 #endif
2081
2082     // This is required, as our Frame might delete itself as soon as it detaches
2083     // us. However, this violates Node::detach() semantics, as it's never
2084     // possible to re-attach. Eventually Document::detach() should be renamed,
2085     // or this setting of the frame to 0 could be made explicit in each of the
2086     // callers of Document::detach().
2087     m_frame = 0;
2088     m_renderArena.clear();
2089
2090     if (m_mediaQueryMatcher)
2091         m_mediaQueryMatcher->documentDestroyed();
2092 }
2093
2094 void Document::prepareForDestruction()
2095 {
2096     disconnectDescendantFrames();
2097     if (DOMWindow* window = this->domWindow())
2098         window->willDetachDocumentFromFrame();
2099     detach();
2100 }
2101
2102 void Document::removeAllEventListeners()
2103 {
2104     EventTarget::removeAllEventListeners();
2105
2106     if (DOMWindow* domWindow = this->domWindow())
2107         domWindow->removeAllEventListeners();
2108     for (Node* node = firstChild(); node; node = NodeTraversal::next(node))
2109         node->removeAllEventListeners();
2110 }
2111
2112 void Document::suspendActiveDOMObjects(ActiveDOMObject::ReasonForSuspension why)
2113 {
2114     ScriptExecutionContext::suspendActiveDOMObjects(why);
2115 }
2116
2117 void Document::resumeActiveDOMObjects(ActiveDOMObject::ReasonForSuspension why)
2118 {
2119     ScriptExecutionContext::resumeActiveDOMObjects(why);
2120 }
2121
2122 void Document::clearAXObjectCache()
2123 {
2124     ASSERT(topDocument() == this);
2125     // Clear the cache member variable before calling delete because attempts
2126     // are made to access it during destruction.
2127     m_axObjectCache.clear();
2128 }
2129
2130 AXObjectCache* Document::existingAXObjectCache() const
2131 {
2132     if (!AXObjectCache::accessibilityEnabled())
2133         return 0;
2134
2135     // If the renderer is gone then we are in the process of destruction.
2136     // This method will be called before m_frame = 0.
2137     if (!topDocument()->renderer())
2138         return 0;
2139
2140     return topDocument()->m_axObjectCache.get();
2141 }
2142
2143 AXObjectCache* Document::axObjectCache() const
2144 {
2145     if (!AXObjectCache::accessibilityEnabled())
2146         return 0;
2147     
2148     // The only document that actually has a AXObjectCache is the top-level
2149     // document.  This is because we need to be able to get from any WebCoreAXObject
2150     // to any other WebCoreAXObject on the same page.  Using a single cache allows
2151     // lookups across nested webareas (i.e. multiple documents).
2152     Document* topDocument = this->topDocument();
2153
2154     // If the document has already been detached, do not make a new axObjectCache.
2155     if (!topDocument->renderer())
2156         return 0;
2157
2158     ASSERT(topDocument == this || !m_axObjectCache);
2159     if (!topDocument->m_axObjectCache)
2160         topDocument->m_axObjectCache = adoptPtr(new AXObjectCache(topDocument));
2161     return topDocument->m_axObjectCache.get();
2162 }
2163
2164 void Document::setVisuallyOrdered()
2165 {
2166     m_visuallyOrdered = true;
2167     if (renderer())
2168         renderer()->style()->setRTLOrdering(VisualOrder);
2169 }
2170
2171 PassRefPtr<DocumentParser> Document::createParser()
2172 {
2173     // FIXME: this should probably pass the frame instead
2174     return XMLDocumentParser::create(this, view());
2175 }
2176
2177 ScriptableDocumentParser* Document::scriptableDocumentParser() const
2178 {
2179     return parser() ? parser()->asScriptableDocumentParser() : 0;
2180 }
2181
2182 void Document::open(Document* ownerDocument)
2183 {
2184     if (ownerDocument) {
2185         setURL(ownerDocument->url());
2186         m_cookieURL = ownerDocument->cookieURL();
2187         setSecurityOrigin(ownerDocument->securityOrigin());
2188     }
2189
2190     if (m_frame) {
2191         if (ScriptableDocumentParser* parser = scriptableDocumentParser()) {
2192             if (parser->isParsing()) {
2193                 // FIXME: HTML5 doesn't tell us to check this, it might not be correct.
2194                 if (parser->isExecutingScript())
2195                     return;
2196
2197                 if (!parser->wasCreatedByScript() && parser->hasInsertionPoint())
2198                     return;
2199             }
2200         }
2201
2202         if (m_frame->loader()->state() == FrameStateProvisional)
2203             m_frame->loader()->stopAllLoaders();
2204     }
2205
2206     removeAllEventListeners();
2207     implicitOpen();
2208     if (ScriptableDocumentParser* parser = scriptableDocumentParser())
2209         parser->setWasCreatedByScript(true);
2210
2211     if (m_frame)
2212         m_frame->loader()->didExplicitOpen();
2213 }
2214
2215 void Document::detachParser()
2216 {
2217     if (!m_parser)
2218         return;
2219     m_parser->detach();
2220     m_parser.clear();
2221 }
2222
2223 void Document::cancelParsing()
2224 {
2225     if (!m_parser)
2226         return;
2227
2228     // We have to clear the parser to avoid possibly triggering
2229     // the onload handler when closing as a side effect of a cancel-style
2230     // change, such as opening a new document or closing the window while
2231     // still parsing
2232     detachParser();
2233     explicitClose();
2234 }
2235
2236 void Document::implicitOpen()
2237 {
2238     cancelParsing();
2239
2240     removeChildren();
2241
2242     setCompatibilityMode(NoQuirksMode);
2243
2244     // Documents rendered seamlessly should start out requiring a stylesheet
2245     // collection update in order to ensure they inherit all the relevant data
2246     // from their parent.
2247     if (shouldDisplaySeamlesslyWithParent())
2248         styleResolverChanged(DeferRecalcStyle);
2249
2250     m_parser = createParser();
2251     setParsing(true);
2252     setReadyState(Loading);
2253 }
2254
2255 HTMLElement* Document::body() const
2256 {
2257     Node* de = documentElement();
2258     if (!de)
2259         return 0;
2260     
2261     // try to prefer a FRAMESET element over BODY
2262     Node* body = 0;
2263     for (Node* i = de->firstChild(); i; i = i->nextSibling()) {
2264         if (i->hasTagName(framesetTag))
2265             return toHTMLElement(i);
2266         
2267         if (i->hasTagName(bodyTag) && !body)
2268             body = i;
2269     }
2270     return toHTMLElement(body);
2271 }
2272
2273 void Document::setBody(PassRefPtr<HTMLElement> prpNewBody, ExceptionCode& ec)
2274 {
2275     RefPtr<HTMLElement> newBody = prpNewBody;
2276
2277     if (!newBody || !documentElement() || !newBody->hasTagName(bodyTag)) { 
2278         ec = HIERARCHY_REQUEST_ERR;
2279         return;
2280     }
2281
2282     if (newBody->document() && newBody->document() != this) {
2283         ec = 0;
2284         RefPtr<Node> node = importNode(newBody.get(), true, ec);
2285         if (ec)
2286             return;
2287         
2288         newBody = toHTMLElement(node.get());
2289     }
2290
2291     HTMLElement* b = body();
2292     if (!b)
2293         documentElement()->appendChild(newBody.release(), ec);
2294     else
2295         documentElement()->replaceChild(newBody.release(), b, ec);
2296 }
2297
2298 HTMLHeadElement* Document::head()
2299 {
2300     Node* de = documentElement();
2301     if (!de)
2302         return 0;
2303
2304     for (Node* e = de->firstChild(); e; e = e->nextSibling())
2305         if (e->hasTagName(headTag))
2306             return static_cast<HTMLHeadElement*>(e);
2307
2308     return 0;
2309 }
2310
2311 void Document::close()
2312 {
2313     // FIXME: We should follow the specification more closely:
2314     //        http://www.whatwg.org/specs/web-apps/current-work/#dom-document-close
2315
2316     if (!scriptableDocumentParser() || !scriptableDocumentParser()->wasCreatedByScript() || !scriptableDocumentParser()->isParsing())
2317         return;
2318
2319     explicitClose();
2320 }
2321
2322 void Document::explicitClose()
2323 {
2324     if (RefPtr<DocumentParser> parser = m_parser)
2325         parser->finish();
2326
2327     if (!m_frame) {
2328         // Because we have no frame, we don't know if all loading has completed,
2329         // so we just call implicitClose() immediately. FIXME: This might fire
2330         // the load event prematurely <http://bugs.webkit.org/show_bug.cgi?id=14568>.
2331         implicitClose();
2332         return;
2333     }
2334
2335     m_frame->loader()->checkCompleted();
2336 }
2337
2338 void Document::implicitClose()
2339 {
2340     // 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.
2341     if (m_inStyleRecalc) {
2342         m_closeAfterStyleRecalc = true;
2343         return;
2344     }
2345
2346     bool wasLocationChangePending = frame() && frame()->navigationScheduler()->locationChangePending();
2347     bool doload = !parsing() && m_parser && !m_processingLoadEvent && !wasLocationChangePending;
2348     
2349     if (!doload)
2350         return;
2351
2352     // Call to dispatchWindowLoadEvent can blow us from underneath.
2353     RefPtr<Document> protect(this);
2354
2355     m_processingLoadEvent = true;
2356
2357     ScriptableDocumentParser* parser = scriptableDocumentParser();
2358     m_wellFormed = parser && parser->wellFormed();
2359
2360     // We have to clear the parser, in case someone document.write()s from the
2361     // onLoad event handler, as in Radar 3206524.
2362     detachParser();
2363
2364     // FIXME: We kick off the icon loader when the Document is done parsing.
2365     // There are earlier opportunities we could start it:
2366     //  -When the <head> finishes parsing
2367     //  -When any new HTMLLinkElement is inserted into the document
2368     // But those add a dynamic component to the favicon that has UI 
2369     // ramifications, and we need to decide what is the Right Thing To Do(tm)
2370     Frame* f = frame();
2371     if (f) {
2372         f->loader()->icon()->startLoader();
2373         f->animation()->startAnimationsIfNotSuspended(this);
2374     }
2375
2376     ImageLoader::dispatchPendingBeforeLoadEvents();
2377     ImageLoader::dispatchPendingLoadEvents();
2378     ImageLoader::dispatchPendingErrorEvents();
2379
2380     HTMLLinkElement::dispatchPendingLoadEvents();
2381     HTMLStyleElement::dispatchPendingLoadEvents();
2382
2383 #if ENABLE(SVG)
2384     // To align the HTML load event and the SVGLoad event for the outermost <svg> element, fire it from
2385     // here, instead of doing it from SVGElement::finishedParsingChildren (if externalResourcesRequired="false",
2386     // which is the default, for ='true' its fired at a later time, once all external resources finished loading).
2387     if (svgExtensions())
2388         accessSVGExtensions()->dispatchSVGLoadEventToOutermostSVGElements();
2389 #endif
2390
2391     dispatchWindowLoadEvent();
2392     enqueuePageshowEvent(PageshowEventNotPersisted);
2393     enqueuePopstateEvent(m_pendingStateObject ? m_pendingStateObject.release() : SerializedScriptValue::nullValue());
2394     
2395     if (f)
2396         f->loader()->handledOnloadEvents();
2397 #ifdef INSTRUMENT_LAYOUT_SCHEDULING
2398     if (!ownerElement())
2399         printf("onload fired at %d\n", elapsedTime());
2400 #endif
2401
2402     // An event handler may have removed the frame
2403     if (!frame()) {
2404         m_processingLoadEvent = false;
2405         return;
2406     }
2407
2408     // Make sure both the initial layout and reflow happen after the onload
2409     // fires. This will improve onload scores, and other browsers do it.
2410     // If they wanna cheat, we can too. -dwh
2411
2412     if (frame()->navigationScheduler()->locationChangePending() && elapsedTime() < cLayoutScheduleThreshold) {
2413         // Just bail out. Before or during the onload we were shifted to another page.
2414         // The old i-Bench suite does this. When this happens don't bother painting or laying out.        
2415         m_processingLoadEvent = false;
2416         view()->unscheduleRelayout();
2417         return;
2418     }
2419
2420     frame()->loader()->checkCallImplicitClose();
2421     
2422     // We used to force a synchronous display and flush here.  This really isn't
2423     // necessary and can in fact be actively harmful if pages are loading at a rate of > 60fps
2424     // (if your platform is syncing flushes and limiting them to 60fps).
2425     m_overMinimumLayoutThreshold = true;
2426     if (!ownerElement() || (ownerElement()->renderer() && !ownerElement()->renderer()->needsLayout())) {
2427         updateStyleIfNeeded();
2428         
2429         // Always do a layout after loading if needed.
2430         if (view() && renderer() && (!renderer()->firstChild() || renderer()->needsLayout()))
2431             view()->layout();
2432     }
2433
2434     m_processingLoadEvent = false;
2435
2436 #if PLATFORM(MAC) || PLATFORM(WIN)
2437     if (f && renderer() && AXObjectCache::accessibilityEnabled()) {
2438         // The AX cache may have been cleared at this point, but we need to make sure it contains an
2439         // AX object to send the notification to. getOrCreate will make sure that an valid AX object
2440         // exists in the cache (we ignore the return value because we don't need it here). This is 
2441         // only safe to call when a layout is not in progress, so it can not be used in postNotification.    
2442         axObjectCache()->getOrCreate(renderer());
2443         if (this == topDocument())
2444             axObjectCache()->postNotification(renderer(), AXObjectCache::AXLoadComplete, true);
2445         else {
2446             // AXLoadComplete can only be posted on the top document, so if it's a document
2447             // in an iframe that just finished loading, post AXLayoutComplete instead.
2448             axObjectCache()->postNotification(renderer(), AXObjectCache::AXLayoutComplete, true);
2449         }
2450     }
2451 #endif
2452
2453 #if ENABLE(SVG)
2454     if (svgExtensions())
2455         accessSVGExtensions()->startAnimations();
2456 #endif
2457 }
2458
2459 void Document::setParsing(bool b)
2460 {
2461     m_bParsing = b;
2462
2463     if (m_bParsing && !m_sharedObjectPool)
2464         m_sharedObjectPool = DocumentSharedObjectPool::create();
2465
2466     if (!m_bParsing && view())
2467         view()->scheduleRelayout();
2468
2469 #ifdef INSTRUMENT_LAYOUT_SCHEDULING
2470     if (!ownerElement() && !m_bParsing)
2471         printf("Parsing finished at %d\n", elapsedTime());
2472 #endif
2473 }
2474
2475 bool Document::shouldScheduleLayout()
2476 {
2477     // This function will only be called when FrameView thinks a layout is needed.
2478     // This enforces a couple extra rules.
2479     //
2480     //    (a) Only schedule a layout once the stylesheets are loaded.
2481     //    (b) Only schedule layout once we have a body element.
2482
2483     return (haveStylesheetsLoaded() && body())
2484         || (documentElement() && !documentElement()->hasTagName(htmlTag));
2485 }
2486     
2487 bool Document::isLayoutTimerActive()
2488 {
2489     return view() && view()->layoutPending() && !minimumLayoutDelay();
2490 }
2491
2492 int Document::minimumLayoutDelay()
2493 {
2494     if (m_overMinimumLayoutThreshold)
2495         return 0;
2496     
2497     int elapsed = elapsedTime();
2498     m_overMinimumLayoutThreshold = elapsed > cLayoutScheduleThreshold;
2499     
2500     // We'll want to schedule the timer to fire at the minimum layout threshold.
2501     return max(0, cLayoutScheduleThreshold - elapsed);
2502 }
2503
2504 int Document::elapsedTime() const
2505 {
2506     return static_cast<int>((currentTime() - m_startTime) * 1000);
2507 }
2508
2509 void Document::write(const SegmentedString& text, Document* ownerDocument)
2510 {
2511     NestingLevelIncrementer nestingLevelIncrementer(m_writeRecursionDepth);
2512
2513     m_writeRecursionIsTooDeep = (m_writeRecursionDepth > 1) && m_writeRecursionIsTooDeep;
2514     m_writeRecursionIsTooDeep = (m_writeRecursionDepth > cMaxWriteRecursionDepth) || m_writeRecursionIsTooDeep;
2515
2516     if (m_writeRecursionIsTooDeep)
2517        return;
2518
2519 #ifdef INSTRUMENT_LAYOUT_SCHEDULING
2520     if (!ownerElement())
2521         printf("Beginning a document.write at %d\n", elapsedTime());
2522 #endif
2523
2524     bool hasInsertionPoint = m_parser && m_parser->hasInsertionPoint();
2525     if (!hasInsertionPoint && m_ignoreDestructiveWriteCount)
2526         return;
2527
2528     if (!hasInsertionPoint)
2529         open(ownerDocument);
2530
2531     ASSERT(m_parser);
2532     m_parser->insert(text);
2533
2534 #ifdef INSTRUMENT_LAYOUT_SCHEDULING
2535     if (!ownerElement())
2536         printf("Ending a document.write at %d\n", elapsedTime());
2537 #endif    
2538 }
2539
2540 void Document::write(const String& text, Document* ownerDocument)
2541 {
2542     write(SegmentedString(text), ownerDocument);
2543 }
2544
2545 void Document::writeln(const String& text, Document* ownerDocument)
2546 {
2547     write(text, ownerDocument);
2548     write("\n", ownerDocument);
2549 }
2550
2551 const KURL& Document::virtualURL() const
2552 {
2553     return m_url;
2554 }
2555
2556 KURL Document::virtualCompleteURL(const String& url) const
2557 {
2558     return completeURL(url);
2559 }
2560
2561 double Document::minimumTimerInterval() const
2562 {
2563     Page* p = page();
2564     if (!p)
2565         return ScriptExecutionContext::minimumTimerInterval();
2566     return p->settings()->minDOMTimerInterval();
2567 }
2568
2569 double Document::timerAlignmentInterval() const
2570 {
2571     Page* p = page();
2572     if (!p)
2573         return ScriptExecutionContext::timerAlignmentInterval();
2574     return p->settings()->domTimerAlignmentInterval();
2575 }
2576
2577 EventTarget* Document::errorEventTarget()
2578 {
2579     return domWindow();
2580 }
2581
2582 void Document::logExceptionToConsole(const String& errorMessage, const String& sourceURL, int lineNumber, int columnNumber, PassRefPtr<ScriptCallStack> callStack)
2583 {
2584     addMessage(JSMessageSource, ErrorMessageLevel, errorMessage, sourceURL, lineNumber, columnNumber, callStack);
2585 }
2586
2587 void Document::setURL(const KURL& url)
2588 {
2589     const KURL& newURL = url.isEmpty() ? blankURL() : url;
2590     if (newURL == m_url)
2591         return;
2592
2593     m_url = newURL;
2594     m_documentURI = m_url.string();
2595     updateBaseURL();
2596     contextFeatures()->urlDidChange(this);
2597 }
2598
2599 void Document::updateBaseURL()
2600 {
2601     KURL oldBaseURL = m_baseURL;
2602     // DOM 3 Core: When the Document supports the feature "HTML" [DOM Level 2 HTML], the base URI is computed using
2603     // first the value of the href attribute of the HTML BASE element if any, and the value of the documentURI attribute
2604     // from the Document interface otherwise.
2605     if (!m_baseElementURL.isEmpty())
2606         m_baseURL = m_baseElementURL;
2607     else if (!m_baseURLOverride.isEmpty())
2608         m_baseURL = m_baseURLOverride;
2609     else {
2610         // The documentURI attribute is read-only from JavaScript, but writable from Objective C, so we need to retain
2611         // this fallback behavior. We use a null base URL, since the documentURI attribute is an arbitrary string
2612         // and DOM 3 Core does not specify how it should be resolved.
2613         m_baseURL = KURL(ParsedURLString, documentURI());
2614     }
2615
2616     if (m_selectorQueryCache)
2617         m_selectorQueryCache->invalidate();
2618
2619     if (!m_baseURL.isValid())
2620         m_baseURL = KURL();
2621
2622     if (m_elemSheet) {
2623         // Element sheet is silly. It never contains anything.
2624         ASSERT(!m_elemSheet->contents()->ruleCount());
2625         bool usesRemUnits = m_elemSheet->contents()->usesRemUnits();
2626         m_elemSheet = CSSStyleSheet::createInline(this, m_baseURL);
2627         // FIXME: So we are not really the parser. The right fix is to eliminate the element sheet completely.
2628         m_elemSheet->contents()->parserSetUsesRemUnits(usesRemUnits);
2629     }
2630
2631     if (!equalIgnoringFragmentIdentifier(oldBaseURL, m_baseURL)) {
2632         // Base URL change changes any relative visited links.
2633         // FIXME: There are other URLs in the tree that would need to be re-evaluated on dynamic base URL change. Style should be invalidated too.
2634         for (Element* element = ElementTraversal::firstWithin(this); element; element = ElementTraversal::next(element)) {
2635             if (isHTMLAnchorElement(element))
2636                 toHTMLAnchorElement(element)->invalidateCachedVisitedLinkHash();
2637         }
2638     }
2639 }
2640
2641 void Document::setBaseURLOverride(const KURL& url)
2642 {
2643     m_baseURLOverride = url;
2644     updateBaseURL();
2645 }
2646
2647 void Document::processBaseElement()
2648 {
2649     // Find the first href attribute in a base element and the first target attribute in a base element.
2650     const AtomicString* href = 0;
2651     const AtomicString* target = 0;
2652     for (Element* element = ElementTraversal::firstWithin(this); element && (!href || !target); element = ElementTraversal::next(element)) {
2653         if (element->hasTagName(baseTag)) {
2654             if (!href) {
2655                 const AtomicString& value = element->fastGetAttribute(hrefAttr);
2656                 if (!value.isNull())
2657                     href = &value;
2658             }
2659             if (!target) {
2660                 const AtomicString& value = element->fastGetAttribute(targetAttr);
2661                 if (!value.isNull())
2662                     target = &value;
2663             }
2664         }
2665     }
2666
2667     // FIXME: Since this doesn't share code with completeURL it may not handle encodings correctly.
2668     KURL baseElementURL;
2669     if (href) {
2670         String strippedHref = stripLeadingAndTrailingHTMLSpaces(*href);
2671         if (!strippedHref.isEmpty())
2672             baseElementURL = KURL(url(), strippedHref);
2673     }
2674     if (m_baseElementURL != baseElementURL && contentSecurityPolicy()->allowBaseURI(baseElementURL)) {
2675         m_baseElementURL = baseElementURL;
2676         updateBaseURL();
2677     }
2678
2679     m_baseTarget = target ? *target : nullAtom;
2680 }
2681
2682 String Document::userAgent(const KURL& url) const
2683 {
2684     return frame() ? frame()->loader()->userAgent(url) : String();
2685 }
2686
2687 void Document::disableEval(const String& errorMessage)
2688 {
2689     if (!frame())
2690         return;
2691
2692     frame()->script()->disableEval(errorMessage);
2693 }
2694
2695 bool Document::canNavigate(Frame* targetFrame)
2696 {
2697     if (!m_frame)
2698         return false;
2699
2700     // FIXME: We shouldn't call this function without a target frame, but
2701     // fast/forms/submit-to-blank-multiple-times.html depends on this function
2702     // returning true when supplied with a 0 targetFrame.
2703     if (!targetFrame)
2704         return true;
2705
2706     // Frame-busting is generally allowed, but blocked for sandboxed frames lacking the 'allow-top-navigation' flag.
2707     if (!isSandboxed(SandboxTopNavigation) && targetFrame == m_frame->tree()->top())
2708         return true;
2709
2710     if (isSandboxed(SandboxNavigation)) {
2711         if (targetFrame->tree()->isDescendantOf(m_frame))
2712             return true;
2713
2714         const char* reason = "The frame attempting navigation is sandboxed, and is therefore disallowed from navigating its ancestors.";
2715         if (isSandboxed(SandboxTopNavigation) && targetFrame == m_frame->tree()->top())
2716             reason = "The frame attempting navigation of the top-level window is sandboxed, but the 'allow-top-navigation' flag is not set.";
2717
2718         printNavigationErrorMessage(targetFrame, url(), reason);
2719         return false;
2720     }
2721
2722     // This is the normal case. A document can navigate its decendant frames,
2723     // or, more generally, a document can navigate a frame if the document is
2724     // in the same origin as any of that frame's ancestors (in the frame
2725     // hierarchy).
2726     //
2727     // See http://www.adambarth.com/papers/2008/barth-jackson-mitchell.pdf for
2728     // historical information about this security check.
2729     if (canAccessAncestor(securityOrigin(), targetFrame))
2730         return true;
2731
2732     // Top-level frames are easier to navigate than other frames because they
2733     // display their URLs in the address bar (in most browsers). However, there
2734     // are still some restrictions on navigation to avoid nuisance attacks.
2735     // Specifically, a document can navigate a top-level frame if that frame
2736     // opened the document or if the document is the same-origin with any of
2737     // the top-level frame's opener's ancestors (in the frame hierarchy).
2738     //
2739     // In both of these cases, the document performing the navigation is in
2740     // some way related to the frame being navigate (e.g., by the "opener"
2741     // and/or "parent" relation). Requiring some sort of relation prevents a
2742     // document from navigating arbitrary, unrelated top-level frames.
2743     if (!targetFrame->tree()->parent()) {
2744         if (targetFrame == m_frame->loader()->opener())
2745             return true;
2746
2747         if (canAccessAncestor(securityOrigin(), targetFrame->loader()->opener()))
2748             return true;
2749     }
2750
2751     printNavigationErrorMessage(targetFrame, url(), "The frame attempting navigation is neither same-origin with the target, nor is it the target's parent or opener.");
2752     return false;
2753 }
2754
2755 Frame* Document::findUnsafeParentScrollPropagationBoundary()
2756 {
2757     Frame* currentFrame = m_frame;
2758     if (!currentFrame)
2759         return 0;
2760
2761     Frame* ancestorFrame = currentFrame->tree()->parent();
2762
2763     while (ancestorFrame) {
2764         if (!ancestorFrame->document()->securityOrigin()->canAccess(securityOrigin()))
2765             return currentFrame;
2766         currentFrame = ancestorFrame;
2767         ancestorFrame = ancestorFrame->tree()->parent();
2768     }
2769     return 0;
2770 }
2771
2772
2773 void Document::seamlessParentUpdatedStylesheets()
2774 {
2775     styleResolverChanged(RecalcStyleImmediately);
2776 }
2777
2778 void Document::didRemoveAllPendingStylesheet()
2779 {
2780     m_needsNotifyRemoveAllPendingStylesheet = false;
2781
2782     styleResolverChanged(RecalcStyleIfNeeded);
2783
2784     if (ScriptableDocumentParser* parser = scriptableDocumentParser())
2785         parser->executeScriptsWaitingForStylesheets();
2786
2787     if (m_gotoAnchorNeededAfterStylesheetsLoad && view())
2788         view()->scrollToFragment(m_url);
2789 }
2790
2791 CSSStyleSheet* Document::elementSheet()
2792 {
2793     if (!m_elemSheet)
2794         m_elemSheet = CSSStyleSheet::createInline(this, m_baseURL);
2795     return m_elemSheet.get();
2796 }
2797
2798 void Document::processHttpEquiv(const String& equiv, const String& content)
2799 {
2800     ASSERT(!equiv.isNull() && !content.isNull());
2801
2802     Frame* frame = this->frame();
2803
2804     if (equalIgnoringCase(equiv, "default-style")) {
2805         // The preferred style set has been overridden as per section 
2806         // 14.3.2 of the HTML4.0 specification.  We need to update the
2807         // sheet used variable and then update our style selector. 
2808         // For more info, see the test at:
2809         // http://www.hixie.ch/tests/evil/css/import/main/preferred.html
2810         // -dwh
2811         m_styleSheetCollection->setSelectedStylesheetSetName(content);
2812         m_styleSheetCollection->setPreferredStylesheetSetName(content);
2813         styleResolverChanged(DeferRecalcStyle);
2814     } else if (equalIgnoringCase(equiv, "refresh")) {
2815         double delay;
2816         String url;
2817         if (frame && parseHTTPRefresh(content, true, delay, url)) {
2818             if (url.isEmpty())
2819                 url = m_url.string();
2820             else
2821                 url = completeURL(url).string();
2822             frame->navigationScheduler()->scheduleRedirect(delay, url);
2823         }
2824     } else if (equalIgnoringCase(equiv, "set-cookie")) {
2825         // FIXME: make setCookie work on XML documents too; e.g. in case of <html:meta .....>
2826         if (isHTMLDocument()) {
2827             // Exception (for sandboxed documents) ignored.
2828             toHTMLDocument(this)->setCookie(content, IGNORE_EXCEPTION);
2829         }
2830     } else if (equalIgnoringCase(equiv, "content-language"))
2831         setContentLanguage(content);
2832     else if (equalIgnoringCase(equiv, "x-dns-prefetch-control"))
2833         parseDNSPrefetchControlHeader(content);
2834     else if (equalIgnoringCase(equiv, "x-frame-options")) {
2835         if (frame) {
2836             FrameLoader* frameLoader = frame->loader();
2837             unsigned long requestIdentifier = 0;
2838             if (frameLoader->activeDocumentLoader() && frameLoader->activeDocumentLoader()->mainResourceLoader())
2839                 requestIdentifier = frameLoader->activeDocumentLoader()->mainResourceLoader()->identifier();
2840             if (frameLoader->shouldInterruptLoadForXFrameOptions(content, url(), requestIdentifier)) {
2841                 String message = "Refused to display '" + url().stringCenterEllipsizedToLength() + "' in a frame because it set 'X-Frame-Options' to '" + content + "'.";
2842                 frameLoader->stopAllLoaders();
2843                 // Stopping the loader isn't enough, as we're already parsing the document; to honor the header's
2844                 // intent, we must navigate away from the possibly partially-rendered document to a location that
2845                 // doesn't inherit the parent's SecurityOrigin.
2846                 frame->navigationScheduler()->scheduleLocationChange(securityOrigin(), SecurityOrigin::urlWithUniqueSecurityOrigin(), String());
2847                 addConsoleMessage(SecurityMessageSource, ErrorMessageLevel, message, requestIdentifier);
2848             }
2849         }
2850     } else if (equalIgnoringCase(equiv, "content-security-policy"))
2851         contentSecurityPolicy()->didReceiveHeader(content, ContentSecurityPolicy::Enforce);
2852     else if (equalIgnoringCase(equiv, "content-security-policy-report-only"))
2853         contentSecurityPolicy()->didReceiveHeader(content, ContentSecurityPolicy::Report);
2854     else if (equalIgnoringCase(equiv, "x-webkit-csp"))
2855         contentSecurityPolicy()->didReceiveHeader(content, ContentSecurityPolicy::PrefixedEnforce);
2856     else if (equalIgnoringCase(equiv, "x-webkit-csp-report-only"))
2857         contentSecurityPolicy()->didReceiveHeader(content, ContentSecurityPolicy::PrefixedReport);
2858 }
2859
2860 // Though isspace() considers \t and \v to be whitespace, Win IE doesn't.
2861 static bool isSeparator(UChar c)
2862 {
2863     return c == ' ' || c == '\t' || c == '\n' || c == '\r' || c == '=' || c == ',' || c == '\0';
2864 }
2865
2866 void Document::processArguments(const String& features, void* data, ArgumentsCallback callback)
2867 {
2868     // Tread lightly in this code -- it was specifically designed to mimic Win IE's parsing behavior.
2869     int keyBegin, keyEnd;
2870     int valueBegin, valueEnd;
2871
2872     int i = 0;
2873     int length = features.length();
2874     String buffer = features.lower();
2875     while (i < length) {
2876         // skip to first non-separator, but don't skip past the end of the string
2877         while (isSeparator(buffer[i])) {
2878             if (i >= length)
2879                 break;
2880             i++;
2881         }
2882         keyBegin = i;
2883
2884         // skip to first separator
2885         while (!isSeparator(buffer[i]))
2886             i++;
2887         keyEnd = i;
2888
2889         // skip to first '=', but don't skip past a ',' or the end of the string
2890         while (buffer[i] != '=') {
2891             if (buffer[i] == ',' || i >= length)
2892                 break;
2893             i++;
2894         }
2895
2896         // skip to first non-separator, but don't skip past a ',' or the end of the string
2897         while (isSeparator(buffer[i])) {
2898             if (buffer[i] == ',' || i >= length)
2899                 break;
2900             i++;
2901         }
2902         valueBegin = i;
2903
2904         // skip to first separator
2905         while (!isSeparator(buffer[i]))
2906             i++;
2907         valueEnd = i;
2908
2909         ASSERT_WITH_SECURITY_IMPLICATION(i <= length);
2910
2911         String keyString = buffer.substring(keyBegin, keyEnd - keyBegin);
2912         String valueString = buffer.substring(valueBegin, valueEnd - valueBegin);
2913         callback(keyString, valueString, this, data);
2914     }
2915 }
2916
2917 void Document::processViewport(const String& features, ViewportArguments::Type origin)
2918 {
2919     ASSERT(!features.isNull());
2920
2921     if (origin < m_viewportArguments.type)
2922         return;
2923
2924     m_viewportArguments = ViewportArguments(origin);
2925     processArguments(features, (void*)&m_viewportArguments, &setViewportFeature);
2926
2927     updateViewportArguments();
2928 }
2929
2930 void Document::updateViewportArguments()
2931 {
2932     if (page() && page()->mainFrame() == frame()) {
2933 #ifndef NDEBUG
2934         m_didDispatchViewportPropertiesChanged = true;
2935 #endif
2936         page()->chrome().dispatchViewportPropertiesDidChange(m_viewportArguments);
2937     }
2938 }
2939
2940 void Document::processReferrerPolicy(const String& policy)
2941 {
2942     ASSERT(!policy.isNull());
2943
2944     m_referrerPolicy = ReferrerPolicyDefault;
2945
2946     if (equalIgnoringCase(policy, "never"))
2947         m_referrerPolicy = ReferrerPolicyNever;
2948     else if (equalIgnoringCase(policy, "always"))
2949         m_referrerPolicy = ReferrerPolicyAlways;
2950     else if (equalIgnoringCase(policy, "origin"))
2951         m_referrerPolicy = ReferrerPolicyOrigin;
2952 }
2953
2954 MouseEventWithHitTestResults Document::prepareMouseEvent(const HitTestRequest& request, const LayoutPoint& documentPoint, const PlatformMouseEvent& event)
2955 {
2956     ASSERT(!renderer() || renderer()->isRenderView());
2957
2958     if (!renderer())
2959         return MouseEventWithHitTestResults(event, HitTestResult(LayoutPoint()));
2960
2961     HitTestResult result(documentPoint);
2962     renderView()->hitTest(request, result);
2963
2964     if (!request.readOnly())
2965         updateHoverActiveState(request, result.innerElement(), &event);
2966
2967     return MouseEventWithHitTestResults(event, result);
2968 }
2969
2970 // DOM Section 1.1.1
2971 bool Document::childTypeAllowed(NodeType type) const
2972 {
2973     switch (type) {
2974     case ATTRIBUTE_NODE:
2975     case CDATA_SECTION_NODE:
2976     case DOCUMENT_FRAGMENT_NODE:
2977     case DOCUMENT_NODE:
2978     case ENTITY_NODE:
2979     case ENTITY_REFERENCE_NODE:
2980     case NOTATION_NODE:
2981     case TEXT_NODE:
2982     case XPATH_NAMESPACE_NODE:
2983         return false;
2984     case COMMENT_NODE:
2985     case PROCESSING_INSTRUCTION_NODE:
2986         return true;
2987     case DOCUMENT_TYPE_NODE:
2988     case ELEMENT_NODE:
2989         // Documents may contain no more than one of each of these.
2990         // (One Element and one DocumentType.)
2991         for (Node* c = firstChild(); c; c = c->nextSibling())
2992             if (c->nodeType() == type)
2993                 return false;
2994         return true;
2995     }
2996     return false;
2997 }
2998
2999 bool Document::canReplaceChild(Node* newChild, Node* oldChild)
3000 {
3001     if (!oldChild)
3002         // ContainerNode::replaceChild will raise a NOT_FOUND_ERR.
3003         return true;
3004
3005     if (oldChild->nodeType() == newChild->nodeType())
3006         return true;
3007
3008     int numDoctypes = 0;
3009     int numElements = 0;
3010
3011     // First, check how many doctypes and elements we have, not counting
3012     // the child we're about to remove.
3013     for (Node* c = firstChild(); c; c = c->nextSibling()) {
3014         if (c == oldChild)
3015             continue;
3016         
3017         switch (c->nodeType()) {
3018         case DOCUMENT_TYPE_NODE:
3019             numDoctypes++;
3020             break;
3021         case ELEMENT_NODE:
3022             numElements++;
3023             break;
3024         default:
3025             break;
3026         }
3027     }
3028     
3029     // Then, see how many doctypes and elements might be added by the new child.
3030     if (newChild->nodeType() == DOCUMENT_FRAGMENT_NODE) {
3031         for (Node* c = newChild->firstChild(); c; c = c->nextSibling()) {
3032             switch (c->nodeType()) {
3033             case ATTRIBUTE_NODE:
3034             case CDATA_SECTION_NODE:
3035             case DOCUMENT_FRAGMENT_NODE:
3036             case DOCUMENT_NODE:
3037             case ENTITY_NODE:
3038             case ENTITY_REFERENCE_NODE:
3039             case NOTATION_NODE:
3040             case TEXT_NODE:
3041             case XPATH_NAMESPACE_NODE:
3042                 return false;
3043             case COMMENT_NODE:
3044             case PROCESSING_INSTRUCTION_NODE:
3045                 break;
3046             case DOCUMENT_TYPE_NODE:
3047                 numDoctypes++;
3048                 break;
3049             case ELEMENT_NODE:
3050                 numElements++;
3051                 break;
3052             }
3053         }
3054     } else {
3055         switch (newChild->nodeType()) {
3056         case ATTRIBUTE_NODE:
3057         case CDATA_SECTION_NODE:
3058         case DOCUMENT_FRAGMENT_NODE:
3059         case DOCUMENT_NODE:
3060         case ENTITY_NODE:
3061         case ENTITY_REFERENCE_NODE:
3062         case NOTATION_NODE:
3063         case TEXT_NODE:
3064         case XPATH_NAMESPACE_NODE:
3065             return false;
3066         case COMMENT_NODE:
3067         case PROCESSING_INSTRUCTION_NODE:
3068             return true;
3069         case DOCUMENT_TYPE_NODE:
3070             numDoctypes++;
3071             break;
3072         case ELEMENT_NODE:
3073             numElements++;
3074             break;
3075         }                
3076     }
3077         
3078     if (numElements > 1 || numDoctypes > 1)
3079         return false;
3080     
3081     return true;
3082 }
3083
3084 PassRefPtr<Node> Document::cloneNode(bool /*deep*/)
3085 {
3086     // Spec says cloning Document nodes is "implementation dependent"
3087     // so we do not support it...
3088     return 0;
3089 }
3090
3091 StyleSheetList* Document::styleSheets()
3092 {
3093     if (!m_styleSheetList)
3094         m_styleSheetList = StyleSheetList::create(this);
3095     return m_styleSheetList.get();
3096 }
3097
3098 String Document::preferredStylesheetSet() const
3099 {
3100     return m_styleSheetCollection->preferredStylesheetSetName();
3101 }
3102
3103 String Document::selectedStylesheetSet() const
3104 {
3105     return m_styleSheetCollection->selectedStylesheetSetName();
3106 }
3107
3108 void Document::setSelectedStylesheetSet(const String& aString)
3109 {
3110     m_styleSheetCollection->setSelectedStylesheetSetName(aString);
3111     styleResolverChanged(DeferRecalcStyle);
3112 }
3113
3114 void Document::evaluateMediaQueryList()
3115 {
3116     if (m_mediaQueryMatcher)
3117         m_mediaQueryMatcher->styleResolverChanged();
3118 }
3119
3120 void Document::optimizedStyleSheetUpdateTimerFired(Timer<Document>*)
3121 {
3122     styleResolverChanged(RecalcStyleIfNeeded);
3123 }
3124
3125 void Document::scheduleOptimizedStyleSheetUpdate()
3126 {
3127     if (m_optimizedStyleSheetUpdateTimer.isActive())
3128         return;
3129     styleSheetCollection()->setPendingUpdateType(DocumentStyleSheetCollection::OptimizedUpdate);
3130     m_optimizedStyleSheetUpdateTimer.startOneShot(0);
3131 }
3132
3133 void Document::styleResolverChanged(StyleResolverUpdateFlag updateFlag)
3134 {
3135     if (m_optimizedStyleSheetUpdateTimer.isActive())
3136         m_optimizedStyleSheetUpdateTimer.stop();
3137
3138     // Don't bother updating, since we haven't loaded all our style info yet
3139     // and haven't calculated the style selector for the first time.
3140     if (!attached() || (!m_didCalculateStyleResolver && !haveStylesheetsLoaded())) {
3141         m_styleResolver.clear();
3142         return;
3143     }
3144     m_didCalculateStyleResolver = true;
3145
3146 #ifdef INSTRUMENT_LAYOUT_SCHEDULING
3147     if (!ownerElement())
3148         printf("Beginning update of style selector at time %d.\n", elapsedTime());
3149 #endif
3150
3151     DocumentStyleSheetCollection::UpdateFlag styleSheetUpdate = (updateFlag == RecalcStyleIfNeeded || updateFlag == DeferRecalcStyleIfNeeded)
3152         ? DocumentStyleSheetCollection::OptimizedUpdate
3153         : DocumentStyleSheetCollection::FullUpdate;
3154     bool stylesheetChangeRequiresStyleRecalc = m_styleSheetCollection->updateActiveStyleSheets(styleSheetUpdate);
3155
3156     if (updateFlag == DeferRecalcStyle) {
3157         scheduleForcedStyleRecalc();
3158         return;
3159     }
3160
3161     if (updateFlag == DeferRecalcStyleIfNeeded) {
3162         if (stylesheetChangeRequiresStyleRecalc)
3163             scheduleForcedStyleRecalc();
3164         return;
3165     }
3166
3167     if (didLayoutWithPendingStylesheets() && !m_styleSheetCollection->hasPendingSheets()) {
3168         m_pendingSheetLayout = IgnoreLayoutWithPendingSheets;
3169         if (renderer())
3170             renderView()->repaintViewAndCompositedLayers();
3171     }
3172
3173     if (!stylesheetChangeRequiresStyleRecalc)
3174         return;
3175
3176     // This recalcStyle initiates a new recalc cycle. We need to bracket it to
3177     // make sure animations get the correct update time
3178     {
3179         AnimationUpdateBlock animationUpdateBlock(m_frame ? m_frame->animation() : 0);
3180         recalcStyle(Style::Force);
3181     }
3182
3183 #ifdef INSTRUMENT_LAYOUT_SCHEDULING
3184     if (!ownerElement())
3185         printf("Finished update of style selector at time %d\n", elapsedTime());
3186 #endif
3187
3188     if (renderer()) {
3189         renderer()->setNeedsLayoutAndPrefWidthsRecalc();
3190         if (view())
3191             view()->scheduleRelayout();
3192     }
3193
3194     evaluateMediaQueryList();
3195 }
3196
3197 void Document::notifySeamlessChildDocumentsOfStylesheetUpdate() const
3198 {
3199     // If we're not in a frame yet any potential child documents won't have a StyleResolver to update.
3200     if (!frame())
3201         return;
3202
3203     // Seamless child frames are expected to notify their seamless children recursively, so we only do direct children.
3204     for (Frame* child = frame()->tree()->firstChild(); child; child = child->tree()->nextSibling()) {
3205         Document* childDocument = child->document();
3206         if (childDocument->shouldDisplaySeamlesslyWithParent()) {
3207             ASSERT(childDocument->seamlessParentIFrame()->document() == this);
3208             childDocument->seamlessParentUpdatedStylesheets();
3209         }
3210     }
3211 }
3212
3213 void Document::removeFocusedNodeOfSubtree(Node* node, bool amongChildrenOnly)
3214 {
3215     if (!m_focusedElement || this->inPageCache()) // If the document is in the page cache, then we don't need to clear out the focused node.
3216         return;
3217
3218     Element* focusedElement = node->treeScope()->focusedElement();
3219     if (!focusedElement)
3220         return;
3221
3222     bool nodeInSubtree = false;
3223     if (amongChildrenOnly)
3224         nodeInSubtree = focusedElement->isDescendantOf(node);
3225     else
3226         nodeInSubtree = (focusedElement == node) || focusedElement->isDescendantOf(node);
3227     
3228     if (nodeInSubtree)
3229         setFocusedElement(0);
3230 }
3231
3232 void Document::hoveredElementDidDetach(Element* element)
3233 {
3234     if (!m_hoveredElement || element != m_hoveredElement)
3235         return;
3236
3237     m_hoveredElement = element->parentElement();
3238     while (m_hoveredElement && !m_hoveredElement->renderer())
3239         m_hoveredElement = m_hoveredElement->parentElement();
3240     if (frame())
3241         frame()->eventHandler()->scheduleHoverStateUpdate();
3242 }
3243
3244 void Document::elementInActiveChainDidDetach(Element* element)
3245 {
3246     if (!m_activeElement || element != m_activeElement)
3247         return;
3248
3249     m_activeElement = element->parentElement();
3250     while (m_activeElement && !m_activeElement->renderer())
3251         m_activeElement = m_activeElement->parentElement();
3252 }
3253
3254 #if ENABLE(DASHBOARD_SUPPORT) || ENABLE(DRAGGABLE_REGION)
3255 const Vector<AnnotatedRegionValue>& Document::annotatedRegions() const
3256 {
3257     return m_annotatedRegions;
3258 }
3259
3260 void Document::setAnnotatedRegions(const Vector<AnnotatedRegionValue>& regions)
3261 {
3262     m_annotatedRegions = regions;
3263     setAnnotatedRegionsDirty(false);
3264 }
3265 #endif
3266
3267 bool Document::setFocusedElement(PassRefPtr<Element> prpNewFocusedElement, FocusDirection direction)
3268 {
3269     RefPtr<Element> newFocusedElement = prpNewFocusedElement;
3270
3271     // Make sure newFocusedElement is actually in this document
3272     if (newFocusedElement && (newFocusedElement->document() != this))
3273         return true;
3274
3275     if (m_focusedElement == newFocusedElement)
3276         return true;
3277
3278     if (m_inPageCache)
3279         return false;
3280
3281     bool focusChangeBlocked = false;
3282     RefPtr<Element> oldFocusedElement = m_focusedElement.release();
3283
3284     // Remove focus from the existing focus node (if any)
3285     if (oldFocusedElement) {
3286         ASSERT(!oldFocusedElement->inDetach());
3287
3288         if (oldFocusedElement->active())
3289             oldFocusedElement->setActive(false);
3290
3291         oldFocusedElement->setFocus(false);
3292
3293         // Dispatch a change event for form control elements that have been edited.
3294         if (oldFocusedElement->isFormControlElement()) {
3295             HTMLFormControlElement* formControlElement = toHTMLFormControlElement(oldFocusedElement.get());
3296             if (formControlElement->wasChangedSinceLastFormControlChangeEvent())
3297                 formControlElement->dispatchFormControlChangeEvent();
3298         }
3299
3300         // Dispatch the blur event and let the node do any other blur related activities (important for text fields)
3301         oldFocusedElement->dispatchBlurEvent(newFocusedElement);
3302
3303         if (m_focusedElement) {
3304             // handler shifted focus
3305             focusChangeBlocked = true;
3306             newFocusedElement = 0;
3307         }
3308         
3309         oldFocusedElement->dispatchFocusOutEvent(eventNames().focusoutEvent, newFocusedElement); // DOM level 3 name for the bubbling blur event.
3310         // FIXME: We should remove firing DOMFocusOutEvent event when we are sure no content depends
3311         // on it, probably when <rdar://problem/8503958> is resolved.
3312         oldFocusedElement->dispatchFocusOutEvent(eventNames().DOMFocusOutEvent, newFocusedElement); // DOM level 2 name for compatibility.
3313
3314         if (m_focusedElement) {
3315             // handler shifted focus
3316             focusChangeBlocked = true;
3317             newFocusedElement = 0;
3318         }
3319             
3320         if (oldFocusedElement->isRootEditableElement())
3321             frame()->editor().didEndEditing();
3322
3323         if (view()) {
3324             Widget* oldWidget = widgetForNode(oldFocusedElement.get());
3325             if (oldWidget)
3326                 oldWidget->setFocus(false);
3327             else
3328                 view()->setFocus(false);
3329         }
3330     }
3331
3332     if (newFocusedElement && newFocusedElement->isFocusable()) {
3333         if (newFocusedElement->isRootEditableElement() && !acceptsEditingFocus(newFocusedElement.get())) {
3334             // delegate blocks focus change
3335             focusChangeBlocked = true;
3336             goto SetFocusedNodeDone;
3337         }
3338         // Set focus on the new node
3339         m_focusedElement = newFocusedElement;
3340
3341         // Dispatch the focus event and let the node do any other focus related activities (important for text fields)
3342         m_focusedElement->dispatchFocusEvent(oldFocusedElement, direction);
3343
3344         if (m_focusedElement != newFocusedElement) {
3345             // handler shifted focus
3346             focusChangeBlocked = true;
3347             goto SetFocusedNodeDone;
3348         }
3349
3350         m_focusedElement->dispatchFocusInEvent(eventNames().focusinEvent, oldFocusedElement); // DOM level 3 bubbling focus event.
3351
3352         if (m_focusedElement != newFocusedElement) {
3353             // handler shifted focus
3354             focusChangeBlocked = true;
3355             goto SetFocusedNodeDone;
3356         }
3357
3358         // FIXME: We should remove firing DOMFocusInEvent event when we are sure no content depends
3359         // on it, probably when <rdar://problem/8503958> is m.
3360         m_focusedElement->dispatchFocusInEvent(eventNames().DOMFocusInEvent, oldFocusedElement); // DOM level 2 for compatibility.
3361
3362         if (m_focusedElement != newFocusedElement) {
3363             // handler shifted focus
3364             focusChangeBlocked = true;
3365             goto SetFocusedNodeDone;
3366         }
3367
3368         m_focusedElement->setFocus(true);
3369
3370         if (m_focusedElement->isRootEditableElement())
3371             frame()->editor().didBeginEditing();
3372
3373         // eww, I suck. set the qt focus correctly
3374         // ### find a better place in the code for this
3375         if (view()) {
3376             Widget* focusWidget = widgetForNode(m_focusedElement.get());
3377             if (focusWidget) {
3378                 // Make sure a widget has the right size before giving it focus.
3379                 // Otherwise, we are testing edge cases of the Widget code.
3380                 // Specifically, in WebCore this does not work well for text fields.
3381                 updateLayout();
3382                 // Re-get the widget in case updating the layout changed things.
3383                 focusWidget = widgetForNode(m_focusedElement.get());
3384             }
3385             if (focusWidget)
3386                 focusWidget->setFocus(true);
3387             else
3388                 view()->setFocus(true);
3389         }
3390     }
3391
3392     if (!focusChangeBlocked && m_focusedElement) {
3393         // Create the AXObject cache in a focus change because GTK relies on it.
3394         if (AXObjectCache* cache = axObjectCache())
3395             cache->handleFocusedUIElementChanged(oldFocusedElement.get(), newFocusedElement.get());
3396     }
3397
3398     if (!focusChangeBlocked)
3399         page()->chrome().focusedElementChanged(m_focusedElement.get());
3400
3401 SetFocusedNodeDone:
3402     updateStyleIfNeeded();
3403     return !focusChangeBlocked;
3404 }
3405
3406 void Document::setCSSTarget(Element* n)
3407 {
3408     if (m_cssTarget)
3409         m_cssTarget->didAffectSelector(AffectedSelectorTarget);
3410     m_cssTarget = n;
3411     if (n)
3412         n->didAffectSelector(AffectedSelectorTarget);
3413 }
3414
3415 void Document::registerNodeList(LiveNodeListBase* list)
3416 {
3417     if (list->hasIdNameCache())
3418         m_nodeListCounts[InvalidateOnIdNameAttrChange]++;
3419     m_nodeListCounts[list->invalidationType()]++;
3420     if (list->isRootedAtDocument())
3421         m_listsInvalidatedAtDocument.add(list);
3422 }
3423
3424 void Document::unregisterNodeList(LiveNodeListBase* list)
3425 {
3426     if (list->hasIdNameCache())
3427         m_nodeListCounts[InvalidateOnIdNameAttrChange]--;
3428     m_nodeListCounts[list->invalidationType()]--;
3429     if (list->isRootedAtDocument()) {
3430         ASSERT(m_listsInvalidatedAtDocument.contains(list));
3431         m_listsInvalidatedAtDocument.remove(list);
3432     }
3433 }
3434
3435 void Document::attachNodeIterator(NodeIterator* ni)
3436 {
3437     m_nodeIterators.add(ni);
3438 }
3439
3440 void Document::detachNodeIterator(NodeIterator* ni)
3441 {
3442     // The node iterator can be detached without having been attached if its root node didn't have a document
3443     // when the iterator was created, but has it now.
3444     m_nodeIterators.remove(ni);
3445 }
3446
3447 void Document::moveNodeIteratorsToNewDocument(Node* node, Document* newDocument)
3448 {
3449     HashSet<NodeIterator*> nodeIteratorsList = m_nodeIterators;
3450     HashSet<NodeIterator*>::const_iterator nodeIteratorsEnd = nodeIteratorsList.end();
3451     for (HashSet<NodeIterator*>::const_iterator it = nodeIteratorsList.begin(); it != nodeIteratorsEnd; ++it) {
3452         if ((*it)->root() == node) {
3453             detachNodeIterator(*it);
3454             newDocument->attachNodeIterator(*it);
3455         }
3456     }
3457 }
3458
3459 void Document::updateRangesAfterChildrenChanged(ContainerNode* container)
3460 {
3461     if (!m_ranges.isEmpty()) {
3462         HashSet<Range*>::const_iterator end = m_ranges.end();
3463         for (HashSet<Range*>::const_iterator it = m_ranges.begin(); it != end; ++it)
3464             (*it)->nodeChildrenChanged(container);
3465     }
3466 }
3467
3468 void Document::nodeChildrenWillBeRemoved(ContainerNode* container)
3469 {
3470     if (!m_ranges.isEmpty()) {
3471         HashSet<Range*>::const_iterator end = m_ranges.end();
3472         for (HashSet<Range*>::const_iterator it = m_ranges.begin(); it != end; ++it)
3473             (*it)->nodeChildrenWillBeRemoved(container);
3474     }
3475
3476     HashSet<NodeIterator*>::const_iterator nodeIteratorsEnd = m_nodeIterators.end();
3477     for (HashSet<NodeIterator*>::const_iterator it = m_nodeIterators.begin(); it != nodeIteratorsEnd; ++it) {
3478         for (Node* n = container->firstChild(); n; n = n->nextSibling())
3479             (*it)->nodeWillBeRemoved(n);
3480     }
3481
3482     if (Frame* frame = this->frame()) {
3483         for (Node* n = container->firstChild(); n; n = n->nextSibling()) {
3484             frame->eventHandler()->nodeWillBeRemoved(n);
3485             frame->selection()->nodeWillBeRemoved(n);
3486             frame->page()->dragCaretController()->nodeWillBeRemoved(n);
3487         }
3488     }
3489 }
3490
3491 void Document::nodeWillBeRemoved(Node* n)
3492 {
3493     HashSet<NodeIterator*>::const_iterator nodeIteratorsEnd = m_nodeIterators.end();
3494     for (HashSet<NodeIterator*>::const_iterator it = m_nodeIterators.begin(); it != nodeIteratorsEnd; ++it)
3495         (*it)->nodeWillBeRemoved(n);
3496
3497     if (!m_ranges.isEmpty()) {
3498         HashSet<Range*>::const_iterator rangesEnd = m_ranges.end();
3499         for (HashSet<Range*>::const_iterator it = m_ranges.begin(); it != rangesEnd; ++it)
3500             (*it)->nodeWillBeRemoved(n);
3501     }
3502
3503     if (Frame* frame = this->frame()) {
3504         frame->eventHandler()->nodeWillBeRemoved(n);
3505         frame->selection()->nodeWillBeRemoved(n);
3506         frame->page()->dragCaretController()->nodeWillBeRemoved(n);
3507     }
3508 }
3509
3510 void Document::textInserted(Node* text, unsigned offset, unsigned length)
3511 {
3512     if (!m_ranges.isEmpty()) {
3513         HashSet<Range*>::const_iterator end = m_ranges.end();
3514         for (HashSet<Range*>::const_iterator it = m_ranges.begin(); it != end; ++it)
3515             (*it)->textInserted(text, offset, length);
3516     }
3517
3518     // Update the markers for spelling and grammar checking.
3519     m_markers->shiftMarkers(text, offset, length);
3520 }
3521
3522 void Document::textRemoved(Node* text, unsigned offset, unsigned length)
3523 {
3524     if (!m_ranges.isEmpty()) {
3525         HashSet<Range*>::const_iterator end = m_ranges.end();
3526         for (HashSet<Range*>::const_iterator it = m_ranges.begin(); it != end; ++it)
3527             (*it)->textRemoved(text, offset, length);
3528     }
3529
3530     // Update the markers for spelling and grammar checking.
3531     m_markers->removeMarkers(text, offset, length);
3532     m_markers->shiftMarkers(text, offset + length, 0 - length);
3533 }
3534
3535 void Document::textNodesMerged(Text* oldNode, unsigned offset)
3536 {
3537     if (!m_ranges.isEmpty()) {
3538         NodeWithIndex oldNodeWithIndex(oldNode);
3539         HashSet<Range*>::const_iterator end = m_ranges.end();
3540         for (HashSet<Range*>::const_iterator it = m_ranges.begin(); it != end; ++it)
3541             (*it)->textNodesMerged(oldNodeWithIndex, offset);
3542     }
3543
3544     // FIXME: This should update markers for spelling and grammar checking.
3545 }
3546
3547 void Document::textNodeSplit(Text* oldNode)
3548 {
3549     if (!m_ranges.isEmpty()) {
3550         HashSet<Range*>::const_iterator end = m_ranges.end();
3551         for (HashSet<Range*>::const_iterator it = m_ranges.begin(); it != end; ++it)
3552             (*it)->textNodeSplit(oldNode);
3553     }
3554
3555     // FIXME: This should update markers for spelling and grammar checking.
3556 }
3557
3558 void Document::createDOMWindow()
3559 {
3560     ASSERT(m_frame);
3561     ASSERT(!m_domWindow);
3562
3563     m_domWindow = DOMWindow::create(this);
3564
3565     ASSERT(m_domWindow->document() == this);
3566     ASSERT(m_domWindow->frame() == m_frame);
3567 }
3568
3569 void Document::takeDOMWindowFrom(Document* document)
3570 {
3571     ASSERT(m_frame);
3572     ASSERT(!m_domWindow);
3573     ASSERT(document->domWindow());
3574     // A valid DOMWindow is needed by CachedFrame for its documents.
3575     ASSERT(!document->inPageCache());
3576
3577     m_domWindow = document->m_domWindow.release();
3578     m_domWindow->didSecureTransitionTo(this);
3579
3580     ASSERT(m_domWindow->document() == this);
3581     ASSERT(m_domWindow->frame() == m_frame);
3582 }
3583
3584 void Document::setWindowAttributeEventListener(const AtomicString& eventType, PassRefPtr<EventListener> listener)
3585 {
3586     DOMWindow* domWindow = this->domWindow();
3587     if (!domWindow)
3588         return;
3589     domWindow->setAttributeEventListener(eventType, listener);
3590 }
3591
3592 EventListener* Document::getWindowAttributeEventListener(const AtomicString& eventType)
3593 {
3594     DOMWindow* domWindow = this->domWindow();
3595     if (!domWindow)
3596         return 0;
3597     return domWindow->getAttributeEventListener(eventType);
3598 }
3599
3600 void Document::dispatchWindowEvent(PassRefPtr<Event> event,  PassRefPtr<EventTarget> target)
3601 {
3602     ASSERT(!NoEventDispatchAssertion::isEventDispatchForbidden());
3603     DOMWindow* domWindow = this->domWindow();
3604     if (!domWindow)
3605         return;
3606     domWindow->dispatchEvent(event, target);
3607 }
3608
3609 void Document::dispatchWindowLoadEvent()
3610 {
3611     ASSERT(!NoEventDispatchAssertion::isEventDispatchForbidden());
3612     DOMWindow* domWindow = this->domWindow();
3613     if (!domWindow)
3614         return;
3615     domWindow->dispatchLoadEvent();
3616     m_loadEventFinished = true;
3617 }
3618
3619 void Document::enqueueWindowEvent(PassRefPtr<Event> event)
3620 {
3621     event->setTarget(domWindow());
3622     m_eventQueue->enqueueEvent(event);
3623 }
3624
3625 void Document::enqueueDocumentEvent(PassRefPtr<Event> event)
3626 {
3627     event->setTarget(this);
3628     m_eventQueue->enqueueEvent(event);
3629 }
3630
3631 PassRefPtr<Event> Document::createEvent(const String& eventType, ExceptionCode& ec)
3632 {
3633     RefPtr<Event> event = EventFactory::create(eventType);
3634     if (event)
3635         return event.release();
3636
3637     ec = NOT_SUPPORTED_ERR;
3638     return 0;
3639 }
3640
3641 void Document::addMutationEventListenerTypeIfEnabled(ListenerType listenerType)
3642 {
3643     if (ContextFeatures::mutationEventsEnabled(this))
3644         addListenerType(listenerType);
3645 }
3646
3647 void Document::addListenerTypeIfNeeded(const AtomicString& eventType)
3648 {
3649     if (eventType == eventNames().DOMSubtreeModifiedEvent)