Document::securityOrigin() should return a reference.
[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-2017 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 "CDATASection.h"
35 #include "CSSFontSelector.h"
36 #include "CSSStyleDeclaration.h"
37 #include "CSSStyleSheet.h"
38 #include "CachedCSSStyleSheet.h"
39 #include "CachedResourceLoader.h"
40 #include "Chrome.h"
41 #include "ChromeClient.h"
42 #include "Comment.h"
43 #include "CommonVM.h"
44 #include "CompositionEvent.h"
45 #include "ContentSecurityPolicy.h"
46 #include "CookieJar.h"
47 #include "CustomElementReactionQueue.h"
48 #include "CustomElementRegistry.h"
49 #include "CustomEvent.h"
50 #include "DOMImplementation.h"
51 #include "DOMNamedFlowCollection.h"
52 #include "DOMWindow.h"
53 #include "DateComponents.h"
54 #include "DebugPageOverlays.h"
55 #include "DocumentLoader.h"
56 #include "DocumentMarkerController.h"
57 #include "DocumentSharedObjectPool.h"
58 #include "DocumentType.h"
59 #include "Editor.h"
60 #include "ElementIterator.h"
61 #include "EventHandler.h"
62 #include "ExtensionStyleSheets.h"
63 #include "FocusController.h"
64 #include "FontFaceSet.h"
65 #include "FormController.h"
66 #include "FrameLoader.h"
67 #include "FrameLoaderClient.h"
68 #include "FrameView.h"
69 #include "GenericCachedHTMLCollection.h"
70 #include "HTMLAllCollection.h"
71 #include "HTMLAnchorElement.h"
72 #include "HTMLBaseElement.h"
73 #include "HTMLBodyElement.h"
74 #include "HTMLCanvasElement.h"
75 #include "HTMLDocument.h"
76 #include "HTMLElementFactory.h"
77 #include "HTMLFormControlElement.h"
78 #include "HTMLFrameOwnerElement.h"
79 #include "HTMLFrameSetElement.h"
80 #include "HTMLHeadElement.h"
81 #include "HTMLHtmlElement.h"
82 #include "HTMLImageElement.h"
83 #include "HTMLInputElement.h"
84 #include "HTMLLinkElement.h"
85 #include "HTMLMediaElement.h"
86 #include "HTMLNameCollection.h"
87 #include "HTMLParserIdioms.h"
88 #include "HTMLPictureElement.h"
89 #include "HTMLPlugInElement.h"
90 #include "HTMLScriptElement.h"
91 #include "HTMLStyleElement.h"
92 #include "HTMLTitleElement.h"
93 #include "HTMLUnknownElement.h"
94 #include "HTTPHeaderNames.h"
95 #include "HTTPParsers.h"
96 #include "HashChangeEvent.h"
97 #include "History.h"
98 #include "HitTestResult.h"
99 #include "IconController.h"
100 #include "ImageLoader.h"
101 #include "InspectorInstrumentation.h"
102 #include "JSCustomElementInterface.h"
103 #include "JSLazyEventListener.h"
104 #include "KeyboardEvent.h"
105 #include "Language.h"
106 #include "LoaderStrategy.h"
107 #include "Logging.h"
108 #include "MainFrame.h"
109 #include "MediaCanStartListener.h"
110 #include "MediaProducer.h"
111 #include "MediaQueryList.h"
112 #include "MediaQueryMatcher.h"
113 #include "MessageEvent.h"
114 #include "MouseEventWithHitTestResults.h"
115 #include "MutationEvent.h"
116 #include "NameNodeList.h"
117 #include "NamedFlowCollection.h"
118 #include "NestingLevelIncrementer.h"
119 #include "NoEventDispatchAssertion.h"
120 #include "NodeIterator.h"
121 #include "NodeRareData.h"
122 #include "NodeWithIndex.h"
123 #include "OriginAccessEntry.h"
124 #include "OverflowEvent.h"
125 #include "PageConsoleClient.h"
126 #include "PageGroup.h"
127 #include "PageTransitionEvent.h"
128 #include "PlatformLocale.h"
129 #include "PlatformMediaSessionManager.h"
130 #include "PlatformScreen.h"
131 #include "PlatformStrategies.h"
132 #include "PlugInsResources.h"
133 #include "PluginDocument.h"
134 #include "PointerLockController.h"
135 #include "PopStateEvent.h"
136 #include "ProcessingInstruction.h"
137 #include "RenderChildIterator.h"
138 #include "RenderLayerCompositor.h"
139 #include "RenderTreeUpdater.h"
140 #include "RenderView.h"
141 #include "RenderWidget.h"
142 #include "RequestAnimationFrameCallback.h"
143 #include "ResourceLoadObserver.h"
144 #include "RuntimeEnabledFeatures.h"
145 #include "SVGDocumentExtensions.h"
146 #include "SVGElement.h"
147 #include "SVGElementFactory.h"
148 #include "SVGNames.h"
149 #include "SVGSVGElement.h"
150 #include "SVGTitleElement.h"
151 #include "SVGZoomEvent.h"
152 #include "SchemeRegistry.h"
153 #include "ScopedEventQueue.h"
154 #include "ScriptController.h"
155 #include "ScriptModuleLoader.h"
156 #include "ScriptRunner.h"
157 #include "ScriptSourceCode.h"
158 #include "ScriptedAnimationController.h"
159 #include "ScrollingCoordinator.h"
160 #include "SecurityOrigin.h"
161 #include "SecurityOriginData.h"
162 #include "SecurityOriginPolicy.h"
163 #include "SecurityPolicy.h"
164 #include "SegmentedString.h"
165 #include "SelectorQuery.h"
166 #include "Settings.h"
167 #include "ShadowRoot.h"
168 #include "SocketProvider.h"
169 #include "StorageEvent.h"
170 #include "StyleProperties.h"
171 #include "StyleResolveForDocument.h"
172 #include "StyleResolver.h"
173 #include "StyleScope.h"
174 #include "StyleSheetContents.h"
175 #include "StyleSheetList.h"
176 #include "StyleTreeResolver.h"
177 #include "SubresourceLoader.h"
178 #include "TextAutoSizing.h"
179 #include "TextEvent.h"
180 #include "TextNodeTraversal.h"
181 #include "TransformSource.h"
182 #include "TreeWalker.h"
183 #include "VisitedLinkState.h"
184 #include "WheelEvent.h"
185 #include "WindowFeatures.h"
186 #include "XMLDocument.h"
187 #include "XMLDocumentParser.h"
188 #include "XMLNSNames.h"
189 #include "XMLNames.h"
190 #include "XPathEvaluator.h"
191 #include "XPathExpression.h"
192 #include "XPathNSResolver.h"
193 #include "XPathResult.h"
194 #include "htmlediting.h"
195 #include <ctime>
196 #include <inspector/ScriptCallStack.h>
197 #include <wtf/CurrentTime.h>
198 #include <wtf/NeverDestroyed.h>
199 #include <wtf/SetForScope.h>
200 #include <wtf/SystemTracing.h>
201 #include <wtf/text/StringBuffer.h>
202 #include <yarr/RegularExpression.h>
203
204 #if ENABLE(DEVICE_ORIENTATION)
205 #include "DeviceMotionEvent.h"
206 #include "DeviceOrientationEvent.h"
207 #endif
208
209 #if ENABLE(FULLSCREEN_API)
210 #include "RenderFullScreen.h"
211 #endif
212
213 #if ENABLE(INDEXED_DATABASE)
214 #include "IDBConnectionProxy.h"
215 #include "IDBOpenDBRequest.h"
216 #endif
217
218 #if PLATFORM(IOS)
219 #include "CSSFontSelector.h"
220 #include "DeviceMotionClientIOS.h"
221 #include "DeviceMotionController.h"
222 #include "DeviceOrientationClientIOS.h"
223 #include "DeviceOrientationController.h"
224 #include "Geolocation.h"
225 #include "Navigator.h"
226 #include "NavigatorGeolocation.h"
227 #include "WKContentObservation.h"
228 #include "WebCoreSystemInterface.h"
229 #endif
230
231 #if ENABLE(IOS_GESTURE_EVENTS)
232 #include "GestureEvent.h"
233 #endif
234
235 #if ENABLE(MATHML)
236 #include "MathMLElement.h"
237 #include "MathMLElementFactory.h"
238 #include "MathMLNames.h"
239 #endif
240
241 #if ENABLE(MEDIA_SESSION)
242 #include "MediaSession.h"
243 #endif
244
245 #if USE(QUICK_LOOK)
246 #include "QuickLook.h"
247 #endif
248
249 #if ENABLE(TOUCH_EVENTS)
250 #include "TouchEvent.h"
251 #include "TouchList.h"
252 #endif
253
254 #if ENABLE(VIDEO_TRACK)
255 #include "CaptionUserPreferences.h"
256 #endif
257
258 #if ENABLE(WEB_REPLAY)
259 #include "WebReplayInputs.h"
260 #include <replay/EmptyInputCursor.h>
261 #include <replay/InputCursor.h>
262 #endif
263
264 #if ENABLE(WIRELESS_PLAYBACK_TARGET)
265 #include "MediaPlaybackTargetClient.h"
266 #endif
267
268 #if ENABLE(XSLT)
269 #include "XSLTProcessor.h"
270 #endif
271
272 using namespace WTF;
273 using namespace Unicode;
274
275 namespace WebCore {
276
277 using namespace HTMLNames;
278
279 static const unsigned cMaxWriteRecursionDepth = 21;
280 bool Document::hasEverCreatedAnAXObjectCache = false;
281
282 // DOM Level 2 says (letters added):
283 //
284 // a) Name start characters must have one of the categories Ll, Lu, Lo, Lt, Nl.
285 // b) Name characters other than Name-start characters must have one of the categories Mc, Me, Mn, Lm, or Nd.
286 // c) Characters in the compatibility area (i.e. with character code greater than #xF900 and less than #xFFFE) are not allowed in XML names.
287 // 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.
288 // 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.
289 // f) Characters #x20DD-#x20E0 are excluded (in accordance with Unicode, section 5.14).
290 // g) Character #x00B7 is classified as an extender, because the property list so identifies it.
291 // h) Character #x0387 is added as a name character, because #x00B7 is its canonical equivalent.
292 // i) Characters ':' and '_' are allowed as name-start characters.
293 // j) Characters '-' and '.' are allowed as name characters.
294 //
295 // It also contains complete tables. If we decide it's better, we could include those instead of the following code.
296
297 static inline bool isValidNameStart(UChar32 c)
298 {
299     // rule (e) above
300     if ((c >= 0x02BB && c <= 0x02C1) || c == 0x559 || c == 0x6E5 || c == 0x6E6)
301         return true;
302
303     // rule (i) above
304     if (c == ':' || c == '_')
305         return true;
306
307     // rules (a) and (f) above
308     if (!(U_GET_GC_MASK(c) & (U_GC_LL_MASK | U_GC_LU_MASK | U_GC_LO_MASK | U_GC_LT_MASK | U_GC_NL_MASK)))
309         return false;
310
311     // rule (c) above
312     if (c >= 0xF900 && c < 0xFFFE)
313         return false;
314
315     // rule (d) above
316     int type = u_getIntPropertyValue(c, UCHAR_DECOMPOSITION_TYPE);
317     if (type == U_DT_FONT || type == U_DT_COMPAT)
318         return false;
319
320     return true;
321 }
322
323 static inline bool isValidNamePart(UChar32 c)
324 {
325     // rules (a), (e), and (i) above
326     if (isValidNameStart(c))
327         return true;
328
329     // rules (g) and (h) above
330     if (c == 0x00B7 || c == 0x0387)
331         return true;
332
333     // rule (j) above
334     if (c == '-' || c == '.')
335         return true;
336
337     // rules (b) and (f) above
338     if (!(U_GET_GC_MASK(c) & (U_GC_M_MASK | U_GC_LM_MASK | U_GC_ND_MASK)))
339         return false;
340
341     // rule (c) above
342     if (c >= 0xF900 && c < 0xFFFE)
343         return false;
344
345     // rule (d) above
346     int type = u_getIntPropertyValue(c, UCHAR_DECOMPOSITION_TYPE);
347     if (type == U_DT_FONT || type == U_DT_COMPAT)
348         return false;
349
350     return true;
351 }
352
353 static Widget* widgetForElement(Element* focusedElement)
354 {
355     if (!focusedElement)
356         return nullptr;
357     auto* renderer = focusedElement->renderer();
358     if (!is<RenderWidget>(renderer))
359         return nullptr;
360     return downcast<RenderWidget>(*renderer).widget();
361 }
362
363 static bool acceptsEditingFocus(Node* node)
364 {
365     ASSERT(node);
366     ASSERT(node->hasEditableStyle());
367
368     Node* root = node->rootEditableElement();
369     Frame* frame = node->document().frame();
370     if (!frame || !root)
371         return false;
372
373     return frame->editor().shouldBeginEditing(rangeOfContents(*root).ptr());
374 }
375
376 static bool canAccessAncestor(const SecurityOrigin& activeSecurityOrigin, Frame* targetFrame)
377 {
378     // targetFrame can be 0 when we're trying to navigate a top-level frame
379     // that has a 0 opener.
380     if (!targetFrame)
381         return false;
382
383     const bool isLocalActiveOrigin = activeSecurityOrigin.isLocal();
384     for (Frame* ancestorFrame = targetFrame; ancestorFrame; ancestorFrame = ancestorFrame->tree().parent()) {
385         Document* ancestorDocument = ancestorFrame->document();
386         // FIXME: Should be an ASSERT? Frames should alway have documents.
387         if (!ancestorDocument)
388             return true;
389
390         const SecurityOrigin& ancestorSecurityOrigin = ancestorDocument->securityOrigin();
391         if (activeSecurityOrigin.canAccess(ancestorSecurityOrigin))
392             return true;
393         
394         // Allow file URL descendant navigation even when allowFileAccessFromFileURLs is false.
395         // FIXME: It's a bit strange to special-case local origins here. Should we be doing
396         // something more general instead?
397         if (isLocalActiveOrigin && ancestorSecurityOrigin.isLocal())
398             return true;
399     }
400
401     return false;
402 }
403
404 static void printNavigationErrorMessage(Frame* frame, const URL& activeURL, const char* reason)
405 {
406     String message = "Unsafe JavaScript attempt to initiate navigation for frame with URL '" + frame->document()->url().string() + "' from frame with URL '" + activeURL.string() + "'. " + reason + "\n";
407
408     // FIXME: should we print to the console of the document performing the navigation instead?
409     frame->document()->domWindow()->printErrorMessage(message);
410 }
411
412 #if ENABLE(TEXT_AUTOSIZING)
413
414 void TextAutoSizingTraits::constructDeletedValue(TextAutoSizingKey& slot)
415 {
416     new (NotNull, &slot) TextAutoSizingKey(TextAutoSizingKey::Deleted);
417 }
418
419 bool TextAutoSizingTraits::isDeletedValue(const TextAutoSizingKey& value)
420 {
421     return value.isDeleted();
422 }
423
424 #endif
425
426 uint64_t Document::s_globalTreeVersion = 0;
427
428 HashSet<Document*>& Document::allDocuments()
429 {
430     static NeverDestroyed<HashSet<Document*>> documents;
431     return documents;
432 }
433
434 Document::Document(Frame* frame, const URL& url, unsigned documentClasses, unsigned constructionFlags)
435     : ContainerNode(*this, CreateDocument)
436     , TreeScope(*this)
437     , FrameDestructionObserver(frame)
438 #if ENABLE(IOS_TOUCH_EVENTS)
439     , m_touchEventsChangedTimer(*this, &Document::touchEventsChangedTimerFired)
440 #endif
441     , m_referencingNodeCount(0)
442     , m_hasNodesWithPlaceholderStyle(false)
443     , m_needsNotifyRemoveAllPendingStylesheet(false)
444     , m_ignorePendingStylesheets(false)
445     , m_pendingSheetLayout(NoLayoutWithPendingSheets)
446     , m_cachedResourceLoader(m_frame ? Ref<CachedResourceLoader>(m_frame->loader().activeDocumentLoader()->cachedResourceLoader()) : CachedResourceLoader::create(nullptr))
447     , m_activeParserCount(0)
448     , m_wellFormed(false)
449     , m_printing(false)
450     , m_paginatedForScreen(false)
451     , m_compatibilityMode(DocumentCompatibilityMode::NoQuirksMode)
452     , m_compatibilityModeLocked(false)
453     , m_textColor(Color::black)
454     , m_domTreeVersion(++s_globalTreeVersion)
455     , m_listenerTypes(0)
456     , m_mutationObserverTypes(0)
457     , m_styleScope(std::make_unique<Style::Scope>(*this))
458     , m_extensionStyleSheets(std::make_unique<ExtensionStyleSheets>(*this))
459     , m_visitedLinkState(std::make_unique<VisitedLinkState>(*this))
460     , m_visuallyOrdered(false)
461     , m_readyState(Complete)
462     , m_bParsing(false)
463     , m_styleRecalcTimer(*this, &Document::updateStyleIfNeeded)
464     , m_pendingStyleRecalcShouldForce(false)
465     , m_inStyleRecalc(false)
466     , m_closeAfterStyleRecalc(false)
467     , m_gotoAnchorNeededAfterStylesheetsLoad(false)
468     , m_frameElementsShouldIgnoreScrolling(false)
469     , m_updateFocusAppearanceRestoresSelection(SelectionRestorationMode::SetDefault)
470     , m_markers(std::make_unique<DocumentMarkerController>(*this))
471     , m_updateFocusAppearanceTimer(*this, &Document::updateFocusAppearanceTimerFired)
472     , m_cssTarget(nullptr)
473     , m_processingLoadEvent(false)
474     , m_loadEventFinished(false)
475     , m_documentCreationTime(MonotonicTime::now())
476     , m_overMinimumLayoutThreshold(false)
477     , m_scriptRunner(std::make_unique<ScriptRunner>(*this))
478     , m_moduleLoader(std::make_unique<ScriptModuleLoader>(*this))
479     , m_xmlVersion(ASCIILiteral("1.0"))
480     , m_xmlStandalone(StandaloneUnspecified)
481     , m_hasXMLDeclaration(false)
482     , m_designMode(inherit)
483 #if ENABLE(DASHBOARD_SUPPORT)
484     , m_hasAnnotatedRegions(false)
485     , m_annotatedRegionsDirty(false)
486 #endif
487     , m_createRenderers(true)
488     , m_accessKeyMapValid(false)
489     , m_documentClasses(documentClasses)
490     , m_isSynthesized(constructionFlags & Synthesized)
491     , m_isNonRenderedPlaceholder(constructionFlags & NonRenderedPlaceholder)
492     , m_sawElementsInKnownNamespaces(false)
493     , m_isSrcdocDocument(false)
494     , m_eventQueue(*this)
495     , m_weakFactory(this)
496 #if ENABLE(FULLSCREEN_API)
497     , m_areKeysEnabledInFullScreen(0)
498     , m_fullScreenRenderer(nullptr)
499     , m_fullScreenChangeDelayTimer(*this, &Document::fullScreenChangeDelayTimerFired)
500     , m_isAnimatingFullScreen(false)
501 #endif
502     , m_loadEventDelayCount(0)
503     , m_loadEventDelayTimer(*this, &Document::loadEventDelayTimerFired)
504     , m_referrerPolicy(ReferrerPolicy::Default)
505     , m_writeRecursionIsTooDeep(false)
506     , m_writeRecursionDepth(0)
507     , m_lastHandledUserGestureTimestamp(0)
508 #if PLATFORM(IOS)
509 #if ENABLE(DEVICE_ORIENTATION)
510     , m_deviceMotionClient(std::make_unique<DeviceMotionClientIOS>())
511     , m_deviceMotionController(std::make_unique<DeviceMotionController>(m_deviceMotionClient.get()))
512     , m_deviceOrientationClient(std::make_unique<DeviceOrientationClientIOS>())
513     , m_deviceOrientationController(std::make_unique<DeviceOrientationController>(m_deviceOrientationClient.get()))
514 #endif
515 #endif
516 #if ENABLE(TELEPHONE_NUMBER_DETECTION)
517     , m_isTelephoneNumberParsingAllowed(true)
518 #endif
519     , m_pendingTasksTimer(*this, &Document::pendingTasksTimerFired)
520     , m_scheduledTasksAreSuspended(false)
521     , m_visualUpdatesAllowed(true)
522     , m_visualUpdatesSuppressionTimer(*this, &Document::visualUpdatesSuppressionTimerFired)
523     , m_sharedObjectPoolClearTimer(*this, &Document::clearSharedObjectPool)
524 #ifndef NDEBUG
525     , m_didDispatchViewportPropertiesChanged(false)
526 #endif
527     , m_templateDocumentHost(nullptr)
528     , m_fontSelector(CSSFontSelector::create(*this))
529 #if ENABLE(WEB_REPLAY)
530     , m_inputCursor(EmptyInputCursor::create())
531 #endif
532     , m_didAssociateFormControlsTimer(*this, &Document::didAssociateFormControlsTimerFired)
533     , m_cookieCacheExpiryTimer(*this, &Document::invalidateDOMCookieCache)
534     , m_disabledFieldsetElementsCount(0)
535     , m_hasInjectedPlugInsScript(false)
536     , m_hasStyleWithViewportUnits(false)
537 #if ENABLE(WEB_SOCKETS)
538     , m_socketProvider(page() ? &page()->socketProvider() : nullptr)
539 #endif
540 {
541     allDocuments().add(this);
542
543     // We depend on the url getting immediately set in subframes, but we
544     // also depend on the url NOT getting immediately set in opened windows.
545     // See fast/dom/early-frame-url.html
546     // and fast/dom/location-new-window-no-crash.html, respectively.
547     // FIXME: Can/should we unify this behavior?
548     if ((frame && frame->ownerElement()) || !url.isEmpty())
549         setURL(url);
550
551     m_cachedResourceLoader->setDocument(this);
552
553     resetLinkColor();
554     resetVisitedLinkColor();
555     resetActiveLinkColor();
556
557     initSecurityContext();
558     initDNSPrefetch();
559
560     m_fontSelector->registerForInvalidationCallbacks(*this);
561
562     for (auto& nodeListAndCollectionCount : m_nodeListAndCollectionCounts)
563         nodeListAndCollectionCount = 0;
564 }
565
566 #if ENABLE(FULLSCREEN_API)
567
568 static bool isAttributeOnAllOwners(const WebCore::QualifiedName& attribute, const WebCore::QualifiedName& prefixedAttribute, const HTMLFrameOwnerElement* owner)
569 {
570     if (!owner)
571         return true;
572     do {
573         if (!(owner->hasAttribute(attribute) || owner->hasAttribute(prefixedAttribute)))
574             return false;
575     } while ((owner = owner->document().ownerElement()));
576     return true;
577 }
578
579 #endif
580
581 Ref<Document> Document::create(Document& contextDocument)
582 {
583     auto document = adoptRef(*new Document(nullptr, URL()));
584     document->setContextDocument(contextDocument);
585     document->setSecurityOriginPolicy(contextDocument.securityOriginPolicy());
586     return document;
587 }
588
589 Document::~Document()
590 {
591     allDocuments().remove(this);
592
593     ASSERT(!renderView());
594     ASSERT(m_pageCacheState != InPageCache);
595     ASSERT(m_ranges.isEmpty());
596     ASSERT(!m_parentTreeScope);
597     ASSERT(!m_disabledFieldsetElementsCount);
598     ASSERT(m_inDocumentShadowRoots.isEmpty());
599
600 #if ENABLE(DEVICE_ORIENTATION) && PLATFORM(IOS)
601     m_deviceMotionClient->deviceMotionControllerDestroyed();
602     m_deviceOrientationClient->deviceOrientationControllerDestroyed();
603 #endif
604
605     if (m_templateDocument)
606         m_templateDocument->setTemplateDocumentHost(nullptr); // balanced in templateDocument().
607
608     // FIXME: Should we reset m_domWindow when we detach from the Frame?
609     if (m_domWindow)
610         m_domWindow->resetUnlessSuspendedForDocumentSuspension();
611
612     m_scriptRunner = nullptr;
613     m_moduleLoader = nullptr;
614
615     removeAllEventListeners();
616
617     // Currently we believe that Document can never outlive the parser.
618     // Although the Document may be replaced synchronously, DocumentParsers
619     // generally keep at least one reference to an Element which would in turn
620     // has a reference to the Document.  If you hit this ASSERT, then that
621     // assumption is wrong.  DocumentParser::detach() should ensure that even
622     // if the DocumentParser outlives the Document it won't cause badness.
623     ASSERT(!m_parser || m_parser->refCount() == 1);
624     detachParser();
625
626     if (this == &topDocument())
627         clearAXObjectCache();
628
629     m_decoder = nullptr;
630
631     if (m_styleSheetList)
632         m_styleSheetList->detachFromDocument();
633
634     extensionStyleSheets().detachFromDocument();
635
636     styleScope().clearResolver(); // We need to destroy CSSFontSelector before destroying m_cachedResourceLoader.
637     m_fontSelector->clearDocument();
638     m_fontSelector->unregisterForInvalidationCallbacks(*this);
639
640     // It's possible for multiple Documents to end up referencing the same CachedResourceLoader (e.g., SVGImages
641     // load the initial empty document and the SVGDocument with the same DocumentLoader).
642     if (m_cachedResourceLoader->document() == this)
643         m_cachedResourceLoader->setDocument(nullptr);
644
645 #if ENABLE(VIDEO)
646     if (auto* platformMediaSessionManager = PlatformMediaSessionManager::sharedManagerIfExists())
647         platformMediaSessionManager->stopAllMediaPlaybackForDocument(this);
648 #endif
649     
650     // We must call clearRareData() here since a Document class inherits TreeScope
651     // as well as Node. See a comment on TreeScope.h for the reason.
652     if (hasRareData())
653         clearRareData();
654
655     ASSERT(!m_listsInvalidatedAtDocument.size());
656     ASSERT(!m_collectionsInvalidatedAtDocument.size());
657
658     for (unsigned i = 0; i < WTF_ARRAY_LENGTH(m_nodeListAndCollectionCounts); ++i)
659         ASSERT(!m_nodeListAndCollectionCounts[i]);
660 }
661
662 void Document::removedLastRef()
663 {
664     ASSERT(!m_deletionHasBegun);
665     if (m_referencingNodeCount) {
666         // If removing a child removes the last node reference, we don't want the scope to be destroyed
667         // until after removeDetachedChildren returns, so we protect ourselves.
668         incrementReferencingNodeCount();
669
670         RELEASE_ASSERT(!hasLivingRenderTree());
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_focusedElement = nullptr;
674         m_hoveredElement = nullptr;
675         m_activeElement = nullptr;
676         m_titleElement = nullptr;
677         m_documentElement = nullptr;
678         m_focusNavigationStartingNode = nullptr;
679         m_userActionElements.documentDidRemoveLastRef();
680 #if ENABLE(FULLSCREEN_API)
681         m_fullScreenElement = nullptr;
682         m_fullScreenElementStack.clear();
683 #endif
684
685         detachParser();
686
687         // removeDetachedChildren() doesn't always unregister IDs,
688         // so tear down scope information up front to avoid having
689         // stale references in the map.
690
691         destroyTreeScopeData();
692         removeDetachedChildren();
693         m_formController = nullptr;
694         
695         m_markers->detach();
696         
697         m_cssCanvasElements.clear();
698         
699         commonTeardown();
700
701 #ifndef NDEBUG
702         // We need to do this right now since selfOnlyDeref() can delete this.
703         m_inRemovedLastRefFunction = false;
704 #endif
705         decrementReferencingNodeCount();
706     } else {
707 #ifndef NDEBUG
708         m_inRemovedLastRefFunction = false;
709         m_deletionHasBegun = true;
710 #endif
711         delete this;
712     }
713 }
714
715 void Document::commonTeardown()
716 {
717     if (svgExtensions())
718         accessSVGExtensions().pauseAnimations();
719
720     clearScriptedAnimationController();
721 }
722
723 Element* Document::getElementByAccessKey(const String& key)
724 {
725     if (key.isEmpty())
726         return nullptr;
727     if (!m_accessKeyMapValid) {
728         buildAccessKeyMap(this);
729         m_accessKeyMapValid = true;
730     }
731     return m_elementsByAccessKey.get(key.impl());
732 }
733
734 void Document::buildAccessKeyMap(TreeScope* scope)
735 {
736     ASSERT(scope);
737     for (auto& element : descendantsOfType<Element>(scope->rootNode())) {
738         const AtomicString& accessKey = element.attributeWithoutSynchronization(accesskeyAttr);
739         if (!accessKey.isEmpty())
740             m_elementsByAccessKey.set(accessKey.impl(), &element);
741
742         if (ShadowRoot* root = element.shadowRoot())
743             buildAccessKeyMap(root);
744     }
745 }
746
747 void Document::invalidateAccessKeyMap()
748 {
749     m_accessKeyMapValid = false;
750     m_elementsByAccessKey.clear();
751 }
752
753 void Document::addImageElementByUsemap(const AtomicStringImpl& name, HTMLImageElement& element)
754 {
755     return m_imagesByUsemap.add(name, element, *this);
756 }
757
758 void Document::removeImageElementByUsemap(const AtomicStringImpl& name, HTMLImageElement& element)
759 {
760     return m_imagesByUsemap.remove(name, element);
761 }
762
763 HTMLImageElement* Document::imageElementByUsemap(const AtomicStringImpl& name) const
764 {
765     return m_imagesByUsemap.getElementByUsemap(name, *this);
766 }
767
768 ExceptionOr<SelectorQuery&> Document::selectorQueryForString(const String& selectorString)
769 {
770     if (selectorString.isEmpty())
771         return Exception { SYNTAX_ERR };
772     if (!m_selectorQueryCache)
773         m_selectorQueryCache = std::make_unique<SelectorQueryCache>();
774     return m_selectorQueryCache->add(selectorString, *this);
775 }
776
777 void Document::clearSelectorQueryCache()
778 {
779     m_selectorQueryCache = nullptr;
780 }
781
782 MediaQueryMatcher& Document::mediaQueryMatcher()
783 {
784     if (!m_mediaQueryMatcher)
785         m_mediaQueryMatcher = MediaQueryMatcher::create(*this);
786     return *m_mediaQueryMatcher;
787 }
788
789 void Document::setCompatibilityMode(DocumentCompatibilityMode mode)
790 {
791     if (m_compatibilityModeLocked || mode == m_compatibilityMode)
792         return;
793     bool wasInQuirksMode = inQuirksMode();
794     m_compatibilityMode = mode;
795
796     clearSelectorQueryCache();
797
798     if (inQuirksMode() != wasInQuirksMode) {
799         // All user stylesheets have to reparse using the different mode.
800         extensionStyleSheets().clearPageUserSheet();
801         extensionStyleSheets().invalidateInjectedStyleSheetCache();
802     }
803 }
804
805 String Document::compatMode() const
806 {
807     return inQuirksMode() ? "BackCompat" : "CSS1Compat";
808 }
809
810 void Document::resetLinkColor()
811 {
812     m_linkColor = Color(0, 0, 238);
813 }
814
815 void Document::resetVisitedLinkColor()
816 {
817     m_visitedLinkColor = Color(85, 26, 139);    
818 }
819
820 void Document::resetActiveLinkColor()
821 {
822     m_activeLinkColor = Color(255, 0, 0);
823 }
824
825 DOMImplementation& Document::implementation()
826 {
827     if (!m_implementation)
828         m_implementation = std::make_unique<DOMImplementation>(*this);
829     return *m_implementation;
830 }
831
832 bool Document::hasManifest() const
833 {
834     return documentElement() && documentElement()->hasTagName(htmlTag) && documentElement()->hasAttributeWithoutSynchronization(manifestAttr);
835 }
836
837 DocumentType* Document::doctype() const
838 {
839     for (Node* node = firstChild(); node; node = node->nextSibling()) {
840         if (node->isDocumentTypeNode())
841             return static_cast<DocumentType*>(node);
842     }
843     return nullptr;
844 }
845
846 void Document::childrenChanged(const ChildChange& change)
847 {
848     ContainerNode::childrenChanged(change);
849
850 #if PLATFORM(IOS)
851     // FIXME: Chrome::didReceiveDocType() used to be called only when the doctype changed. We need to check the
852     // impact of calling this systematically. If the overhead is negligible, we need to rename didReceiveDocType,
853     // otherwise, we need to detect the doc type changes before updating the viewport.
854     if (Page* page = this->page())
855         page->chrome().didReceiveDocType(frame());
856 #endif
857
858     Element* newDocumentElement = childrenOfType<Element>(*this).first();
859     if (newDocumentElement == m_documentElement)
860         return;
861     m_documentElement = newDocumentElement;
862     // The root style used for media query matching depends on the document element.
863     styleScope().clearResolver();
864 }
865
866 static ALWAYS_INLINE Ref<HTMLElement> createUpgradeCandidateElement(Document& document, const QualifiedName& name)
867 {
868     if (!RuntimeEnabledFeatures::sharedFeatures().customElementsEnabled()
869         || Document::validateCustomElementName(name.localName()) != CustomElementNameValidationStatus::Valid)
870         return HTMLUnknownElement::create(name, document);
871
872     auto element = HTMLElement::create(name, document);
873     element->setIsCustomElementUpgradeCandidate();
874     return element;
875 }
876
877 static ALWAYS_INLINE Ref<HTMLElement> createUpgradeCandidateElement(Document& document, const AtomicString& localName)
878 {
879     return createUpgradeCandidateElement(document, QualifiedName { nullAtom, localName, xhtmlNamespaceURI });
880 }
881
882 static inline bool isValidHTMLElementName(const AtomicString& localName)
883 {
884     return Document::isValidName(localName);
885 }
886
887 static inline bool isValidHTMLElementName(const QualifiedName& name)
888 {
889     return Document::isValidName(name.localName());
890 }
891
892 template<typename NameType>
893 static ExceptionOr<Ref<Element>> createHTMLElementWithNameValidation(Document& document, const NameType& name)
894 {
895     auto element = HTMLElementFactory::createKnownElement(name, document);
896     if (LIKELY(element))
897         return Ref<Element> { element.releaseNonNull() };
898
899     if (auto* window = document.domWindow()) {
900         auto* registry = window->customElementRegistry();
901         if (UNLIKELY(registry)) {
902             if (auto* elementInterface = registry->findInterface(name))
903                 return elementInterface->constructElementWithFallback(document, name);
904         }
905     }
906
907     if (UNLIKELY(!isValidHTMLElementName(name)))
908         return Exception { INVALID_CHARACTER_ERR };
909
910     return Ref<Element> { createUpgradeCandidateElement(document, name) };
911 }
912
913 ExceptionOr<Ref<Element>> Document::createElementForBindings(const AtomicString& name)
914 {
915     if (isHTMLDocument())
916         return createHTMLElementWithNameValidation(*this, name.convertToASCIILowercase());
917
918     if (isXHTMLDocument())
919         return createHTMLElementWithNameValidation(*this, name);
920
921     if (!isValidName(name))
922         return Exception { INVALID_CHARACTER_ERR };
923
924     return createElement(QualifiedName(nullAtom, name, nullAtom), false);
925 }
926
927 Ref<DocumentFragment> Document::createDocumentFragment()
928 {
929     return DocumentFragment::create(document());
930 }
931
932 Ref<Text> Document::createTextNode(const String& data)
933 {
934     return Text::create(*this, data);
935 }
936
937 Ref<Comment> Document::createComment(const String& data)
938 {
939     return Comment::create(*this, data);
940 }
941
942 ExceptionOr<Ref<CDATASection>> Document::createCDATASection(const String& data)
943 {
944     if (isHTMLDocument())
945         return Exception { NOT_SUPPORTED_ERR };
946     return CDATASection::create(*this, data);
947 }
948
949 ExceptionOr<Ref<ProcessingInstruction>> Document::createProcessingInstruction(const String& target, const String& data)
950 {
951     if (!isValidName(target))
952         return Exception { INVALID_CHARACTER_ERR };
953
954     if (data.contains("?>"))
955         return Exception { INVALID_CHARACTER_ERR };
956
957     return ProcessingInstruction::create(*this, target, data);
958 }
959
960 Ref<Text> Document::createEditingTextNode(const String& text)
961 {
962     return Text::createEditingText(*this, text);
963 }
964
965 Ref<CSSStyleDeclaration> Document::createCSSStyleDeclaration()
966 {
967     Ref<MutableStyleProperties> propertySet(MutableStyleProperties::create());
968     return *propertySet->ensureCSSStyleDeclaration();
969 }
970
971 ExceptionOr<Ref<Node>> Document::importNode(Node& nodeToImport, bool deep)
972 {
973     switch (nodeToImport.nodeType()) {
974     case DOCUMENT_FRAGMENT_NODE:
975         if (nodeToImport.isShadowRoot())
976             break;
977         FALLTHROUGH;
978     case ELEMENT_NODE:
979     case TEXT_NODE:
980     case CDATA_SECTION_NODE:
981     case PROCESSING_INSTRUCTION_NODE:
982     case COMMENT_NODE:
983         return nodeToImport.cloneNodeInternal(document(), deep ? CloningOperation::Everything : CloningOperation::OnlySelf);
984
985     case ATTRIBUTE_NODE:
986         // FIXME: This will "Attr::normalize" child nodes of Attr.
987         return Ref<Node> { Attr::create(*this, QualifiedName(nullAtom, downcast<Attr>(nodeToImport).name(), nullAtom), downcast<Attr>(nodeToImport).value()) };
988
989     case DOCUMENT_NODE: // Can't import a document into another document.
990     case DOCUMENT_TYPE_NODE: // FIXME: Support cloning a DocumentType node per DOM4.
991         break;
992     }
993
994     return Exception { NOT_SUPPORTED_ERR };
995 }
996
997
998 ExceptionOr<Ref<Node>> Document::adoptNode(Node& source)
999 {
1000     EventQueueScope scope;
1001
1002     switch (source.nodeType()) {
1003     case DOCUMENT_NODE:
1004         return Exception { NOT_SUPPORTED_ERR };
1005     case ATTRIBUTE_NODE: {
1006         auto& attr = downcast<Attr>(source);
1007         if (auto* element = attr.ownerElement()) {
1008             auto result = element->removeAttributeNode(attr);
1009             if (result.hasException())
1010                 return result.releaseException();
1011         }
1012         break;
1013     }       
1014     default:
1015         if (source.isShadowRoot()) {
1016             // ShadowRoot cannot disconnect itself from the host node.
1017             return Exception { HIERARCHY_REQUEST_ERR };
1018         }
1019         if (is<HTMLFrameOwnerElement>(source)) {
1020             auto& frameOwnerElement = downcast<HTMLFrameOwnerElement>(source);
1021             if (frame() && frame()->tree().isDescendantOf(frameOwnerElement.contentFrame()))
1022                 return Exception { HIERARCHY_REQUEST_ERR };
1023         }
1024         auto result = source.remove();
1025         if (result.hasException())
1026             return result.releaseException();
1027     }
1028
1029     adoptIfNeeded(source);
1030
1031     return Ref<Node> { source };
1032 }
1033
1034 bool Document::hasValidNamespaceForElements(const QualifiedName& qName)
1035 {
1036     // These checks are from DOM Core Level 2, createElementNS
1037     // http://www.w3.org/TR/DOM-Level-2-Core/core.html#ID-DocCrElNS
1038     if (!qName.prefix().isEmpty() && qName.namespaceURI().isNull()) // createElementNS(null, "html:div")
1039         return false;
1040     if (qName.prefix() == xmlAtom && qName.namespaceURI() != XMLNames::xmlNamespaceURI) // createElementNS("http://www.example.com", "xml:lang")
1041         return false;
1042
1043     // Required by DOM Level 3 Core and unspecified by DOM Level 2 Core:
1044     // http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core.html#ID-DocCrElNS
1045     // createElementNS("http://www.w3.org/2000/xmlns/", "foo:bar"), createElementNS(null, "xmlns:bar"), createElementNS(null, "xmlns")
1046     if (qName.prefix() == xmlnsAtom || (qName.prefix().isEmpty() && qName.localName() == xmlnsAtom))
1047         return qName.namespaceURI() == XMLNSNames::xmlnsNamespaceURI;
1048     return qName.namespaceURI() != XMLNSNames::xmlnsNamespaceURI;
1049 }
1050
1051 bool Document::hasValidNamespaceForAttributes(const QualifiedName& qName)
1052 {
1053     return hasValidNamespaceForElements(qName);
1054 }
1055
1056 static Ref<HTMLElement> createFallbackHTMLElement(Document& document, const QualifiedName& name)
1057 {
1058     if (auto* window = document.domWindow()) {
1059         auto* registry = window->customElementRegistry();
1060         if (UNLIKELY(registry)) {
1061             if (auto* elementInterface = registry->findInterface(name)) {
1062                 auto element = HTMLElement::create(name, document);
1063                 element->enqueueToUpgrade(*elementInterface);
1064                 return element;
1065             }
1066         }
1067     }
1068     // FIXME: Should we also check the equality of prefix between the custom element and name?
1069     return createUpgradeCandidateElement(document, name);
1070 }
1071
1072 // FIXME: This should really be in a possible ElementFactory class.
1073 Ref<Element> Document::createElement(const QualifiedName& name, bool createdByParser)
1074 {
1075     RefPtr<Element> element;
1076
1077     // FIXME: Use registered namespaces and look up in a hash to find the right factory.
1078     if (name.namespaceURI() == xhtmlNamespaceURI) {
1079         element = HTMLElementFactory::createKnownElement(name, *this, nullptr, createdByParser);
1080         if (UNLIKELY(!element))
1081             element = createFallbackHTMLElement(*this, name);
1082     } else if (name.namespaceURI() == SVGNames::svgNamespaceURI)
1083         element = SVGElementFactory::createElement(name, *this, createdByParser);
1084 #if ENABLE(MATHML)
1085     else if (name.namespaceURI() == MathMLNames::mathmlNamespaceURI)
1086         element = MathMLElementFactory::createElement(name, *this, createdByParser);
1087 #endif
1088
1089     if (element)
1090         m_sawElementsInKnownNamespaces = true;
1091     else
1092         element = Element::create(name, document());
1093
1094     // <image> uses imgTag so we need a special rule.
1095     ASSERT((name.matches(imageTag) && element->tagQName().matches(imgTag) && element->tagQName().prefix() == name.prefix()) || name == element->tagQName());
1096
1097     return element.releaseNonNull();
1098 }
1099
1100 CustomElementNameValidationStatus Document::validateCustomElementName(const AtomicString& localName)
1101 {
1102     bool containsHyphen = false;
1103     for (auto character : StringView(localName).codeUnits()) {
1104         if (isASCIIUpper(character))
1105             return CustomElementNameValidationStatus::ContainsUpperCase;
1106         if (character == '-')
1107             containsHyphen = true;
1108     }
1109
1110     if (!containsHyphen)
1111         return CustomElementNameValidationStatus::NoHyphen;
1112
1113 #if ENABLE(MATHML)
1114     const auto& annotationXmlLocalName = MathMLNames::annotation_xmlTag.localName();
1115 #else
1116     static NeverDestroyed<const AtomicString> annotationXmlLocalName("annotation-xml", AtomicString::ConstructFromLiteral);
1117 #endif
1118
1119     if (localName == SVGNames::color_profileTag.localName()
1120         || localName == SVGNames::font_faceTag.localName()
1121         || localName == SVGNames::font_face_formatTag.localName()
1122         || localName == SVGNames::font_face_nameTag.localName()
1123         || localName == SVGNames::font_face_srcTag.localName()
1124         || localName == SVGNames::font_face_uriTag.localName()
1125         || localName == SVGNames::missing_glyphTag.localName()
1126         || localName == annotationXmlLocalName)
1127         return CustomElementNameValidationStatus::ConflictsWithBuiltinNames;
1128
1129     return CustomElementNameValidationStatus::Valid;
1130 }
1131
1132 #if ENABLE(CSS_GRID_LAYOUT)
1133
1134 bool Document::isCSSGridLayoutEnabled() const
1135 {
1136     return RuntimeEnabledFeatures::sharedFeatures().isCSSGridLayoutEnabled();
1137 }
1138
1139 #endif
1140
1141 #if ENABLE(CSS_REGIONS)
1142
1143 RefPtr<DOMNamedFlowCollection> Document::webkitGetNamedFlows()
1144 {
1145     if (!renderView())
1146         return nullptr;
1147
1148     updateStyleIfNeeded();
1149
1150     return namedFlows().createCSSOMSnapshot();
1151 }
1152
1153 #endif
1154
1155 NamedFlowCollection& Document::namedFlows()
1156 {
1157     if (!m_namedFlows)
1158         m_namedFlows = NamedFlowCollection::create(this);
1159
1160     return *m_namedFlows;
1161 }
1162
1163 ExceptionOr<Ref<Element>> Document::createElementNS(const AtomicString& namespaceURI, const String& qualifiedName)
1164 {
1165     auto parseResult = parseQualifiedName(namespaceURI, qualifiedName);
1166     if (parseResult.hasException())
1167         return parseResult.releaseException();
1168     QualifiedName parsedName { parseResult.releaseReturnValue() };
1169     if (!hasValidNamespaceForElements(parsedName))
1170         return Exception { NAMESPACE_ERR };
1171
1172     if (parsedName.namespaceURI() == xhtmlNamespaceURI)
1173         return createHTMLElementWithNameValidation(*this, parsedName);
1174
1175     return createElement(parsedName, false);
1176 }
1177
1178 String Document::readyState() const
1179 {
1180     static NeverDestroyed<const String> loading(ASCIILiteral("loading"));
1181     static NeverDestroyed<const String> interactive(ASCIILiteral("interactive"));
1182     static NeverDestroyed<const String> complete(ASCIILiteral("complete"));
1183
1184     switch (m_readyState) {
1185     case Loading:
1186         return loading;
1187     case Interactive:
1188         return interactive;
1189     case Complete:
1190         return complete;
1191     }
1192
1193     ASSERT_NOT_REACHED();
1194     return String();
1195 }
1196
1197 void Document::setReadyState(ReadyState readyState)
1198 {
1199     if (readyState == m_readyState)
1200         return;
1201
1202 #if ENABLE(WEB_TIMING)
1203     switch (readyState) {
1204     case Loading:
1205         if (!m_documentTiming.domLoading)
1206             m_documentTiming.domLoading = monotonicallyIncreasingTime();
1207         break;
1208     case Interactive:
1209         if (!m_documentTiming.domInteractive)
1210             m_documentTiming.domInteractive = monotonicallyIncreasingTime();
1211         break;
1212     case Complete:
1213         if (!m_documentTiming.domComplete)
1214             m_documentTiming.domComplete = monotonicallyIncreasingTime();
1215         break;
1216     }
1217 #endif
1218
1219     m_readyState = readyState;
1220     dispatchEvent(Event::create(eventNames().readystatechangeEvent, false, false));
1221     
1222     if (settings() && settings()->suppressesIncrementalRendering())
1223         setVisualUpdatesAllowed(readyState);
1224 }
1225
1226 void Document::setVisualUpdatesAllowed(ReadyState readyState)
1227 {
1228     ASSERT(settings() && settings()->suppressesIncrementalRendering());
1229     switch (readyState) {
1230     case Loading:
1231         ASSERT(!m_visualUpdatesSuppressionTimer.isActive());
1232         ASSERT(m_visualUpdatesAllowed);
1233         setVisualUpdatesAllowed(false);
1234         break;
1235     case Interactive:
1236         ASSERT(m_visualUpdatesSuppressionTimer.isActive() || m_visualUpdatesAllowed);
1237         break;
1238     case Complete:
1239         if (m_visualUpdatesSuppressionTimer.isActive()) {
1240             ASSERT(!m_visualUpdatesAllowed);
1241
1242             if (!view()->visualUpdatesAllowedByClient())
1243                 return;
1244
1245             setVisualUpdatesAllowed(true);
1246         } else
1247             ASSERT(m_visualUpdatesAllowed);
1248         break;
1249     }
1250 }
1251     
1252 void Document::setVisualUpdatesAllowed(bool visualUpdatesAllowed)
1253 {
1254     if (m_visualUpdatesAllowed == visualUpdatesAllowed)
1255         return;
1256
1257     m_visualUpdatesAllowed = visualUpdatesAllowed;
1258
1259     if (visualUpdatesAllowed)
1260         m_visualUpdatesSuppressionTimer.stop();
1261     else
1262         m_visualUpdatesSuppressionTimer.startOneShot(settings()->incrementalRenderingSuppressionTimeoutInSeconds());
1263
1264     if (!visualUpdatesAllowed)
1265         return;
1266
1267     FrameView* frameView = view();
1268     bool needsLayout = frameView && renderView() && (frameView->layoutPending() || renderView()->needsLayout());
1269     if (needsLayout)
1270         updateLayout();
1271
1272     if (Page* page = this->page()) {
1273         if (frame()->isMainFrame()) {
1274             frameView->addPaintPendingMilestones(DidFirstPaintAfterSuppressedIncrementalRendering);
1275             if (page->requestedLayoutMilestones() & DidFirstLayoutAfterSuppressedIncrementalRendering)
1276                 frame()->loader().didReachLayoutMilestone(DidFirstLayoutAfterSuppressedIncrementalRendering);
1277         }
1278     }
1279
1280     if (view())
1281         view()->updateCompositingLayersAfterLayout();
1282
1283     if (RenderView* renderView = this->renderView())
1284         renderView->repaintViewAndCompositedLayers();
1285
1286     if (Frame* frame = this->frame())
1287         frame->loader().forcePageTransitionIfNeeded();
1288 }
1289
1290 void Document::visualUpdatesSuppressionTimerFired()
1291 {
1292     ASSERT(!m_visualUpdatesAllowed);
1293
1294     // If the client is extending the visual update suppression period explicitly, the
1295     // watchdog should not re-enable visual updates itself, but should wait for the client.
1296     if (!view()->visualUpdatesAllowedByClient())
1297         return;
1298
1299     setVisualUpdatesAllowed(true);
1300 }
1301
1302 void Document::setVisualUpdatesAllowedByClient(bool visualUpdatesAllowedByClient)
1303 {
1304     // We should only re-enable visual updates if ReadyState is Completed or the watchdog timer has fired,
1305     // both of which we can determine by looking at the timer.
1306
1307     if (visualUpdatesAllowedByClient && !m_visualUpdatesSuppressionTimer.isActive() && !visualUpdatesAllowed())
1308         setVisualUpdatesAllowed(true);
1309 }
1310
1311 String Document::characterSetWithUTF8Fallback() const
1312 {
1313     AtomicString name = encoding();
1314     if (!name.isNull())
1315         return name;
1316     return UTF8Encoding().domName();
1317 }
1318
1319 String Document::defaultCharsetForLegacyBindings() const
1320 {
1321     if (Settings* settings = this->settings())
1322         return settings->defaultTextEncodingName();
1323     return UTF8Encoding().domName();
1324 }
1325
1326 void Document::setCharset(const String& charset)
1327 {
1328     if (!decoder())
1329         return;
1330     decoder()->setEncoding(charset, TextResourceDecoder::UserChosenEncoding);
1331 }
1332
1333 void Document::setContentLanguage(const String& language)
1334 {
1335     if (m_contentLanguage == language)
1336         return;
1337     m_contentLanguage = language;
1338
1339     // Recalculate style so language is used when selecting the initial font.
1340     m_styleScope->didChangeStyleSheetEnvironment();
1341 }
1342
1343 ExceptionOr<void> Document::setXMLVersion(const String& version)
1344 {
1345     if (!XMLDocumentParser::supportsXMLVersion(version))
1346         return Exception { NOT_SUPPORTED_ERR };
1347
1348     m_xmlVersion = version;
1349     return { };
1350 }
1351
1352 void Document::setXMLStandalone(bool standalone)
1353 {
1354     m_xmlStandalone = standalone ? Standalone : NotStandalone;
1355 }
1356
1357 void Document::setDocumentURI(const String& uri)
1358 {
1359     // This property is read-only from JavaScript, but writable from Objective-C.
1360     m_documentURI = uri;
1361     updateBaseURL();
1362 }
1363
1364 void Document::setContent(const String& content)
1365 {
1366     open();
1367     // FIXME: This should probably use insert(), but that's (intentionally)
1368     // not implemented for the XML parser as it's normally synonymous with
1369     // document.write(). append() will end up yielding, but close() will
1370     // pump the tokenizer syncrhonously and finish the parse.
1371     m_parser->append(content.impl());
1372     close();
1373 }
1374
1375 String Document::suggestedMIMEType() const
1376 {
1377     if (isXHTMLDocument())
1378         return ASCIILiteral("application/xhtml+xml");
1379     if (isSVGDocument())
1380         return ASCIILiteral("image/svg+xml");
1381     if (xmlStandalone())
1382         return ASCIILiteral("text/xml");
1383     if (isHTMLDocument())
1384         return ASCIILiteral("text/html");
1385     if (DocumentLoader* loader = this->loader())
1386         return loader->responseMIMEType();
1387     return String();
1388 }
1389
1390 void Document::overrideMIMEType(const String& mimeType)
1391 {
1392     m_overriddenMIMEType = mimeType;
1393 }
1394
1395 String Document::contentType() const
1396 {
1397     if (!m_overriddenMIMEType.isNull())
1398         return m_overriddenMIMEType;
1399
1400     if (DocumentLoader* documentLoader = loader())
1401         return documentLoader->currentContentType();
1402
1403     String mimeType = suggestedMIMEType();
1404     if (!mimeType.isNull())
1405         return mimeType;
1406
1407     return ASCIILiteral("application/xml");
1408 }
1409
1410 RefPtr<Range> Document::caretRangeFromPoint(int x, int y)
1411 {
1412     return caretRangeFromPoint(LayoutPoint(x, y));
1413 }
1414
1415 RefPtr<Range> Document::caretRangeFromPoint(const LayoutPoint& clientPoint)
1416 {
1417     if (!hasLivingRenderTree())
1418         return nullptr;
1419
1420     LayoutPoint localPoint;
1421     Node* node = nodeFromPoint(clientPoint, &localPoint);
1422     if (!node)
1423         return nullptr;
1424
1425     RenderObject* renderer = node->renderer();
1426     if (!renderer)
1427         return nullptr;
1428     Position rangeCompliantPosition = renderer->positionForPoint(localPoint, nullptr).deepEquivalent().parentAnchoredEquivalent();
1429     if (rangeCompliantPosition.isNull())
1430         return nullptr;
1431
1432     unsigned offset = rangeCompliantPosition.offsetInContainerNode();
1433     node = &retargetToScope(*rangeCompliantPosition.containerNode());
1434     if (node != rangeCompliantPosition.containerNode())
1435         offset = 0;
1436
1437     return Range::create(*this, node, offset, node, offset);
1438 }
1439
1440 Element* Document::scrollingElement()
1441 {
1442     // FIXME: When we fix https://bugs.webkit.org/show_bug.cgi?id=106133, this should be replaced with the full implementation
1443     // of Document.scrollingElement() as specified at http://dev.w3.org/csswg/cssom-view/#dom-document-scrollingelement.
1444
1445     return body();
1446 }
1447
1448 template<typename CharacterType> static inline String canonicalizedTitle(Document& document, const String& title)
1449 {
1450     // FIXME: Compiling a separate copy of this for LChar and UChar is likely unnecessary.
1451     // FIXME: Missing an optimized case for when title is fine as-is. This unnecessarily allocates
1452     // and keeps around a new copy, and it's even the less optimal type of StringImpl with a separate buffer.
1453     // Could probably just use StringBuilder instead.
1454
1455     auto* characters = title.characters<CharacterType>();
1456     unsigned length = title.length();
1457
1458     StringBuffer<CharacterType> buffer { length };
1459     unsigned bufferLength = 0;
1460
1461     auto* decoder = document.decoder();
1462     auto backslashAsCurrencySymbol = decoder ? decoder->encoding().backslashAsCurrencySymbol() : '\\';
1463
1464     // Collapse runs of HTML spaces into single space characters.
1465     // Strip leading and trailing spaces.
1466     // Replace backslashes with currency symbols.
1467     bool previousCharacterWasHTMLSpace = false;
1468     for (unsigned i = 0; i < length; ++i) {
1469         auto character = characters[i];
1470         if (isHTMLSpace(character))
1471             previousCharacterWasHTMLSpace = true;
1472         else {
1473             if (character == '\\')
1474                 character = backslashAsCurrencySymbol;
1475             if (previousCharacterWasHTMLSpace && bufferLength)
1476                 buffer[bufferLength++] = ' ';
1477             buffer[bufferLength++] = character;
1478             previousCharacterWasHTMLSpace = false;
1479         }
1480     }
1481     if (!bufferLength)
1482         return { };
1483
1484     buffer.shrink(bufferLength);
1485     return String::adopt(WTFMove(buffer));
1486 }
1487
1488 void Document::updateTitle(const StringWithDirection& title)
1489 {
1490     if (m_rawTitle == title)
1491         return;
1492
1493     m_rawTitle = title;
1494     m_title = title;
1495
1496     if (!m_title.string.isEmpty()) {
1497         if (m_title.string.is8Bit())
1498             m_title.string = canonicalizedTitle<LChar>(*this, m_title.string);
1499         else
1500             m_title.string = canonicalizedTitle<UChar>(*this, m_title.string);
1501     }
1502
1503     if (auto* loader = this->loader())
1504         loader->setTitle(m_title);
1505 }
1506
1507 void Document::updateTitleFromTitleElement()
1508 {
1509     if (!m_titleElement) {
1510         updateTitle({ });
1511         return;
1512     }
1513
1514     if (is<HTMLTitleElement>(*m_titleElement))
1515         updateTitle(downcast<HTMLTitleElement>(*m_titleElement).textWithDirection());
1516     else if (is<SVGTitleElement>(*m_titleElement)) {
1517         // FIXME: Does the SVG title element have a text direction?
1518         updateTitle({ downcast<SVGTitleElement>(*m_titleElement).textContent(), LTR });
1519     }
1520 }
1521
1522 void Document::setTitle(const String& title)
1523 {
1524     if (!m_titleElement) {
1525         if (isHTMLDocument() || isXHTMLDocument()) {
1526             auto* headElement = head();
1527             if (!headElement)
1528                 return;
1529             m_titleElement = HTMLTitleElement::create(HTMLNames::titleTag, *this);
1530             headElement->appendChild(*m_titleElement);
1531         } else if (isSVGDocument()) {
1532             auto* element = documentElement();
1533             if (!is<SVGSVGElement>(element))
1534                 return;
1535             m_titleElement = SVGTitleElement::create(SVGNames::titleTag, *this);
1536             element->insertBefore(*m_titleElement, element->firstChild());
1537         }
1538     } else if (!isHTMLDocument() && !isXHTMLDocument() && !isSVGDocument()) {
1539         // FIXME: What exactly is the point of this? This seems like a strange moment
1540         // in time to demote something from being m_titleElement, when setting the
1541         // value of the title attribute. Do we have test coverage for this?
1542         m_titleElement = nullptr;
1543     }
1544
1545     if (is<HTMLTitleElement>(m_titleElement.get()))
1546         downcast<HTMLTitleElement>(*m_titleElement).setTextContent(title);
1547     else if (is<SVGTitleElement>(m_titleElement.get()))
1548         downcast<SVGTitleElement>(*m_titleElement).setTextContent(title);
1549     else
1550         updateTitle({ title, LTR });
1551 }
1552
1553 void Document::updateTitleElement(Element* newTitleElement)
1554 {
1555     if (is<SVGSVGElement>(documentElement()))
1556         m_titleElement = childrenOfType<SVGTitleElement>(*documentElement()).first();
1557     else {
1558         if (m_titleElement) {
1559             if (isHTMLDocument() || isXHTMLDocument())
1560                 m_titleElement = descendantsOfType<HTMLTitleElement>(*this).first();
1561         } else
1562             m_titleElement = newTitleElement;
1563     }
1564
1565     updateTitleFromTitleElement();
1566 }
1567
1568 void Document::titleElementAdded(Element& titleElement)
1569 {
1570     if (m_titleElement == &titleElement)
1571         return;
1572
1573     updateTitleElement(&titleElement);
1574 }
1575
1576 void Document::titleElementRemoved(Element& titleElement)
1577 {
1578     if (m_titleElement != &titleElement)
1579         return;
1580
1581     updateTitleElement(nullptr);
1582 }
1583
1584 void Document::titleElementTextChanged(Element& titleElement)
1585 {
1586     if (m_titleElement != &titleElement)
1587         return;
1588
1589     updateTitleFromTitleElement();
1590 }
1591
1592 void Document::registerForVisibilityStateChangedCallbacks(Element* element)
1593 {
1594     m_visibilityStateCallbackElements.add(element);
1595 }
1596
1597 void Document::unregisterForVisibilityStateChangedCallbacks(Element* element)
1598 {
1599     m_visibilityStateCallbackElements.remove(element);
1600 }
1601
1602 void Document::visibilityStateChanged()
1603 {
1604     dispatchEvent(Event::create(eventNames().visibilitychangeEvent, false, false));
1605     for (auto* element : m_visibilityStateCallbackElements)
1606         element->visibilityStateChanged();
1607 }
1608
1609 auto Document::visibilityState() const -> VisibilityState
1610 {
1611     // The visibility of the document is inherited from the visibility of the
1612     // page. If there is no page associated with the document, we will assume
1613     // that the page is hidden, as specified by the spec:
1614     // http://dvcs.w3.org/hg/webperf/raw-file/tip/specs/PageVisibility/Overview.html#dom-document-hidden
1615     if (!m_frame || !m_frame->page())
1616         return VisibilityState::Hidden;
1617     return m_frame->page()->visibilityState();
1618 }
1619
1620 bool Document::hidden() const
1621 {
1622     return visibilityState() != VisibilityState::Visible;
1623 }
1624
1625 #if ENABLE(VIDEO)
1626
1627 void Document::registerForAllowsMediaDocumentInlinePlaybackChangedCallbacks(HTMLMediaElement& element)
1628 {
1629     m_allowsMediaDocumentInlinePlaybackElements.add(&element);
1630 }
1631
1632 void Document::unregisterForAllowsMediaDocumentInlinePlaybackChangedCallbacks(HTMLMediaElement& element)
1633 {
1634     m_allowsMediaDocumentInlinePlaybackElements.remove(&element);
1635 }
1636
1637 void Document::allowsMediaDocumentInlinePlaybackChanged()
1638 {
1639     for (auto* element : m_allowsMediaDocumentInlinePlaybackElements)
1640         element->allowsMediaDocumentInlinePlaybackChanged();
1641 }
1642
1643 #endif
1644
1645 String Document::nodeName() const
1646 {
1647     return ASCIILiteral("#document");
1648 }
1649
1650 Node::NodeType Document::nodeType() const
1651 {
1652     return DOCUMENT_NODE;
1653 }
1654
1655 FormController& Document::formController()
1656 {
1657     if (!m_formController)
1658         m_formController = std::make_unique<FormController>();
1659     return *m_formController;
1660 }
1661
1662 Vector<String> Document::formElementsState() const
1663 {
1664     if (!m_formController)
1665         return Vector<String>();
1666     return m_formController->formElementsState();
1667 }
1668
1669 void Document::setStateForNewFormElements(const Vector<String>& stateVector)
1670 {
1671     if (!stateVector.size() && !m_formController)
1672         return;
1673     formController().setStateForNewFormElements(stateVector);
1674 }
1675
1676 FrameView* Document::view() const
1677 {
1678     return m_frame ? m_frame->view() : nullptr;
1679 }
1680
1681 Page* Document::page() const
1682 {
1683     return m_frame ? m_frame->page() : nullptr;
1684 }
1685
1686 Settings* Document::settings() const
1687 {
1688     return m_frame ? &m_frame->settings() : nullptr;
1689 }
1690
1691 Ref<Range> Document::createRange()
1692 {
1693     return Range::create(*this);
1694 }
1695
1696 Ref<NodeIterator> Document::createNodeIterator(Node& root, unsigned long whatToShow, RefPtr<NodeFilter>&& filter, bool)
1697 {
1698     return NodeIterator::create(root, whatToShow, WTFMove(filter));
1699 }
1700
1701 Ref<TreeWalker> Document::createTreeWalker(Node& root, unsigned long whatToShow, RefPtr<NodeFilter>&& filter, bool)
1702 {
1703     return TreeWalker::create(root, whatToShow, WTFMove(filter));
1704 }
1705
1706 void Document::scheduleForcedStyleRecalc()
1707 {
1708     m_pendingStyleRecalcShouldForce = true;
1709     scheduleStyleRecalc();
1710 }
1711
1712 void Document::scheduleStyleRecalc()
1713 {
1714     ASSERT(!m_renderView || !m_renderView->inHitTesting());
1715
1716     if (m_styleRecalcTimer.isActive() || pageCacheState() != NotInPageCache)
1717         return;
1718
1719     ASSERT(childNeedsStyleRecalc() || m_pendingStyleRecalcShouldForce);
1720
1721     // FIXME: Why on earth is this here? This is clearly misplaced.
1722     invalidateAccessKeyMap();
1723     
1724     m_styleRecalcTimer.startOneShot(0);
1725
1726     InspectorInstrumentation::didScheduleStyleRecalculation(*this);
1727 }
1728
1729 void Document::unscheduleStyleRecalc()
1730 {
1731     ASSERT(!childNeedsStyleRecalc());
1732
1733     m_styleRecalcTimer.stop();
1734     m_pendingStyleRecalcShouldForce = false;
1735 }
1736
1737 bool Document::hasPendingStyleRecalc() const
1738 {
1739     return m_styleRecalcTimer.isActive() && !m_inStyleRecalc;
1740 }
1741
1742 bool Document::hasPendingForcedStyleRecalc() const
1743 {
1744     return m_styleRecalcTimer.isActive() && m_pendingStyleRecalcShouldForce;
1745 }
1746
1747 void Document::recalcStyle(Style::Change change)
1748 {
1749     ASSERT(!view() || !view()->isPainting());
1750
1751     // NOTE: XSL code seems to be the only client stumbling in here without a RenderView.
1752     if (!m_renderView)
1753         return;
1754
1755     FrameView& frameView = m_renderView->frameView();
1756     Ref<FrameView> protect(frameView);
1757     if (frameView.isPainting())
1758         return;
1759     
1760     if (m_inStyleRecalc)
1761         return; // Guard against re-entrancy. -dwh
1762
1763     TraceScope tracingScope(StyleRecalcStart, StyleRecalcEnd);
1764
1765     RenderView::RepaintRegionAccumulator repaintRegionAccumulator(renderView());
1766     AnimationUpdateBlock animationUpdateBlock(&m_frame->animation());
1767
1768     // FIXME: We should update style on our ancestor chain before proceeding (especially for seamless),
1769     // however doing so currently causes several tests to crash, as Frame::setDocument calls Document::attach
1770     // before setting the DOMWindow on the Frame, or the SecurityOrigin on the document. The attach, in turn
1771     // resolves style (here) and then when we resolve style on the parent chain, we may end up
1772     // re-attaching our containing iframe, which when asked HTMLFrameElementBase::isURLAllowed
1773     // hits a null-dereference due to security code always assuming the document has a SecurityOrigin.
1774
1775     styleScope().flushPendingUpdate();
1776
1777     frameView.willRecalcStyle();
1778
1779     InspectorInstrumentationCookie cookie = InspectorInstrumentation::willRecalculateStyle(*this);
1780
1781     m_inStyleRecalc = true;
1782     bool updatedCompositingLayers = false;
1783     {
1784         Style::PostResolutionCallbackDisabler disabler(*this);
1785         WidgetHierarchyUpdatesSuspensionScope suspendWidgetHierarchyUpdates;
1786
1787         if (m_pendingStyleRecalcShouldForce)
1788             change = Style::Force;
1789
1790         if (change == Style::Force) {
1791             // This may get set again during style resolve.
1792             m_hasNodesWithPlaceholderStyle = false;
1793
1794             auto documentStyle = Style::resolveForDocument(*this);
1795
1796             // Inserting the pictograph font at the end of the font fallback list is done by the
1797             // font selector, so set a font selector if needed.
1798             if (Settings* settings = this->settings()) {
1799                 if (settings->fontFallbackPrefersPictographs())
1800                     documentStyle.fontCascade().update(&fontSelector());
1801             }
1802
1803             auto documentChange = Style::determineChange(documentStyle, m_renderView->style());
1804             if (documentChange != Style::NoChange)
1805                 renderView()->setStyle(WTFMove(documentStyle));
1806         }
1807
1808         Style::TreeResolver resolver(*this);
1809         auto styleUpdate = resolver.resolve(change);
1810
1811         m_lastStyleUpdateSizeForTesting = styleUpdate ? styleUpdate->size() : 0;
1812
1813         setHasValidStyle();
1814         clearChildNeedsStyleRecalc();
1815         unscheduleStyleRecalc();
1816
1817         m_inStyleRecalc = false;
1818
1819         if (styleUpdate) {
1820             SetForScope<bool> inRenderTreeUpdate(m_inRenderTreeUpdate, true);
1821
1822             RenderTreeUpdater updater(*this);
1823             updater.commit(WTFMove(styleUpdate));
1824         }
1825
1826         updatedCompositingLayers = frameView.updateCompositingLayersAfterStyleChange();
1827     }
1828
1829     // If we wanted to call implicitClose() during recalcStyle, do so now that we're finished.
1830     if (m_closeAfterStyleRecalc) {
1831         m_closeAfterStyleRecalc = false;
1832         implicitClose();
1833     }
1834     
1835     ++m_styleRecalcCount;
1836
1837     InspectorInstrumentation::didRecalculateStyle(cookie);
1838
1839     // Some animated images may now be inside the viewport due to style recalc,
1840     // resume them if necessary if there is no layout pending. Otherwise, we'll
1841     // check if they need to be resumed after layout.
1842     if (updatedCompositingLayers && !frameView.needsLayout())
1843         frameView.viewportContentsChanged();
1844
1845     if (!frameView.needsLayout())
1846         frameView.frame().selection().updateAppearanceAfterLayout();
1847
1848     // As a result of the style recalculation, the currently hovered element might have been
1849     // detached (for example, by setting display:none in the :hover style), schedule another mouseMove event
1850     // to check if any other elements ended up under the mouse pointer due to re-layout.
1851     if (m_hoveredElement && !m_hoveredElement->renderer())
1852         frameView.frame().mainFrame().eventHandler().dispatchFakeMouseMoveEventSoon();
1853 }
1854
1855 bool Document::needsStyleRecalc() const
1856 {
1857     if (pageCacheState() != NotInPageCache)
1858         return false;
1859
1860     return m_pendingStyleRecalcShouldForce || childNeedsStyleRecalc() || styleScope().hasPendingUpdate();
1861 }
1862
1863 void Document::updateStyleIfNeeded()
1864 {
1865     ASSERT(isMainThread());
1866     ASSERT(!view() || !view()->isPainting());
1867
1868     if (!view() || view()->isInRenderTreeLayout())
1869         return;
1870
1871     styleScope().flushPendingUpdate();
1872
1873     if (!needsStyleRecalc())
1874         return;
1875
1876     recalcStyle();
1877 }
1878
1879 void Document::updateLayout()
1880 {
1881     ASSERT(isMainThread());
1882
1883     FrameView* frameView = view();
1884     if (frameView && frameView->isInRenderTreeLayout()) {
1885         // View layout should not be re-entrant.
1886         ASSERT_NOT_REACHED();
1887         return;
1888     }
1889
1890     RenderView::RepaintRegionAccumulator repaintRegionAccumulator(renderView());
1891
1892     if (HTMLFrameOwnerElement* owner = ownerElement())
1893         owner->document().updateLayout();
1894
1895     updateStyleIfNeeded();
1896
1897     StackStats::LayoutCheckPoint layoutCheckPoint;
1898
1899     // Only do a layout if changes have occurred that make it necessary.      
1900     if (frameView && renderView() && (frameView->layoutPending() || renderView()->needsLayout()))
1901         frameView->layout();
1902 }
1903
1904 // FIXME: This is a bad idea and needs to be removed eventually.
1905 // Other browsers load stylesheets before they continue parsing the web page.
1906 // Since we don't, we can run JavaScript code that needs answers before the
1907 // stylesheets are loaded. Doing a layout ignoring the pending stylesheets
1908 // lets us get reasonable answers. The long term solution to this problem is
1909 // to instead suspend JavaScript execution.
1910 void Document::updateLayoutIgnorePendingStylesheets(Document::RunPostLayoutTasks runPostLayoutTasks)
1911 {
1912     bool oldIgnore = m_ignorePendingStylesheets;
1913
1914     if (!haveStylesheetsLoaded()) {
1915         m_ignorePendingStylesheets = true;
1916         // FIXME: We are willing to attempt to suppress painting with outdated style info only once.  Our assumption is that it would be
1917         // dangerous to try to stop it a second time, after page content has already been loaded and displayed
1918         // with accurate style information.  (Our suppression involves blanking the whole page at the
1919         // moment.  If it were more refined, we might be able to do something better.)
1920         // It's worth noting though that this entire method is a hack, since what we really want to do is
1921         // suspend JS instead of doing a layout with inaccurate information.
1922         HTMLElement* bodyElement = bodyOrFrameset();
1923         if (bodyElement && !bodyElement->renderer() && m_pendingSheetLayout == NoLayoutWithPendingSheets) {
1924             m_pendingSheetLayout = DidLayoutWithPendingSheets;
1925             styleScope().didChangeActiveStyleSheetCandidates();
1926             recalcStyle(Style::Force);
1927         } else if (m_hasNodesWithPlaceholderStyle)
1928             // If new nodes have been added or style recalc has been done with style sheets still pending, some nodes 
1929             // may not have had their real style calculated yet. Normally this gets cleaned when style sheets arrive 
1930             // but here we need up-to-date style immediately.
1931             recalcStyle(Style::Force);
1932     }
1933
1934     updateLayout();
1935
1936     if (runPostLayoutTasks == RunPostLayoutTasks::Synchronously && view())
1937         view()->flushAnyPendingPostLayoutTasks();
1938
1939     m_ignorePendingStylesheets = oldIgnore;
1940 }
1941
1942 std::unique_ptr<RenderStyle> Document::styleForElementIgnoringPendingStylesheets(Element& element, const RenderStyle* parentStyle)
1943 {
1944     ASSERT(&element.document() == this);
1945
1946     // On iOS request delegates called during styleForElement may result in re-entering WebKit and killing the style resolver.
1947     Style::PostResolutionCallbackDisabler disabler(*this);
1948
1949     SetForScope<bool> change(m_ignorePendingStylesheets, true);
1950     auto elementStyle = element.resolveStyle(parentStyle);
1951
1952     if (elementStyle.relations) {
1953         Style::Update emptyUpdate(*this);
1954         Style::commitRelations(WTFMove(elementStyle.relations), emptyUpdate);
1955     }
1956
1957     return WTFMove(elementStyle.renderStyle);
1958 }
1959
1960 bool Document::updateLayoutIfDimensionsOutOfDate(Element& element, DimensionsCheck dimensionsCheck)
1961 {
1962     ASSERT(isMainThread());
1963     
1964     // If the stylesheets haven't loaded, just give up and do a full layout ignoring pending stylesheets.
1965     if (!haveStylesheetsLoaded()) {
1966         updateLayoutIgnorePendingStylesheets();
1967         return true;
1968     }
1969     
1970     // Check for re-entrancy and assert (same code that is in updateLayout()).
1971     FrameView* frameView = view();
1972     if (frameView && frameView->isInRenderTreeLayout()) {
1973         // View layout should not be re-entrant.
1974         ASSERT_NOT_REACHED();
1975         return true;
1976     }
1977     
1978     RenderView::RepaintRegionAccumulator repaintRegionAccumulator(renderView());
1979     
1980     // Mimic the structure of updateLayout(), but at each step, see if we have been forced into doing a full
1981     // layout.
1982     bool requireFullLayout = false;
1983     if (HTMLFrameOwnerElement* owner = ownerElement()) {
1984         if (owner->document().updateLayoutIfDimensionsOutOfDate(*owner))
1985             requireFullLayout = true;
1986     }
1987     
1988     updateStyleIfNeeded();
1989
1990     RenderObject* renderer = element.renderer();
1991     if (!renderer || renderer->needsLayout() || element.renderNamedFlowFragment()) {
1992         // If we don't have a renderer or if the renderer needs layout for any reason, give up.
1993         // Named flows can have auto height, so don't try to enforce the optimization in this case.
1994         // The 2-pass nature of auto height named flow layout means the region may not be dirty yet.
1995         requireFullLayout = true;
1996     }
1997
1998     bool isVertical = renderer && !renderer->isHorizontalWritingMode();
1999     bool checkingLogicalWidth = ((dimensionsCheck & WidthDimensionsCheck) && !isVertical) || ((dimensionsCheck & HeightDimensionsCheck) && isVertical);
2000     bool checkingLogicalHeight = ((dimensionsCheck & HeightDimensionsCheck) && !isVertical) || ((dimensionsCheck & WidthDimensionsCheck) && isVertical);
2001     bool hasSpecifiedLogicalHeight = renderer && renderer->style().logicalMinHeight() == Length(0, Fixed) && renderer->style().logicalHeight().isFixed() && renderer->style().logicalMaxHeight().isAuto();
2002     
2003     if (!requireFullLayout) {
2004         RenderBox* previousBox = nullptr;
2005         RenderBox* currentBox = nullptr;
2006         
2007         // Check our containing block chain. If anything in the chain needs a layout, then require a full layout.
2008         for (RenderObject* currRenderer = element.renderer(); currRenderer && !currRenderer->isRenderView(); currRenderer = currRenderer->container()) {
2009             
2010             // Require the entire container chain to be boxes.
2011             if (!is<RenderBox>(currRenderer)) {
2012                 requireFullLayout = true;
2013                 break;
2014             }
2015             
2016             previousBox = currentBox;
2017             currentBox = downcast<RenderBox>(currRenderer);
2018             
2019             // If a box needs layout for itself or if a box has changed children and sizes its width to
2020             // its content, then require a full layout.
2021             if (currentBox->selfNeedsLayout() ||
2022                 (checkingLogicalWidth && currRenderer->needsLayout() && currentBox->sizesLogicalWidthToFitContent(MainOrPreferredSize))) {
2023                 requireFullLayout = true;
2024                 break;
2025             }
2026             
2027             // If a block contains floats and the child's height isn't specified, then
2028             // give up also, since our height could end up being influenced by the floats.
2029             if (checkingLogicalHeight && !hasSpecifiedLogicalHeight && currentBox->isRenderBlockFlow()) {
2030                 RenderBlockFlow* currentBlockFlow = downcast<RenderBlockFlow>(currentBox);
2031                 if (currentBlockFlow->containsFloats() && previousBox && !previousBox->isFloatingOrOutOfFlowPositioned()) {
2032                     requireFullLayout = true;
2033                     break;
2034                 }
2035             }
2036             
2037             if (!currentBox->isRenderBlockFlow() || currentBox->flowThreadContainingBlock() || currentBox->isWritingModeRoot()) {
2038                 // FIXME: For now require only block flows all the way back to the root. This limits the optimization
2039                 // for now, and we'll expand it in future patches to apply to more and more scenarios.
2040                 // Disallow regions/columns from having the optimization.
2041                 // Give up if the writing mode changes at all in the containing block chain.
2042                 requireFullLayout = true;
2043                 break;
2044             }
2045             
2046             if (currRenderer == frameView->layoutRoot())
2047                 break;
2048         }
2049     }
2050     
2051     StackStats::LayoutCheckPoint layoutCheckPoint;
2052
2053     // Only do a layout if changes have occurred that make it necessary.      
2054     if (requireFullLayout && frameView && renderView() && (frameView->layoutPending() || renderView()->needsLayout()))
2055         frameView->layout();
2056     
2057     return requireFullLayout;
2058 }
2059
2060 bool Document::isPageBoxVisible(int pageIndex)
2061 {
2062     updateStyleIfNeeded();
2063     std::unique_ptr<RenderStyle> pageStyle(styleScope().resolver().styleForPage(pageIndex));
2064     return pageStyle->visibility() != HIDDEN; // display property doesn't apply to @page.
2065 }
2066
2067 void Document::pageSizeAndMarginsInPixels(int pageIndex, IntSize& pageSize, int& marginTop, int& marginRight, int& marginBottom, int& marginLeft)
2068 {
2069     updateStyleIfNeeded();
2070     auto style = styleScope().resolver().styleForPage(pageIndex);
2071
2072     int width = pageSize.width();
2073     int height = pageSize.height();
2074     switch (style->pageSizeType()) {
2075     case PAGE_SIZE_AUTO:
2076         break;
2077     case PAGE_SIZE_AUTO_LANDSCAPE:
2078         if (width < height)
2079             std::swap(width, height);
2080         break;
2081     case PAGE_SIZE_AUTO_PORTRAIT:
2082         if (width > height)
2083             std::swap(width, height);
2084         break;
2085     case PAGE_SIZE_RESOLVED: {
2086         auto& size = style->pageSize();
2087         ASSERT(size.width.isFixed());
2088         ASSERT(size.height.isFixed());
2089         width = valueForLength(size.width, 0);
2090         height = valueForLength(size.height, 0);
2091         break;
2092     }
2093     default:
2094         ASSERT_NOT_REACHED();
2095     }
2096     pageSize = IntSize(width, height);
2097
2098     // The percentage is calculated with respect to the width even for margin top and bottom.
2099     // http://www.w3.org/TR/CSS2/box.html#margin-properties
2100     marginTop = style->marginTop().isAuto() ? marginTop : intValueForLength(style->marginTop(), width);
2101     marginRight = style->marginRight().isAuto() ? marginRight : intValueForLength(style->marginRight(), width);
2102     marginBottom = style->marginBottom().isAuto() ? marginBottom : intValueForLength(style->marginBottom(), width);
2103     marginLeft = style->marginLeft().isAuto() ? marginLeft : intValueForLength(style->marginLeft(), width);
2104 }
2105
2106 StyleResolver& Document::userAgentShadowTreeStyleResolver()
2107 {
2108     if (!m_userAgentShadowTreeStyleResolver)
2109         m_userAgentShadowTreeStyleResolver = std::make_unique<StyleResolver>(*this);
2110     return *m_userAgentShadowTreeStyleResolver;
2111 }
2112
2113 void Document::fontsNeedUpdate(FontSelector&)
2114 {
2115     if (auto* resolver = styleScope().resolverIfExists())
2116         resolver->invalidateMatchedPropertiesCache();
2117     if (pageCacheState() != NotInPageCache || !renderView())
2118         return;
2119     scheduleForcedStyleRecalc();
2120 }
2121
2122 void Document::didClearStyleResolver()
2123 {
2124     m_userAgentShadowTreeStyleResolver = nullptr;
2125
2126     m_fontSelector->buildStarted();
2127 }
2128
2129 void Document::createRenderTree()
2130 {
2131     ASSERT(!renderView());
2132     ASSERT(m_pageCacheState != InPageCache);
2133     ASSERT(!m_axObjectCache || this != &topDocument());
2134
2135     if (m_isNonRenderedPlaceholder)
2136         return;
2137
2138     // FIXME: It would be better if we could pass the resolved document style directly here.
2139     m_renderView = createRenderer<RenderView>(*this, RenderStyle::create());
2140     Node::setRenderer(m_renderView.get());
2141
2142     renderView()->setIsInWindow(true);
2143
2144     recalcStyle(Style::Force);
2145 }
2146
2147 void Document::didBecomeCurrentDocumentInFrame()
2148 {
2149     // FIXME: Are there cases where the document can be dislodged from the frame during the event handling below?
2150     // If so, then m_frame could become 0, and we need to do something about that.
2151
2152     m_frame->script().updateDocument();
2153
2154     if (!hasLivingRenderTree())
2155         createRenderTree();
2156
2157     updateViewportArguments();
2158
2159     // FIXME: Doing this only for the main frame is insufficient.
2160     // Changing a subframe can also change the wheel event handler count.
2161     // FIXME: Doing this only when a document goes into the frame is insufficient.
2162     // Removing a document can also change the wheel event handler count.
2163     // FIXME: Doing this every time is a waste. If the current document and its
2164     // subframes' documents have no wheel event handlers, then the count did not change,
2165     // unless the documents they are replacing had wheel event handlers.
2166     if (page() && m_frame->isMainFrame())
2167         wheelEventHandlersChanged();
2168
2169     // Ensure that the scheduled task state of the document matches the DOM suspension state of the frame. It can
2170     // be out of sync if the DOM suspension state changed while the document was not in the frame (possibly in the
2171     // page cache, or simply newly created).
2172     if (m_frame->activeDOMObjectsAndAnimationsSuspended()) {
2173         m_frame->animation().suspendAnimationsForDocument(this);
2174         suspendScheduledTasks(ActiveDOMObject::PageWillBeSuspended);
2175     } else {
2176         resumeScheduledTasks(ActiveDOMObject::PageWillBeSuspended);
2177         m_frame->animation().resumeAnimationsForDocument(this);
2178     }
2179 }
2180
2181 void Document::disconnectFromFrame()
2182 {
2183     observeFrame(nullptr);
2184 }
2185
2186 void Document::frameDestroyed()
2187 {
2188     // disconnectFromFrame() must be called before destroying the Frame.
2189     ASSERT_WITH_SECURITY_IMPLICATION(!m_frame);
2190     FrameDestructionObserver::frameDestroyed();
2191 }
2192
2193 void Document::destroyRenderTree()
2194 {
2195     ASSERT(hasLivingRenderTree());
2196     ASSERT(frame());
2197     ASSERT(frame()->view());
2198     ASSERT(page());
2199
2200     FrameView& frameView = *frame()->view();
2201
2202     // Prevent Widget tree changes from committing until the RenderView is dead and gone.
2203     WidgetHierarchyUpdatesSuspensionScope suspendWidgetHierarchyUpdates;
2204
2205     SetForScope<bool> change(m_renderTreeBeingDestroyed, true);
2206
2207     if (this == &topDocument())
2208         clearAXObjectCache();
2209
2210     documentWillBecomeInactive();
2211
2212     frameView.willDestroyRenderTree();
2213
2214 #if ENABLE(FULLSCREEN_API)
2215     if (m_fullScreenRenderer)
2216         setFullScreenRenderer(nullptr);
2217 #endif
2218
2219     m_hoveredElement = nullptr;
2220     m_focusedElement = nullptr;
2221     m_activeElement = nullptr;
2222     m_focusNavigationStartingNode = nullptr;
2223
2224     if (m_documentElement)
2225         RenderTreeUpdater::tearDownRenderers(*m_documentElement);
2226
2227     clearChildNeedsStyleRecalc();
2228
2229     unscheduleStyleRecalc();
2230
2231     m_renderView = nullptr;
2232     Node::setRenderer(nullptr);
2233
2234 #if ENABLE(TEXT_AUTOSIZING)
2235     // Do this before the arena is cleared, which is needed to deref the RenderStyle on TextAutoSizingKey.
2236     m_textAutoSizedNodes.clear();
2237 #endif
2238
2239     frameView.didDestroyRenderTree();
2240 }
2241
2242 void Document::prepareForDestruction()
2243 {
2244     if (m_hasPreparedForDestruction)
2245         return;
2246
2247 #if ENABLE(IOS_TOUCH_EVENTS)
2248     clearTouchEventHandlersAndListeners();
2249 #endif
2250
2251 #if HAVE(ACCESSIBILITY)
2252     // Sub-frames need to cleanup Nodes in the text marker cache when the Document disappears.
2253     if (this != &topDocument()) {
2254         if (AXObjectCache* cache = existingAXObjectCache())
2255             cache->clearTextMarkerNodesInUse(this);
2256     }
2257 #endif
2258     
2259     disconnectDescendantFrames();
2260     if (m_domWindow && m_frame)
2261         m_domWindow->willDetachDocumentFromFrame();
2262
2263     if (hasLivingRenderTree())
2264         destroyRenderTree();
2265
2266     if (is<PluginDocument>(*this))
2267         downcast<PluginDocument>(*this).detachFromPluginElement();
2268
2269 #if ENABLE(POINTER_LOCK)
2270     if (page())
2271         page()->pointerLockController().documentDetached(*this);
2272 #endif
2273
2274     InspectorInstrumentation::documentDetached(*this);
2275
2276     stopActiveDOMObjects();
2277     m_eventQueue.close();
2278 #if ENABLE(FULLSCREEN_API)
2279     m_fullScreenChangeEventTargetQueue.clear();
2280     m_fullScreenErrorEventTargetQueue.clear();
2281 #endif
2282
2283     commonTeardown();
2284
2285 #if ENABLE(TOUCH_EVENTS)
2286     if (m_touchEventTargets && m_touchEventTargets->size() && parentDocument())
2287         parentDocument()->didRemoveEventTargetNode(*this);
2288 #endif
2289
2290     if (m_wheelEventTargets && m_wheelEventTargets->size() && parentDocument())
2291         parentDocument()->didRemoveEventTargetNode(*this);
2292
2293     if (m_mediaQueryMatcher)
2294         m_mediaQueryMatcher->documentDestroyed();
2295
2296 #if ENABLE(WIRELESS_PLAYBACK_TARGET)
2297     if (!m_clientToIDMap.isEmpty() && page()) {
2298         Vector<WebCore::MediaPlaybackTargetClient*> clients;
2299         copyKeysToVector(m_clientToIDMap, clients);
2300         for (auto* client : clients)
2301             removePlaybackTargetPickerClient(*client);
2302     }
2303 #endif
2304
2305     disconnectFromFrame();
2306
2307     m_hasPreparedForDestruction = true;
2308 }
2309
2310 void Document::removeAllEventListeners()
2311 {
2312     EventTarget::removeAllEventListeners();
2313
2314     if (m_domWindow)
2315         m_domWindow->removeAllEventListeners();
2316 #if ENABLE(IOS_TOUCH_EVENTS)
2317     clearTouchEventHandlersAndListeners();
2318 #endif
2319     for (Node* node = firstChild(); node; node = NodeTraversal::next(*node))
2320         node->removeAllEventListeners();
2321
2322 #if ENABLE(TOUCH_EVENTS)
2323     m_touchEventTargets = nullptr;
2324 #endif
2325     m_wheelEventTargets = nullptr;
2326 }
2327
2328 void Document::suspendDeviceMotionAndOrientationUpdates()
2329 {
2330     if (m_areDeviceMotionAndOrientationUpdatesSuspended)
2331         return;
2332     m_areDeviceMotionAndOrientationUpdatesSuspended = true;
2333 #if ENABLE(DEVICE_ORIENTATION) && PLATFORM(IOS)
2334     if (m_deviceMotionController)
2335         m_deviceMotionController->suspendUpdates();
2336     if (m_deviceOrientationController)
2337         m_deviceOrientationController->suspendUpdates();
2338 #endif
2339 }
2340
2341 void Document::resumeDeviceMotionAndOrientationUpdates()
2342 {
2343     if (!m_areDeviceMotionAndOrientationUpdatesSuspended)
2344         return;
2345     m_areDeviceMotionAndOrientationUpdatesSuspended = false;
2346 #if ENABLE(DEVICE_ORIENTATION) && PLATFORM(IOS)
2347     if (m_deviceMotionController)
2348         m_deviceMotionController->resumeUpdates();
2349     if (m_deviceOrientationController)
2350         m_deviceOrientationController->resumeUpdates();
2351 #endif
2352 }
2353
2354 bool Document::shouldBypassMainWorldContentSecurityPolicy() const
2355 {
2356     JSC::CallFrame* callFrame = commonVM().topCallFrame;
2357     if (callFrame == JSC::CallFrame::noCaller())
2358         return false;
2359     DOMWrapperWorld& domWrapperWorld = currentWorld(callFrame);
2360     if (domWrapperWorld.isNormal())
2361         return false;
2362     return true;
2363 }
2364
2365 void Document::platformSuspendOrStopActiveDOMObjects()
2366 {
2367 #if PLATFORM(IOS)
2368     if (WebThreadCountOfObservedContentModifiers() > 0) {
2369         Frame* frame = this->frame();
2370         if (Page* page = frame ? frame->page() : nullptr)
2371             page->chrome().client().clearContentChangeObservers(frame);
2372     }
2373 #endif
2374 }
2375
2376 void Document::suspendActiveDOMObjects(ActiveDOMObject::ReasonForSuspension why)
2377 {
2378     ScriptExecutionContext::suspendActiveDOMObjects(why);
2379     suspendDeviceMotionAndOrientationUpdates();
2380     platformSuspendOrStopActiveDOMObjects();
2381 }
2382
2383 void Document::resumeActiveDOMObjects(ActiveDOMObject::ReasonForSuspension why)
2384 {
2385     ScriptExecutionContext::resumeActiveDOMObjects(why);
2386     resumeDeviceMotionAndOrientationUpdates();
2387     // FIXME: For iOS, do we need to add content change observers that were removed in Document::suspendActiveDOMObjects()?
2388 }
2389
2390 void Document::stopActiveDOMObjects()
2391 {
2392     ScriptExecutionContext::stopActiveDOMObjects();
2393     platformSuspendOrStopActiveDOMObjects();
2394 }
2395
2396 void Document::clearAXObjectCache()
2397 {
2398     ASSERT(&topDocument() == this);
2399     // Clear the cache member variable before calling delete because attempts
2400     // are made to access it during destruction.
2401     m_axObjectCache = nullptr;
2402 }
2403
2404 AXObjectCache* Document::existingAXObjectCacheSlow() const
2405 {
2406     ASSERT(hasEverCreatedAnAXObjectCache);
2407     Document& topDocument = this->topDocument();
2408     if (!topDocument.hasLivingRenderTree())
2409         return nullptr;
2410     return topDocument.m_axObjectCache.get();
2411 }
2412
2413 AXObjectCache* Document::axObjectCache() const
2414 {
2415     if (!AXObjectCache::accessibilityEnabled())
2416         return nullptr;
2417     
2418     // The only document that actually has a AXObjectCache is the top-level
2419     // document.  This is because we need to be able to get from any WebCoreAXObject
2420     // to any other WebCoreAXObject on the same page.  Using a single cache allows
2421     // lookups across nested webareas (i.e. multiple documents).
2422     Document& topDocument = this->topDocument();
2423
2424     // If the document has already been detached, do not make a new axObjectCache.
2425     if (!topDocument.hasLivingRenderTree())
2426         return nullptr;
2427
2428     ASSERT(&topDocument == this || !m_axObjectCache);
2429     if (!topDocument.m_axObjectCache) {
2430         topDocument.m_axObjectCache = std::make_unique<AXObjectCache>(topDocument);
2431         hasEverCreatedAnAXObjectCache = true;
2432     }
2433     return topDocument.m_axObjectCache.get();
2434 }
2435
2436 void Document::setVisuallyOrdered()
2437 {
2438     m_visuallyOrdered = true;
2439     if (renderView())
2440         renderView()->mutableStyle().setRTLOrdering(VisualOrder);
2441 }
2442
2443 Ref<DocumentParser> Document::createParser()
2444 {
2445     // FIXME: this should probably pass the frame instead
2446     return XMLDocumentParser::create(*this, view());
2447 }
2448
2449 ScriptableDocumentParser* Document::scriptableDocumentParser() const
2450 {
2451     return parser() ? parser()->asScriptableDocumentParser() : nullptr;
2452 }
2453
2454 void Document::open(Document* ownerDocument)
2455 {
2456     if (m_ignoreOpensDuringUnloadCount)
2457         return;
2458
2459     if (ownerDocument) {
2460         setURL(ownerDocument->url());
2461         setCookieURL(ownerDocument->cookieURL());
2462         setSecurityOriginPolicy(ownerDocument->securityOriginPolicy());
2463     }
2464
2465     if (m_frame) {
2466         if (ScriptableDocumentParser* parser = scriptableDocumentParser()) {
2467             if (parser->isParsing()) {
2468                 // FIXME: HTML5 doesn't tell us to check this, it might not be correct.
2469                 if (parser->isExecutingScript())
2470                     return;
2471
2472                 if (!parser->wasCreatedByScript() && parser->hasInsertionPoint())
2473                     return;
2474             }
2475         }
2476
2477         if (m_frame->loader().state() == FrameStateProvisional)
2478             m_frame->loader().stopAllLoaders();
2479     }
2480
2481     removeAllEventListeners();
2482     implicitOpen();
2483     if (ScriptableDocumentParser* parser = scriptableDocumentParser())
2484         parser->setWasCreatedByScript(true);
2485
2486     if (m_frame)
2487         m_frame->loader().didExplicitOpen();
2488 }
2489
2490 void Document::detachParser()
2491 {
2492     if (!m_parser)
2493         return;
2494     m_parser->detach();
2495     m_parser = nullptr;
2496 }
2497
2498 void Document::cancelParsing()
2499 {
2500     if (!m_parser)
2501         return;
2502
2503     // We have to clear the parser to avoid possibly triggering
2504     // the onload handler when closing as a side effect of a cancel-style
2505     // change, such as opening a new document or closing the window while
2506     // still parsing
2507     detachParser();
2508     explicitClose();
2509 }
2510
2511 void Document::implicitOpen()
2512 {
2513     removeChildren();
2514
2515     setCompatibilityMode(DocumentCompatibilityMode::NoQuirksMode);
2516
2517     cancelParsing();
2518     m_parser = createParser();
2519     setParsing(true);
2520     setReadyState(Loading);
2521 }
2522
2523 HTMLBodyElement* Document::body() const
2524 {
2525     auto* element = documentElement();
2526     if (!element)
2527         return nullptr;
2528     return childrenOfType<HTMLBodyElement>(*element).first();
2529 }
2530
2531 HTMLElement* Document::bodyOrFrameset() const
2532 {
2533     // Return the first body or frameset child of the html element.
2534     auto* element = documentElement();
2535     if (!is<HTMLHtmlElement>(element))
2536         return nullptr;
2537     for (auto& child : childrenOfType<HTMLElement>(*element)) {
2538         if (is<HTMLBodyElement>(child) || is<HTMLFrameSetElement>(child))
2539             return &child;
2540     }
2541     return nullptr;
2542 }
2543
2544 ExceptionOr<void> Document::setBodyOrFrameset(RefPtr<HTMLElement>&& newBody)
2545 {
2546     if (!is<HTMLBodyElement>(newBody.get()) && !is<HTMLFrameSetElement>(newBody.get()))
2547         return Exception { HIERARCHY_REQUEST_ERR };
2548
2549     auto* currentBody = bodyOrFrameset();
2550     if (newBody == currentBody)
2551         return { };
2552
2553     if (!m_documentElement)
2554         return Exception { HIERARCHY_REQUEST_ERR };
2555
2556     if (currentBody)
2557         return m_documentElement->replaceChild(*newBody, *currentBody);
2558     return m_documentElement->appendChild(*newBody);
2559 }
2560
2561 Location* Document::location() const
2562 {
2563     auto* window = domWindow();
2564     if (!window)
2565         return nullptr;
2566
2567     return window->location();
2568 }
2569
2570 HTMLHeadElement* Document::head()
2571 {
2572     if (auto element = documentElement())
2573         return childrenOfType<HTMLHeadElement>(*element).first();
2574     return nullptr;
2575 }
2576
2577 void Document::close()
2578 {
2579     // FIXME: We should follow the specification more closely:
2580     //        http://www.whatwg.org/specs/web-apps/current-work/#dom-document-close
2581
2582     if (!scriptableDocumentParser() || !scriptableDocumentParser()->wasCreatedByScript() || !scriptableDocumentParser()->isParsing())
2583         return;
2584
2585     explicitClose();
2586 }
2587
2588 void Document::explicitClose()
2589 {
2590     if (RefPtr<DocumentParser> parser = m_parser)
2591         parser->finish();
2592
2593     if (!m_frame) {
2594         // Because we have no frame, we don't know if all loading has completed,
2595         // so we just call implicitClose() immediately. FIXME: This might fire
2596         // the load event prematurely <http://bugs.webkit.org/show_bug.cgi?id=14568>.
2597         implicitClose();
2598         return;
2599     }
2600
2601     m_frame->loader().checkCompleted();
2602 }
2603
2604 void Document::implicitClose()
2605 {
2606     // 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.
2607     if (m_inStyleRecalc) {
2608         m_closeAfterStyleRecalc = true;
2609         return;
2610     }
2611
2612     bool wasLocationChangePending = frame() && frame()->navigationScheduler().locationChangePending();
2613     bool doload = !parsing() && m_parser && !m_processingLoadEvent && !wasLocationChangePending;
2614     
2615     if (!doload)
2616         return;
2617
2618     // Call to dispatchWindowLoadEvent can blow us from underneath.
2619     Ref<Document> protectedThis(*this);
2620
2621     m_processingLoadEvent = true;
2622
2623     ScriptableDocumentParser* parser = scriptableDocumentParser();
2624     m_wellFormed = parser && parser->wellFormed();
2625
2626     // We have to clear the parser, in case someone document.write()s from the
2627     // onLoad event handler, as in Radar 3206524.
2628     detachParser();
2629
2630     // FIXME: We kick off the icon loader when the Document is done parsing.
2631     // There are earlier opportunities we could start it:
2632     //  -When the <head> finishes parsing
2633     //  -When any new HTMLLinkElement is inserted into the document
2634     // But those add a dynamic component to the favicon that has UI 
2635     // ramifications, and we need to decide what is the Right Thing To Do(tm)
2636     Frame* f = frame();
2637     if (f) {
2638         if (f->loader().client().useIconLoadingClient()) {
2639             if (auto* documentLoader = loader())
2640                 documentLoader->startIconLoading();
2641         } else
2642             f->loader().icon().startLoader();
2643
2644         f->animation().startAnimationsIfNotSuspended(this);
2645
2646         // FIXME: We shouldn't be dispatching pending events globally on all Documents here.
2647         // For now, only do this when there is a Frame, otherwise this could cause JS reentrancy
2648         // below SVG font parsing, for example. <https://webkit.org/b/136269>
2649         ImageLoader::dispatchPendingBeforeLoadEvents();
2650         ImageLoader::dispatchPendingLoadEvents();
2651         ImageLoader::dispatchPendingErrorEvents();
2652         HTMLLinkElement::dispatchPendingLoadEvents();
2653         HTMLStyleElement::dispatchPendingLoadEvents();
2654     }
2655
2656     // To align the HTML load event and the SVGLoad event for the outermost <svg> element, fire it from
2657     // here, instead of doing it from SVGElement::finishedParsingChildren (if externalResourcesRequired="false",
2658     // which is the default, for ='true' its fired at a later time, once all external resources finished loading).
2659     if (svgExtensions())
2660         accessSVGExtensions().dispatchSVGLoadEventToOutermostSVGElements();
2661
2662     dispatchWindowLoadEvent();
2663     enqueuePageshowEvent(PageshowEventNotPersisted);
2664     if (m_pendingStateObject)
2665         enqueuePopstateEvent(WTFMove(m_pendingStateObject));
2666
2667     if (f)
2668         f->loader().dispatchOnloadEvents();
2669
2670     // An event handler may have removed the frame
2671     if (!frame()) {
2672         m_processingLoadEvent = false;
2673         return;
2674     }
2675
2676     // Make sure both the initial layout and reflow happen after the onload
2677     // fires. This will improve onload scores, and other browsers do it.
2678     // If they wanna cheat, we can too. -dwh
2679
2680     if (frame()->navigationScheduler().locationChangePending() && timeSinceDocumentCreation() < settings()->layoutInterval()) {
2681         // Just bail out. Before or during the onload we were shifted to another page.
2682         // The old i-Bench suite does this. When this happens don't bother painting or laying out.        
2683         m_processingLoadEvent = false;
2684         view()->unscheduleRelayout();
2685         return;
2686     }
2687
2688     frame()->loader().checkCallImplicitClose();
2689     
2690     // We used to force a synchronous display and flush here.  This really isn't
2691     // necessary and can in fact be actively harmful if pages are loading at a rate of > 60fps
2692     // (if your platform is syncing flushes and limiting them to 60fps).
2693     m_overMinimumLayoutThreshold = true;
2694     if (!ownerElement() || (ownerElement()->renderer() && !ownerElement()->renderer()->needsLayout())) {
2695         updateStyleIfNeeded();
2696         
2697         // Always do a layout after loading if needed.
2698         if (view() && renderView() && (!renderView()->firstChild() || renderView()->needsLayout()))
2699             view()->layout();
2700     }
2701
2702     m_processingLoadEvent = false;
2703
2704 #if PLATFORM(COCOA) || PLATFORM(WIN) || PLATFORM(GTK) || PLATFORM(EFL)
2705     if (f && hasLivingRenderTree() && AXObjectCache::accessibilityEnabled()) {
2706         // The AX cache may have been cleared at this point, but we need to make sure it contains an
2707         // AX object to send the notification to. getOrCreate will make sure that an valid AX object
2708         // exists in the cache (we ignore the return value because we don't need it here). This is 
2709         // only safe to call when a layout is not in progress, so it can not be used in postNotification.
2710         //
2711         // This notification is now called AXNewDocumentLoadComplete because there are other handlers that will
2712         // catch new AND page history loads, and that uses AXLoadComplete
2713         
2714         axObjectCache()->getOrCreate(renderView());
2715         if (this == &topDocument())
2716             axObjectCache()->postNotification(renderView(), AXObjectCache::AXNewDocumentLoadComplete);
2717         else {
2718             // AXLoadComplete can only be posted on the top document, so if it's a document
2719             // in an iframe that just finished loading, post AXLayoutComplete instead.
2720             axObjectCache()->postNotification(renderView(), AXObjectCache::AXLayoutComplete);
2721         }
2722     }
2723 #endif
2724
2725     if (svgExtensions())
2726         accessSVGExtensions().startAnimations();
2727 }
2728
2729 void Document::setParsing(bool b)
2730 {
2731     m_bParsing = b;
2732
2733     if (m_bParsing && !m_sharedObjectPool)
2734         m_sharedObjectPool = std::make_unique<DocumentSharedObjectPool>();
2735
2736     if (!m_bParsing && view() && !view()->needsLayout())
2737         view()->fireLayoutRelatedMilestonesIfNeeded();
2738 }
2739
2740 bool Document::shouldScheduleLayout()
2741 {
2742     // This function will only be called when FrameView thinks a layout is needed.
2743     // This enforces a couple extra rules.
2744     //
2745     //    (a) Only schedule a layout once the stylesheets are loaded.
2746     //    (b) Only schedule layout once we have a body element.
2747
2748     return (haveStylesheetsLoaded() && bodyOrFrameset())
2749         || (documentElement() && !is<HTMLHtmlElement>(*documentElement()));
2750 }
2751     
2752 bool Document::isLayoutTimerActive()
2753 {
2754     return view() && view()->layoutPending() && !minimumLayoutDelay();
2755 }
2756
2757 Seconds Document::minimumLayoutDelay()
2758 {
2759     if (m_overMinimumLayoutThreshold)
2760         return 0_s;
2761     
2762     auto elapsed = timeSinceDocumentCreation();
2763     m_overMinimumLayoutThreshold = elapsed > settings()->layoutInterval();
2764
2765     // We'll want to schedule the timer to fire at the minimum layout threshold.
2766     return std::max(0_s, settings()->layoutInterval() - elapsed);
2767 }
2768
2769 Seconds Document::timeSinceDocumentCreation() const
2770 {
2771     return MonotonicTime::now() - m_documentCreationTime;
2772 }
2773
2774 void Document::write(SegmentedString&& text, Document* ownerDocument)
2775 {
2776     NestingLevelIncrementer nestingLevelIncrementer(m_writeRecursionDepth);
2777
2778     m_writeRecursionIsTooDeep = (m_writeRecursionDepth > 1) && m_writeRecursionIsTooDeep;
2779     m_writeRecursionIsTooDeep = (m_writeRecursionDepth > cMaxWriteRecursionDepth) || m_writeRecursionIsTooDeep;
2780
2781     if (m_writeRecursionIsTooDeep)
2782         return;
2783
2784     bool hasInsertionPoint = m_parser && m_parser->hasInsertionPoint();
2785     if (!hasInsertionPoint && (m_ignoreOpensDuringUnloadCount || m_ignoreDestructiveWriteCount))
2786         return;
2787
2788     if (!hasInsertionPoint)
2789         open(ownerDocument);
2790
2791     ASSERT(m_parser);
2792     m_parser->insert(WTFMove(text));
2793 }
2794
2795 void Document::write(const String& text, Document* ownerDocument)
2796 {
2797     write(SegmentedString { text }, ownerDocument);
2798 }
2799
2800 void Document::writeln(const String& text, Document* ownerDocument)
2801 {
2802     SegmentedString textWithNewline { text };
2803     textWithNewline.append(String { "\n" });
2804     write(WTFMove(textWithNewline), ownerDocument);
2805 }
2806
2807 std::chrono::milliseconds Document::minimumTimerInterval() const
2808 {
2809     auto* page = this->page();
2810     if (!page)
2811         return ScriptExecutionContext::minimumTimerInterval();
2812     return page->settings().minimumDOMTimerInterval();
2813 }
2814
2815 void Document::setTimerThrottlingEnabled(bool shouldThrottle)
2816 {
2817     if (m_isTimerThrottlingEnabled == shouldThrottle)
2818         return;
2819
2820     m_isTimerThrottlingEnabled = shouldThrottle;
2821     didChangeTimerAlignmentInterval();
2822 }
2823
2824 std::chrono::milliseconds Document::timerAlignmentInterval(bool hasReachedMaxNestingLevel) const
2825 {
2826     auto alignmentInterval = ScriptExecutionContext::timerAlignmentInterval(hasReachedMaxNestingLevel);
2827
2828     // Apply Document-level DOMTimer throttling only if timers have reached their maximum nesting level as the Page may still be visible.
2829     if (m_isTimerThrottlingEnabled && hasReachedMaxNestingLevel)
2830         alignmentInterval = std::max(alignmentInterval, DOMTimer::hiddenPageAlignmentInterval());
2831
2832     if (Page* page = this->page())
2833         alignmentInterval = std::max(alignmentInterval, page->domTimerAlignmentInterval());
2834
2835     return alignmentInterval;
2836 }
2837
2838 EventTarget* Document::errorEventTarget()
2839 {
2840     return m_domWindow.get();
2841 }
2842
2843 void Document::logExceptionToConsole(const String& errorMessage, const String& sourceURL, int lineNumber, int columnNumber, RefPtr<Inspector::ScriptCallStack>&& callStack)
2844 {
2845     addMessage(MessageSource::JS, MessageLevel::Error, errorMessage, sourceURL, lineNumber, columnNumber, WTFMove(callStack));
2846 }
2847
2848 void Document::setURL(const URL& url)
2849 {
2850     const URL& newURL = url.isEmpty() ? blankURL() : url;
2851     if (newURL == m_url)
2852         return;
2853
2854     m_url = newURL;
2855     m_documentURI = m_url.string();
2856     updateBaseURL();
2857 }
2858
2859 void Document::updateBaseURL()
2860 {
2861     URL oldBaseURL = m_baseURL;
2862     // DOM 3 Core: When the Document supports the feature "HTML" [DOM Level 2 HTML], the base URI is computed using
2863     // first the value of the href attribute of the HTML BASE element if any, and the value of the documentURI attribute
2864     // from the Document interface otherwise.
2865     if (!m_baseElementURL.isEmpty())
2866         m_baseURL = m_baseElementURL;
2867     else if (!m_baseURLOverride.isEmpty())
2868         m_baseURL = m_baseURLOverride;
2869     else {
2870         // The documentURI attribute is read-only from JavaScript, but writable from Objective C, so we need to retain
2871         // this fallback behavior. We use a null base URL, since the documentURI attribute is an arbitrary string
2872         // and DOM 3 Core does not specify how it should be resolved.
2873         m_baseURL = URL(ParsedURLString, documentURI());
2874     }
2875
2876     clearSelectorQueryCache();
2877
2878     if (!m_baseURL.isValid())
2879         m_baseURL = URL();
2880
2881     if (!equalIgnoringFragmentIdentifier(oldBaseURL, m_baseURL)) {
2882         // Base URL change changes any relative visited links.
2883         // 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.
2884         for (auto& anchor : descendantsOfType<HTMLAnchorElement>(*this))
2885             anchor.invalidateCachedVisitedLinkHash();
2886     }
2887 }
2888
2889 void Document::setBaseURLOverride(const URL& url)
2890 {
2891     m_baseURLOverride = url;
2892     updateBaseURL();
2893 }
2894
2895 void Document::processBaseElement()
2896 {
2897     // Find the first href attribute in a base element and the first target attribute in a base element.
2898     const AtomicString* href = nullptr;
2899     const AtomicString* target = nullptr;
2900     auto baseDescendants = descendantsOfType<HTMLBaseElement>(*this);
2901     for (auto& base : baseDescendants) {
2902         if (!href) {
2903             const AtomicString& value = base.attributeWithoutSynchronization(hrefAttr);
2904             if (!value.isNull()) {
2905                 href = &value;
2906                 if (target)
2907                     break;
2908             }
2909         }
2910         if (!target) {
2911             const AtomicString& value = base.attributeWithoutSynchronization(targetAttr);
2912             if (!value.isNull()) {
2913                 target = &value;
2914                 if (href)
2915                     break;
2916             }
2917         }
2918     }
2919
2920     // FIXME: Since this doesn't share code with completeURL it may not handle encodings correctly.
2921     URL baseElementURL;
2922     if (href) {
2923         String strippedHref = stripLeadingAndTrailingHTMLSpaces(*href);
2924         if (!strippedHref.isEmpty())
2925             baseElementURL = URL(url(), strippedHref);
2926     }
2927     if (m_baseElementURL != baseElementURL && contentSecurityPolicy()->allowBaseURI(baseElementURL)) {
2928         m_baseElementURL = baseElementURL;
2929         updateBaseURL();
2930     }
2931
2932     m_baseTarget = target ? *target : nullAtom;
2933 }
2934
2935 String Document::userAgent(const URL& url) const
2936 {
2937     return frame() ? frame()->loader().userAgent(url) : String();
2938 }
2939
2940 void Document::disableEval(const String& errorMessage)
2941 {
2942     if (!frame())
2943         return;
2944
2945     frame()->script().disableEval(errorMessage);
2946 }
2947
2948 #if ENABLE(INDEXED_DATABASE)
2949
2950 IDBClient::IDBConnectionProxy* Document::idbConnectionProxy()
2951 {
2952     if (!m_idbConnectionProxy) {
2953         Page* currentPage = page();
2954         if (!currentPage)
2955             return nullptr;
2956         m_idbConnectionProxy = &currentPage->idbConnection().proxy();
2957     }
2958     return m_idbConnectionProxy.get();
2959 }
2960
2961 #endif
2962
2963 #if ENABLE(WEB_SOCKETS)
2964
2965 SocketProvider* Document::socketProvider()
2966 {
2967     return m_socketProvider.get();
2968 }
2969
2970 #endif
2971     
2972 bool Document::canNavigate(Frame* targetFrame)
2973 {
2974     if (!m_frame)
2975         return false;
2976
2977     if (pageCacheState() != Document::NotInPageCache)
2978         return false;
2979
2980     // FIXME: We shouldn't call this function without a target frame, but
2981     // fast/forms/submit-to-blank-multiple-times.html depends on this function
2982     // returning true when supplied with a 0 targetFrame.
2983     if (!targetFrame)
2984         return true;
2985
2986     // Frame-busting is generally allowed, but blocked for sandboxed frames lacking the 'allow-top-navigation' flag.
2987     if (!isSandboxed(SandboxTopNavigation) && targetFrame == &m_frame->tree().top())
2988         return true;
2989
2990     if (isSandboxed(SandboxNavigation)) {
2991         if (targetFrame->tree().isDescendantOf(m_frame))
2992             return true;
2993
2994         const char* reason = "The frame attempting navigation is sandboxed, and is therefore disallowed from navigating its ancestors.";
2995         if (isSandboxed(SandboxTopNavigation) && targetFrame == &m_frame->tree().top())
2996             reason = "The frame attempting navigation of the top-level window is sandboxed, but the 'allow-top-navigation' flag is not set.";
2997
2998         printNavigationErrorMessage(targetFrame, url(), reason);
2999         return false;
3000     }
3001
3002     // This is the normal case. A document can navigate its decendant frames,
3003     // or, more generally, a document can navigate a frame if the document is
3004     // in the same origin as any of that frame's ancestors (in the frame
3005     // hierarchy).
3006     //
3007     // See http://www.adambarth.com/papers/2008/barth-jackson-mitchell.pdf for
3008     // historical information about this security check.
3009     if (canAccessAncestor(securityOrigin(), targetFrame))
3010         return true;
3011
3012     // Top-level frames are easier to navigate than other frames because they
3013     // display their URLs in the address bar (in most browsers). However, there
3014     // are still some restrictions on navigation to avoid nuisance attacks.
3015     // Specifically, a document can navigate a top-level frame if that frame
3016     // opened the document or if the document is the same-origin with any of
3017     // the top-level frame's opener's ancestors (in the frame hierarchy).
3018     //
3019     // In both of these cases, the document performing the navigation is in
3020     // some way related to the frame being navigate (e.g., by the "opener"
3021     // and/or "parent" relation). Requiring some sort of relation prevents a
3022     // document from navigating arbitrary, unrelated top-level frames.
3023     if (!targetFrame->tree().parent()) {
3024         if (targetFrame == m_frame->loader().opener())
3025             return true;
3026
3027         if (canAccessAncestor(securityOrigin(), targetFrame->loader().opener()))
3028             return true;
3029     }
3030
3031     printNavigationErrorMessage(targetFrame, url(), "The frame attempting navigation is neither same-origin with the target, nor is it the target's parent or opener.");
3032     return false;
3033 }
3034
3035 Frame* Document::findUnsafeParentScrollPropagationBoundary()
3036 {
3037     Frame* currentFrame = m_frame;
3038     if (!currentFrame)
3039         return nullptr;
3040
3041     Frame* ancestorFrame = currentFrame->tree().parent();
3042
3043     while (ancestorFrame) {
3044         if (!ancestorFrame->document()->securityOrigin().canAccess(securityOrigin()))
3045             return currentFrame;
3046         currentFrame = ancestorFrame;
3047         ancestorFrame = ancestorFrame->tree().parent();
3048     }
3049     return nullptr;
3050 }
3051
3052 void Document::didRemoveAllPendingStylesheet()
3053 {
3054     m_needsNotifyRemoveAllPendingStylesheet = false;
3055
3056     if (m_pendingSheetLayout == DidLayoutWithPendingSheets) {
3057         m_pendingSheetLayout = IgnoreLayoutWithPendingSheets;
3058         if (renderView())
3059             renderView()->repaintViewAndCompositedLayers();
3060     }
3061
3062     if (ScriptableDocumentParser* parser = scriptableDocumentParser())
3063         parser->executeScriptsWaitingForStylesheets();
3064
3065     if (m_gotoAnchorNeededAfterStylesheetsLoad && view())
3066         view()->scrollToFragment(m_url);
3067 }
3068
3069 bool Document::usesStyleBasedEditability() const
3070 {
3071     if (m_hasElementUsingStyleBasedEditability)
3072         return true;
3073
3074     ASSERT(!m_renderView || !m_renderView->frameView().isPainting());
3075     ASSERT(!m_inStyleRecalc);
3076
3077     auto& styleScope = const_cast<Style::Scope&>(this->styleScope());
3078     styleScope.flushPendingUpdate();
3079     return styleScope.usesStyleBasedEditability();
3080 }
3081
3082 void Document::setHasElementUsingStyleBasedEditability()
3083 {
3084     m_hasElementUsingStyleBasedEditability = true;
3085 }
3086
3087 void Document::processHttpEquiv(const String& equiv, const String& content, bool isInDocumentHead)
3088 {
3089     ASSERT(!equiv.isNull());
3090     ASSERT(!content.isNull());
3091
3092     HttpEquivPolicy policy = httpEquivPolicy();
3093     if (policy != HttpEquivPolicy::Enabled) {
3094         String reason;
3095         switch (policy) {
3096         case HttpEquivPolicy::Enabled:
3097             ASSERT_NOT_REACHED();
3098             break;
3099         case HttpEquivPolicy::DisabledBySettings:
3100             reason = "by the embedder.";
3101             break;
3102         case HttpEquivPolicy::DisabledByContentDispositionAttachmentSandbox:
3103             reason = "for documents with Content-Disposition: attachment.";
3104             break;
3105         }
3106         String message = "http-equiv '" + equiv + "' is disabled " + reason;
3107         addConsoleMessage(MessageSource::Security, MessageLevel::Error, message);
3108         return;
3109     }
3110
3111     Frame* frame = this->frame();
3112
3113     HTTPHeaderName headerName;
3114     if (!findHTTPHeaderName(equiv, headerName))
3115         return;
3116
3117     switch (headerName) {
3118     case HTTPHeaderName::DefaultStyle:
3119         // The preferred style set has been overridden as per section
3120         // 14.3.2 of the HTML4.0 specification.  We need to update the
3121         // sheet used variable and then update our style selector.
3122         // For more info, see the test at:
3123         // http://www.hixie.ch/tests/evil/css/import/main/preferred.html
3124         // -dwh
3125         styleScope().setSelectedStylesheetSetName(content);
3126         styleScope().setPreferredStylesheetSetName(content);
3127         break;
3128
3129     case HTTPHeaderName::Refresh: {
3130         double delay;
3131         String urlString;
3132         if (frame && parseMetaHTTPEquivRefresh(content, delay, urlString)) {
3133             URL completedURL;
3134             if (urlString.isEmpty())
3135                 completedURL = m_url;
3136             else
3137                 completedURL = completeURL(urlString);
3138             if (!protocolIsJavaScript(completedURL))
3139                 frame->navigationScheduler().scheduleRedirect(*this, delay, completedURL);
3140             else {
3141                 String message = "Refused to refresh " + m_url.stringCenterEllipsizedToLength() + " to a javascript: URL";
3142                 addConsoleMessage(MessageSource::Security, MessageLevel::Error, message);
3143             }
3144         }
3145
3146         break;
3147     }
3148
3149     case HTTPHeaderName::SetCookie:
3150         // FIXME: make setCookie work on XML documents too; e.g. in case of <html:meta .....>
3151         if (is<HTMLDocument>(*this)) {
3152             // Exception (for sandboxed documents) ignored.
3153             downcast<HTMLDocument>(*this).setCookie(content);
3154         }
3155         break;
3156
3157     case HTTPHeaderName::ContentLanguage:
3158         setContentLanguage(content);
3159         break;
3160
3161     case HTTPHeaderName::XDNSPrefetchControl:
3162         parseDNSPrefetchControlHeader(content);
3163         break;
3164
3165     case HTTPHeaderName::XFrameOptions:
3166         if (frame) {
3167             FrameLoader& frameLoader = frame->loader();
3168             unsigned long requestIdentifier = 0;
3169             if (frameLoader.activeDocumentLoader() && frameLoader.activeDocumentLoader()->mainResourceLoader())
3170                 requestIdentifier = frameLoader.activeDocumentLoader()->mainResourceLoader()->identifier();
3171
3172             String message = "The X-Frame-Option '" + content + "' supplied in a <meta> element was ignored. X-Frame-Options may only be provided by an HTTP header sent with the document.";
3173             addConsoleMessage(MessageSource::Security, MessageLevel::Error, message, requestIdentifier);
3174         }
3175         break;
3176
3177     case HTTPHeaderName::ContentSecurityPolicy:
3178         if (isInDocumentHead)
3179             contentSecurityPolicy()->didReceiveHeader(content, ContentSecurityPolicyHeaderType::Enforce, ContentSecurityPolicy::PolicyFrom::HTTPEquivMeta);
3180         break;
3181
3182     case HTTPHeaderName::XWebKitCSP:
3183         if (isInDocumentHead)
3184             contentSecurityPolicy()->didReceiveHeader(content, ContentSecurityPolicyHeaderType::PrefixedEnforce, ContentSecurityPolicy::PolicyFrom::HTTPEquivMeta);
3185         break;
3186
3187     default:
3188         break;
3189     }
3190 }
3191
3192 void Document::processViewport(const String& features, ViewportArguments::Type origin)
3193 {
3194     ASSERT(!features.isNull());
3195
3196     if (origin < m_viewportArguments.type)
3197         return;
3198
3199     m_viewportArguments = ViewportArguments(origin);
3200
3201     processFeaturesString(features, [this](StringView key, StringView value) {
3202         setViewportFeature(m_viewportArguments, *this, key, value);
3203     });
3204
3205     updateViewportArguments();
3206 }
3207
3208 void Document::updateViewportArguments()
3209 {
3210     if (page() && frame()->isMainFrame()) {
3211 #ifndef NDEBUG
3212         m_didDispatchViewportPropertiesChanged = true;
3213 #endif
3214         page()->chrome().dispatchViewportPropertiesDidChange(m_viewportArguments);
3215 #if PLATFORM(IOS)
3216         page()->chrome().didReceiveDocType(frame());
3217 #endif
3218     }
3219 }
3220
3221 #if PLATFORM(IOS)
3222
3223 void Document::processFormatDetection(const String& features)
3224 {
3225     // FIXME: Find a better place for this function.
3226     processFeaturesString(features, [this](StringView key, StringView value) {
3227         if (equalLettersIgnoringASCIICase(key, "telephone") && equalLettersIgnoringASCIICase(value, "no"))
3228             setIsTelephoneNumberParsingAllowed(false);
3229     });
3230 }
3231
3232 void Document::processWebAppOrientations()
3233 {
3234     if (Page* page = this->page())
3235         page->chrome().client().webAppOrientationsUpdated();
3236 }
3237
3238 #endif
3239
3240 void Document::processReferrerPolicy(const String& policy)
3241 {
3242     ASSERT(!policy.isNull());
3243
3244     // Documents in a Content-Disposition: attachment sandbox should never send a Referer header,
3245     // even if the document has a meta tag saying otherwise.
3246     if (shouldEnforceContentDispositionAttachmentSandbox())
3247         return;
3248
3249 #if USE(QUICK_LOOK)
3250     if (shouldEnforceQuickLookSandbox())
3251         return;
3252 #endif
3253
3254     // Note that we're supporting both the standard and legacy keywords for referrer
3255     // policies, as defined by http://www.w3.org/TR/referrer-policy/#referrer-policy-delivery-meta
3256     if (equalLettersIgnoringASCIICase(policy, "no-referrer") || equalLettersIgnoringASCIICase(policy, "never"))
3257         setReferrerPolicy(ReferrerPolicy::Never);
3258     else if (equalLettersIgnoringASCIICase(policy, "unsafe-url") || equalLettersIgnoringASCIICase(policy, "always"))
3259         setReferrerPolicy(ReferrerPolicy::Always);
3260     else if (equalLettersIgnoringASCIICase(policy, "origin"))
3261         setReferrerPolicy(ReferrerPolicy::Origin);
3262     else if (equalLettersIgnoringASCIICase(policy, "no-referrer-when-downgrade") || equalLettersIgnoringASCIICase(policy, "default"))
3263         setReferrerPolicy(ReferrerPolicy::Default);
3264     else {
3265         addConsoleMessage(MessageSource::Rendering, MessageLevel::Error, "Failed to set referrer policy: The value '" + policy + "' is not one of 'no-referrer', 'origin', 'no-referrer-when-downgrade', or 'unsafe-url'. Defaulting to 'no-referrer'.");
3266         setReferrerPolicy(ReferrerPolicy::Never);
3267     }
3268 }
3269
3270 MouseEventWithHitTestResults Document::prepareMouseEvent(const HitTestRequest& request, const LayoutPoint& documentPoint, const PlatformMouseEvent& event)
3271 {
3272     if (!hasLivingRenderTree())
3273         return MouseEventWithHitTestResults(event, HitTestResult(LayoutPoint()));
3274
3275     HitTestResult result(documentPoint);
3276     renderView()->hitTest(request, result);
3277
3278     if (!request.readOnly())
3279         updateHoverActiveState(request, result.targetElement());
3280
3281     return MouseEventWithHitTestResults(event, result);
3282 }
3283
3284 // DOM Section 1.1.1
3285 bool Document::childTypeAllowed(NodeType type) const
3286 {
3287     switch (type) {
3288     case ATTRIBUTE_NODE:
3289     case CDATA_SECTION_NODE:
3290     case DOCUMENT_FRAGMENT_NODE:
3291     case DOCUMENT_NODE:
3292     case TEXT_NODE:
3293         return false;
3294     case COMMENT_NODE:
3295     case PROCESSING_INSTRUCTION_NODE:
3296         return true;
3297     case DOCUMENT_TYPE_NODE:
3298     case ELEMENT_NODE:
3299         // Documents may contain no more than one of each of these.
3300         // (One Element and one DocumentType.)
3301         for (Node* c = firstChild(); c; c = c->nextSibling())
3302             if (c->nodeType() == type)
3303                 return false;
3304         return true;
3305     }
3306     return false;
3307 }
3308
3309 bool Document::canAcceptChild(const Node& newChild, const Node* refChild, AcceptChildOperation operation) const
3310 {
3311     if (operation == AcceptChildOperation::Replace && refChild->nodeType() == newChild.nodeType())
3312         return true;
3313
3314     switch (newChild.nodeType()) {
3315     case ATTRIBUTE_NODE:
3316     case CDATA_SECTION_NODE:
3317     case DOCUMENT_NODE:
3318     case TEXT_NODE:
3319         return false;
3320     case COMMENT_NODE:
3321     case PROCESSING_INSTRUCTION_NODE:
3322         return true;
3323     case DOCUMENT_FRAGMENT_NODE: {
3324         bool hasSeenElementChild = false;
3325         for (auto* node = downcast<DocumentFragment>(newChild).firstChild(); node; node = node->nextSibling()) {
3326             if (is<Element>(*node)) {
3327                 if (hasSeenElementChild)
3328                     return false;
3329                 hasSeenElementChild = true;
3330             }
3331             if (!canAcceptChild(*node, refChild, operation))
3332                 return false;
3333         }
3334         break;
3335     }
3336     case DOCUMENT_TYPE_NODE: {
3337         auto* existingDocType = childrenOfType<DocumentType>(*this).first();
3338         if (operation == AcceptChildOperation::Replace) {
3339             //  parent has a doctype child that is not child, or an element is preceding child.
3340             if (existingDocType && existingDocType != refChild)
3341                 return false;
3342             if (refChild->previousElementSibling())
3343                 return false;
3344         } else {
3345             ASSERT(operation == AcceptChildOperation::InsertOrAdd);
3346             if (existingDocType)
3347                 return false;
3348             if ((refChild && refChild->previousElementSibling()) || (!refChild && firstElementChild()))
3349                 return false;
3350         }
3351         break;
3352     }
3353     case ELEMENT_NODE: {
3354         auto* existingElementChild = firstElementChild();
3355         if (operation == AcceptChildOperation::Replace) {
3356             if (existingElementChild && existingElementChild != refChild)
3357                 return false;
3358             for (auto* child = refChild->nextSibling(); child; child = child->nextSibling()) {
3359                 if (is<DocumentType>(*child))
3360                     return false;
3361             }
3362         } else {
3363             ASSERT(operation == AcceptChildOperation::InsertOrAdd);
3364             if (existingElementChild)
3365                 return false;
3366             for (auto* child = refChild; child; child = child->nextSibling()) {
3367                 if (is<DocumentType>(*child))
3368                     return false;
3369             }
3370         }
3371         break;
3372     }
3373     }
3374     return true;
3375 }
3376
3377 Ref<Node> Document::cloneNodeInternal(Document&, CloningOperation type)
3378 {
3379     Ref<Document> clone = cloneDocumentWithoutChildren();
3380     clone->cloneDataFromDocument(*this);
3381     switch (type) {
3382     case CloningOperation::OnlySelf:
3383     case CloningOperation::SelfWithTemplateContent:
3384         break;
3385     case CloningOperation::Everything:
3386         cloneChildNodes(clone);
3387         break;
3388     }
3389     return WTFMove(clone);
3390 }
3391
3392 Ref<Document> Document::cloneDocumentWithoutChildren() const
3393 {
3394     if (isXMLDocument()) {
3395         if (isXHTMLDocument())
3396             return XMLDocument::createXHTML(nullptr, url());
3397         return XMLDocument::create(nullptr, url());
3398     }
3399     return create(nullptr, url());
3400 }
3401
3402 void Document::cloneDataFromDocument(const Document& other)
3403 {
3404     ASSERT(m_url == other.url());
3405     m_baseURL = other.baseURL();
3406     m_baseURLOverride = other.baseURLOverride();
3407     m_documentURI = other.documentURI();
3408
3409     setCompatibilityMode(other.m_compatibilityMode);
3410     setContextDocument(other.contextDocument());
3411     setSecurityOriginPolicy(other.securityOriginPolicy());
3412     overrideMIMEType(other.contentType());
3413     setDecoder(other.decoder());
3414 }
3415
3416 StyleSheetList& Document::styleSheets()
3417 {
3418     if (!m_styleSheetList)
3419         m_styleSheetList = StyleSheetList::create(this);
3420     return *m_styleSheetList;
3421 }
3422
3423 String Document::preferredStylesheetSet() const
3424 {
3425     return styleScope().preferredStylesheetSetName();
3426 }
3427
3428 String Document::selectedStylesheetSet() const
3429 {
3430     return styleScope().selectedStylesheetSetName();
3431 }
3432
3433 void Document::setSelectedStylesheetSet(const String& aString)
3434 {
3435     styleScope().setSelectedStylesheetSetName(aString);
3436 }
3437
3438 void Document::evaluateMediaQueryList()
3439 {
3440     if (m_mediaQueryMatcher)
3441         m_mediaQueryMatcher->styleResolverChanged();
3442     
3443     checkViewportDependentPictures();
3444 }
3445
3446 void Document::checkViewportDependentPictures()
3447 {
3448     Vector<HTMLPictureElement*, 16> changedPictures;
3449     HashSet<HTMLPictureElement*>::iterator end = m_viewportDependentPictures.end();
3450     for (HashSet<HTMLPictureElement*>::iterator it = m_viewportDependentPictures.begin(); it != end; ++it) {
3451         if ((*it)->viewportChangeAffectedPicture())
3452             changedPictures.append(*it);
3453     }
3454     for (auto* picture : changedPictures)
3455         picture->sourcesChanged();
3456 }
3457
3458 void Document::updateViewportUnitsOnResize()
3459 {
3460     if (!hasStyleWithViewportUnits())
3461         return;
3462
3463     styleScope().resolver().clearCachedPropertiesAffectedByViewportUnits();
3464
3465     // FIXME: Ideally, we should save the list of elements that have viewport units and only iterate over those.
3466     for (Element* element = ElementTraversal::firstWithin(rootNode()); element; element = ElementTraversal::nextIncludingPseudo(*element)) {
3467         auto* renderer = element->renderer();
3468         if (renderer && renderer->style().hasViewportUnits())
3469             element->invalidateStyle();
3470     }
3471 }
3472
3473 void Document::addAudioProducer(MediaProducer* audioProducer)
3474 {
3475     m_audioProducers.add(audioProducer);
3476     updateIsPlayingMedia();
3477 }
3478
3479 void Document::removeAudioProducer(MediaProducer* audioProducer)
3480 {
3481     m_audioProducers.remove(audioProducer);
3482     updateIsPlayingMedia();
3483 }
3484
3485 void Document::updateIsPlayingMedia(uint64_t sourceElementID)
3486 {
3487     MediaProducer::MediaStateFlags state = MediaProducer::IsNotPlaying;
3488     for (auto* audioProducer : m_audioProducers)
3489         state |= audioProducer->mediaState();
3490
3491 #if ENABLE(MEDIA_SESSION)
3492     if (HTMLMediaElement* sourceElement = HTMLMediaElement::elementWithID(sourceElementID)) {
3493         if (sourceElement->isPlaying())
3494             state |= MediaProducer::IsSourceElementPlaying;
3495
3496         if (auto* session = sourceElement->session()) {
3497             if (auto* controls = session->controls()) {
3498                 if (controls->previousTrackEnabled())
3499                     state |= MediaProducer::IsPreviousTrackControlEnabled;
3500                 if (controls->nextTrackEnabled())
3501                     state |= MediaProducer::IsNextTrackControlEnabled;
3502             }
3503         }
3504     }
3505 #endif
3506
3507     if (state == m_mediaState)
3508         return;
3509
3510     m_mediaState = state;
3511
3512     if (page())
3513         page()->updateIsPlayingMedia(sourceElementID);
3514 }
3515
3516 void Document::pageMutedStateDidChange()
3517 {
3518     for (auto* audioProducer : m_audioProducers)
3519         audioProducer->pageMutedStateDidChange();
3520 }
3521
3522 static bool isNodeInSubtree(Node& node, Node& container, bool amongChildrenOnly)
3523 {
3524     if (amongChildrenOnly)
3525         return node.isDescendantOf(container);
3526     else
3527         return &node == &container || node.isDescendantOf(container);
3528 }
3529
3530 void Document::removeFocusedNodeOfSubtree(Node& node, bool amongChildrenOnly)
3531 {
3532     if (!m_focusedElement || pageCacheState() != NotInPageCache) // If the document is in the page cache, then we don't need to clear out the focused node.
3533         return;
3534
3535     Element* focusedElement = node.treeScope().focusedElementInScope();
3536     if (!focusedElement)
3537         return;
3538     
3539     if (isNodeInSubtree(*focusedElement, node, amongChildrenOnly)) {
3540         setFocusedElement(nullptr, FocusDirectionNone, FocusRemovalEventsMode::DoNotDispatch);
3541         // Set the focus navigation starting node to the previous focused element so that
3542         // we can fallback to the siblings or parent node for the next search.
3543         // Also we need to call removeFocusNavigationNodeOfSubtree after this function because
3544         // setFocusedElement(nullptr) will reset m_focusNavigationStartingNode.
3545         setFocusNavigationStartingNode(focusedElement);
3546     }
3547 }
3548
3549 void Document::hoveredElementDidDetach(Element* element)
3550 {
3551     if (!m_hoveredElement || element != m_hoveredElement)
3552         return;
3553
3554     m_hoveredElement = element->parentElement();
3555     while (m_hoveredElement && !m_hoveredElement->renderer())
3556         m_hoveredElement = m_hoveredElement->parentElement();
3557     if (frame())
3558         frame()->eventHandler().scheduleHoverStateUpdate();
3559 }
3560
3561 void Document::elementInActiveChainDidDetach(Element* element)
3562 {
3563     if (!m_activeElement || element != m_activeElement)
3564         return;
3565
3566     m_activeElement = element->parentElement();
3567     while (m_activeElement && !m_activeElement->renderer())
3568         m_activeElement = m_activeElement->parentElement();
3569 }
3570
3571 #if ENABLE(DASHBOARD_SUPPORT)
3572
3573 const Vector<AnnotatedRegionValue>& Document::annotatedRegions() const
3574 {
3575     return m_annotatedRegions;
3576 }
3577
3578 void Document::setAnnotatedRegions(const Vector<AnnotatedRegionValue>& regions)
3579 {
3580     m_annotatedRegions = regions;
3581     setAnnotatedRegionsDirty(false);
3582 }
3583
3584 #endif
3585
3586 bool Document::setFocusedElement(Element* element, FocusDirection direction, FocusRemovalEventsMode eventsMode)
3587 {
3588     RefPtr<Element> newFocusedElement = element;
3589     // Make sure newFocusedElement is actually in this document
3590     if (newFocusedElement && (&newFocusedElement->document() != this))
3591         return true;
3592
3593     if (m_focusedElement == newFocusedElement)
3594         return true;
3595
3596     if (pageCacheState() != NotInPageCache)
3597         return false;
3598
3599     bool focusChangeBlocked = false;
3600     RefPtr<Element> oldFocusedElement = WTFMove(m_focusedElement);
3601
3602     // Remove focus from the existing focus node (if any)
3603     if (oldFocusedElement) {
3604         oldFocusedElement->setFocus(false);
3605         setFocusNavigationStartingNode(nullptr);
3606
3607         if (eventsMode == FocusRemovalEventsMode::Dispatch) {
3608             // Dispatch a change event for form control elements that have been edited.
3609             if (is<HTMLFormControlElement>(*oldFocusedElement)) {
3610                 HTMLFormControlElement& formControlElement = downcast<HTMLFormControlElement>(*oldFocusedElement);
3611                 if (formControlElement.wasChangedSinceLastFormControlChangeEvent())
3612                     formControlElement.dispatchFormControlChangeEvent();
3613             }
3614
3615             // Dispatch the blur event and let the node do any other blur related activities (important for text fields)
3616             oldFocusedElement->dispatchBlurEvent(newFocusedElement.copyRef());
3617
3618             if (m_focusedElement) {
3619                 // handler shifted focus
3620                 focusChangeBlocked = true;
3621                 newFocusedElement = nullptr;
3622             }
3623
3624             oldFocusedElement->dispatchFocusOutEvent(eventNames().focusoutEvent, newFocusedElement.copyRef()); // DOM level 3 name for the bubbling blur event.
3625             // FIXME: We should remove firing DOMFocusOutEvent event when we are sure no content depends
3626             // on it, probably when <rdar://problem/8503958> is resolved.
3627             oldFocusedElement->dispatchFocusOutEvent(eventNames().DOMFocusOutEvent, newFocusedElement.copyRef()); // DOM level 2 name for compatibility.
3628
3629             if (m_focusedElement) {
3630                 // handler shifted focus
3631                 focusChangeBlocked = true;
3632                 newFocusedElement = nullptr;
3633             }
3634         } else {
3635             // Match the order in HTMLTextFormControlElement::dispatchBlurEvent.
3636             if (is<HTMLInputElement>(*oldFocusedElement))
3637                 downcast<HTMLInputElement>(*oldFocusedElement).endEditing();
3638             if (page())
3639                 page()->chrome().client().elementDidBlur(oldFocusedElement.get());
3640             ASSERT(!m_focusedElement);
3641         }
3642
3643         if (oldFocusedElement->isRootEditableElement())
3644             frame()->editor().didEndEditing();