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