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