668564d4a7c862db3f419273ed8d4733ff1b01f0
[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 "Dictionary.h"
51 #include "DocumentLoader.h"
52 #include "DocumentMarkerController.h"
53 #include "DocumentSharedObjectPool.h"
54 #include "DocumentType.h"
55 #include "Editor.h"
56 #include "ElementIterator.h"
57 #include "EntityReference.h"
58 #include "EventFactory.h"
59 #include "EventHandler.h"
60 #include "FocusController.h"
61 #include "FontLoader.h"
62 #include "FormController.h"
63 #include "FrameLoader.h"
64 #include "FrameLoaderClient.h"
65 #include "FrameView.h"
66 #include "HTMLAllCollection.h"
67 #include "HTMLAnchorElement.h"
68 #include "HTMLBaseElement.h"
69 #include "HTMLBodyElement.h"
70 #include "HTMLCanvasElement.h"
71 #include "HTMLCollection.h"
72 #include "HTMLDocument.h"
73 #include "HTMLElementFactory.h"
74 #include "HTMLFormControlElement.h"
75 #include "HTMLFrameOwnerElement.h"
76 #include "HTMLFrameSetElement.h"
77 #include "HTMLHeadElement.h"
78 #include "HTMLIFrameElement.h"
79 #include "HTMLImageElement.h"
80 #include "HTMLLinkElement.h"
81 #include "HTMLMediaElement.h"
82 #include "HTMLNameCollection.h"
83 #include "HTMLParserIdioms.h"
84 #include "HTMLPlugInElement.h"
85 #include "HTMLScriptElement.h"
86 #include "HTMLStyleElement.h"
87 #include "HTMLTitleElement.h"
88 #include "HTTPHeaderNames.h"
89 #include "HTTPParsers.h"
90 #include "HashChangeEvent.h"
91 #include "History.h"
92 #include "HitTestResult.h"
93 #include "IconController.h"
94 #include "ImageLoader.h"
95 #include "InspectorInstrumentation.h"
96 #include "JSLazyEventListener.h"
97 #include "Language.h"
98 #include "LoaderStrategy.h"
99 #include "Logging.h"
100 #include "MainFrame.h"
101 #include "MediaCanStartListener.h"
102 #include "MediaQueryList.h"
103 #include "MediaQueryMatcher.h"
104 #include "MouseEventWithHitTestResults.h"
105 #include "NameNodeList.h"
106 #include "NestingLevelIncrementer.h"
107 #include "NodeIterator.h"
108 #include "NodeRareData.h"
109 #include "NodeWithIndex.h"
110 #include "PageConsoleClient.h"
111 #include "PageGroup.h"
112 #include "PageTransitionEvent.h"
113 #include "PlatformLocale.h"
114 #include "PlatformStrategies.h"
115 #include "PlugInsResources.h"
116 #include "PluginDocument.h"
117 #include "PointerLockController.h"
118 #include "PopStateEvent.h"
119 #include "ProcessingInstruction.h"
120 #include "RenderChildIterator.h"
121 #include "RenderLayerCompositor.h"
122 #include "RenderView.h"
123 #include "RenderWidget.h"
124 #include "ResourceLoadScheduler.h"
125 #include "ResourceLoader.h"
126 #include "RuntimeEnabledFeatures.h"
127 #include "SVGDocumentExtensions.h"
128 #include "SVGElement.h"
129 #include "SVGElementFactory.h"
130 #include "SVGNames.h"
131 #include "SchemeRegistry.h"
132 #include "ScopedEventQueue.h"
133 #include "ScriptController.h"
134 #include "ScriptRunner.h"
135 #include "ScriptSourceCode.h"
136 #include "ScrollingCoordinator.h"
137 #include "SecurityOrigin.h"
138 #include "SecurityOriginPolicy.h"
139 #include "SecurityPolicy.h"
140 #include "SegmentedString.h"
141 #include "SelectorQuery.h"
142 #include "Settings.h"
143 #include "ShadowRoot.h"
144 #include "StyleProperties.h"
145 #include "StyleResolver.h"
146 #include "StyleSheetContents.h"
147 #include "StyleSheetList.h"
148 #include "TextNodeTraversal.h"
149 #include "TextResourceDecoder.h"
150 #include "TransformSource.h"
151 #include "TreeWalker.h"
152 #include "VisitedLinkState.h"
153 #include "XMLDocumentParser.h"
154 #include "XMLNSNames.h"
155 #include "XMLNames.h"
156 #include "XPathEvaluator.h"
157 #include "XPathExpression.h"
158 #include "XPathNSResolver.h"
159 #include "XPathResult.h"
160 #include "htmlediting.h"
161 #include <JavaScriptCore/Profile.h>
162 #include <inspector/ScriptCallStack.h>
163 #include <wtf/CurrentTime.h>
164 #include <wtf/TemporaryChange.h>
165 #include <wtf/text/StringBuffer.h>
166 #include <yarr/RegularExpression.h>
167
168 #if ENABLE(XSLT)
169 #include "XSLTProcessor.h"
170 #endif
171
172
173 #if ENABLE(TOUCH_EVENTS)
174 #include "TouchList.h"
175 #endif
176
177 #if PLATFORM(IOS)
178 #include "CSSFontSelector.h"
179 #include "DeviceMotionClientIOS.h"
180 #include "DeviceMotionController.h"
181 #include "DeviceOrientationClientIOS.h"
182 #include "DeviceOrientationController.h"
183 #include "Geolocation.h"
184 #include "Navigator.h"
185 #include "NavigatorGeolocation.h"
186 #include "WKContentObservation.h"
187 #include "WebCoreSystemInterface.h"
188 #endif
189
190 #if ENABLE(IOS_GESTURE_EVENTS)
191 #include "GestureEvent.h"
192 #endif
193
194 #if ENABLE(MATHML)
195 #include "MathMLElement.h"
196 #include "MathMLElementFactory.h"
197 #include "MathMLNames.h"
198 #endif
199
200 #if ENABLE(FULLSCREEN_API)
201 #include "RenderFullScreen.h"
202 #endif
203
204 #if ENABLE(REQUEST_ANIMATION_FRAME)
205 #include "RequestAnimationFrameCallback.h"
206 #include "ScriptedAnimationController.h"
207 #endif
208
209 #if ENABLE(IOS_TEXT_AUTOSIZING)
210 #include "TextAutoSizing.h"
211 #endif
212
213 #if ENABLE(TEXT_AUTOSIZING)
214 #include "TextAutosizer.h"
215 #endif
216
217 #if ENABLE(CSP_NEXT)
218 #include "DOMSecurityPolicy.h"
219 #endif
220
221 #if ENABLE(VIDEO_TRACK)
222 #include "CaptionUserPreferences.h"
223 #endif
224
225 #if ENABLE(WEB_REPLAY)
226 #include "WebReplayInputs.h"
227 #include <replay/EmptyInputCursor.h>
228 #include <replay/InputCursor.h>
229 #endif
230
231 #if ENABLE(WIRELESS_PLAYBACK_TARGET)
232 #include "HTMLVideoElement.h"
233 #endif
234
235 using namespace WTF;
236 using namespace Unicode;
237
238 namespace WebCore {
239
240 using namespace HTMLNames;
241
242 // #define INSTRUMENT_LAYOUT_SCHEDULING 1
243
244 static const unsigned cMaxWriteRecursionDepth = 21;
245
246 // DOM Level 2 says (letters added):
247 //
248 // a) Name start characters must have one of the categories Ll, Lu, Lo, Lt, Nl.
249 // b) Name characters other than Name-start characters must have one of the categories Mc, Me, Mn, Lm, or Nd.
250 // c) Characters in the compatibility area (i.e. with character code greater than #xF900 and less than #xFFFE) are not allowed in XML names.
251 // 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.
252 // 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.
253 // f) Characters #x20DD-#x20E0 are excluded (in accordance with Unicode, section 5.14).
254 // g) Character #x00B7 is classified as an extender, because the property list so identifies it.
255 // h) Character #x0387 is added as a name character, because #x00B7 is its canonical equivalent.
256 // i) Characters ':' and '_' are allowed as name-start characters.
257 // j) Characters '-' and '.' are allowed as name characters.
258 //
259 // It also contains complete tables. If we decide it's better, we could include those instead of the following code.
260
261 static inline bool isValidNameStart(UChar32 c)
262 {
263     // rule (e) above
264     if ((c >= 0x02BB && c <= 0x02C1) || c == 0x559 || c == 0x6E5 || c == 0x6E6)
265         return true;
266
267     // rule (i) above
268     if (c == ':' || c == '_')
269         return true;
270
271     // rules (a) and (f) above
272     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)))
273         return false;
274
275     // rule (c) above
276     if (c >= 0xF900 && c < 0xFFFE)
277         return false;
278
279     // rule (d) above
280     int type = u_getIntPropertyValue(c, UCHAR_DECOMPOSITION_TYPE);
281     if (type == U_DT_FONT || type == U_DT_COMPAT)
282         return false;
283
284     return true;
285 }
286
287 static inline bool isValidNamePart(UChar32 c)
288 {
289     // rules (a), (e), and (i) above
290     if (isValidNameStart(c))
291         return true;
292
293     // rules (g) and (h) above
294     if (c == 0x00B7 || c == 0x0387)
295         return true;
296
297     // rule (j) above
298     if (c == '-' || c == '.')
299         return true;
300
301     // rules (b) and (f) above
302     if (!(U_GET_GC_MASK(c) & (U_GC_M_MASK | U_GC_LM_MASK | U_GC_ND_MASK)))
303         return false;
304
305     // rule (c) above
306     if (c >= 0xF900 && c < 0xFFFE)
307         return false;
308
309     // rule (d) above
310     int type = u_getIntPropertyValue(c, UCHAR_DECOMPOSITION_TYPE);
311     if (type == U_DT_FONT || type == U_DT_COMPAT)
312         return false;
313
314     return true;
315 }
316
317 static bool shouldInheritSecurityOriginFromOwner(const URL& url)
318 {
319     // http://www.whatwg.org/specs/web-apps/current-work/#origin-0
320     //
321     // If a Document has the address "about:blank"
322     //     The origin of the Document is the origin it was assigned when its browsing context was created.
323     //
324     // Note: We generalize this to all "blank" URLs and invalid URLs because we
325     // treat all of these URLs as about:blank.
326     //
327     return url.isEmpty() || url.isBlankURL();
328 }
329
330 static Widget* widgetForElement(Element* focusedElement)
331 {
332     if (!focusedElement)
333         return nullptr;
334     auto* renderer = focusedElement->renderer();
335     if (!is<RenderWidget>(renderer))
336         return nullptr;
337     return downcast<RenderWidget>(*renderer).widget();
338 }
339
340 static bool acceptsEditingFocus(Node* node)
341 {
342     ASSERT(node);
343     ASSERT(node->hasEditableStyle());
344
345     Node* root = node->rootEditableElement();
346     Frame* frame = node->document().frame();
347     if (!frame || !root)
348         return false;
349
350     return frame->editor().shouldBeginEditing(rangeOfContents(*root).ptr());
351 }
352
353 static bool canAccessAncestor(const SecurityOrigin* activeSecurityOrigin, Frame* targetFrame)
354 {
355     // targetFrame can be 0 when we're trying to navigate a top-level frame
356     // that has a 0 opener.
357     if (!targetFrame)
358         return false;
359
360     const bool isLocalActiveOrigin = activeSecurityOrigin->isLocal();
361     for (Frame* ancestorFrame = targetFrame; ancestorFrame; ancestorFrame = ancestorFrame->tree().parent()) {
362         Document* ancestorDocument = ancestorFrame->document();
363         // FIXME: Should be an ASSERT? Frames should alway have documents.
364         if (!ancestorDocument)
365             return true;
366
367         const SecurityOrigin* ancestorSecurityOrigin = ancestorDocument->securityOrigin();
368         if (activeSecurityOrigin->canAccess(ancestorSecurityOrigin))
369             return true;
370         
371         // Allow file URL descendant navigation even when allowFileAccessFromFileURLs is false.
372         // FIXME: It's a bit strange to special-case local origins here. Should we be doing
373         // something more general instead?
374         if (isLocalActiveOrigin && ancestorSecurityOrigin->isLocal())
375             return true;
376     }
377
378     return false;
379 }
380
381 static void printNavigationErrorMessage(Frame* frame, const URL& activeURL, const char* reason)
382 {
383     String message = "Unsafe JavaScript attempt to initiate navigation for frame with URL '" + frame->document()->url().string() + "' from frame with URL '" + activeURL.string() + "'. " + reason + "\n";
384
385     // FIXME: should we print to the console of the document performing the navigation instead?
386     frame->document()->domWindow()->printErrorMessage(message);
387 }
388
389 uint64_t Document::s_globalTreeVersion = 0;
390
391 #if ENABLE(IOS_TEXT_AUTOSIZING)
392 void TextAutoSizingTraits::constructDeletedValue(TextAutoSizingKey& slot)
393 {
394     new (&slot) TextAutoSizingKey(TextAutoSizingKey::deletedKeyStyle(), TextAutoSizingKey::deletedKeyDoc());
395 }
396
397 bool TextAutoSizingTraits::isDeletedValue(const TextAutoSizingKey& value)
398 {
399     return value.style() == TextAutoSizingKey::deletedKeyStyle() && value.doc() == TextAutoSizingKey::deletedKeyDoc();
400 }
401 #endif
402
403 HashSet<Document*>& Document::allDocuments()
404 {
405     static NeverDestroyed<HashSet<Document*>> documents;
406     return documents;
407 }
408
409 Document::Document(Frame* frame, const URL& url, unsigned documentClasses, unsigned constructionFlags)
410     : ContainerNode(*this, CreateDocument)
411     , TreeScope(*this)
412 #if ENABLE(IOS_TOUCH_EVENTS)
413     , m_handlingTouchEvent(false)
414     , m_touchEventRegionsDirty(false)
415     , m_touchEventsChangedTimer(*this, &Document::touchEventsChangedTimerFired)
416 #endif
417     , m_referencingNodeCount(0)
418     , m_didCalculateStyleResolver(false)
419     , m_hasNodesWithPlaceholderStyle(false)
420     , m_needsNotifyRemoveAllPendingStylesheet(false)
421     , m_ignorePendingStylesheets(false)
422     , m_pendingSheetLayout(NoLayoutWithPendingSheets)
423     , m_frame(frame)
424     , m_cachedResourceLoader(m_frame ? Ref<CachedResourceLoader>(m_frame->loader().activeDocumentLoader()->cachedResourceLoader()) : CachedResourceLoader::create(nullptr))
425     , m_activeParserCount(0)
426     , m_wellFormed(false)
427     , m_printing(false)
428     , m_paginatedForScreen(false)
429     , m_compatibilityMode(DocumentCompatibilityMode::NoQuirksMode)
430     , m_compatibilityModeLocked(false)
431     , m_textColor(Color::black)
432     , m_domTreeVersion(++s_globalTreeVersion)
433     , m_listenerTypes(0)
434     , m_mutationObserverTypes(0)
435     , m_styleSheetCollection(*this)
436     , m_visitedLinkState(std::make_unique<VisitedLinkState>(*this))
437     , m_visuallyOrdered(false)
438     , m_readyState(Complete)
439     , m_bParsing(false)
440     , m_optimizedStyleSheetUpdateTimer(*this, &Document::optimizedStyleSheetUpdateTimerFired)
441     , m_styleRecalcTimer(*this, &Document::styleRecalcTimerFired)
442     , m_pendingStyleRecalcShouldForce(false)
443     , m_inStyleRecalc(false)
444     , m_closeAfterStyleRecalc(false)
445     , m_gotoAnchorNeededAfterStylesheetsLoad(false)
446     , m_frameElementsShouldIgnoreScrolling(false)
447     , m_updateFocusAppearanceRestoresSelection(false)
448     , m_ignoreDestructiveWriteCount(0)
449     , m_titleSetExplicitly(false)
450     , m_markers(std::make_unique<DocumentMarkerController>())
451     , m_updateFocusAppearanceTimer(*this, &Document::updateFocusAppearanceTimerFired)
452     , m_cssTarget(nullptr)
453     , m_processingLoadEvent(false)
454     , m_loadEventFinished(false)
455     , m_startTime(std::chrono::steady_clock::now())
456     , m_overMinimumLayoutThreshold(false)
457     , m_scriptRunner(std::make_unique<ScriptRunner>(*this))
458     , m_xmlVersion(ASCIILiteral("1.0"))
459     , m_xmlStandalone(StandaloneUnspecified)
460     , m_hasXMLDeclaration(false)
461     , m_designMode(inherit)
462 #if !ASSERT_DISABLED
463     , m_inInvalidateNodeListAndCollectionCaches(false)
464 #endif
465 #if ENABLE(DASHBOARD_SUPPORT)
466     , m_hasAnnotatedRegions(false)
467     , m_annotatedRegionsDirty(false)
468 #endif
469     , m_createRenderers(true)
470     , m_inPageCache(false)
471     , m_accessKeyMapValid(false)
472     , m_documentClasses(documentClasses)
473     , m_isSynthesized(constructionFlags & Synthesized)
474     , m_isNonRenderedPlaceholder(constructionFlags & NonRenderedPlaceholder)
475     , m_sawElementsInKnownNamespaces(false)
476     , m_isSrcdocDocument(false)
477     , m_eventQueue(*this)
478     , m_weakFactory(this)
479 #if ENABLE(FULLSCREEN_API)
480     , m_areKeysEnabledInFullScreen(0)
481     , m_fullScreenRenderer(nullptr)
482     , m_fullScreenChangeDelayTimer(*this, &Document::fullScreenChangeDelayTimerFired)
483     , m_isAnimatingFullScreen(false)
484 #endif
485     , m_loadEventDelayCount(0)
486     , m_loadEventDelayTimer(*this, &Document::loadEventDelayTimerFired)
487     , m_referrerPolicy(ReferrerPolicyDefault)
488     , m_directionSetOnDocumentElement(false)
489     , m_writingModeSetOnDocumentElement(false)
490     , m_writeRecursionIsTooDeep(false)
491     , m_writeRecursionDepth(0)
492     , m_wheelEventHandlerCount(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())
1931         requireFullLayout = true;
1932
1933     bool isVertical = renderer && !renderer->isHorizontalWritingMode();
1934     bool checkingLogicalWidth = ((dimensionsCheck & WidthDimensionsCheck) && !isVertical) || ((dimensionsCheck & HeightDimensionsCheck) && isVertical);
1935     bool checkingLogicalHeight = ((dimensionsCheck & HeightDimensionsCheck) && !isVertical) || ((dimensionsCheck & WidthDimensionsCheck) && !isVertical);
1936     bool hasSpecifiedLogicalHeight = renderer && renderer->style().logicalMinHeight() == Length(0, Fixed) && renderer->style().logicalHeight().isFixed() && renderer->style().logicalMaxHeight().isAuto();
1937     
1938     if (!requireFullLayout) {
1939         RenderBox* previousBox = nullptr;
1940         RenderBox* currentBox = nullptr;
1941         
1942         // Check our containing block chain. If anything in the chain needs a layout, then require a full layout.
1943         for (RenderObject* currRenderer = element->renderer(); currRenderer && !currRenderer->isRenderView(); currRenderer = currRenderer->container()) {
1944             
1945             // Require the entire container chain to be boxes.
1946             if (!is<RenderBox>(currRenderer)) {
1947                 requireFullLayout = true;
1948                 break;
1949             }
1950             
1951             previousBox = currentBox;
1952             currentBox = downcast<RenderBox>(currRenderer);
1953             
1954             // If a box needs layout for itself or if a box has changed children and sizes its width to
1955             // its content, then require a full layout.
1956             if (currentBox->selfNeedsLayout() ||
1957                 (checkingLogicalWidth && currRenderer->needsLayout() && currentBox->sizesLogicalWidthToFitContent(MainOrPreferredSize))) {
1958                 requireFullLayout = true;
1959                 break;
1960             }
1961             
1962             // If a block contains floats and the child's height isn't specified, then
1963             // give up also, since our height could end up being influenced by the floats.
1964             if (checkingLogicalHeight && !hasSpecifiedLogicalHeight && currentBox->isRenderBlockFlow()) {
1965                 RenderBlockFlow* currentBlockFlow = downcast<RenderBlockFlow>(currentBox);
1966                 if (currentBlockFlow->containsFloats() && previousBox && !previousBox->isFloatingOrOutOfFlowPositioned()) {
1967                     requireFullLayout = true;
1968                     break;
1969                 }
1970             }
1971             
1972             if (!currentBox->isRenderBlockFlow() || currentBox->isInline() || currentBox->isOutOfFlowPositioned() || currentBox->flowThreadContainingBlock() || currentBox->isWritingModeRoot()) {
1973                 // FIXME: For now require only block-level non-positioned
1974                 // block flows all the way back to the root. This limits the optimization
1975                 // for now, and we'll expand it in future patches to apply to more and more scenarios.
1976                 // Disallow regions/columns from having the optimization.
1977                 // Give up if the writing mode changes at all in the containing block chain.
1978                 requireFullLayout = true;
1979                 break;
1980             }
1981             
1982             if (currRenderer == frameView->layoutRoot())
1983                 break;
1984         }
1985     }
1986     
1987     StackStats::LayoutCheckPoint layoutCheckPoint;
1988
1989     // Only do a layout if changes have occurred that make it necessary.      
1990     if (requireFullLayout && frameView && renderView() && (frameView->layoutPending() || renderView()->needsLayout()))
1991         frameView->layout();
1992     
1993     return requireFullLayout;
1994 }
1995
1996 bool Document::isPageBoxVisible(int pageIndex)
1997 {
1998     Ref<RenderStyle> pageStyle(ensureStyleResolver().styleForPage(pageIndex));
1999     return pageStyle->visibility() != HIDDEN; // display property doesn't apply to @page.
2000 }
2001
2002 void Document::pageSizeAndMarginsInPixels(int pageIndex, IntSize& pageSize, int& marginTop, int& marginRight, int& marginBottom, int& marginLeft)
2003 {
2004     RefPtr<RenderStyle> style = ensureStyleResolver().styleForPage(pageIndex);
2005
2006     int width = pageSize.width();
2007     int height = pageSize.height();
2008     switch (style->pageSizeType()) {
2009     case PAGE_SIZE_AUTO:
2010         break;
2011     case PAGE_SIZE_AUTO_LANDSCAPE:
2012         if (width < height)
2013             std::swap(width, height);
2014         break;
2015     case PAGE_SIZE_AUTO_PORTRAIT:
2016         if (width > height)
2017             std::swap(width, height);
2018         break;
2019     case PAGE_SIZE_RESOLVED: {
2020         LengthSize size = style->pageSize();
2021         ASSERT(size.width().isFixed());
2022         ASSERT(size.height().isFixed());
2023         width = valueForLength(size.width(), 0);
2024         height = valueForLength(size.height(), 0);
2025         break;
2026     }
2027     default:
2028         ASSERT_NOT_REACHED();
2029     }
2030     pageSize = IntSize(width, height);
2031
2032     // The percentage is calculated with respect to the width even for margin top and bottom.
2033     // http://www.w3.org/TR/CSS2/box.html#margin-properties
2034     marginTop = style->marginTop().isAuto() ? marginTop : intValueForLength(style->marginTop(), width);
2035     marginRight = style->marginRight().isAuto() ? marginRight : intValueForLength(style->marginRight(), width);
2036     marginBottom = style->marginBottom().isAuto() ? marginBottom : intValueForLength(style->marginBottom(), width);
2037     marginLeft = style->marginLeft().isAuto() ? marginLeft : intValueForLength(style->marginLeft(), width);
2038 }
2039
2040 void Document::createStyleResolver()
2041 {
2042     bool matchAuthorAndUserStyles = true;
2043     if (Settings* settings = this->settings())
2044         matchAuthorAndUserStyles = settings->authorAndUserStylesEnabled();
2045     m_styleResolver = std::make_unique<StyleResolver>(*this, matchAuthorAndUserStyles);
2046     m_styleSheetCollection.combineCSSFeatureFlags();
2047 }
2048
2049 void Document::fontsNeedUpdate(FontSelector*)
2050 {
2051     if (m_styleResolver)
2052         m_styleResolver->invalidateMatchedPropertiesCache();
2053     if (inPageCache() || !renderView())
2054         return;
2055     scheduleForcedStyleRecalc();
2056 }
2057
2058 CSSFontSelector& Document::fontSelector()
2059 {
2060     if (!m_fontSelector) {
2061         m_fontSelector = CSSFontSelector::create(*this);
2062         m_fontSelector->registerForInvalidationCallbacks(this);
2063     }
2064     return *m_fontSelector;
2065 }
2066
2067 void Document::clearStyleResolver()
2068 {
2069     m_styleResolver = nullptr;
2070
2071     // FIXME: It would be better if the FontSelector could survive this operation.
2072     if (m_fontSelector) {
2073         m_fontSelector->clearDocument();
2074         m_fontSelector->unregisterForInvalidationCallbacks(this);
2075         m_fontSelector = nullptr;
2076     }
2077 }
2078
2079 void Document::createRenderTree()
2080 {
2081     ASSERT(!renderView());
2082     ASSERT(!m_inPageCache);
2083     ASSERT(!m_axObjectCache || this != &topDocument());
2084
2085     if (m_isNonRenderedPlaceholder)
2086         return;
2087
2088     // FIXME: It would be better if we could pass the resolved document style directly here.
2089     m_renderView = createRenderer<RenderView>(*this, RenderStyle::create());
2090     Node::setRenderer(m_renderView.get());
2091
2092     renderView()->setIsInWindow(true);
2093
2094     recalcStyle(Style::Force);
2095 }
2096
2097 static void pageWheelEventHandlerCountChanged(Page& page)
2098 {
2099     unsigned count = 0;
2100     for (const Frame* frame = &page.mainFrame(); frame; frame = frame->tree().traverseNext()) {
2101         if (Document* document = frame->document())
2102             count += document->wheelEventHandlerCount();
2103     }
2104     page.chrome().client().numWheelEventHandlersChanged(count);
2105 }
2106
2107 void Document::didBecomeCurrentDocumentInFrame()
2108 {
2109     // FIXME: Are there cases where the document can be dislodged from the frame during the event handling below?
2110     // If so, then m_frame could become 0, and we need to do something about that.
2111
2112     m_frame->script().updateDocument();
2113
2114     if (!hasLivingRenderTree())
2115         createRenderTree();
2116
2117     updateViewportArguments();
2118
2119     // FIXME: Doing this only for the main frame is insufficient.
2120     // Changing a subframe can also change the wheel event handler count.
2121     // FIXME: Doing this only when a document goes into the frame is insufficient.
2122     // Removing a document can also change the wheel event handler count.
2123     // FIXME: Doing this every time is a waste. If the current document and its
2124     // subframes' documents have no wheel event handlers, then the count did not change,
2125     // unless the documents they are replacing had wheel event handlers.
2126     if (page() && m_frame->isMainFrame())
2127         pageWheelEventHandlerCountChanged(*page());
2128
2129 #if ENABLE(TOUCH_EVENTS)
2130     // FIXME: Doing this only for the main frame is insufficient.
2131     // A subframe could have touch event handlers.
2132     if (hasTouchEventHandlers() && page() && m_frame->isMainFrame())
2133         page()->chrome().client().needTouchEvents(true);
2134 #endif
2135
2136 #if PLATFORM(IOS)
2137     // Ensure that document scheduled task state matches frame timer state. It can be out of sync
2138     // if timers state changed while the document was not in the frame (possibly in page cache,
2139     // or simply newly created).
2140     // FIXME: How does this interact with cross-platform code below?
2141     if (m_frame->timersPaused())
2142         suspendScheduledTasks(ActiveDOMObject::DocumentWillBePaused);
2143     else
2144         resumeScheduledTasks(ActiveDOMObject::DocumentWillBePaused);
2145 #endif
2146
2147     if (m_frame->activeDOMObjectsAndAnimationsSuspended()) {
2148         suspendScriptedAnimationControllerCallbacks();
2149         m_frame->animation().suspendAnimationsForDocument(this);
2150         suspendActiveDOMObjects(ActiveDOMObject::PageWillBeSuspended);
2151     }
2152 }
2153
2154 void Document::disconnectFromFrame()
2155 {
2156     m_frame = nullptr;
2157 }
2158
2159 void Document::destroyRenderTree()
2160 {
2161     ASSERT(hasLivingRenderTree());
2162     ASSERT(!m_inPageCache);
2163
2164     TemporaryChange<bool> change(m_renderTreeBeingDestroyed, true);
2165
2166     if (this == &topDocument())
2167         clearAXObjectCache();
2168
2169     documentWillBecomeInactive();
2170
2171     if (FrameView* frameView = view())
2172         frameView->detachCustomScrollbars();
2173
2174 #if ENABLE(FULLSCREEN_API)
2175     if (m_fullScreenRenderer)
2176         setFullScreenRenderer(nullptr);
2177 #endif
2178
2179     m_hoveredElement = nullptr;
2180     m_focusedElement = nullptr;
2181     m_activeElement = nullptr;
2182
2183     if (m_documentElement)
2184         Style::detachRenderTree(*m_documentElement);
2185
2186     clearChildNeedsStyleRecalc();
2187
2188     unscheduleStyleRecalc();
2189
2190     m_renderView = nullptr;
2191     Node::setRenderer(nullptr);
2192
2193 #if ENABLE(IOS_TEXT_AUTOSIZING)
2194     // Do this before the arena is cleared, which is needed to deref the RenderStyle on TextAutoSizingKey.
2195     m_textAutoSizedNodes.clear();
2196 #endif
2197 }
2198
2199 void Document::prepareForDestruction()
2200 {
2201     if (m_hasPreparedForDestruction)
2202         return;
2203
2204 #if ENABLE(IOS_TOUCH_EVENTS)
2205     clearTouchEventListeners();
2206 #endif
2207
2208 #if HAVE(ACCESSIBILITY)
2209     // Sub-frames need to cleanup Nodes in the text marker cache when the Document disappears.
2210     if (this != &topDocument()) {
2211         if (AXObjectCache* cache = existingAXObjectCache())
2212             cache->clearTextMarkerNodesInUse(this);
2213     }
2214 #endif
2215     
2216     disconnectDescendantFrames();
2217     if (m_domWindow && m_frame)
2218         m_domWindow->willDetachDocumentFromFrame();
2219
2220     if (hasLivingRenderTree())
2221         destroyRenderTree();
2222
2223     if (is<PluginDocument>(*this))
2224         downcast<PluginDocument>(*this).detachFromPluginElement();
2225
2226 #if ENABLE(POINTER_LOCK)
2227     if (page())
2228         page()->pointerLockController().documentDetached(this);
2229 #endif
2230
2231     stopActiveDOMObjects();
2232     m_eventQueue.close();
2233 #if ENABLE(FULLSCREEN_API)
2234     m_fullScreenChangeEventTargetQueue.clear();
2235     m_fullScreenErrorEventTargetQueue.clear();
2236 #endif
2237
2238     commonTeardown();
2239
2240 #if ENABLE(TOUCH_EVENTS)
2241     if (m_touchEventTargets && m_touchEventTargets->size() && parentDocument())
2242         parentDocument()->didRemoveEventTargetNode(*this);
2243 #endif
2244
2245     if (m_mediaQueryMatcher)
2246         m_mediaQueryMatcher->documentDestroyed();
2247
2248     disconnectFromFrame();
2249
2250     m_hasPreparedForDestruction = true;
2251 }
2252
2253 void Document::removeAllEventListeners()
2254 {
2255     EventTarget::removeAllEventListeners();
2256
2257     if (m_domWindow)
2258         m_domWindow->removeAllEventListeners();
2259 #if ENABLE(IOS_TOUCH_EVENTS)
2260     clearTouchEventListeners();
2261 #endif
2262     for (Node* node = firstChild(); node; node = NodeTraversal::next(*node))
2263         node->removeAllEventListeners();
2264 }
2265
2266 void Document::platformSuspendOrStopActiveDOMObjects()
2267 {
2268 #if PLATFORM(IOS)
2269 #if ENABLE(DEVICE_ORIENTATION)
2270     if (m_deviceMotionController)
2271         m_deviceMotionController->suspendUpdates();
2272     if (m_deviceOrientationController)
2273         m_deviceOrientationController->suspendUpdates();
2274 #endif
2275
2276     if (WebThreadCountOfObservedContentModifiers() > 0) {
2277         Frame* frame = this->frame();
2278         if (Page* page = frame ? frame->page() : nullptr)
2279             page->chrome().client().clearContentChangeObservers(frame);
2280     }
2281 #endif
2282 }
2283
2284 void Document::suspendActiveDOMObjects(ActiveDOMObject::ReasonForSuspension why)
2285 {
2286     ScriptExecutionContext::suspendActiveDOMObjects(why);
2287     platformSuspendOrStopActiveDOMObjects();
2288 }
2289
2290 void Document::resumeActiveDOMObjects(ActiveDOMObject::ReasonForSuspension why)
2291 {
2292     ScriptExecutionContext::resumeActiveDOMObjects(why);
2293
2294 #if ENABLE(DEVICE_ORIENTATION) && PLATFORM(IOS)
2295     if (m_deviceMotionController)
2296         m_deviceMotionController->resumeUpdates();
2297     if (m_deviceOrientationController)
2298         m_deviceOrientationController->resumeUpdates();
2299 #endif
2300     // FIXME: For iOS, do we need to add content change observers that were removed in Document::suspendActiveDOMObjects()?
2301 }
2302
2303 void Document::stopActiveDOMObjects()
2304 {
2305     ScriptExecutionContext::stopActiveDOMObjects();
2306     platformSuspendOrStopActiveDOMObjects();
2307 }
2308
2309 void Document::clearAXObjectCache()
2310 {
2311     ASSERT(&topDocument() == this);
2312     // Clear the cache member variable before calling delete because attempts
2313     // are made to access it during destruction.
2314     m_axObjectCache = nullptr;
2315 }
2316
2317 AXObjectCache* Document::existingAXObjectCache() const
2318 {
2319     Document& topDocument = this->topDocument();
2320     if (!topDocument.hasLivingRenderTree())
2321         return nullptr;
2322     return topDocument.m_axObjectCache.get();
2323 }
2324
2325 AXObjectCache* Document::axObjectCache() const
2326 {
2327     if (!AXObjectCache::accessibilityEnabled())
2328         return nullptr;
2329     
2330     // The only document that actually has a AXObjectCache is the top-level
2331     // document.  This is because we need to be able to get from any WebCoreAXObject
2332     // to any other WebCoreAXObject on the same page.  Using a single cache allows
2333     // lookups across nested webareas (i.e. multiple documents).
2334     Document& topDocument = this->topDocument();
2335
2336     // If the document has already been detached, do not make a new axObjectCache.
2337     if (!topDocument.hasLivingRenderTree())
2338         return nullptr;
2339
2340     ASSERT(&topDocument == this || !m_axObjectCache);
2341     if (!topDocument.m_axObjectCache)
2342         topDocument.m_axObjectCache = std::make_unique<AXObjectCache>(topDocument);
2343     return topDocument.m_axObjectCache.get();
2344 }
2345
2346 void Document::setVisuallyOrdered()
2347 {
2348     m_visuallyOrdered = true;
2349     if (renderView())
2350         renderView()->style().setRTLOrdering(VisualOrder);
2351 }
2352
2353 Ref<DocumentParser> Document::createParser()
2354 {
2355     // FIXME: this should probably pass the frame instead
2356     return XMLDocumentParser::create(*this, view());
2357 }
2358
2359 ScriptableDocumentParser* Document::scriptableDocumentParser() const
2360 {
2361     return parser() ? parser()->asScriptableDocumentParser() : nullptr;
2362 }
2363
2364 void Document::open(Document* ownerDocument)
2365 {
2366     if (ownerDocument) {
2367         setURL(ownerDocument->url());
2368         setCookieURL(ownerDocument->cookieURL());
2369         setSecurityOriginPolicy(ownerDocument->securityOriginPolicy());
2370     }
2371
2372     if (m_frame) {
2373         if (ScriptableDocumentParser* parser = scriptableDocumentParser()) {
2374             if (parser->isParsing()) {
2375                 // FIXME: HTML5 doesn't tell us to check this, it might not be correct.
2376                 if (parser->isExecutingScript())
2377                     return;
2378
2379                 if (!parser->wasCreatedByScript() && parser->hasInsertionPoint())
2380                     return;
2381             }
2382         }
2383
2384         if (m_frame->loader().state() == FrameStateProvisional)
2385             m_frame->loader().stopAllLoaders();
2386     }
2387
2388     removeAllEventListeners();
2389     implicitOpen();
2390     if (ScriptableDocumentParser* parser = scriptableDocumentParser())
2391         parser->setWasCreatedByScript(true);
2392
2393     if (m_frame)
2394         m_frame->loader().didExplicitOpen();
2395 }
2396
2397 void Document::detachParser()
2398 {
2399     if (!m_parser)
2400         return;
2401     m_parser->detach();
2402     m_parser.clear();
2403 }
2404
2405 void Document::cancelParsing()
2406 {
2407     if (!m_parser)
2408         return;
2409
2410     // We have to clear the parser to avoid possibly triggering
2411     // the onload handler when closing as a side effect of a cancel-style
2412     // change, such as opening a new document or closing the window while
2413     // still parsing
2414     detachParser();
2415     explicitClose();
2416 }
2417
2418 void Document::implicitOpen()
2419 {
2420     cancelParsing();
2421
2422     removeChildren();
2423
2424     setCompatibilityMode(DocumentCompatibilityMode::NoQuirksMode);
2425
2426     m_parser = createParser();
2427     setParsing(true);
2428     setReadyState(Loading);
2429 }
2430
2431 HTMLBodyElement* Document::body() const
2432 {
2433     auto* element = documentElement();
2434     if (!element)
2435         return nullptr;
2436     return childrenOfType<HTMLBodyElement>(*element).first();
2437 }
2438
2439 HTMLElement* Document::bodyOrFrameset() const
2440 {
2441     // If the document element contains both a frameset and a body, the frameset wins.
2442     auto* element = documentElement();
2443     if (!element)
2444         return nullptr;
2445     if (auto* frameset = childrenOfType<HTMLFrameSetElement>(*element).first())
2446         return frameset;
2447     return childrenOfType<HTMLBodyElement>(*element).first();
2448 }
2449
2450 void Document::setBodyOrFrameset(PassRefPtr<HTMLElement> prpNewBody, ExceptionCode& ec)
2451 {
2452     RefPtr<HTMLElement> newBody = prpNewBody;
2453
2454     // FIXME: This does not support setting a <frameset> Element, only a <body>. This does
2455     // not match the HTML specification:
2456     // https://html.spec.whatwg.org/multipage/dom.html#dom-document-body
2457     if (!newBody || !documentElement() || !newBody->hasTagName(bodyTag)) { 
2458         ec = HIERARCHY_REQUEST_ERR;
2459         return;
2460     }
2461
2462     if (&newBody->document() != this) {
2463         ec = 0;
2464         RefPtr<Node> node = importNode(newBody.get(), true, ec);
2465         if (ec)
2466             return;
2467         
2468         newBody = downcast<HTMLElement>(node.get());
2469     }
2470
2471     HTMLElement* b = bodyOrFrameset();
2472     if (!b)
2473         documentElement()->appendChild(newBody.release(), ec);
2474     else
2475         documentElement()->replaceChild(newBody.release(), b, ec);
2476 }
2477
2478 HTMLHeadElement* Document::head()
2479 {
2480     if (auto element = documentElement())
2481         return childrenOfType<HTMLHeadElement>(*element).first();
2482     return nullptr;
2483 }
2484
2485 void Document::close()
2486 {
2487     // FIXME: We should follow the specification more closely:
2488     //        http://www.whatwg.org/specs/web-apps/current-work/#dom-document-close
2489
2490     if (!scriptableDocumentParser() || !scriptableDocumentParser()->wasCreatedByScript() || !scriptableDocumentParser()->isParsing())
2491         return;
2492
2493     explicitClose();
2494 }
2495
2496 void Document::explicitClose()
2497 {
2498     if (RefPtr<DocumentParser> parser = m_parser)
2499         parser->finish();
2500
2501     if (!m_frame) {
2502         // Because we have no frame, we don't know if all loading has completed,
2503         // so we just call implicitClose() immediately. FIXME: This might fire
2504         // the load event prematurely <http://bugs.webkit.org/show_bug.cgi?id=14568>.
2505         implicitClose();
2506         return;
2507     }
2508
2509     m_frame->loader().checkCompleted();
2510 }
2511
2512 void Document::implicitClose()
2513 {
2514     // 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.
2515     if (m_inStyleRecalc) {
2516         m_closeAfterStyleRecalc = true;
2517         return;
2518     }
2519
2520     bool wasLocationChangePending = frame() && frame()->navigationScheduler().locationChangePending();
2521     bool doload = !parsing() && m_parser && !m_processingLoadEvent && !wasLocationChangePending;
2522     
2523     if (!doload)
2524         return;
2525
2526     // Call to dispatchWindowLoadEvent can blow us from underneath.
2527     Ref<Document> protect(*this);
2528
2529     m_processingLoadEvent = true;
2530
2531     ScriptableDocumentParser* parser = scriptableDocumentParser();
2532     m_wellFormed = parser && parser->wellFormed();
2533
2534     // We have to clear the parser, in case someone document.write()s from the
2535     // onLoad event handler, as in Radar 3206524.
2536     detachParser();
2537
2538     // FIXME: We kick off the icon loader when the Document is done parsing.
2539     // There are earlier opportunities we could start it:
2540     //  -When the <head> finishes parsing
2541     //  -When any new HTMLLinkElement is inserted into the document
2542     // But those add a dynamic component to the favicon that has UI 
2543     // ramifications, and we need to decide what is the Right Thing To Do(tm)
2544     Frame* f = frame();
2545     if (f) {
2546         f->loader().icon().startLoader();
2547         f->animation().startAnimationsIfNotSuspended(this);
2548
2549         // FIXME: We shouldn't be dispatching pending events globally on all Documents here.
2550         // For now, only do this when there is a Frame, otherwise this could cause JS reentrancy
2551         // below SVG font parsing, for example. <https://webkit.org/b/136269>
2552         ImageLoader::dispatchPendingBeforeLoadEvents();
2553         ImageLoader::dispatchPendingLoadEvents();
2554         ImageLoader::dispatchPendingErrorEvents();
2555         HTMLLinkElement::dispatchPendingLoadEvents();
2556         HTMLStyleElement::dispatchPendingLoadEvents();
2557     }
2558
2559     // To align the HTML load event and the SVGLoad event for the outermost <svg> element, fire it from
2560     // here, instead of doing it from SVGElement::finishedParsingChildren (if externalResourcesRequired="false",
2561     // which is the default, for ='true' its fired at a later time, once all external resources finished loading).
2562     if (svgExtensions())
2563         accessSVGExtensions().dispatchSVGLoadEventToOutermostSVGElements();
2564
2565     dispatchWindowLoadEvent();
2566     enqueuePageshowEvent(PageshowEventNotPersisted);
2567     enqueuePopstateEvent(m_pendingStateObject ? m_pendingStateObject.release() : SerializedScriptValue::nullValue());
2568     
2569     if (f)
2570         f->loader().handledOnloadEvents();
2571 #ifdef INSTRUMENT_LAYOUT_SCHEDULING
2572     if (!ownerElement())
2573         printf("onload fired at %lld\n", elapsedTime().count());
2574 #endif
2575
2576     // An event handler may have removed the frame
2577     if (!frame()) {
2578         m_processingLoadEvent = false;
2579         return;
2580     }
2581
2582     // Make sure both the initial layout and reflow happen after the onload
2583     // fires. This will improve onload scores, and other browsers do it.
2584     // If they wanna cheat, we can too. -dwh
2585
2586     if (frame()->navigationScheduler().locationChangePending() && elapsedTime() < settings()->layoutInterval()) {
2587         // Just bail out. Before or during the onload we were shifted to another page.
2588         // The old i-Bench suite does this. When this happens don't bother painting or laying out.        
2589         m_processingLoadEvent = false;
2590         view()->unscheduleRelayout();
2591         return;
2592     }
2593
2594     frame()->loader().checkCallImplicitClose();
2595     
2596     // We used to force a synchronous display and flush here.  This really isn't
2597     // necessary and can in fact be actively harmful if pages are loading at a rate of > 60fps
2598     // (if your platform is syncing flushes and limiting them to 60fps).
2599     m_overMinimumLayoutThreshold = true;
2600     if (!ownerElement() || (ownerElement()->renderer() && !ownerElement()->renderer()->needsLayout())) {
2601         updateStyleIfNeeded();
2602         
2603         // Always do a layout after loading if needed.
2604         if (view() && renderView() && (!renderView()->firstChild() || renderView()->needsLayout()))
2605             view()->layout();
2606     }
2607
2608     m_processingLoadEvent = false;
2609
2610 #if PLATFORM(COCOA) || PLATFORM(WIN) || PLATFORM(GTK) || PLATFORM(EFL)
2611     if (f && hasLivingRenderTree() && AXObjectCache::accessibilityEnabled()) {
2612         // The AX cache may have been cleared at this point, but we need to make sure it contains an
2613         // AX object to send the notification to. getOrCreate will make sure that an valid AX object
2614         // exists in the cache (we ignore the return value because we don't need it here). This is 
2615         // only safe to call when a layout is not in progress, so it can not be used in postNotification.
2616         //
2617         // This notification is now called AXNewDocumentLoadComplete because there are other handlers that will
2618         // catch new AND page history loads, and that uses AXLoadComplete
2619         
2620         axObjectCache()->getOrCreate(renderView());
2621         if (this == &topDocument())
2622             axObjectCache()->postNotification(renderView(), AXObjectCache::AXNewDocumentLoadComplete);
2623         else {
2624             // AXLoadComplete can only be posted on the top document, so if it's a document
2625             // in an iframe that just finished loading, post AXLayoutComplete instead.
2626             axObjectCache()->postNotification(renderView(), AXObjectCache::AXLayoutComplete);
2627         }
2628     }
2629 #endif
2630
2631     if (svgExtensions())
2632         accessSVGExtensions().startAnimations();
2633 }
2634
2635 void Document::setParsing(bool b)
2636 {
2637     m_bParsing = b;
2638
2639     if (m_bParsing && !m_sharedObjectPool)
2640         m_sharedObjectPool = std::make_unique<DocumentSharedObjectPool>();
2641
2642     if (!m_bParsing && view() && !view()->needsLayout())
2643         view()->fireLayoutRelatedMilestonesIfNeeded();
2644
2645 #ifdef INSTRUMENT_LAYOUT_SCHEDULING
2646     if (!ownerElement() && !m_bParsing)
2647         printf("Parsing finished at %lld\n", elapsedTime().count());
2648 #endif
2649 }
2650
2651 bool Document::shouldScheduleLayout()
2652 {
2653     // This function will only be called when FrameView thinks a layout is needed.
2654     // This enforces a couple extra rules.
2655     //
2656     //    (a) Only schedule a layout once the stylesheets are loaded.
2657     //    (b) Only schedule layout once we have a body element.
2658
2659     return (haveStylesheetsLoaded() && bodyOrFrameset())
2660         || (documentElement() && !is<HTMLHtmlElement>(*documentElement()));
2661 }
2662     
2663 bool Document::isLayoutTimerActive()
2664 {
2665     return view() && view()->layoutPending() && !minimumLayoutDelay().count();
2666 }
2667
2668 std::chrono::milliseconds Document::minimumLayoutDelay()
2669 {
2670     if (m_overMinimumLayoutThreshold)
2671         return std::chrono::milliseconds(0);
2672     
2673     std::chrono::milliseconds elapsed = elapsedTime();
2674     m_overMinimumLayoutThreshold = elapsed > settings()->layoutInterval();
2675
2676     // We'll want to schedule the timer to fire at the minimum layout threshold.
2677     return std::max(std::chrono::milliseconds(0), settings()->layoutInterval() - elapsed);
2678 }
2679
2680 std::chrono::milliseconds Document::elapsedTime() const
2681 {
2682     auto elapsedTime = std::chrono::steady_clock::now() - m_startTime;
2683
2684     return std::chrono::duration_cast<std::chrono::milliseconds>(elapsedTime);
2685 }
2686
2687 void Document::write(const SegmentedString& text, Document* ownerDocument)
2688 {
2689     NestingLevelIncrementer nestingLevelIncrementer(m_writeRecursionDepth);
2690
2691     m_writeRecursionIsTooDeep = (m_writeRecursionDepth > 1) && m_writeRecursionIsTooDeep;
2692     m_writeRecursionIsTooDeep = (m_writeRecursionDepth > cMaxWriteRecursionDepth) || m_writeRecursionIsTooDeep;
2693
2694     if (m_writeRecursionIsTooDeep)
2695        return;
2696
2697 #ifdef INSTRUMENT_LAYOUT_SCHEDULING
2698     if (!ownerElement())
2699         printf("Beginning a document.write at %lld\n", elapsedTime().count());
2700 #endif
2701
2702     bool hasInsertionPoint = m_parser && m_parser->hasInsertionPoint();
2703     if (!hasInsertionPoint && m_ignoreDestructiveWriteCount)
2704         return;
2705
2706     if (!hasInsertionPoint)
2707         open(ownerDocument);
2708
2709     ASSERT(m_parser);
2710     m_parser->insert(text);
2711
2712 #ifdef INSTRUMENT_LAYOUT_SCHEDULING
2713     if (!ownerElement())
2714         printf("Ending a document.write at %lld\n", elapsedTime().count());
2715 #endif    
2716 }
2717
2718 void Document::write(const String& text, Document* ownerDocument)
2719 {
2720     write(SegmentedString(text), ownerDocument);
2721 }
2722
2723 void Document::writeln(const String& text, Document* ownerDocument)
2724 {
2725     write(text, ownerDocument);
2726     write("\n", ownerDocument);
2727 }
2728
2729 double Document::minimumTimerInterval() const
2730 {
2731     Page* page = this->page();
2732     if (!page)
2733         return ScriptExecutionContext::minimumTimerInterval();
2734     return page->settings().minimumDOMTimerInterval();
2735 }
2736
2737 double Document::timerAlignmentInterval() const
2738 {
2739     Page* page = this->page();
2740     if (!page)
2741         return ScriptExecutionContext::timerAlignmentInterval();
2742     return page->settings().domTimerAlignmentInterval();
2743 }
2744
2745 EventTarget* Document::errorEventTarget()
2746 {
2747     return m_domWindow.get();
2748 }
2749
2750 void Document::logExceptionToConsole(const String& errorMessage, const String& sourceURL, int lineNumber, int columnNumber, RefPtr<Inspector::ScriptCallStack>&& callStack)
2751 {
2752     addMessage(MessageSource::JS, MessageLevel::Error, errorMessage, sourceURL, lineNumber, columnNumber, WTF::move(callStack));
2753 }
2754
2755 void Document::setURL(const URL& url)
2756 {
2757     const URL& newURL = url.isEmpty() ? blankURL() : url;
2758     if (newURL == m_url)
2759         return;
2760
2761     m_url = newURL;
2762     m_documentURI = m_url.string();
2763     updateBaseURL();
2764 }
2765
2766 void Document::updateBaseURL()
2767 {
2768     URL oldBaseURL = m_baseURL;
2769     // DOM 3 Core: When the Document supports the feature "HTML" [DOM Level 2 HTML], the base URI is computed using
2770     // first the value of the href attribute of the HTML BASE element if any, and the value of the documentURI attribute
2771     // from the Document interface otherwise.
2772     if (!m_baseElementURL.isEmpty())
2773         m_baseURL = m_baseElementURL;
2774     else if (!m_baseURLOverride.isEmpty())
2775         m_baseURL = m_baseURLOverride;
2776     else {
2777         // The documentURI attribute is read-only from JavaScript, but writable from Objective C, so we need to retain
2778         // this fallback behavior. We use a null base URL, since the documentURI attribute is an arbitrary string
2779         // and DOM 3 Core does not specify how it should be resolved.
2780         m_baseURL = URL(ParsedURLString, documentURI());
2781     }
2782
2783     clearSelectorQueryCache();
2784
2785     if (!m_baseURL.isValid())
2786         m_baseURL = URL();
2787
2788     if (m_elementSheet) {
2789         // Element sheet is silly. It never contains anything.
2790         ASSERT(!m_elementSheet->contents().ruleCount());
2791         bool usesRemUnits = m_elementSheet->contents().usesRemUnits();
2792         bool usesStyleBasedEditability = m_elementSheet->contents().usesStyleBasedEditability();
2793         m_elementSheet = CSSStyleSheet::createInline(*this, m_baseURL);
2794         // FIXME: So we are not really the parser. The right fix is to eliminate the element sheet completely.
2795         if (usesRemUnits)
2796             m_elementSheet->contents().parserSetUsesRemUnits();
2797         if (usesStyleBasedEditability)
2798             m_elementSheet->contents().parserSetUsesStyleBasedEditability();
2799     }
2800
2801     if (!equalIgnoringFragmentIdentifier(oldBaseURL, m_baseURL)) {
2802         // Base URL change changes any relative visited links.
2803         // 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.
2804         for (auto& anchor : descendantsOfType<HTMLAnchorElement>(*this))
2805             anchor.invalidateCachedVisitedLinkHash();
2806     }
2807 }
2808
2809 void Document::setBaseURLOverride(const URL& url)
2810 {
2811     m_baseURLOverride = url;
2812     updateBaseURL();
2813 }
2814
2815 void Document::processBaseElement()
2816 {
2817     // Find the first href attribute in a base element and the first target attribute in a base element.
2818     const AtomicString* href = nullptr;
2819     const AtomicString* target = nullptr;
2820     auto baseDescendants = descendantsOfType<HTMLBaseElement>(*this);
2821     for (auto base = baseDescendants.begin(), end = baseDescendants.end(); base != end && (!href || !target); ++base) {
2822         if (!href) {
2823             const AtomicString& value = base->fastGetAttribute(hrefAttr);
2824             if (!value.isNull())
2825                 href = &value;
2826         }
2827         if (!target) {
2828             const AtomicString& value = base->fastGetAttribute(targetAttr);
2829             if (!value.isNull())
2830                 target = &value;
2831         }
2832     }
2833
2834     // FIXME: Since this doesn't share code with completeURL it may not handle encodings correctly.
2835     URL baseElementURL;
2836     if (href) {
2837         String strippedHref = stripLeadingAndTrailingHTMLSpaces(*href);
2838         if (!strippedHref.isEmpty())
2839             baseElementURL = URL(url(), strippedHref);
2840     }
2841     if (m_baseElementURL != baseElementURL && contentSecurityPolicy()->allowBaseURI(baseElementURL)) {
2842         m_baseElementURL = baseElementURL;
2843         updateBaseURL();
2844     }
2845
2846     m_baseTarget = target ? *target : nullAtom;
2847 }
2848
2849 String Document::userAgent(const URL& url) const
2850 {
2851     return frame() ? frame()->loader().userAgent(url) : String();
2852 }
2853
2854 void Document::disableEval(const String& errorMessage)
2855 {
2856     if (!frame())
2857         return;
2858
2859     frame()->script().disableEval(errorMessage);
2860 }
2861
2862 bool Document::canNavigate(Frame* targetFrame)
2863 {
2864     if (!m_frame)
2865         return false;
2866
2867     // FIXME: We shouldn't call this function without a target frame, but
2868     // fast/forms/submit-to-blank-multiple-times.html depends on this function
2869     // returning true when supplied with a 0 targetFrame.
2870     if (!targetFrame)
2871         return true;
2872
2873     // Frame-busting is generally allowed, but blocked for sandboxed frames lacking the 'allow-top-navigation' flag.
2874     if (!isSandboxed(SandboxTopNavigation) && targetFrame == &m_frame->tree().top())
2875         return true;
2876
2877     if (isSandboxed(SandboxNavigation)) {
2878         if (targetFrame->tree().isDescendantOf(m_frame))
2879             return true;
2880
2881         const char* reason = "The frame attempting navigation is sandboxed, and is therefore disallowed from navigating its ancestors.";
2882         if (isSandboxed(SandboxTopNavigation) && targetFrame == &m_frame->tree().top())
2883             reason = "The frame attempting navigation of the top-level window is sandboxed, but the 'allow-top-navigation' flag is not set.";
2884
2885         printNavigationErrorMessage(targetFrame, url(), reason);
2886         return false;
2887     }
2888
2889     // This is the normal case. A document can navigate its decendant frames,
2890     // or, more generally, a document can navigate a frame if the document is
2891     // in the same origin as any of that frame's ancestors (in the frame
2892     // hierarchy).
2893     //
2894     // See http://www.adambarth.com/papers/2008/barth-jackson-mitchell.pdf for
2895     // historical information about this security check.
2896     if (canAccessAncestor(securityOrigin(), targetFrame))
2897         return true;
2898
2899     // Top-level frames are easier to navigate than other frames because they
2900     // display their URLs in the address bar (in most browsers). However, there
2901     // are still some restrictions on navigation to avoid nuisance attacks.
2902     // Specifically, a document can navigate a top-level frame if that frame
2903     // opened the document or if the document is the same-origin with any of
2904     // the top-level frame's opener's ancestors (in the frame hierarchy).
2905     //
2906     // In both of these cases, the document performing the navigation is in
2907     // some way related to the frame being navigate (e.g., by the "opener"
2908     // and/or "parent" relation). Requiring some sort of relation prevents a
2909     // document from navigating arbitrary, unrelated top-level frames.
2910     if (!targetFrame->tree().parent()) {
2911         if (targetFrame == m_frame->loader().opener())
2912             return true;
2913
2914         if (canAccessAncestor(securityOrigin(), targetFrame->loader().opener()))
2915             return true;
2916     }
2917
2918     printNavigationErrorMessage(targetFrame, url(), "The frame attempting navigation is neither same-origin with the target, nor is it the target's parent or opener.");
2919     return false;
2920 }
2921
2922 Frame* Document::findUnsafeParentScrollPropagationBoundary()
2923 {
2924     Frame* currentFrame = m_frame;
2925     if (!currentFrame)
2926         return nullptr;
2927
2928     Frame* ancestorFrame = currentFrame->tree().parent();
2929
2930     while (ancestorFrame) {
2931         if (!ancestorFrame->document()->securityOrigin()->canAccess(securityOrigin()))
2932             return currentFrame;
2933         currentFrame = ancestorFrame;
2934         ancestorFrame = ancestorFrame->tree().parent();
2935     }
2936     return nullptr;
2937 }
2938
2939 void Document::didRemoveAllPendingStylesheet()
2940 {
2941     m_needsNotifyRemoveAllPendingStylesheet = false;
2942
2943     styleResolverChanged(DeferRecalcStyleIfNeeded);
2944
2945     if (m_pendingSheetLayout == DidLayoutWithPendingSheets) {
2946         m_pendingSheetLayout = IgnoreLayoutWithPendingSheets;
2947         if (renderView())
2948             renderView()->repaintViewAndCompositedLayers();
2949     }
2950
2951     if (ScriptableDocumentParser* parser = scriptableDocumentParser())
2952         parser->executeScriptsWaitingForStylesheets();
2953
2954     if (m_gotoAnchorNeededAfterStylesheetsLoad && view())
2955         view()->scrollToFragment(m_url);
2956 }
2957
2958 CSSStyleSheet& Document::elementSheet()
2959 {
2960     if (!m_elementSheet)
2961         m_elementSheet = CSSStyleSheet::createInline(*this, m_baseURL);
2962     return *m_elementSheet;
2963 }
2964
2965 bool Document::usesStyleBasedEditability() const
2966 {
2967     if (m_elementSheet && m_elementSheet->contents().usesStyleBasedEditability())
2968         return true;
2969
2970     ASSERT(!m_renderView || !m_renderView->frameView().isPainting());
2971     ASSERT(!m_inStyleRecalc);
2972
2973     auto& collection = document().styleSheetCollection();
2974     collection.flushPendingUpdates();
2975     return collection.usesStyleBasedEditability();
2976 }
2977
2978 void Document::processHttpEquiv(const String& equiv, const String& content)
2979 {
2980     ASSERT(!equiv.isNull() && !content.isNull());
2981
2982     Frame* frame = this->frame();
2983
2984     HTTPHeaderName headerName;
2985     if (!findHTTPHeaderName(equiv, headerName))
2986         return;
2987
2988     switch (headerName) {
2989     case HTTPHeaderName::DefaultStyle:
2990         // The preferred style set has been overridden as per section
2991         // 14.3.2 of the HTML4.0 specification.  We need to update the
2992         // sheet used variable and then update our style selector.
2993         // For more info, see the test at:
2994         // http://www.hixie.ch/tests/evil/css/import/main/preferred.html
2995         // -dwh
2996         m_styleSheetCollection.setSelectedStylesheetSetName(content);
2997         m_styleSheetCollection.setPreferredStylesheetSetName(content);
2998         styleResolverChanged(DeferRecalcStyle);
2999         break;
3000
3001     case HTTPHeaderName::Refresh: {
3002         double delay;
3003         String urlString;
3004         if (frame && parseHTTPRefresh(content, true, delay, urlString)) {
3005             URL completedURL;
3006             if (urlString.isEmpty())
3007                 completedURL = m_url;
3008             else
3009                 completedURL = completeURL(urlString);
3010             if (!protocolIsJavaScript(completedURL))
3011                 frame->navigationScheduler().scheduleRedirect(delay, completedURL);
3012             else {
3013                 String message = "Refused to refresh " + m_url.stringCenterEllipsizedToLength() + " to a javascript: URL";
3014                 addConsoleMessage(MessageSource::Security, MessageLevel::Error, message);
3015             }
3016         }
3017
3018         break;
3019     }
3020
3021     case HTTPHeaderName::SetCookie:
3022         // FIXME: make setCookie work on XML documents too; e.g. in case of <html:meta .....>
3023         if (is<HTMLDocument>(*this)) {
3024             // Exception (for sandboxed documents) ignored.
3025             downcast<HTMLDocument>(*this).setCookie(content, IGNORE_EXCEPTION);
3026         }
3027         break;
3028
3029     case HTTPHeaderName::ContentLanguage:
3030         setContentLanguage(content);
3031         break;
3032
3033     case HTTPHeaderName::XDNSPrefetchControl:
3034         parseDNSPrefetchControlHeader(content);
3035         break;
3036
3037     case HTTPHeaderName::XFrameOptions:
3038         if (frame) {
3039             FrameLoader& frameLoader = frame->loader();
3040             unsigned long requestIdentifier = 0;
3041             if (frameLoader.activeDocumentLoader() && frameLoader.activeDocumentLoader()->mainResourceLoader())
3042                 requestIdentifier = frameLoader.activeDocumentLoader()->mainResourceLoader()->identifier();
3043             if (frameLoader.shouldInterruptLoadForXFrameOptions(content, url(), requestIdentifier)) {
3044                 String message = "Refused to display '" + url().stringCenterEllipsizedToLength() + "' in a frame because it set 'X-Frame-Options' to '" + content + "'.";
3045                 frameLoader.stopAllLoaders();
3046                 // Stopping the loader isn't enough, as we're already parsing the document; to honor the header's
3047                 // intent, we must navigate away from the possibly partially-rendered document to a location that
3048                 // doesn't inherit the parent's SecurityOrigin.
3049                 frame->navigationScheduler().scheduleLocationChange(securityOrigin(), SecurityOrigin::urlWithUniqueSecurityOrigin(), String());
3050                 addConsoleMessage(MessageSource::Security, MessageLevel::Error, message, requestIdentifier);
3051             }
3052         }
3053         break;
3054
3055     case HTTPHeaderName::ContentSecurityPolicy:
3056         contentSecurityPolicy()->didReceiveHeader(content, ContentSecurityPolicy::Enforce);
3057         break;
3058
3059     case HTTPHeaderName::ContentSecurityPolicyReportOnly:
3060         contentSecurityPolicy()->didReceiveHeader(content, ContentSecurityPolicy::Report);
3061         break;
3062
3063     case HTTPHeaderName::XWebKitCSP:
3064         contentSecurityPolicy()->didReceiveHeader(content, ContentSecurityPolicy::PrefixedEnforce);
3065         break;
3066
3067     case HTTPHeaderName::XWebKitCSPReportOnly:
3068         contentSecurityPolicy()->didReceiveHeader(content, ContentSecurityPolicy::PrefixedReport);
3069         break;
3070
3071     default:
3072         break;
3073     }
3074 }
3075
3076 // Though isspace() considers \t and \v to be whitespace, Win IE doesn't.
3077 static bool isSeparator(UChar c)
3078 {
3079     return c == ' ' || c == '\t' || c == '\n' || c == '\r' || c == '=' || c == ',' || c == '\0';
3080 }
3081
3082 void Document::processArguments(const String& features, void* data, ArgumentsCallback callback)
3083 {
3084     // Tread lightly in this code -- it was specifically designed to mimic Win IE's parsing behavior.
3085     unsigned keyBegin, keyEnd;
3086     unsigned valueBegin, valueEnd;
3087
3088     String buffer = features.lower();
3089     unsigned length = buffer.length();
3090     for (unsigned i = 0; i < length; ) {
3091         // skip to first non-separator, but don't skip past the end of the string
3092         while (isSeparator(buffer[i])) {
3093             if (i >= length)
3094                 break;
3095             i++;
3096         }
3097         keyBegin = i;
3098
3099         // skip to first separator
3100         while (!isSeparator(buffer[i]))
3101             i++;
3102         keyEnd = i;
3103
3104         // skip to first '=', but don't skip past a ',' or the end of the string
3105         while (buffer[i] != '=') {
3106             if (buffer[i] == ',' || i >= length)
3107                 break;
3108             i++;
3109         }
3110
3111         // skip to first non-separator, but don't skip past a ',' or the end of the string
3112         while (isSeparator(buffer[i])) {
3113             if (buffer[i] == ',' || i >= length)
3114                 break;
3115             i++;
3116         }
3117         valueBegin = i;
3118
3119         // skip to first separator
3120         while (!isSeparator(buffer[i]))
3121             i++;
3122         valueEnd = i;
3123
3124         ASSERT_WITH_SECURITY_IMPLICATION(i <= length);
3125
3126         String keyString = buffer.substring(keyBegin, keyEnd - keyBegin);
3127         String valueString = buffer.substring(valueBegin, valueEnd - valueBegin);
3128         callback(keyString, valueString, this, data);
3129     }
3130 }
3131
3132 void Document::processViewport(const String& features, ViewportArguments::Type origin)
3133 {
3134     ASSERT(!features.isNull());
3135
3136     if (origin < m_viewportArguments.type)
3137         return;
3138
3139     m_viewportArguments = ViewportArguments(origin);
3140     processArguments(features, (void*)&m_viewportArguments, &setViewportFeature);
3141
3142     updateViewportArguments();
3143 }
3144
3145 void Document::updateViewportArguments()
3146 {
3147     if (page() && frame()->isMainFrame()) {
3148 #ifndef NDEBUG
3149         m_didDispatchViewportPropertiesChanged = true;
3150 #endif
3151         page()->chrome().dispatchViewportPropertiesDidChange(m_viewportArguments);
3152 #if PLATFORM(IOS)
3153         page()->chrome().didReceiveDocType(frame());
3154 #endif
3155     }
3156 }
3157
3158 #if PLATFORM(IOS)
3159 // FIXME: Find a better place for this functionality.
3160 void setParserFeature(const String& key, const String& value, Document* document, void*)
3161 {
3162     if (key == "telephone" && equalIgnoringCase(value, "no"))
3163         document->setIsTelephoneNumberParsingAllowed(false);
3164 }
3165
3166 void Document::processFormatDetection(const String& features)
3167 {
3168     ASSERT(!features.isNull());
3169     processArguments(features, nullptr, &setParserFeature);
3170 }
3171
3172 void Document::processWebAppOrientations()
3173 {
3174     if (Page* page = this->page())
3175         page->chrome().client().webAppOrientationsUpdated();
3176 }
3177 #endif
3178
3179 void Document::processReferrerPolicy(const String& policy)
3180 {
3181     ASSERT(!policy.isNull());
3182
3183     // Note that we're supporting both the standard and legacy keywords for referrer
3184     // policies, as defined by http://www.w3.org/TR/referrer-policy/#referrer-policy-delivery-meta
3185     if (equalIgnoringCase(policy, "no-referrer") || equalIgnoringCase(policy, "never"))
3186         setReferrerPolicy(ReferrerPolicyNever);
3187     else if (equalIgnoringCase(policy, "unsafe-url") || equalIgnoringCase(policy, "always"))
3188         setReferrerPolicy(ReferrerPolicyAlways);
3189     else if (equalIgnoringCase(policy, "origin"))
3190         setReferrerPolicy(ReferrerPolicyOrigin);
3191     else if (equalIgnoringCase(policy, "no-referrer-when-downgrade") || equalIgnoringCase(policy, "default"))
3192         setReferrerPolicy(ReferrerPolicyDefault);
3193     else {
3194         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'.");
3195         setReferrerPolicy(ReferrerPolicyNever);
3196     }
3197 }
3198
3199 MouseEventWithHitTestResults Document::prepareMouseEvent(const HitTestRequest& request, const LayoutPoint& documentPoint, const PlatformMouseEvent& event)
3200 {
3201     if (!hasLivingRenderTree())
3202         return MouseEventWithHitTestResults(event, HitTestResult(LayoutPoint()));
3203
3204     HitTestResult result(documentPoint);
3205     renderView()->hitTest(request, result);
3206
3207     if (!request.readOnly())
3208         updateHoverActiveState(request, result.innerElement());
3209
3210     return MouseEventWithHitTestResults(event, result);
3211 }
3212
3213 // DOM Section 1.1.1
3214 bool Document::childTypeAllowed(NodeType type) const
3215 {
3216     switch (type) {
3217     case ATTRIBUTE_NODE:
3218     case CDATA_SECTION_NODE:
3219     case DOCUMENT_FRAGMENT_NODE:
3220     case DOCUMENT_NODE:
3221     case ENTITY_NODE:
3222     case ENTITY_REFERENCE_NODE:
3223     case TEXT_NODE:
3224     case XPATH_NAMESPACE_NODE:
3225         return false;
3226     case COMMENT_NODE:
3227     case PROCESSING_INSTRUCTION_NODE:
3228         return true;
3229     case DOCUMENT_TYPE_NODE:
3230     case ELEMENT_NODE:
3231         // Documents may contain no more than one of each of these.
3232         // (One Element and one DocumentType.)
3233         for (Node* c = firstChild(); c; c = c->nextSibling())
3234             if (c->nodeType() == type)
3235                 return false;
3236         return true;
3237     }
3238     return false;
3239 }
3240
3241 bool Document::canReplaceChild(Node* newChild, Node* oldChild)
3242 {
3243     if (!oldChild)
3244         // ContainerNode::replaceChild will raise a NOT_FOUND_ERR.
3245         return true;
3246
3247     if (oldChild->nodeType() == newChild->nodeType())
3248         return true;
3249
3250     int numDoctypes = 0;
3251     int numElements = 0;
3252
3253     // First, check how many doctypes and elements we have, not counting
3254     // the child we're about to remove.
3255     for (Node* c = firstChild(); c; c = c->nextSibling()) {
3256         if (c == oldChild)
3257             continue;
3258         
3259         switch (c->nodeType()) {
3260         case DOCUMENT_TYPE_NODE:
3261             numDoctypes++;
3262             break;
3263         case ELEMENT_NODE:
3264             numElements++;
3265             break;
3266         default:
3267             break;
3268         }
3269     }
3270     
3271     // Then, see how many doctypes and elements might be added by the new child.
3272     if (newChild->isDocumentFragment()) {
3273         for (Node* c = newChild->firstChild(); c; c = c->nextSibling()) {
3274             switch (c->nodeType()) {
3275             case ATTRIBUTE_NODE:
3276             case CDATA_SECTION_NODE:
3277             case DOCUMENT_FRAGMENT_NODE:
3278             case DOCUMENT_NODE:
3279             case ENTITY_NODE:
3280             case ENTITY_REFERENCE_NODE:
3281             case TEXT_NODE:
3282             case XPATH_NAMESPACE_NODE:
3283                 return false;
3284             case COMMENT_NODE:
3285             case PROCESSING_INSTRUCTION_NODE:
3286                 break;
3287             case DOCUMENT_TYPE_NODE:
3288                 numDoctypes++;
3289                 break;
3290             case ELEMENT_NODE:
3291                 numElements++;
3292                 break;
3293             }
3294         }
3295     } else {
3296         switch (newChild->nodeType()) {
3297         case ATTRIBUTE_NODE:
3298         case CDATA_SECTION_NODE:
3299         case DOCUMENT_FRAGMENT_NODE:
3300         case DOCUMENT_NODE:
3301         case ENTITY_NODE:
3302         case ENTITY_REFERENCE_NODE:
3303         case TEXT_NODE:
3304         case XPATH_NAMESPACE_NODE:
3305             return false;
3306         case COMMENT_NODE:
3307         case PROCESSING_INSTRUCTION_NODE:
3308             return true;
3309         case DOCUMENT_TYPE_NODE:
3310             numDoctypes++;
3311             break;
3312         case ELEMENT_NODE:
3313             numElements++;
3314             break;
3315         }                
3316     }
3317         
3318     if (numElements > 1 || numDoctypes > 1)
3319         return false;
3320     
3321     return true;
3322 }
3323
3324 RefPtr<Node> Document::cloneNodeInternal(Document&, CloningOperation type)
3325 {
3326     Ref<Document> clone = cloneDocumentWithoutChildren();
3327     clone->cloneDataFromDocument(*this);
3328     switch (type) {
3329     case CloningOperation::OnlySelf:
3330     case CloningOperation::SelfWithTemplateContent:
3331         break;
3332     case CloningOperation::Everything:
3333         cloneChildNodes(clone.ptr());
3334         break;
3335     }
3336     return WTF::move(clone);
3337 }
3338
3339 Ref<Document> Document::cloneDocumentWithoutChildren() const
3340 {
3341     return isXHTMLDocument() ? createXHTML(nullptr, url()) : create(nullptr, url());
3342 }
3343
3344 void Document::cloneDataFromDocument(const Document& other)
3345 {
3346     ASSERT(m_url == other.url());
3347     m_baseURL = other.baseURL();
3348     m_baseURLOverride = other.baseURLOverride();
3349     m_documentURI = other.documentURI();
3350
3351     setCompatibilityMode(other.m_compatibilityMode);
3352     setSecurityOriginPolicy(other.securityOriginPolicy());
3353     overrideMIMEType(other.contentType());
3354     setDecoder(other.decoder());
3355 }
3356
3357 StyleSheetList& Document::styleSheets()
3358 {
3359     if (!m_styleSheetList)
3360         m_styleSheetList = StyleSheetList::create(this);
3361     return *m_styleSheetList;
3362 }
3363
3364 String Document::preferredStylesheetSet() const
3365 {
3366     return m_styleSheetCollection.preferredStylesheetSetName();
3367 }
3368
3369 String Document::selectedStylesheetSet() const
3370 {
3371     return m_styleSheetCollection.selectedStylesheetSetName();
3372 }
3373
3374 void Document::setSelectedStylesheetSet(const String& aString)
3375 {
3376     m_styleSheetCollection.setSelectedStylesheetSetName(aString);
3377     styleResolverChanged(DeferRecalcStyle);
3378 }
3379
3380 void Document::evaluateMediaQueryList()
3381 {
3382     if (m_mediaQueryMatcher)
3383         m_mediaQueryMatcher->styleResolverChanged();
3384 }
3385
3386 void Document::optimizedStyleSheetUpdateTimerFired()
3387 {
3388     styleResolverChanged(RecalcStyleIfNeeded);
3389 }
3390
3391 void Document::scheduleOptimizedStyleSheetUpdate()
3392 {
3393     if (m_optimizedStyleSheetUpdateTimer.isActive())
3394         return;
3395     m_styleSheetCollection.setPendingUpdateType(DocumentStyleSheetCollection::OptimizedUpdate);
3396     m_optimizedStyleSheetUpdateTimer.startOneShot(0);
3397 }
3398
3399 void Document::updateViewportUnitsOnResize()
3400 {
3401     if (!hasStyleWithViewportUnits())
3402         return;
3403
3404     ensureStyleResolver().clearCachedPropertiesAffectedByViewportUnits();
3405
3406     // FIXME: Ideally, we should save the list of elements that have viewport units and only iterate over those.
3407     for (Element* element = ElementTraversal::firstWithin(rootNode()); element; element = ElementTraversal::nextIncludingPseudo(*element)) {
3408         auto* renderer = element->renderer();
3409         if (renderer && renderer->style().hasViewportUnits())
3410             element->setNeedsStyleRecalc(InlineStyleChange);
3411     }
3412 }
3413
3414 void Document::addAudioProducer(AudioProducer* audioProducer)
3415 {
3416     m_audioProducers.add(audioProducer);
3417     updateIsPlayingAudio();
3418 }
3419
3420 void Document::removeAudioProducer(AudioProducer* audioProducer)
3421 {
3422     m_audioProducers.remove(audioProducer);
3423     updateIsPlayingAudio();
3424 }
3425
3426 void Document::updateIsPlayingAudio()
3427 {
3428     bool isPlayingAudio = false;
3429     for (auto audioProducer : m_audioProducers) {
3430         if (audioProducer->isPlayingAudio()) {
3431             isPlayingAudio = true;
3432             break;
3433         }
3434     }
3435
3436     if (isPlayingAudio == m_isPlayingAudio)
3437         return;
3438
3439     m_isPlayingAudio = isPlayingAudio;
3440
3441     if (page())
3442         page()->updateIsPlayingAudio();
3443 }
3444
3445 void Document::pageMutedStateDidChange()
3446 {
3447     for (auto audioProducer : m_audioProducers)
3448         audioProducer->pageMutedStateDidChange();
3449 }
3450
3451 void Document::styleResolverChanged(StyleResolverUpdateFlag updateFlag)
3452 {
3453     if (m_optimizedStyleSheetUpdateTimer.isActive())
3454         m_optimizedStyleSheetUpdateTimer.stop();
3455
3456     // Don't bother updating, since we haven't loaded all our style info yet
3457     // and haven't calculated the style selector for the first time.
3458     if (!hasLivingRenderTree() || (!m_didCalculateStyleResolver && !haveStylesheetsLoaded())) {
3459         m_styleResolver = nullptr;
3460         return;
3461     }
3462     m_didCalculateStyleResolver = true;
3463
3464 #ifdef INSTRUMENT_LAYOUT_SCHEDULING
3465     if (!ownerElement())
3466         printf("Beginning update of style selector at time %lld.\n", elapsedTime().count());
3467 #endif
3468
3469     DocumentStyleSheetCollection::UpdateFlag styleSheetUpdate = (updateFlag == RecalcStyleIfNeeded || updateFlag == DeferRecalcStyleIfNeeded)
3470         ? DocumentStyleSheetCollection::OptimizedUpdate
3471         : DocumentStyleSheetCollection::FullUpdate;
3472     bool stylesheetChangeRequiresStyleRecalc = m_styleSheetCollection.updateActiveStyleSheets(styleSheetUpdate);
3473
3474     if (updateFlag == DeferRecalcStyle) {
3475         scheduleForcedStyleRecalc();
3476         return;
3477     }
3478
3479     if (updateFlag == DeferRecalcStyleIfNeeded) {
3480         if (stylesheetChangeRequiresStyleRecalc)
3481             scheduleForcedStyleRecalc();
3482         return;
3483     }
3484
3485     if (!stylesheetChangeRequiresStyleRecalc)
3486         return;
3487
3488     // This recalcStyle initiates a new recalc cycle. We need to bracket it to
3489     // make sure animations get the correct update time
3490     {
3491         AnimationUpdateBlock animationUpdateBlock(m_frame ? &m_frame->animation() : nullptr);
3492         recalcStyle(Style::Force);
3493     }
3494
3495 #ifdef INSTRUMENT_LAYOUT_SCHEDULING
3496     if (!ownerElement())
3497         printf("Finished update of style selector at time %lld\n", elapsedTime().count());
3498 #endif
3499
3500     if (renderView()) {
3501         renderView()->setNeedsLayoutAndPrefWidthsRecalc();
3502         if (view())
3503             view()->scheduleRelayout();
3504     }
3505
3506     evaluateMediaQueryList();
3507 }
3508
3509 void Document::removeFocusedNodeOfSubtree(Node* node, bool amongChildrenOnly)
3510 {
3511     if (!m_focusedElement || this->inPageCache()) // If the document is in the page cache, then we don't need to clear out the focused node.
3512         return;
3513
3514     Element* focusedElement = node->treeScope().focusedElement();
3515     if (!focusedElement)
3516         return;
3517
3518     bool nodeInSubtree = false;
3519     if (amongChildrenOnly)
3520         nodeInSubtree = focusedElement->isDescendantOf(node);
3521     else
3522         nodeInSubtree = (focusedElement == node) || focusedElement->isDescendantOf(node);
3523     
3524     if (nodeInSubtree)
3525         setFocusedElement(nullptr);
3526 }
3527
3528 void Document::hoveredElementDidDetach(Element* element)
3529 {
3530     if (!m_hoveredElement || element != m_hoveredElement)
3531         return;
3532
3533     m_hoveredElement = element->parentElement();
3534     while (m_hoveredElement && !m_hoveredElement->renderer())
3535         m_hoveredElement = m_hoveredElement->parentElement();
3536     if (frame())
3537         frame()->eventHandler().scheduleHoverStateUpdate();
3538 }
3539
3540 void Document::elementInActiveChainDidDetach(Element* element)
3541 {
3542     if (!m_activeElement || element != m_activeElement)
3543         return;
3544
3545     m_activeElement = element->parentElement();
3546     while (m_activeElement && !m_activeElement->renderer())
3547         m_activeElement = m_activeElement->parentElement();
3548 }
3549
3550 #if ENABLE(DASHBOARD_SUPPORT)
3551 const Vector<AnnotatedRegionValue>& Document::annotatedRegions() const
3552 {
3553     return m_annotatedRegions;
3554 }
3555
3556 void Document::setAnnotatedRegions(const Vector<AnnotatedRegionValue>& regions)
3557 {
3558     m_annotatedRegions = regions;
3559     setAnnotatedRegionsDirty(false);
3560 }
3561 #endif
3562
3563 bool Document::setFocusedElement(PassRefPtr<Element> prpNewFocusedElement, FocusDirection direction)
3564 {
3565     RefPtr<Element> newFocusedElement = prpNewFocusedElement;
3566
3567     // Make sure newFocusedElement is actually in this document
3568     if (newFocusedElement && (&newFocusedElement->document() != this))
3569         return true;
3570
3571     if (m_focusedElement == newFocusedElement)
3572         return true;
3573
3574     if (m_inPageCache)
3575         return false;
3576
3577     bool focusChangeBlocked = false;
3578     RefPtr<Element> oldFocusedElement = m_focusedElement.release();
3579
3580     // Remove focus from the existing focus node (if any)
3581     if (oldFocusedElement) {
3582         if (oldFocusedElement->active())
3583             oldFocusedElement->setActive(false);
3584
3585         oldFocusedElement->setFocus(false);
3586
3587         // Dispatch a change event for form control elements that have been edited.
3588         if (is<HTMLFormControlElement>(*oldFocusedElement)) {
3589             HTMLFormControlElement& formControlElement = downcast<HTMLFormControlElement>(*oldFocusedElement);
3590             if (formControlElement.wasChangedSinceLastFormControlChangeEvent())
3591                 formControlElement.dispatchFormControlChangeEvent();
3592         }
3593
3594         // Dispatch the blur event and let the node do any other blur related activities (important for text fields)
3595         oldFocusedElement->dispatchBlurEvent(newFocusedElement.copyRef());
3596
3597         if (m_focusedElement) {
3598             // handler shifted focus
3599             focusChangeBlocked = true;
3600             newFocusedElement = nullptr;
3601         }
3602         
3603         oldFocusedElement->dispatchFocusOutEvent(eventNames().focusoutEvent, newFocusedElement.copyRef()); // DOM level 3 name for the bubbling blur event.
3604         // FIXME: We should remove firing DOMFocusOutEvent event when we are sure no content depends
3605         // on it, probably when <rdar://problem/8503958> is resolved.
3606         oldFocusedElement->dispatchFocusOutEvent(eventNames().DOMFocusOutEvent, newFocusedElement.copyRef()); // DOM level 2 name for compatibility.
3607
3608         if (m_focusedElement) {
3609             // handler shifted focus
3610             focusChangeBlocked = true;
3611             newFocusedElement = nullptr;
3612         }
3613             
3614         if (oldFocusedElement->isRootEditableElement())
3615             frame()->editor().didEndEditing();
3616
3617         if (view()) {
3618             if (Widget* oldWidget = widgetForElement(oldFocusedElement.get()))
3619                 oldWidget->setFocus(false);
3620             else
3621                 view()->setFocus(false);
3622         }
3623     }
3624
3625     if (newFocusedElement && newFocusedElement->isFocusable()) {
3626         if (newFocusedElement->isRootEditableElement() && !acceptsEditingFocus(newFocusedElement.get())) {
3627             // delegate blocks focus change
3628             focusChangeBlocked = true;
3629             goto SetFocusedNodeDone;
3630         }
3631         // Set focus on the new node
3632         m_focusedElement = newFocusedElement;
3633
3634         // Dispatch the focus event and let the node do any other focus related activities (important for text fields)
3635         m_focusedElement->dispatchFocusEvent(oldFocusedElement.copyRef(), direction);
3636
3637         if (m_focusedElement != newFocusedElement) {
3638             // handler shifted focus
3639             focusChangeBlocked = true;
3640             goto SetFocusedNodeDone;
3641         }
3642
3643         m_focusedElement->dispatchFocusInEvent(eventNames().focusinEvent, oldFocusedElement.copyRef()); // DOM level 3 bubbling focus event.
3644
3645         if (m_focusedElement != newFocusedElement) {
3646             // handler shifted focus
3647             focusChangeBlocked = true;
3648             goto SetFocusedNodeDone;
3649         }
3650
3651         // FIXME: We should remove firing DOMFocusInEvent event when we are sure no content depends
3652         // on it, probably when <rdar://problem/8503958> is m.
3653         m_focusedElement->dispatchFocusInEvent(eventNames().DOMFocusInEvent, oldFocusedElement.copyRef()); // DOM level 2 for compatibility.
3654
3655         if (m_focusedElement != newFocusedElement) {
3656             // handler shifted focus
3657             focusChangeBlocked = true;
3658             goto SetFocusedNodeDone;
3659         }
3660
3661         m_focusedElement->setFocus(true);
3662
3663         if (m_focusedElement->isRootEditableElement())
3664             frame()->editor().didBeginEditing();
3665
3666         // eww, I suck. set the qt focus correctly
3667         // ### find a better place in the code for this
3668         if (view()) {
3669             Widget* focusWidget = widgetForElement(m_focusedElement.get());
3670             if (focusWidget) {
3671                 // Make sure a widget has the right size before giving it focus.
3672                 // Otherwise, we are testing edge cases of the Widget code.
3673                 // Specifically, in WebCore this does not work well for text fields.
3674                 updateLayout();
3675                 // Re-get the widget in case updating the layout changed things.
3676                 focusWidget = widgetForElement(m_focusedElement.get());
3677             }
3678             if (focusWidget)
3679                 focusWidget->setFocus(true);
3680             else
3681                 view()->setFocus(true);
3682         }
3683     }
3684
3685     if (!focusChangeBlocked && m_focusedElement) {
3686         // Create the AXObject cache in a focus change because GTK relies on it.
3687         if (AXObjectCache* cache = axObjectCache())
3688             cache->handleFocusedUIElementChanged(oldFocusedElement.get(), newFocusedElement.get());
3689     }
3690
3691     if (!focusChangeBlocked && page())
3692         page()->chrome().focusedElementChanged(m_focusedElement.get());
3693
3694 SetFocusedNodeDone:
3695     updateStyleIfNeeded();
3696     return !focusChangeBlocked;
3697 }
3698
3699 void Document::setCSSTarget(Element* n)
3700 {
3701     if (m_cssTarget)
3702         m_cssTarget->setNeedsStyleRecalc();
3703     m_cssTarget = n;
3704     if (n)
3705         n->setNeedsStyleRecalc();
3706 }
3707
3708 void Document::registerNodeListForInvalidation(LiveNodeList& list)
3709 {
3710     m_nodeListAndCollectionCounts[list.invalidationType()]++;
3711     if (!list.isRootedAtDocument())
3712         return;
3713     ASSERT(!list.isRegisteredForInvalidationAtDocument());
3714     list.setRegisteredForInvalidationAtDocument(true);
3715     m_listsInvalidatedAtDocument.add(&list);
3716 }
3717
3718 void Document::unregisterNodeListForInvalidation(LiveNodeList& list)
3719 {
3720     m_nodeListAndCollectionCounts[list.invalidationType()]--;
3721     if (!list.isRegisteredForInvalidationAtDocument())
3722         return;
3723
3724     list.setRegisteredForInvalidationAtDocument(false);
3725     ASSERT(m_inInvalidateNodeListAndCollectionCaches
3726         ? m_listsInvalidatedAtDocument.isEmpty()
3727         : m_listsInvalidatedAtDocument.contains(&list));
3728     m_listsInvalidatedAtDocument.remove(&list);
3729 }
3730
3731 void Document::registerCollection(HTMLCollection& collection)
3732 {
3733     m_nodeListAndCollectionCounts[collection.invalidationType()]++;
3734     if (collection.isRootedAtDocument())
3735         m_collectionsInvalidatedAtDocument.add(&collection);
3736 }
3737
3738 void Document::unregisterCollection(HTMLCollection& collection)
3739 {
3740     ASSERT(m_nodeListAndCollectionCounts[collection.invalidationType()]);
3741     m_nodeListAndCollectionCounts[collection.invalidationType()]--;
3742     if (!collection.isRootedAtDocument())
3743         return;
3744
3745     m_collectionsInvalidatedAtDocument.remove(&collection);
3746 }
3747
3748 void Document::collectionCachedIdNameMap(const HTMLCollection& collection)
3749 {
3750     ASSERT_UNUSED(collection, collection.hasNamedElementCache());
3751     m_nodeListAndCollectionCounts[InvalidateOnIdNameAttrChange]++;
3752 }
3753
3754 void Document::collectionWillClearIdNameMap(const HTMLCollection& collection)
3755 {
3756     ASSERT_UNUSED(collection, collection.hasNamedElementCache());
3757     ASSERT(m_nodeListAndCollectionCounts[InvalidateOnIdNameAttrChange]);
3758     m_nodeListAndCollectionCounts[InvalidateOnIdNameAttrChange]--;
3759 }
3760
3761 void Document::attachNodeIterator(NodeIterator* ni)
3762 {
3763     m_nodeIterators.add(ni);
3764 }
3765
3766 void Document::detachNodeIterator(NodeIterator* ni)
3767 {
3768     // The node iterator can be detached without having been attached if its root node didn't have a document
3769     // when the iterator was created, but has it now.
3770     m_nodeIterators.remove(ni);
3771 }
3772
3773 void Document::moveNodeIteratorsToNewDocument(Node* node, Document* newDocument)
3774 {
3775     HashSet<NodeIterator*> nodeIteratorsList = m_nodeIterators;
3776     HashSet<NodeIterator*>::const_iterator nodeIteratorsEnd = nodeIteratorsList.end();
3777     for (HashSet<NodeIterator*>::const_iterator it = nodeIteratorsList.begin(); it != nodeIteratorsEnd; ++it) {
3778         if ((*it)->root() == node) {
3779             detachNodeIterator(*it);
3780             newDocument->attachNodeIterator(*it);
3781         }
3782     }
3783 }
3784
3785 void Document::updateRangesAfterChildrenChanged(ContainerNode& container)
3786 {
3787     if (!m_ranges.isEmpty()) {
3788         for (auto it = m_ranges.begin(), end = m_ranges.end(); it != end; ++it)
3789             (*it)->nodeChildrenChanged(container);
3790     }
3791 }
3792
3793 void Document::nodeChildrenWillBeRemoved(ContainerNode& container)
3794 {
3795     if (!m_ranges.isEmpty()) {
3796         for (auto it = m_ranges.begin(), end = m_ranges.end(); it != end; ++it)
3797             (*it)->nodeChildrenWillBeRemoved(container);
3798     }
3799
3800     for (auto it = m_nodeIterators.begin(), end = m_nodeIterators.end(); it != end; ++it) {
3801         for (Node* n = container.firstChild(); n; n = n->nextSibling())
3802             (*it)->nodeWillBeRemoved(*n);
3803     }
3804
3805     if (Frame* frame = this->frame()) {
3806         for (Node* n = container.firstChild(); n; n = n->nextSibling()) {
3807             frame->eventHandler().nodeWillBeRemoved(*n);
3808             frame->selection().nodeWillBeRemoved(*n);
3809             frame->page()->dragCaretController().nodeWillBeRemoved(*n);
3810         }
3811     }
3812
3813     if (m_markers->hasMarkers()) {
3814         for (Text* textNode = TextNodeTraversal::firstChild(container); textNode; textNode = TextNodeTraversal::nextSibling(*textNode))
3815             m_markers->removeMarkers(textNode);
3816     }
3817 }
3818
3819 void Document::nodeWillBeRemoved(Node& n)
3820 {
3821     HashSet<NodeIterator*>::const_iterator nodeIteratorsEnd = m_nodeIterators.end();
3822     for (HashSet<NodeIterator*>::const_iterator it = m_nodeIterators.begin(); it != nodeIteratorsEnd; ++it)
3823         (*it)->nodeWillBeRemoved(n);
3824
3825     if (!m_ranges.isEmpty()) {
3826         HashSet<Range*>::const_iterator rangesEnd = m_ranges.end();
3827         for (HashSet<Range*>::const_iterator it = m_ranges.begin(); it != rangesEnd; ++it)
3828             (*it)->nodeWillBeRemoved(n);
3829     }
3830
3831     if (Frame* frame = this->frame()) {
3832         frame->eventHandler().nodeWillBeRemoved(n);
3833         frame->selection().nodeWillBeRemoved(n);
3834         frame->page()->dragCaretController().nodeWillBeRemoved(n);
3835     }
3836
3837     if (is<Text>(n))
3838         m_markers->removeMarkers(&n);
3839 }
3840
3841 void Document::textInserted(Node* text, unsigned offset, unsigned length)
3842 {
3843     if (!m_ranges.isEmpty()) {
3844         for (auto& range : m_ranges)
3845             range->textInserted(text, offset, length);
3846     }
3847
3848     // Update the markers for spelling and grammar checking.
3849     m_markers->shiftMarkers(text, offset, length);
3850 }
3851
3852 void Document::textRemoved(Node* text, unsigned offset, unsigned length)
3853 {
3854     if (!m_ranges.isEmpty()) {
3855         for (auto& range : m_ranges)
3856             range->textRemoved(text, offset, length);
3857     }
3858
3859     // Update the markers for spelling and grammar checking.
3860     m_markers->removeMarkers(text, offset, length);
3861     m_markers->shiftMarkers(text, offset + length, 0 - length);
3862 }
3863
3864 void Document::textNodesMerged(Text* oldNode, unsigned offset)
3865 {
3866     if (!m_ranges.isEmpty()) {
3867         NodeWithIndex oldNodeWithIndex(oldNode);
3868         for (auto& range : m_ranges)
3869             range->textNodesMerged(oldNodeWithIndex, offset);
3870     }
3871
3872     // FIXME: This should update markers for spelling and grammar checking.
3873 }
3874
3875 void Document::textNodeSplit(Text* oldNode)
3876 {
3877     if (!m_ranges.isEmpty()) {
3878         HashSet<Range*>::const_iterator end = m_ranges.end();
3879         for (HashSet<Range*>::const_iterator it = m_ranges.begin(); it != end; ++it)
3880             (*it)->textNodeSplit(oldNode);
3881     }
3882
3883     // FIXME: This should update markers for spelling and grammar checking.
3884 }
3885
3886 void Document::createDOMWindow()
3887 {
3888     ASSERT(m_frame);
3889     ASSERT(!m_domWindow);
3890
3891     m_domWindow = DOMWindow::create(this);
3892
3893     ASSERT(m_domWindow->document() == this);
3894     ASSERT(m_domWindow->frame() == m_frame);
3895 }
3896
3897 void Document::takeDOMWindowFrom(Document* document)
3898 {
3899     ASSERT(m_frame);
3900     ASSERT(!m_domWindow);
3901     ASSERT(document->m_domWindow);
3902     // A valid DOMWindow is needed by CachedFrame for its documents.
3903     ASSERT(!document->inPageCache());
3904
3905     m_domWindow = document->m_domWindow.release();
3906     m_domWindow->didSecureTransitionTo(this);
3907
3908     ASSERT(m_domWindow->document() == this);
3909     ASSERT(m_domWindow->frame() == m_frame);
3910 }
3911
3912 void Document::setWindowAttributeEventListener(const AtomicString& eventType, PassRefPtr<EventListener> listener)
3913 {
3914     if (!m_domWindow)
3915         return;
3916     m_domWindow->setAttributeEventListener(eventType, listener);
3917 }
3918
3919 void Document::setWindowAttributeEventListener(const AtomicString& eventType, const QualifiedName& attributeName, const AtomicString& attributeValue)
3920 {
3921     if (!m_frame)
3922         return;
3923     setWindowAttributeEventListener(eventType, JSLazyEventListener::createForDOMWindow(*m_frame, attributeName, attributeValue));
3924 }
3925
3926 EventListener* Document::getWindowAttributeEventListener(const AtomicString& eventType)
3927 {
3928     if (!m_domWindow)
3929         return nullptr;
3930     return m_domWindow->getAttributeEventListener(eventType);
3931 }
3932
3933 void Document::dispatchWindowEvent(PassRefPtr<Event> event,  PassRefPtr<EventTarget> target)
3934 {
3935     ASSERT(!NoEventDispatchAssertion::isEventDispatchForbidden());
3936     if (!m_domWindow)
3937         return;
3938     m_domWindow->dispatchEvent(event, target);
3939 }
3940
3941 void Document::dispatchWindowLoadEvent()
3942 {
3943     ASSERT(!NoEventDispatchAssertion::isEventDispatchForbidden());
3944     if (!m_domWindow)
3945         return;
3946     m_domWindow->dispatchLoadEvent();
3947     m_loadEventFinished = true;
3948     m_cachedResourceLoader->documentDidFinishLoadEvent();
3949 }
3950
3951 void Document::enqueueWindowEvent(PassRefPtr<Event> event)
3952 {
3953     event->setTarget(m_domWindow.get());
3954     m_eventQueue.enqueueEvent(event);
3955 }
3956
3957 void Document::enqueueDocumentEvent(PassRefPtr<Event> event)
3958 {
3959     event->setTarget(this);
3960     m_eventQueue.enqueueEvent(event);
3961 }
3962
3963 void Document::enqueueOverflowEvent(PassRefPtr<Event> event)
3964 {
3965     m_eventQueue.enqueueEvent(event);
3966 }
3967
3968 RefPtr<Event> Document::createEvent(const String& eventType, ExceptionCode& ec)
3969 {
3970     RefPtr<Event> event = EventFactory::create(eventType);
3971     if (event)
3972         return event.release();
3973
3974     ec = NOT_SUPPORTED_ERR;
3975     return nullptr;
3976 }
3977
3978 void Document::addListenerTypeIfNeeded(const AtomicString& eventType)
3979 {
3980     if (eventType == eventNames().DOMSubtreeModifiedEvent)
3981         addListenerType(DOMSUBTREEMODIFIED_LISTENER);
3982     else if (eventType == eventNames().DOMNodeInsertedEvent)
3983         addListenerType(DOMNODEINSERTED_LISTENER);
3984     else if (eventType == eventNames().DOMNodeRemovedEvent)
3985         addListenerType(DOMNODEREMOVED_LISTENER);
3986     else if (eventType == eventNames().DOMNodeRemovedFromDocumentEvent)
3987         addListenerType(DOMNODEREMOVEDFROMDOCUMENT_LISTENER);
3988     else if (eventType == eventNames().DOMNodeInsertedIntoDocumentEvent)
3989         addListenerType(DOMNODEINSERTEDINTODOCUMENT_LISTENER);
3990     else if (eventType == eventNames().DOMCharacterDataModifiedEvent)
3991         addListenerType(DOMCHARACTERDATAMODIFIED_LISTENER);
3992     else if (eventType == eventNames().overflowchangedEvent)
3993         addListenerType(OVERFLOWCHANGED_LISTENER);
3994     else if (eventType == eventNames().webkitAnimationStartEvent || eventType == eventNames().animationstartEvent)
3995         addListenerType(ANIMATIONSTART_LISTENER);
3996     else if (eventType == eventNames().webkitAnimationEndEvent || eventType == eventNames().animationendEvent)
3997         addListenerType(ANIMATIONEND_LISTENER);
3998     else if (eventType == eventNames().webkitAnimationIterationEvent || eventType == eventNames().animationiterationEvent)
3999         addListenerType(ANIMATIONITERATION_LISTENER);
4000     else if (eventType == eventNames().webkitTransitionEndEvent || eventType == eventNames().transitionendEvent)
4001         addListenerType(TRANSITIONEND_LISTENER);
4002     else if (eventType == eventNames().beforeloadEvent)
4003         addListenerType(BEFORELOAD_LISTENER);
4004     else if (eventType == eventNames().scrollEvent)
4005         addListenerType(SCROLL_LISTENER);
4006 }
4007
4008 CSSStyleDeclaration* Document::getOverrideStyle(Element*, const String&)
4009 {
4010     return nullptr;
4011 }
4012
4013 HTMLFrameOwnerElement* Document::ownerElement() const
4014 {
4015     if (!frame())
4016         return nullptr;
4017     return frame()->ownerElement();
4018 }
4019
4020 String Document::cookie(ExceptionCode& ec)
4021 {
4022     if (page() && !page()->settings().cookieEnabled())
4023         return String();
4024
4025     // FIXME: The HTML5 DOM spec states that this attribute can raise an
4026     // INVALID_STATE_ERR exception on getting if the Document has no
4027     // browsing context.
4028
4029     if (!securityOrigin()->canAccessCookies()) {
4030         ec = SECURITY_ERR;
4031         return String();
4032     }
4033
4034     URL cookieURL = this->cookieURL();
4035     if (cookieURL.isEmpty())
4036         return String();
4037
4038     if (!isDOMCookieCacheValid())
4039         setCachedDOMCookies(cookies(this, cookieURL));
4040
4041     return cachedDOMCookies();
4042 }
4043
4044 void Document::setCookie(const String& value, ExceptionCode& ec)
4045 {
4046     if (page() && !page()->settings().cookieEnabled())
4047         return;
4048
4049     // FIXME: The HTML5 DOM spec states that this attribute can raise an
4050     // INVALID_STATE_ERR exception on setting if the Document has no
4051     // browsing context.
4052
4053     if (!securityOrigin()->canAccessCookies()) {
4054         ec = SECURITY_ERR;
4055         return;
4056     }
4057
4058     URL cookieURL = this->cookieURL();
4059     if (cookieURL.isEmpty())
4060         return;
4061
4062     invalidateDOMCookieCache();
4063     setCookies(this, cookieURL, value);
4064 }
4065
4066 String Document::referrer() const
4067 {
4068     if (frame())
4069         return frame()->loader().referrer();
4070     return String();
4071 }
4072
4073 String Document::origin() const
4074 {
4075     return securityOrigin()->databaseIdentifier();
4076 }
4077
4078 String Document::domain() const
4079 {
4080     return securityOrigin()->domain();
4081 }
4082
4083 void Document::setDomain(const String& newDomain, ExceptionCode& ec)
4084 {
4085     if (SchemeRegistry::isDomainRelaxationForbiddenForURLScheme(securityOrigin()->protocol())) {
4086         ec = SECURITY_ERR;
4087         return;
4088     }
4089
4090     // Both NS and IE specify that changing the domain is only allowed when
4091     // the new domain is a suffix of the old domain.
4092
4093     // FIXME: We should add logging indicating why a domain was not allowed.
4094
4095     // If the new domain is the same as the old domain, still call
4096     // securityOrigin()->setDomainForDOM. This will change the
4097     // security check behavior. For example, if a page loaded on port 8000
4098     // assigns its current domain using document.domain, the page will
4099     // allow other pages loaded on different ports in the same domain that
4100     // have also assigned to access this page.
4101     if (equalIgnoringCase(domain(), newDomain)) {
4102         securityOrigin()->setDomainFromDOM(newDomain);
4103         return;
4104     }
4105
4106     int oldLength = domain().length();
4107     int newLength = newDomain.length();
4108     // e.g. newDomain = webkit.org (10) and domain() = www.webkit.org (14)
4109     if (newLength >= oldLength) {
4110         ec = SECURITY_ERR;
4111         return;
4112     }
4113
4114     String test = domain();
4115     // Check that it's a subdomain, not e.g. "ebkit.org"
4116     if (test[oldLength - newLength - 1] != '.') {
4117         ec = SECURITY_ERR;
4118         return;
4119     }
4120
4121     // Now test is "webkit.org" from domain()
4122     // and we check that it's the same thing as newDomain
4123     test.remove(0, oldLength - newLength);
4124     if (test != newDomain) {
4125         ec = SECURITY_ERR;
4126         return;
4127     }
4128
4129     securityOrigin()->setDomainFromDOM(newDomain);
4130 }
4131
4132 // http://www.whatwg.org/specs/web-apps/current-work/#dom-document-lastmodified
4133 String Document::lastModified() const
4134 {
4135     DateComponents date;
4136     bool foundDate = false;
4137     if (m_frame) {
4138         String httpLastModified;
4139         if (DocumentLoader* documentLoader = loader()) 
4140             httpLastModified = documentLoader->response().httpHeaderField(HTTPHeaderName::LastModified);
4141         if (!httpLastModified.isEmpty()) {
4142             date.setMillisecondsSinceEpochForDateTime(parseDate(httpLastModified));
4143             foundDate = true;
4144         }
4145     }
4146     // FIXME: If this document came from the file system, the HTML5
4147     // specificiation tells us to read the last modification date from the file
4148     // system.
4149     if (!foundDate) {
4150         double fallbackDate = currentTimeMS();
4151 #if ENABLE(WEB_REPLAY)
4152         InputCursor& cursor = inputCursor();
4153         if (cursor.isCapturing())
4154             cursor.appendInput<DocumentLastModifiedDate>(fallbackDate);
4155         else if (cursor.isReplaying()) {
4156             if (DocumentLastModifiedDate* input = cursor.fetchInput<DocumentLastModifiedDate>())
4157                 fallbackDate = input->fallbackValue();
4158         }
4159 #endif
4160         date.setMillisecondsSinceEpochForDateTime(fallbackDate);
4161     }
4162
4163     return String::format("%02d/%02d/%04d %02d:%02d:%02d", date.month() + 1, date.monthDay(), date.fullYear(), date.hour(), date.minute(), date.second());
4164 }
4165
4166 void Document::setCookieURL(const URL& url)
4167 {
4168     if (m_cookieURL == url)
4169         return;
4170     m_cookieURL = url;
4171     invalidateDOMCookieCache();
4172 }
4173
4174 static bool isValidNameNonASCII(const LChar* characters, unsigned length)
4175 {
4176     if (!isValidNameStart(characters[0]))
4177         return false;
4178
4179     for (unsigned i = 1; i < length; ++i) {
4180         if (!isValidNamePart(characters[i]))
4181             return false;
4182     }
4183
4184     return true;
4185 }
4186
4187 static bool isValidNameNonASCII(const UChar* characters, unsigned length)
4188 {
4189     unsigned i = 0;
4190
4191     UChar32 c;
4192     U16_NEXT(characters, i, length, c)
4193     if (!isValidNameStart(c))
4194         return false;
4195
4196     while (i < length) {
4197         U16_NEXT(characters, i, length, c)
4198         if (!isValidNamePart(c))
4199             return false;
4200     }
4201
4202     return true;
4203 }
4204
4205 template<typename CharType>
4206 static inline bool isValidNameASCII(const CharType* characters, unsigned length)
4207 {
4208     CharType c = characters[0];
4209     if (!(isASCIIAlpha(c) || c == ':' || c == '_'))
4210         return false;
4211
4212     for (unsigned i = 1; i < length; ++i) {
4213         c = characters[i];
4214         if (!(isASCIIAlphanumeric(c) || c == ':' || c == '_' || c == '-' || c == '.'))
4215             return false;
4216     }
4217
4218     return true;
4219 }
4220
4221 bool Document::isValidName(const String& name)
4222 {
4223     unsigned length = name.length();
4224     if (!length)
4225         return false;
4226
4227     if (name.is8Bit()) {
4228         const LChar* characters = name.characters8();
4229
4230         if (isValidNameASCII(characters, length))
4231             return true;
4232
4233         return isValidNameNonASCII(characters, length);
4234     }
4235
4236     const UChar* characters = name.characters16();
4237
4238     if (isValidNameASCII(characters, length))
4239         return true;
4240
4241     return isValidNameNonASCII(characters, length);
4242 }
4243
4244 bool Document::parseQualifiedName(const String& qualifiedName, String& prefix, String& localName, ExceptionCode& ec)
4245 {
4246     unsigned length = qualifiedName.length();
4247
4248     if (!length) {
4249         ec = INVALID_CHARACTER_ERR;
4250         return false;
4251     }
4252
4253     bool nameStart = true;
4254     bool sawColon = false;
4255     int colonPos = 0;
4256
4257     for (unsigned i = 0; i < length;) {
4258         UChar32 c;
4259         U16_NEXT(qualifiedName, i, length, c)
4260         if (c == ':') {
4261             if (sawColon) {
4262                 ec = NAMESPACE_ERR;
4263                 return false; // multiple colons: not allowed
4264             }
4265             nameStart = true;
4266             sawColon = true;
4267             colonPos = i - 1;
4268         } else if (nameStart) {
4269             if (!isValidNameStart(c)) {
4270                 ec = INVALID_CHARACTER_ERR;
4271                 return false;
4272             }
4273             nameStart = false;
4274         } else {
4275             if (!isValidNamePart(c)) {
4276                 ec = INVALID_CHARACTER_ERR;
4277                 return false;
4278             }
4279         }
4280     }
4281
4282     if (!sawColon) {
4283         prefix = String();
4284         localName = qualifiedName;
4285     } else {
4286         prefix = qualifiedName.substring(0, colonPos);
4287         if (prefix.isEmpty()) {
4288             ec = NAMESPACE_ERR;
4289             return false;
4290         }
4291         localName = qualifiedName.substring(colonPos + 1);
4292     }
4293
4294     if (localName.isEmpty()) {
4295         ec = NAMESPACE_ERR;
4296         return false;
4297     }
4298
4299     return true;
4300 }
4301
4302 void Document::setDecoder(PassRefPtr<TextResourceDecoder> decoder)
4303 {
4304     m_decoder = decoder;
4305 }
4306
4307 URL Document::completeURL(const String& url, const URL& baseURLOverride) const
4308 {
4309     // Always return a null URL when passed a null string.
4310     // FIXME: Should we change the URL constructor to have this behavior?
4311     // See also [CSS]StyleSheet::completeURL(const String&)
4312     if (url.isNull())
4313         return URL();
4314     const URL& baseURL = ((baseURLOverride.isEmpty() || baseURLOverride == blankURL()) && parentDocument()) ? parentDocument()->baseURL() : baseURLOverride;
4315     if (!m_decoder)
4316         return URL(baseURL, url);
4317     return URL(baseURL, url, m_decoder->encoding());
4318 }
4319
4320 URL Document::completeURL(const String& url) const
4321 {
4322     return completeURL(url, m_baseURL);
4323 }