Add IDL for requestIdleCallback
[WebKit-https.git] / Source / WebCore / dom / Document.h
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-2019 Apple Inc. All rights reserved.
7  * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
8  * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)
9  * Copyright (C) 2011 Google Inc. All rights reserved.
10  *
11  * This library is free software; you can redistribute it and/or
12  * modify it under the terms of the GNU Library General Public
13  * License as published by the Free Software Foundation; either
14  * version 2 of the License, or (at your option) any later version.
15  *
16  * This library is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
19  * Library General Public License for more details.
20  *
21  * You should have received a copy of the GNU Library General Public License
22  * along with this library; see the file COPYING.LIB.  If not, write to
23  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
24  * Boston, MA 02110-1301, USA.
25  *
26  */
27
28 #pragma once
29
30 #include "CSSRegisteredCustomProperty.h"
31 #include "Color.h"
32 #include "ContainerNode.h"
33 #include "DisabledAdaptations.h"
34 #include "DocumentEventQueue.h"
35 #include "DocumentIdentifier.h"
36 #include "DocumentTiming.h"
37 #include "ElementIdentifier.h"
38 #include "FocusDirection.h"
39 #include "FontSelectorClient.h"
40 #include "FrameDestructionObserver.h"
41 #include "GenericTaskQueue.h"
42 #include "GraphicsTypes.h"
43 #include "MediaProducer.h"
44 #include "MutationObserver.h"
45 #include "OrientationNotifier.h"
46 #include "PageIdentifier.h"
47 #include "PlatformEvent.h"
48 #include "ReferrerPolicy.h"
49 #include "Region.h"
50 #include "RegistrableDomain.h"
51 #include "RenderPtr.h"
52 #include "ScriptExecutionContext.h"
53 #include "SecurityPolicyViolationEvent.h"
54 #include "StringWithDirection.h"
55 #include "StyleColor.h"
56 #include "Supplementable.h"
57 #include "TextResourceDecoder.h"
58 #include "Timer.h"
59 #include "TreeScope.h"
60 #include "UserActionElementSet.h"
61 #include "ViewportArguments.h"
62 #include "VisibilityState.h"
63 #include <pal/SessionID.h>
64 #include <wtf/Deque.h>
65 #include <wtf/Forward.h>
66 #include <wtf/HashCountedSet.h>
67 #include <wtf/HashSet.h>
68 #include <wtf/Logger.h>
69 #include <wtf/ObjectIdentifier.h>
70 #include <wtf/UniqueRef.h>
71 #include <wtf/WeakHashSet.h>
72 #include <wtf/WeakPtr.h>
73 #include <wtf/text/AtomStringHash.h>
74
75 #if PLATFORM(IOS_FAMILY)
76 #include "EventTrackingRegions.h"
77 #endif
78
79 #if ENABLE(IOS_TOUCH_EVENTS)
80 #include <wtf/ThreadingPrimitives.h>
81 #endif
82
83 namespace JSC {
84 class CallFrame;
85 class InputCursor;
86 using ExecState = CallFrame;
87 }
88
89 namespace WebCore {
90
91 class ApplicationStateChangeListener;
92 class AXObjectCache;
93 class Attr;
94 class CDATASection;
95 class CSSCustomPropertyValue;
96 class CSSFontSelector;
97 class CSSStyleDeclaration;
98 class CSSStyleSheet;
99 class CachedCSSStyleSheet;
100 class CachedFrameBase;
101 class CachedResourceLoader;
102 class CachedScript;
103 class CanvasRenderingContext2D;
104 class CharacterData;
105 class Comment;
106 class ConstantPropertyMap;
107 class ContentChangeObserver;
108 class DOMImplementation;
109 class DOMSelection;
110 class DOMTimerHoldingTank;
111 class DOMWindow;
112 class DOMWrapperWorld;
113 class Database;
114 class DatabaseThread;
115 class DocumentFragment;
116 class DocumentLoader;
117 class DocumentMarkerController;
118 class DocumentParser;
119 class DocumentSharedObjectPool;
120 class DocumentTimeline;
121 class DocumentType;
122 class EditingBehavior;
123 class ExtensionStyleSheets;
124 class FloatQuad;
125 class FloatRect;
126 class FontFaceSet;
127 class FormController;
128 class Frame;
129 class FrameView;
130 class FullscreenManager;
131 class HTMLAllCollection;
132 class HTMLBodyElement;
133 class HTMLCanvasElement;
134 class HTMLCollection;
135 class HTMLDocument;
136 class HTMLElement;
137 class HTMLFrameOwnerElement;
138 class HTMLHeadElement;
139 class HTMLIFrameElement;
140 class HTMLImageElement;
141 class HTMLMapElement;
142 class HTMLMediaElement;
143 class HTMLPictureElement;
144 class HTMLScriptElement;
145 class HitTestLocation;
146 class HitTestRequest;
147 class HitTestResult;
148 class IdleCallbackController;
149 class IdleRequestCallback;
150 class ImageBitmapRenderingContext;
151 class IntPoint;
152 class JSNode;
153 class LayoutPoint;
154 class LayoutRect;
155 class LiveNodeList;
156 class Locale;
157 class Location;
158 class MediaCanStartListener;
159 class MediaPlaybackTarget;
160 class MediaPlaybackTargetClient;
161 class MediaQueryList;
162 class MediaQueryMatcher;
163 class MessagePortChannelProvider;
164 class MouseEventWithHitTestResults;
165 class NodeFilter;
166 class NodeIterator;
167 class Page;
168 class PaintWorkletGlobalScope;
169 class PlatformMouseEvent;
170 class ProcessingInstruction;
171 class QualifiedName;
172 class Quirks;
173 class Range;
174 class RenderTreeBuilder;
175 class RenderView;
176 class RequestAnimationFrameCallback;
177 class SVGDocumentExtensions;
178 class SVGSVGElement;
179 class SVGUseElement;
180 class SWClientConnection;
181 class ScriptElementData;
182 class ScriptModuleLoader;
183 class ScriptRunner;
184 class ScriptableDocumentParser;
185 class ScriptedAnimationController;
186 class SecurityOrigin;
187 class SegmentedString;
188 class SelectorQuery;
189 class SelectorQueryCache;
190 class SerializedScriptValue;
191 class Settings;
192 class StringCallback;
193 class StyleResolver;
194 class StyleSheet;
195 class StyleSheetContents;
196 class StyleSheetList;
197 class Text;
198 class TextResourceDecoder;
199 class TreeWalker;
200 class UndoManager;
201 class VisibilityChangeClient;
202 class VisitedLinkState;
203 class WebAnimation;
204 class WebGL2RenderingContext;
205 class WebGLRenderingContext;
206 class GPUCanvasContext;
207 class WindowProxy;
208 class Worklet;
209 class XPathEvaluator;
210 class XPathExpression;
211 class XPathNSResolver;
212 class XPathResult;
213
214 template<typename> class ExceptionOr;
215
216 enum CollectionType;
217 enum class ShouldOpenExternalURLsPolicy : uint8_t;
218
219 enum class RouteSharingPolicy : uint8_t;
220
221 using PlatformDisplayID = uint32_t;
222
223 #if ENABLE(XSLT)
224 class TransformSource;
225 #endif
226
227 #if ENABLE(TOUCH_EVENTS) || ENABLE(IOS_TOUCH_EVENTS)
228 class Touch;
229 class TouchList;
230 #endif
231
232 #if ENABLE(DEVICE_ORIENTATION)
233 #if PLATFORM(IOS_FAMILY)
234 class DeviceMotionClient;
235 class DeviceMotionController;
236 class DeviceOrientationClient;
237 class DeviceOrientationController;
238 #endif
239 class DeviceOrientationAndMotionAccessController;
240 #endif
241
242 #if ENABLE(TEXT_AUTOSIZING)
243 class TextAutoSizing;
244 #endif
245
246 #if ENABLE(MEDIA_SESSION)
247 class MediaSession;
248 #endif
249
250 #if ENABLE(ATTACHMENT_ELEMENT)
251 class HTMLAttachmentElement;
252 #endif
253
254 #if ENABLE(INTERSECTION_OBSERVER)
255 class IntersectionObserver;
256 #endif
257
258 #if ENABLE(RESIZE_OBSERVER)
259 class ResizeObserver;
260 #endif
261
262 namespace Style {
263 class Scope;
264 };
265
266 const uint64_t HTMLMediaElementInvalidID = 0;
267
268 enum PageshowEventPersistence { PageshowEventNotPersisted, PageshowEventPersisted };
269
270 enum NodeListInvalidationType {
271     DoNotInvalidateOnAttributeChanges,
272     InvalidateOnClassAttrChange,
273     InvalidateOnIdNameAttrChange,
274     InvalidateOnNameAttrChange,
275     InvalidateOnForTypeAttrChange,
276     InvalidateForFormControls,
277     InvalidateOnHRefAttrChange,
278     InvalidateOnAnyAttrChange,
279 };
280 const int numNodeListInvalidationTypes = InvalidateOnAnyAttrChange + 1;
281
282 enum class EventHandlerRemoval { One, All };
283 typedef HashCountedSet<Node*> EventTargetSet;
284
285 enum DocumentClass {
286     DefaultDocumentClass = 0,
287     HTMLDocumentClass = 1,
288     XHTMLDocumentClass = 1 << 1,
289     ImageDocumentClass = 1 << 2,
290     PluginDocumentClass = 1 << 3,
291     MediaDocumentClass = 1 << 4,
292     SVGDocumentClass = 1 << 5,
293     TextDocumentClass = 1 << 6,
294     XMLDocumentClass = 1 << 7,
295 };
296 typedef unsigned char DocumentClassFlags;
297
298 enum class DocumentCompatibilityMode : unsigned char {
299     NoQuirksMode = 1,
300     QuirksMode = 1 << 1,
301     LimitedQuirksMode = 1 << 2
302 };
303
304 enum DimensionsCheck { WidthDimensionsCheck = 1 << 0, HeightDimensionsCheck = 1 << 1, AllDimensionsCheck = 1 << 2 };
305
306 enum class SelectionRestorationMode { Restore, SetDefault };
307
308 enum class HttpEquivPolicy {
309     Enabled,
310     DisabledBySettings,
311     DisabledByContentDispositionAttachmentSandbox
312 };
313
314 enum class CustomElementNameValidationStatus {
315     Valid,
316     FirstCharacterIsNotLowercaseASCIILetter,
317     ContainsNoHyphen,
318     ContainsUppercaseASCIILetter,
319     ContainsDisallowedCharacter,
320     ConflictsWithStandardElementName
321 };
322
323 using RenderingContext = Variant<
324 #if ENABLE(WEBGL)
325     RefPtr<WebGLRenderingContext>,
326 #endif
327 #if ENABLE(WEBGL2)
328     RefPtr<WebGL2RenderingContext>,
329 #endif
330 #if ENABLE(WEBGPU)
331     RefPtr<GPUCanvasContext>,
332 #endif
333     RefPtr<ImageBitmapRenderingContext>,
334     RefPtr<CanvasRenderingContext2D>
335 >;
336
337 class DocumentParserYieldToken {
338     WTF_MAKE_FAST_ALLOCATED;
339 public:
340     WEBCORE_EXPORT DocumentParserYieldToken(Document&);
341     WEBCORE_EXPORT ~DocumentParserYieldToken();
342
343 private:
344     WeakPtr<Document> m_document;
345 };
346
347 class Document
348     : public ContainerNode
349     , public TreeScope
350     , public ScriptExecutionContext
351     , public FontSelectorClient
352     , public FrameDestructionObserver
353     , public Supplementable<Document>
354     , public Logger::Observer {
355     WTF_MAKE_ISO_ALLOCATED(Document);
356 public:
357     static Ref<Document> create(const URL&);
358     static Ref<Document> createNonRenderedPlaceholder(Frame&, const URL&);
359     static Ref<Document> create(Document&);
360
361     virtual ~Document();
362
363     // Nodes belonging to this document increase referencingNodeCount -
364     // these are enough to keep the document from being destroyed, but
365     // not enough to keep it from removing its children. This allows a
366     // node that outlives its document to still have a valid document
367     // pointer without introducing reference cycles.
368     void incrementReferencingNodeCount()
369     {
370         ASSERT(!m_deletionHasBegun);
371         ++m_referencingNodeCount;
372     }
373
374     void decrementReferencingNodeCount()
375     {
376         ASSERT(!m_deletionHasBegun || !m_referencingNodeCount);
377         --m_referencingNodeCount;
378         if (!m_referencingNodeCount && !refCount()) {
379 #if !ASSERT_DISABLED
380             m_deletionHasBegun = true;
381 #endif
382             m_refCountAndParentBit = s_refCountIncrement; // Avoid double destruction through use of Ref<T>/RefPtr<T>. (This is a security mitigation in case of programmer error. It will ASSERT in debug builds.)
383             delete this;
384         }
385     }
386
387     unsigned referencingNodeCount() const { return m_referencingNodeCount; }
388
389     void removedLastRef();
390
391     DocumentIdentifier identifier() const { return m_identifier; }
392
393     using DocumentsMap = HashMap<DocumentIdentifier, Document*>;
394     WEBCORE_EXPORT static DocumentsMap::ValuesIteratorRange allDocuments();
395     WEBCORE_EXPORT static DocumentsMap& allDocumentsMap();
396
397     WEBCORE_EXPORT ElementIdentifier identifierForElement(Element&);
398     WEBCORE_EXPORT Element* searchForElementByIdentifier(const ElementIdentifier&);
399     void identifiedElementWasRemovedFromDocument(Element&);
400
401     MediaQueryMatcher& mediaQueryMatcher();
402
403     using ContainerNode::ref;
404     using ContainerNode::deref;
405     using TreeScope::rootNode;
406
407     bool canContainRangeEndPoint() const final { return true; }
408
409     Element* elementForAccessKey(const String& key);
410     void invalidateAccessKeyCache();
411
412     ExceptionOr<SelectorQuery&> selectorQueryForString(const String&);
413     void clearSelectorQueryCache();
414
415     void setViewportArguments(const ViewportArguments& viewportArguments) { m_viewportArguments = viewportArguments; }
416     WEBCORE_EXPORT ViewportArguments viewportArguments() const;
417
418     OptionSet<DisabledAdaptations> disabledAdaptations() const { return m_disabledAdaptations; }
419 #ifndef NDEBUG
420     bool didDispatchViewportPropertiesChanged() const { return m_didDispatchViewportPropertiesChanged; }
421 #endif
422
423     void setReferrerPolicy(ReferrerPolicy);
424     ReferrerPolicy referrerPolicy() const { return m_referrerPolicy.valueOr(ReferrerPolicy::NoReferrerWhenDowngrade); }
425
426     WEBCORE_EXPORT DocumentType* doctype() const;
427
428     WEBCORE_EXPORT DOMImplementation& implementation();
429     
430     Element* documentElement() const { return m_documentElement.get(); }
431     static ptrdiff_t documentElementMemoryOffset() { return OBJECT_OFFSETOF(Document, m_documentElement); }
432
433     WEBCORE_EXPORT Element* activeElement();
434     WEBCORE_EXPORT bool hasFocus() const;
435
436     bool hasManifest() const;
437     
438     WEBCORE_EXPORT ExceptionOr<Ref<Element>> createElementForBindings(const AtomString& tagName);
439     WEBCORE_EXPORT Ref<DocumentFragment> createDocumentFragment();
440     WEBCORE_EXPORT Ref<Text> createTextNode(const String& data);
441     WEBCORE_EXPORT Ref<Comment> createComment(const String& data);
442     WEBCORE_EXPORT ExceptionOr<Ref<CDATASection>> createCDATASection(const String& data);
443     WEBCORE_EXPORT ExceptionOr<Ref<ProcessingInstruction>> createProcessingInstruction(const String& target, const String& data);
444     WEBCORE_EXPORT ExceptionOr<Ref<Attr>> createAttribute(const String& name);
445     WEBCORE_EXPORT ExceptionOr<Ref<Attr>> createAttributeNS(const AtomString& namespaceURI, const String& qualifiedName, bool shouldIgnoreNamespaceChecks = false);
446     WEBCORE_EXPORT ExceptionOr<Ref<Node>> importNode(Node& nodeToImport, bool deep);
447     WEBCORE_EXPORT ExceptionOr<Ref<Element>> createElementNS(const AtomString& namespaceURI, const String& qualifiedName);
448     WEBCORE_EXPORT Ref<Element> createElement(const QualifiedName&, bool createdByParser);
449
450     static CustomElementNameValidationStatus validateCustomElementName(const AtomString&);
451
452     WEBCORE_EXPORT RefPtr<Range> caretRangeFromPoint(int x, int y);
453     RefPtr<Range> caretRangeFromPoint(const LayoutPoint& clientPoint);
454
455     WEBCORE_EXPORT Element* scrollingElementForAPI();
456     Element* scrollingElement();
457
458     enum ReadyState { Loading, Interactive,  Complete };
459     ReadyState readyState() const { return m_readyState; }
460
461     WEBCORE_EXPORT String defaultCharsetForLegacyBindings() const;
462
463     String charset() const { return Document::encoding(); }
464     WEBCORE_EXPORT String characterSetWithUTF8Fallback() const;
465     TextEncoding textEncoding() const;
466
467     AtomString encoding() const { return textEncoding().domName(); }
468
469     WEBCORE_EXPORT void setCharset(const String&); // Used by ObjC / GOBject bindings only.
470
471     void setContent(const String&);
472
473     String suggestedMIMEType() const;
474
475     void overrideMIMEType(const String&);
476     WEBCORE_EXPORT String contentType() const;
477
478     String contentLanguage() const { return m_contentLanguage; }
479     void setContentLanguage(const String&);
480
481     String xmlEncoding() const { return m_xmlEncoding; }
482     String xmlVersion() const { return m_xmlVersion; }
483     enum class StandaloneStatus : uint8_t { Unspecified, Standalone, NotStandalone };
484     bool xmlStandalone() const { return m_xmlStandalone == StandaloneStatus::Standalone; }
485     StandaloneStatus xmlStandaloneStatus() const { return m_xmlStandalone; }
486     bool hasXMLDeclaration() const { return m_hasXMLDeclaration; }
487
488     void setXMLEncoding(const String& encoding) { m_xmlEncoding = encoding; } // read-only property, only to be set from XMLDocumentParser
489     WEBCORE_EXPORT ExceptionOr<void> setXMLVersion(const String&);
490     WEBCORE_EXPORT void setXMLStandalone(bool);
491     void setHasXMLDeclaration(bool hasXMLDeclaration) { m_hasXMLDeclaration = hasXMLDeclaration; }
492
493     String documentURI() const { return m_documentURI; }
494     WEBCORE_EXPORT void setDocumentURI(const String&);
495
496     WEBCORE_EXPORT VisibilityState visibilityState() const;
497     void visibilityStateChanged();
498     WEBCORE_EXPORT bool hidden() const;
499
500     void setTimerThrottlingEnabled(bool);
501     bool isTimerThrottlingEnabled() const { return m_isTimerThrottlingEnabled; }
502
503     WEBCORE_EXPORT ExceptionOr<Ref<Node>> adoptNode(Node& source);
504
505     WEBCORE_EXPORT Ref<HTMLCollection> images();
506     WEBCORE_EXPORT Ref<HTMLCollection> embeds();
507     WEBCORE_EXPORT Ref<HTMLCollection> plugins(); // an alias for embeds() required for the JS DOM bindings.
508     WEBCORE_EXPORT Ref<HTMLCollection> applets();
509     WEBCORE_EXPORT Ref<HTMLCollection> links();
510     WEBCORE_EXPORT Ref<HTMLCollection> forms();
511     WEBCORE_EXPORT Ref<HTMLCollection> anchors();
512     WEBCORE_EXPORT Ref<HTMLCollection> scripts();
513     Ref<HTMLCollection> all();
514     Ref<HTMLCollection> allFilteredByName(const AtomString&);
515
516     Ref<HTMLCollection> windowNamedItems(const AtomString&);
517     Ref<HTMLCollection> documentNamedItems(const AtomString&);
518
519     // Other methods (not part of DOM)
520     bool isSynthesized() const { return m_isSynthesized; }
521     bool isHTMLDocument() const { return m_documentClasses & HTMLDocumentClass; }
522     bool isXHTMLDocument() const { return m_documentClasses & XHTMLDocumentClass; }
523     bool isXMLDocument() const { return m_documentClasses & XMLDocumentClass; }
524     bool isImageDocument() const { return m_documentClasses & ImageDocumentClass; }
525     bool isSVGDocument() const { return m_documentClasses & SVGDocumentClass; }
526     bool isPluginDocument() const { return m_documentClasses & PluginDocumentClass; }
527     bool isMediaDocument() const { return m_documentClasses & MediaDocumentClass; }
528     bool isTextDocument() const { return m_documentClasses & TextDocumentClass; }
529     bool hasSVGRootNode() const;
530     virtual bool isFrameSet() const { return false; }
531
532     static ptrdiff_t documentClassesMemoryOffset() { return OBJECT_OFFSETOF(Document, m_documentClasses); }
533     static uint32_t isHTMLDocumentClassFlag() { return HTMLDocumentClass; }
534
535     bool isSrcdocDocument() const { return m_isSrcdocDocument; }
536
537     bool sawElementsInKnownNamespaces() const { return m_sawElementsInKnownNamespaces; }
538
539     StyleResolver& userAgentShadowTreeStyleResolver();
540
541     CSSFontSelector& fontSelector() { return m_fontSelector; }
542
543     WEBCORE_EXPORT bool haveStylesheetsLoaded() const;
544     bool isIgnoringPendingStylesheets() const { return m_ignorePendingStylesheets; }
545
546     WEBCORE_EXPORT StyleSheetList& styleSheets();
547
548     Style::Scope& styleScope() { return *m_styleScope; }
549     const Style::Scope& styleScope() const { return *m_styleScope; }
550     ExtensionStyleSheets& extensionStyleSheets() { return *m_extensionStyleSheets; }
551     const ExtensionStyleSheets& extensionStyleSheets() const { return *m_extensionStyleSheets; }
552
553     bool gotoAnchorNeededAfterStylesheetsLoad() { return m_gotoAnchorNeededAfterStylesheetsLoad; }
554     void setGotoAnchorNeededAfterStylesheetsLoad(bool b) { m_gotoAnchorNeededAfterStylesheetsLoad = b; }
555
556     void evaluateMediaQueryList();
557
558     FormController& formController();
559     Vector<String> formElementsState() const;
560     void setStateForNewFormElements(const Vector<String>&);
561
562     WEBCORE_EXPORT FrameView* view() const; // Can be null.
563     WEBCORE_EXPORT Page* page() const; // Can be null.
564     const Settings& settings() const { return m_settings.get(); }
565     Settings& mutableSettings() { return m_settings.get(); }
566     EditingBehavior editingBehavior() const;
567
568     const Quirks& quirks() const { return m_quirks; }
569
570     float deviceScaleFactor() const;
571
572     WEBCORE_EXPORT bool useSystemAppearance() const;
573     WEBCORE_EXPORT bool useElevatedUserInterfaceLevel() const;
574     WEBCORE_EXPORT bool useDarkAppearance(const RenderStyle*) const;
575
576     OptionSet<StyleColor::Options> styleColorOptions(const RenderStyle*) const;
577     CompositeOperator compositeOperatorForBackgroundColor(const Color&, const RenderObject&) const;
578
579     WEBCORE_EXPORT Ref<Range> createRange();
580
581     // The last bool parameter is for ObjC bindings.
582     WEBCORE_EXPORT Ref<NodeIterator> createNodeIterator(Node& root, unsigned long whatToShow = 0xFFFFFFFF, RefPtr<NodeFilter>&& = nullptr, bool = false);
583
584     // The last bool parameter is for ObjC bindings.
585     WEBCORE_EXPORT Ref<TreeWalker> createTreeWalker(Node& root, unsigned long whatToShow = 0xFFFFFFFF, RefPtr<NodeFilter>&& = nullptr, bool = false);
586
587     // Special support for editing
588     WEBCORE_EXPORT Ref<CSSStyleDeclaration> createCSSStyleDeclaration();
589     Ref<Text> createEditingTextNode(const String&);
590
591     enum class ResolveStyleType { Normal, Rebuild };
592     void resolveStyle(ResolveStyleType = ResolveStyleType::Normal);
593     WEBCORE_EXPORT bool updateStyleIfNeeded();
594     bool needsStyleRecalc() const;
595     unsigned lastStyleUpdateSizeForTesting() const { return m_lastStyleUpdateSizeForTesting; }
596
597     WEBCORE_EXPORT void updateLayout();
598     
599     // updateLayoutIgnorePendingStylesheets() forces layout even if we are waiting for pending stylesheet loads,
600     // so calling this may cause a flash of unstyled content (FOUC).
601     enum class RunPostLayoutTasks { Asynchronously, Synchronously };
602     WEBCORE_EXPORT void updateLayoutIgnorePendingStylesheets(RunPostLayoutTasks = RunPostLayoutTasks::Asynchronously);
603
604     std::unique_ptr<RenderStyle> styleForElementIgnoringPendingStylesheets(Element&, const RenderStyle* parentStyle, PseudoId = PseudoId::None);
605
606     // Returns true if page box (margin boxes and page borders) is visible.
607     WEBCORE_EXPORT bool isPageBoxVisible(int pageIndex);
608
609     // Returns the preferred page size and margins in pixels, assuming 96
610     // pixels per inch. pageSize, marginTop, marginRight, marginBottom,
611     // marginLeft must be initialized to the default values that are used if
612     // auto is specified.
613     WEBCORE_EXPORT void pageSizeAndMarginsInPixels(int pageIndex, IntSize& pageSize, int& marginTop, int& marginRight, int& marginBottom, int& marginLeft);
614
615     CachedResourceLoader& cachedResourceLoader() { return m_cachedResourceLoader; }
616
617     void didBecomeCurrentDocumentInFrame();
618     void destroyRenderTree();
619     void prepareForDestruction();
620
621     // Override ScriptExecutionContext methods to do additional work
622     WEBCORE_EXPORT bool shouldBypassMainWorldContentSecurityPolicy() const final;
623     void suspendActiveDOMObjects(ReasonForSuspension) final;
624     void resumeActiveDOMObjects(ReasonForSuspension) final;
625     void stopActiveDOMObjects() final;
626
627     void suspendDeviceMotionAndOrientationUpdates();
628     void resumeDeviceMotionAndOrientationUpdates();
629
630     RenderView* renderView() const { return m_renderView.get(); }
631
632     bool renderTreeBeingDestroyed() const { return m_renderTreeBeingDestroyed; }
633     bool hasLivingRenderTree() const { return renderView() && !renderTreeBeingDestroyed(); }
634     
635     bool updateLayoutIfDimensionsOutOfDate(Element&, DimensionsCheck = AllDimensionsCheck);
636     
637     AXObjectCache* existingAXObjectCache() const;
638     WEBCORE_EXPORT AXObjectCache* axObjectCache() const;
639     void clearAXObjectCache();
640
641     WEBCORE_EXPORT Optional<PageIdentifier> pageID() const;
642     // to get visually ordered hebrew and arabic pages right
643     void setVisuallyOrdered();
644     bool visuallyOrdered() const { return m_visuallyOrdered; }
645     
646     WEBCORE_EXPORT DocumentLoader* loader() const;
647
648     WEBCORE_EXPORT ExceptionOr<RefPtr<WindowProxy>> openForBindings(DOMWindow& activeWindow, DOMWindow& firstDOMWindow, const String& url, const AtomString& name, const String& features);
649     WEBCORE_EXPORT ExceptionOr<Document&> openForBindings(Document* responsibleDocument, const String&, const String&);
650
651     // FIXME: We should rename this at some point and give back the name 'open' to the HTML specified ones.
652     WEBCORE_EXPORT ExceptionOr<void> open(Document* responsibleDocument = nullptr);
653     void implicitOpen();
654
655     WEBCORE_EXPORT ExceptionOr<void> closeForBindings();
656
657     // FIXME: We should rename this at some point and give back the name 'close' to the HTML specified one.
658     WEBCORE_EXPORT void close();
659     // In some situations (see the code), we ignore document.close().
660     // explicitClose() bypass these checks and actually tries to close the
661     // input stream.
662     void explicitClose();
663     // implicitClose() actually does the work of closing the input stream.
664     void implicitClose();
665
666     void cancelParsing();
667
668     ExceptionOr<void> write(Document* responsibleDocument, SegmentedString&&);
669     WEBCORE_EXPORT ExceptionOr<void> write(Document* responsibleDocument, Vector<String>&&);
670     WEBCORE_EXPORT ExceptionOr<void> writeln(Document* responsibleDocument, Vector<String>&&);
671
672     bool wellFormed() const { return m_wellFormed; }
673
674     const URL& url() const final { return m_url; }
675     void setURL(const URL&);
676     const URL& urlForBindings() const { return m_url.isEmpty() ? WTF::blankURL() : m_url; }
677
678     // To understand how these concepts relate to one another, please see the
679     // comments surrounding their declaration.
680     const URL& baseURL() const { return m_baseURL; }
681     void setBaseURLOverride(const URL&);
682     const URL& baseURLOverride() const { return m_baseURLOverride; }
683     const URL& baseElementURL() const { return m_baseElementURL; }
684     const String& baseTarget() const { return m_baseTarget; }
685     void processBaseElement();
686
687     WEBCORE_EXPORT URL completeURL(const String&) const final;
688     URL completeURL(const String&, const URL& baseURLOverride) const;
689
690     String userAgent(const URL&) const final;
691
692     void disableEval(const String& errorMessage) final;
693     void disableWebAssembly(const String& errorMessage) final;
694
695 #if ENABLE(INDEXED_DATABASE)
696     IDBClient::IDBConnectionProxy* idbConnectionProxy() final;
697 #endif
698     SocketProvider* socketProvider() final;
699
700     bool canNavigate(Frame* targetFrame, const URL& destinationURL = URL());
701
702     bool usesStyleBasedEditability() const;
703     void setHasElementUsingStyleBasedEditability();
704     
705     virtual Ref<DocumentParser> createParser();
706     DocumentParser* parser() const { return m_parser.get(); }
707     ScriptableDocumentParser* scriptableDocumentParser() const;
708     
709     bool printing() const { return m_printing; }
710     void setPrinting(bool p) { m_printing = p; }
711
712     bool paginatedForScreen() const { return m_paginatedForScreen; }
713     void setPaginatedForScreen(bool p) { m_paginatedForScreen = p; }
714     
715     bool paginated() const { return printing() || paginatedForScreen(); }
716
717     void setCompatibilityMode(DocumentCompatibilityMode);
718     void lockCompatibilityMode() { m_compatibilityModeLocked = true; }
719     static ptrdiff_t compatibilityModeMemoryOffset() { return OBJECT_OFFSETOF(Document, m_compatibilityMode); }
720
721     WEBCORE_EXPORT String compatMode() const;
722
723     bool inQuirksMode() const { return m_compatibilityMode == DocumentCompatibilityMode::QuirksMode; }
724     bool inLimitedQuirksMode() const { return m_compatibilityMode == DocumentCompatibilityMode::LimitedQuirksMode; }
725     bool inNoQuirksMode() const { return m_compatibilityMode == DocumentCompatibilityMode::NoQuirksMode; }
726
727     void setReadyState(ReadyState);
728     void setParsing(bool);
729     bool parsing() const { return m_bParsing; }
730     Seconds minimumLayoutDelay();
731
732     bool shouldScheduleLayout();
733     bool isLayoutTimerActive();
734     Seconds timeSinceDocumentCreation() const;
735     
736     void setTextColor(const Color& color) { m_textColor = color; }
737     const Color& textColor() const { return m_textColor; }
738
739     const Color& linkColor() const { return m_linkColor; }
740     const Color& visitedLinkColor() const { return m_visitedLinkColor; }
741     const Color& activeLinkColor() const { return m_activeLinkColor; }
742     void setLinkColor(const Color& c) { m_linkColor = c; }
743     void setVisitedLinkColor(const Color& c) { m_visitedLinkColor = c; }
744     void setActiveLinkColor(const Color& c) { m_activeLinkColor = c; }
745     void resetLinkColor();
746     void resetVisitedLinkColor();
747     void resetActiveLinkColor();
748     VisitedLinkState& visitedLinkState() const { return *m_visitedLinkState; }
749
750     MouseEventWithHitTestResults prepareMouseEvent(const HitTestRequest&, const LayoutPoint&, const PlatformMouseEvent&);
751
752     enum class FocusRemovalEventsMode { Dispatch, DoNotDispatch };
753     WEBCORE_EXPORT bool setFocusedElement(Element*, FocusDirection = FocusDirectionNone,
754         FocusRemovalEventsMode = FocusRemovalEventsMode::Dispatch);
755     Element* focusedElement() const { return m_focusedElement.get(); }
756     UserActionElementSet& userActionElements()  { return m_userActionElements; }
757     const UserActionElementSet& userActionElements() const { return m_userActionElements; }
758
759     void setFocusNavigationStartingNode(Node*);
760     Element* focusNavigationStartingNode(FocusDirection) const;
761
762     enum class NodeRemoval { Node, ChildrenOfNode };
763     void adjustFocusedNodeOnNodeRemoval(Node&, NodeRemoval = NodeRemoval::Node);
764     void adjustFocusNavigationNodeOnNodeRemoval(Node&, NodeRemoval = NodeRemoval::Node);
765
766     void hoveredElementDidDetach(Element&);
767     void elementInActiveChainDidDetach(Element&);
768
769     enum class CaptureChange : uint8_t { Yes, No };
770     void updateHoverActiveState(const HitTestRequest&, Element*, CaptureChange = CaptureChange::No);
771
772     // Updates for :target (CSS3 selector).
773     void setCSSTarget(Element*);
774     Element* cssTarget() const { return m_cssTarget; }
775     static ptrdiff_t cssTargetMemoryOffset() { return OBJECT_OFFSETOF(Document, m_cssTarget); }
776
777     WEBCORE_EXPORT void scheduleFullStyleRebuild();
778     void scheduleStyleRecalc();
779     void unscheduleStyleRecalc();
780     bool hasPendingStyleRecalc() const;
781     bool hasPendingFullStyleRebuild() const;
782
783     void registerNodeListForInvalidation(LiveNodeList&);
784     void unregisterNodeListForInvalidation(LiveNodeList&);
785     WEBCORE_EXPORT void registerCollection(HTMLCollection&);
786     void unregisterCollection(HTMLCollection&);
787     void collectionCachedIdNameMap(const HTMLCollection&);
788     void collectionWillClearIdNameMap(const HTMLCollection&);
789     bool shouldInvalidateNodeListAndCollectionCaches() const;
790     bool shouldInvalidateNodeListAndCollectionCachesForAttribute(const QualifiedName& attrName) const;
791
792     template <typename InvalidationFunction>
793     void invalidateNodeListAndCollectionCaches(InvalidationFunction);
794
795     void attachNodeIterator(NodeIterator&);
796     void detachNodeIterator(NodeIterator&);
797     void moveNodeIteratorsToNewDocument(Node& node, Document& newDocument)
798     {
799         if (!m_nodeIterators.isEmpty())
800             moveNodeIteratorsToNewDocumentSlowCase(node, newDocument);
801     }
802
803     void attachRange(Range&);
804     void detachRange(Range&);
805
806     void updateRangesAfterChildrenChanged(ContainerNode&);
807     // nodeChildrenWillBeRemoved is used when removing all node children at once.
808     void nodeChildrenWillBeRemoved(ContainerNode&);
809     // nodeWillBeRemoved is only safe when removing one node at a time.
810     void nodeWillBeRemoved(Node&);
811
812     enum class AcceptChildOperation { Replace, InsertOrAdd };
813     bool canAcceptChild(const Node& newChild, const Node* refChild, AcceptChildOperation) const;
814
815     void textInserted(Node&, unsigned offset, unsigned length);
816     void textRemoved(Node&, unsigned offset, unsigned length);
817     void textNodesMerged(Text& oldNode, unsigned offset);
818     void textNodeSplit(Text& oldNode);
819
820     void createDOMWindow();
821     void takeDOMWindowFrom(Document&);
822
823     DOMWindow* domWindow() const { return m_domWindow.get(); }
824     // In DOM Level 2, the Document's DOMWindow is called the defaultView.
825     WEBCORE_EXPORT WindowProxy* windowProxy() const;
826
827     bool hasBrowsingContext() const { return !!frame(); }
828
829     Document& contextDocument() const;
830     void setContextDocument(Document& document) { m_contextDocument = makeWeakPtr(document); }
831
832     // Helper functions for forwarding DOMWindow event related tasks to the DOMWindow if it exists.
833     void setWindowAttributeEventListener(const AtomString& eventType, const QualifiedName& attributeName, const AtomString& value, DOMWrapperWorld&);
834     void setWindowAttributeEventListener(const AtomString& eventType, RefPtr<EventListener>&&, DOMWrapperWorld&);
835     EventListener* getWindowAttributeEventListener(const AtomString& eventType, DOMWrapperWorld&);
836     WEBCORE_EXPORT void dispatchWindowEvent(Event&, EventTarget* = nullptr);
837     void dispatchWindowLoadEvent();
838
839     WEBCORE_EXPORT ExceptionOr<Ref<Event>> createEvent(const String& eventType);
840
841     // keep track of what types of event listeners are registered, so we don't
842     // dispatch events unnecessarily
843     enum ListenerType {
844         DOMSUBTREEMODIFIED_LISTENER          = 1,
845         DOMNODEINSERTED_LISTENER             = 1 << 1,
846         DOMNODEREMOVED_LISTENER              = 1 << 2,
847         DOMNODEREMOVEDFROMDOCUMENT_LISTENER  = 1 << 3,
848         DOMNODEINSERTEDINTODOCUMENT_LISTENER = 1 << 4,
849         DOMCHARACTERDATAMODIFIED_LISTENER    = 1 << 5,
850         OVERFLOWCHANGED_LISTENER             = 1 << 6,
851         ANIMATIONEND_LISTENER                = 1 << 7,
852         ANIMATIONSTART_LISTENER              = 1 << 8,
853         ANIMATIONITERATION_LISTENER          = 1 << 9,
854         TRANSITIONEND_LISTENER               = 1 << 10,
855         BEFORELOAD_LISTENER                  = 1 << 11,
856         SCROLL_LISTENER                      = 1 << 12,
857         FORCEWILLBEGIN_LISTENER              = 1 << 13,
858         FORCECHANGED_LISTENER                = 1 << 14,
859         FORCEDOWN_LISTENER                   = 1 << 15,
860         FORCEUP_LISTENER                     = 1 << 16,
861         RESIZE_LISTENER                      = 1 << 17
862     };
863
864     bool hasListenerType(ListenerType listenerType) const { return (m_listenerTypes & listenerType); }
865     bool hasListenerTypeForEventType(PlatformEvent::Type) const;
866     void addListenerTypeIfNeeded(const AtomString& eventType);
867
868     bool hasMutationObserversOfType(MutationObserver::MutationType type) const
869     {
870         return m_mutationObserverTypes & type;
871     }
872     bool hasMutationObservers() const { return m_mutationObserverTypes; }
873     void addMutationObserverTypes(MutationObserverOptions types) { m_mutationObserverTypes |= types; }
874
875     CSSStyleDeclaration* getOverrideStyle(Element*, const String&) { return nullptr; }
876
877     // Handles an HTTP header equivalent set by a meta tag using <meta http-equiv="..." content="...">. This is called
878     // when a meta tag is encountered during document parsing, and also when a script dynamically changes or adds a meta
879     // tag. This enables scripts to use meta tags to perform refreshes and set expiry dates in addition to them being
880     // specified in an HTML file.
881     void processHttpEquiv(const String& equiv, const String& content, bool isInDocumentHead);
882
883 #if PLATFORM(IOS_FAMILY)
884     void processFormatDetection(const String&);
885
886     // Called when <meta name="apple-mobile-web-app-orientations"> changes.
887     void processWebAppOrientations();
888
889     WEBCORE_EXPORT ContentChangeObserver& contentChangeObserver();
890
891     DOMTimerHoldingTank* domTimerHoldingTankIfExists() { return m_domTimerHoldingTank.get(); }
892     DOMTimerHoldingTank& domTimerHoldingTank();
893 #endif
894     
895     void processViewport(const String& features, ViewportArguments::Type origin);
896     void processDisabledAdaptations(const String& adaptations);
897     void updateViewportArguments();
898     void processReferrerPolicy(const String& policy, ReferrerPolicySource);
899
900 #if ENABLE(DARK_MODE_CSS)
901     void processColorScheme(const String& colorScheme);
902 #endif
903
904     // Returns the owning element in the parent document.
905     // Returns nullptr if this is the top level document.
906     HTMLFrameOwnerElement* ownerElement() const;
907
908     // Used by DOM bindings; no direction known.
909     const String& title() const { return m_title.string; }
910     WEBCORE_EXPORT void setTitle(const String&);
911
912     WEBCORE_EXPORT const AtomString& dir() const;
913     WEBCORE_EXPORT void setDir(const AtomString&);
914
915     void titleElementAdded(Element& titleElement);
916     void titleElementRemoved(Element& titleElement);
917     void titleElementTextChanged(Element& titleElement);
918
919     WEBCORE_EXPORT ExceptionOr<String> cookie();
920     WEBCORE_EXPORT ExceptionOr<void> setCookie(const String&);
921
922     WEBCORE_EXPORT String referrer();
923
924     WEBCORE_EXPORT String origin() const final;
925
926     WEBCORE_EXPORT String domain() const;
927     ExceptionOr<void> setDomain(const String& newDomain);
928
929     void overrideLastModified(const Optional<WallTime>&);
930     WEBCORE_EXPORT String lastModified() const;
931
932     // The cookieURL is used to query the cookie database for this document's
933     // cookies. For example, if the cookie URL is http://example.com, we'll
934     // use the non-Secure cookies for example.com when computing
935     // document.cookie.
936     //
937     // Q: How is the cookieURL different from the document's URL?
938     // A: The two URLs are the same almost all the time.  However, if one
939     //    document inherits the security context of another document, it
940     //    inherits its cookieURL but not its URL.
941     //
942     const URL& cookieURL() const { return m_cookieURL; }
943     void setCookieURL(const URL&);
944
945     // The firstPartyForCookies is used to compute whether this document
946     // appears in a "third-party" context for the purpose of third-party
947     // cookie blocking.  The document is in a third-party context if the
948     // cookieURL and the firstPartyForCookies are from different hosts.
949     //
950     // Note: Some ports (including possibly Apple's) only consider the
951     //       document in a third-party context if the cookieURL and the
952     //       firstPartyForCookies have a different registry-controlled
953     //       domain.
954     //
955     const URL& firstPartyForCookies() const { return m_firstPartyForCookies; }
956     void setFirstPartyForCookies(const URL& url) { m_firstPartyForCookies = url; }
957
958     bool isFullyActive() const;
959
960     // The full URL corresponding to the "site for cookies" in the Same-Site Cookies spec.,
961     // <https://tools.ietf.org/html/draft-ietf-httpbis-cookie-same-site-00>. It is either
962     // the URL of the top-level document or the null URL depending on whether the registrable
963     // domain of this document's URL matches the registrable domain of its parent's/opener's
964     // URL. For the top-level document, it is set to the document's URL.
965     const URL& siteForCookies() const { return m_siteForCookies; }
966     void setSiteForCookies(const URL& url) { m_siteForCookies = url; }
967     
968     // The following implements the rule from HTML 4 for what valid names are.
969     // To get this right for all the XML cases, we probably have to improve this or move it
970     // and make it sensitive to the type of document.
971     static bool isValidName(const String&);
972
973     // The following breaks a qualified name into a prefix and a local name.
974     // It also does a validity check, and returns an error if the qualified name is invalid.
975     static ExceptionOr<std::pair<AtomString, AtomString>> parseQualifiedName(const String& qualifiedName);
976     static ExceptionOr<QualifiedName> parseQualifiedName(const AtomString& namespaceURI, const String& qualifiedName);
977
978     // Checks to make sure prefix and namespace do not conflict (per DOM Core 3)
979     static bool hasValidNamespaceForElements(const QualifiedName&);
980     static bool hasValidNamespaceForAttributes(const QualifiedName&);
981
982     // This is the "HTML body element" as defined by CSSOM View spec, the first body child of the
983     // document element. See http://dev.w3.org/csswg/cssom-view/#the-html-body-element.
984     WEBCORE_EXPORT HTMLBodyElement* body() const;
985
986     // This is the "body element" as defined by HTML5, the first body or frameset child of the
987     // document element. See https://html.spec.whatwg.org/multipage/dom.html#the-body-element-2.
988     WEBCORE_EXPORT HTMLElement* bodyOrFrameset() const;
989     WEBCORE_EXPORT ExceptionOr<void> setBodyOrFrameset(RefPtr<HTMLElement>&&);
990
991     Location* location() const;
992
993     WEBCORE_EXPORT HTMLHeadElement* head();
994
995     DocumentMarkerController& markers() const { return *m_markers; }
996
997     WEBCORE_EXPORT bool execCommand(const String& command, bool userInterface = false, const String& value = String());
998     WEBCORE_EXPORT bool queryCommandEnabled(const String& command);
999     WEBCORE_EXPORT bool queryCommandIndeterm(const String& command);
1000     WEBCORE_EXPORT bool queryCommandState(const String& command);
1001     WEBCORE_EXPORT bool queryCommandSupported(const String& command);
1002     WEBCORE_EXPORT String queryCommandValue(const String& command);
1003
1004     UndoManager& undoManager() const { return m_undoManager.get(); }
1005
1006     // designMode support
1007     enum InheritedBool { off = false, on = true, inherit };    
1008     void setDesignMode(InheritedBool value);
1009     InheritedBool getDesignMode() const;
1010     bool inDesignMode() const;
1011     WEBCORE_EXPORT String designMode() const;
1012     WEBCORE_EXPORT void setDesignMode(const String&);
1013
1014     Document* parentDocument() const;
1015     WEBCORE_EXPORT Document& topDocument() const;
1016     
1017     ScriptRunner& scriptRunner() { return *m_scriptRunner; }
1018     ScriptModuleLoader& moduleLoader() { return *m_moduleLoader; }
1019
1020     HTMLScriptElement* currentScript() const { return !m_currentScriptStack.isEmpty() ? m_currentScriptStack.last().get() : nullptr; }
1021     void pushCurrentScript(HTMLScriptElement*);
1022     void popCurrentScript();
1023
1024     bool shouldDeferAsynchronousScriptsUntilParsingFinishes() const;
1025
1026 #if ENABLE(XSLT)
1027     void scheduleToApplyXSLTransforms();
1028     void applyPendingXSLTransformsNowIfScheduled();
1029     RefPtr<Document> transformSourceDocument() { return m_transformSourceDocument; }
1030     void setTransformSourceDocument(Document* document) { m_transformSourceDocument = document; }
1031
1032     void setTransformSource(std::unique_ptr<TransformSource>);
1033     TransformSource* transformSource() const { return m_transformSource.get(); }
1034 #endif
1035
1036     void incDOMTreeVersion() { m_domTreeVersion = ++s_globalTreeVersion; }
1037     uint64_t domTreeVersion() const { return m_domTreeVersion; }
1038
1039     WEBCORE_EXPORT String originIdentifierForPasteboard() const;
1040
1041     // XPathEvaluator methods
1042     WEBCORE_EXPORT ExceptionOr<Ref<XPathExpression>> createExpression(const String& expression, RefPtr<XPathNSResolver>&&);
1043     WEBCORE_EXPORT Ref<XPathNSResolver> createNSResolver(Node* nodeResolver);
1044     WEBCORE_EXPORT ExceptionOr<Ref<XPathResult>> evaluate(const String& expression, Node& contextNode, RefPtr<XPathNSResolver>&&, unsigned short type, XPathResult*);
1045
1046     bool hasNodesWithNonFinalStyle() const { return m_hasNodesWithNonFinalStyle; }
1047     void setHasNodesWithNonFinalStyle() { m_hasNodesWithNonFinalStyle = true; }
1048     bool hasNodesWithMissingStyle() const { return m_hasNodesWithMissingStyle; }
1049     void setHasNodesWithMissingStyle() { m_hasNodesWithMissingStyle = true; }
1050
1051     // Extension for manipulating canvas drawing contexts for use in CSS
1052     Optional<RenderingContext> getCSSCanvasContext(const String& type, const String& name, int width, int height);
1053     HTMLCanvasElement* getCSSCanvasElement(const String& name);
1054     String nameForCSSCanvasElement(const HTMLCanvasElement&) const;
1055
1056     bool isDNSPrefetchEnabled() const { return m_isDNSPrefetchEnabled; }
1057     void parseDNSPrefetchControlHeader(const String&);
1058
1059     WEBCORE_EXPORT void postTask(Task&&) final; // Executes the task on context's thread asynchronously.
1060
1061     ScriptedAnimationController* scriptedAnimationController() { return m_scriptedAnimationController.get(); }
1062     void suspendScriptedAnimationControllerCallbacks();
1063     void resumeScriptedAnimationControllerCallbacks();
1064
1065     void updateAnimationsAndSendEvents(DOMHighResTimeStamp timestamp);
1066     void serviceRequestAnimationFrameCallbacks(DOMHighResTimeStamp timestamp);
1067
1068     void windowScreenDidChange(PlatformDisplayID);
1069
1070     void finishedParsing();
1071
1072     enum PageCacheState { NotInPageCache, AboutToEnterPageCache, InPageCache };
1073
1074     PageCacheState pageCacheState() const { return m_pageCacheState; }
1075     void setPageCacheState(PageCacheState);
1076
1077     void registerForDocumentSuspensionCallbacks(Element&);
1078     void unregisterForDocumentSuspensionCallbacks(Element&);
1079
1080     void documentWillBecomeInactive();
1081     void suspend(ReasonForSuspension);
1082     void resume(ReasonForSuspension);
1083
1084     void registerForMediaVolumeCallbacks(Element&);
1085     void unregisterForMediaVolumeCallbacks(Element&);
1086     void mediaVolumeDidChange();
1087
1088     bool audioPlaybackRequiresUserGesture() const;
1089     bool videoPlaybackRequiresUserGesture() const;
1090
1091 #if ENABLE(MEDIA_SESSION)
1092     MediaSession& defaultMediaSession();
1093 #endif
1094
1095     void registerForPrivateBrowsingStateChangedCallbacks(Element&);
1096     void unregisterForPrivateBrowsingStateChangedCallbacks(Element&);
1097     void storageBlockingStateDidChange();
1098     void privateBrowsingStateDidChange(PAL::SessionID);
1099
1100 #if ENABLE(VIDEO_TRACK)
1101     void registerForCaptionPreferencesChangedCallbacks(Element&);
1102     void unregisterForCaptionPreferencesChangedCallbacks(Element&);
1103     void captionPreferencesChanged();
1104 #endif
1105
1106 #if ENABLE(MEDIA_CONTROLS_SCRIPT)
1107     void registerForPageScaleFactorChangedCallbacks(HTMLMediaElement&);
1108     void unregisterForPageScaleFactorChangedCallbacks(HTMLMediaElement&);
1109     void pageScaleFactorChangedAndStable();
1110     void registerForUserInterfaceLayoutDirectionChangedCallbacks(HTMLMediaElement&);
1111     void unregisterForUserInterfaceLayoutDirectionChangedCallbacks(HTMLMediaElement&);
1112     void userInterfaceLayoutDirectionChanged();
1113 #endif
1114
1115     void registerForVisibilityStateChangedCallbacks(VisibilityChangeClient&);
1116     void unregisterForVisibilityStateChangedCallbacks(VisibilityChangeClient&);
1117
1118 #if ENABLE(VIDEO)
1119     void registerForAllowsMediaDocumentInlinePlaybackChangedCallbacks(HTMLMediaElement&);
1120     void unregisterForAllowsMediaDocumentInlinePlaybackChangedCallbacks(HTMLMediaElement&);
1121     void allowsMediaDocumentInlinePlaybackChanged();
1122
1123     void stopAllMediaPlayback();
1124     void suspendAllMediaPlayback();
1125     void resumeAllMediaPlayback();
1126     void suspendAllMediaBuffering();
1127     void resumeAllMediaBuffering();
1128 #endif
1129
1130     WEBCORE_EXPORT void setShouldCreateRenderers(bool);
1131     bool shouldCreateRenderers();
1132
1133     void setDecoder(RefPtr<TextResourceDecoder>&&);
1134     TextResourceDecoder* decoder() const { return m_decoder.get(); }
1135
1136     WEBCORE_EXPORT String displayStringModifiedByEncoding(const String&) const;
1137
1138     void invalidateRenderingDependentRegions();
1139
1140     void removeAllEventListeners() final;
1141
1142     WEBCORE_EXPORT const SVGDocumentExtensions* svgExtensions();
1143     WEBCORE_EXPORT SVGDocumentExtensions& accessSVGExtensions();
1144
1145     void addSVGUseElement(SVGUseElement&);
1146     void removeSVGUseElement(SVGUseElement&);
1147     HashSet<SVGUseElement*> const svgUseElements() const { return m_svgUseElements; }
1148
1149     void initSecurityContext();
1150     void initContentSecurityPolicy();
1151
1152     void updateURLForPushOrReplaceState(const URL&);
1153     void statePopped(Ref<SerializedScriptValue>&&);
1154
1155     bool processingLoadEvent() const { return m_processingLoadEvent; }
1156     bool loadEventFinished() const { return m_loadEventFinished; }
1157
1158     bool isContextThread() const final;
1159     bool isSecureContext() const final;
1160     bool isJSExecutionForbidden() const final { return false; }
1161
1162     void enqueueWindowEvent(Ref<Event>&&);
1163     void enqueueDocumentEvent(Ref<Event>&&);
1164     void enqueueOverflowEvent(Ref<Event>&&);
1165     void dispatchPageshowEvent(PageshowEventPersistence);
1166     WEBCORE_EXPORT void enqueueSecurityPolicyViolationEvent(SecurityPolicyViolationEvent::Init&&);
1167     void enqueueHashchangeEvent(const String& oldURL, const String& newURL);
1168     void dispatchPopstateEvent(RefPtr<SerializedScriptValue>&& stateObject);
1169     DocumentEventQueue& eventQueue() const final { return m_eventQueue; }
1170
1171     WEBCORE_EXPORT void addMediaCanStartListener(MediaCanStartListener&);
1172     WEBCORE_EXPORT void removeMediaCanStartListener(MediaCanStartListener&);
1173     MediaCanStartListener* takeAnyMediaCanStartListener();
1174
1175 #if ENABLE(FULLSCREEN_API)
1176     FullscreenManager& fullscreenManager() { return m_fullscreenManager; }
1177     const FullscreenManager& fullscreenManager() const { return m_fullscreenManager; }
1178 #endif
1179
1180 #if ENABLE(POINTER_LOCK)
1181     WEBCORE_EXPORT void exitPointerLock();
1182 #endif
1183
1184     // Used to allow element that loads data without going through a FrameLoader to delay the 'load' event.
1185     void incrementLoadEventDelayCount() { ++m_loadEventDelayCount; }
1186     void decrementLoadEventDelayCount();
1187     bool isDelayingLoadEvent() const { return m_loadEventDelayCount; }
1188     void checkCompleted();
1189
1190 #if ENABLE(IOS_TOUCH_EVENTS)
1191 #include <WebKitAdditions/DocumentIOS.h>
1192 #endif
1193
1194 #if ENABLE(DEVICE_ORIENTATION)
1195 #if PLATFORM(IOS_FAMILY)
1196     DeviceMotionController& deviceMotionController() const;
1197     DeviceOrientationController& deviceOrientationController() const;
1198     WEBCORE_EXPORT void simulateDeviceOrientationChange(double alpha, double beta, double gamma);
1199 #endif
1200
1201     DeviceOrientationAndMotionAccessController& deviceOrientationAndMotionAccessController();
1202 #endif // ENABLE(DEVICE_ORIENTATION)
1203
1204     const DocumentTiming& timing() const { return m_documentTiming; }
1205
1206     WEBCORE_EXPORT double monotonicTimestamp() const;
1207
1208     int requestAnimationFrame(Ref<RequestAnimationFrameCallback>&&);
1209     void cancelAnimationFrame(int id);
1210
1211     int requestIdleCallback(Ref<IdleRequestCallback>&&, Seconds timeout);
1212     void cancelIdleCallback(int id);
1213
1214     EventTarget* errorEventTarget() final;
1215     void logExceptionToConsole(const String& errorMessage, const String& sourceURL, int lineNumber, int columnNumber, RefPtr<Inspector::ScriptCallStack>&&) final;
1216
1217     void initDNSPrefetch();
1218
1219     void didAddWheelEventHandler(Node&);
1220     void didRemoveWheelEventHandler(Node&, EventHandlerRemoval = EventHandlerRemoval::One);
1221
1222     MonotonicTime lastHandledUserGestureTimestamp() const { return m_lastHandledUserGestureTimestamp; }
1223     bool hasHadUserInteraction() const { return static_cast<bool>(m_lastHandledUserGestureTimestamp); }
1224     void updateLastHandledUserGestureTimestamp(MonotonicTime);
1225     bool processingUserGestureForMedia() const;
1226     void userActivatedMediaFinishedPlaying() { m_userActivatedMediaFinishedPlayingTimestamp = MonotonicTime::now(); }
1227
1228     void setUserDidInteractWithPage(bool userDidInteractWithPage) { ASSERT(&topDocument() == this); m_userDidInteractWithPage = userDidInteractWithPage; }
1229     bool userDidInteractWithPage() const { ASSERT(&topDocument() == this); return m_userDidInteractWithPage; }
1230
1231     // Used for testing. Count handlers in the main document, and one per frame which contains handlers.
1232     WEBCORE_EXPORT unsigned wheelEventHandlerCount() const;
1233     WEBCORE_EXPORT unsigned touchEventHandlerCount() const;
1234
1235     WEBCORE_EXPORT void startTrackingStyleRecalcs();
1236     WEBCORE_EXPORT unsigned styleRecalcCount() const;
1237
1238 #if ENABLE(TOUCH_EVENTS)
1239     bool hasTouchEventHandlers() const { return (m_touchEventTargets.get()) ? m_touchEventTargets->size() : false; }
1240     bool touchEventTargetsContain(Node& node) const { return m_touchEventTargets ? m_touchEventTargets->contains(&node) : false; }
1241 #else
1242     bool hasTouchEventHandlers() const { return false; }
1243     bool touchEventTargetsContain(Node&) const { return false; }
1244 #endif
1245 #if PLATFORM(IOS_FAMILY) && ENABLE(POINTER_EVENTS)
1246     bool mayHaveElementsWithNonAutoTouchAction() const { return m_mayHaveElementsWithNonAutoTouchAction; }
1247     void setMayHaveElementsWithNonAutoTouchAction() { m_mayHaveElementsWithNonAutoTouchAction = true; }
1248 #endif
1249
1250     void didAddTouchEventHandler(Node&);
1251     void didRemoveTouchEventHandler(Node&, EventHandlerRemoval = EventHandlerRemoval::One);
1252
1253     void didRemoveEventTargetNode(Node&);
1254
1255     const EventTargetSet* touchEventTargets() const
1256     {
1257 #if ENABLE(TOUCH_EVENTS)
1258         return m_touchEventTargets.get();
1259 #else
1260         return nullptr;
1261 #endif
1262     }
1263
1264     const EventTargetSet* wheelEventTargets() const { return m_wheelEventTargets.get(); }
1265
1266     typedef std::pair<Region, bool> RegionFixedPair;
1267     RegionFixedPair absoluteEventRegionForNode(Node&);
1268     RegionFixedPair absoluteRegionForEventTargets(const EventTargetSet*);
1269
1270     LayoutRect absoluteEventHandlerBounds(bool&) final;
1271
1272     bool visualUpdatesAllowed() const { return m_visualUpdatesAllowed; }
1273
1274     bool isInDocumentWrite() { return m_writeRecursionDepth > 0; }
1275
1276     void suspendScheduledTasks(ReasonForSuspension);
1277     void resumeScheduledTasks(ReasonForSuspension);
1278
1279 #if ENABLE(CSS_DEVICE_ADAPTATION)
1280     IntSize initialViewportSize() const;
1281 #endif
1282
1283     void convertAbsoluteToClientQuads(Vector<FloatQuad>&, const RenderStyle&);
1284     void convertAbsoluteToClientRects(Vector<FloatRect>&, const RenderStyle&);
1285     void convertAbsoluteToClientRect(FloatRect&, const RenderStyle&);
1286
1287     bool hasActiveParser();
1288     void incrementActiveParserCount() { ++m_activeParserCount; }
1289     void decrementActiveParserCount();
1290
1291     std::unique_ptr<DocumentParserYieldToken> createParserYieldToken()
1292     {
1293         return makeUnique<DocumentParserYieldToken>(*this);
1294     }
1295
1296     bool hasActiveParserYieldToken() const { return m_parserYieldTokenCount; }
1297
1298     DocumentSharedObjectPool* sharedObjectPool() { return m_sharedObjectPool.get(); }
1299
1300     void invalidateMatchedPropertiesCacheAndForceStyleRecalc();
1301
1302     void didRemoveAllPendingStylesheet();
1303     void didClearStyleResolver();
1304
1305     bool inStyleRecalc() const { return m_inStyleRecalc; }
1306     bool inRenderTreeUpdate() const { return m_inRenderTreeUpdate; }
1307     bool isResolvingTreeStyle() const { return m_isResolvingTreeStyle; }
1308     void setIsResolvingTreeStyle(bool);
1309
1310     void updateTextRenderer(Text&, unsigned offsetOfReplacedText, unsigned lengthOfReplacedText);
1311
1312     // Return a Locale for the default locale if the argument is null or empty.
1313     Locale& getCachedLocale(const AtomString& locale = nullAtom());
1314
1315     const Document* templateDocument() const;
1316     Document& ensureTemplateDocument();
1317     void setTemplateDocumentHost(Document* templateDocumentHost) { m_templateDocumentHost = makeWeakPtr(templateDocumentHost); }
1318     Document* templateDocumentHost() { return m_templateDocumentHost.get(); }
1319
1320     void didAssociateFormControl(Element&);
1321     bool hasDisabledFieldsetElement() const { return m_disabledFieldsetElementsCount; }
1322     void addDisabledFieldsetElement() { m_disabledFieldsetElementsCount++; }
1323     void removeDisabledFieldsetElement() { ASSERT(m_disabledFieldsetElementsCount); m_disabledFieldsetElementsCount--; }
1324
1325     void getParserLocation(String& url, unsigned& line, unsigned& column) const;
1326
1327     WEBCORE_EXPORT void addConsoleMessage(std::unique_ptr<Inspector::ConsoleMessage>&&) final;
1328
1329     // The following addConsoleMessage function is deprecated.
1330     // Callers should try to create the ConsoleMessage themselves.
1331     WEBCORE_EXPORT void addConsoleMessage(MessageSource, MessageLevel, const String& message, unsigned long requestIdentifier = 0) final;
1332
1333     // The following addMessage function is deprecated.
1334     // Callers should try to create the ConsoleMessage themselves.
1335     void addMessage(MessageSource, MessageLevel, const String& message, const String& sourceURL, unsigned lineNumber, unsigned columnNumber, RefPtr<Inspector::ScriptCallStack>&&, JSC::ExecState* = nullptr, unsigned long requestIdentifier = 0) final;
1336
1337     SecurityOrigin& securityOrigin() const { return *SecurityContext::securityOrigin(); }
1338     SecurityOrigin& topOrigin() const final { return topDocument().securityOrigin(); }
1339
1340     Ref<FontFaceSet> fonts();
1341
1342     void ensurePlugInsInjectedScript(DOMWrapperWorld&);
1343
1344     void setVisualUpdatesAllowedByClient(bool);
1345
1346 #if ENABLE(WEB_CRYPTO)
1347     bool wrapCryptoKey(const Vector<uint8_t>& key, Vector<uint8_t>& wrappedKey) final;
1348     bool unwrapCryptoKey(const Vector<uint8_t>& wrappedKey, Vector<uint8_t>& key) final;
1349 #endif
1350
1351     void setHasStyleWithViewportUnits() { m_hasStyleWithViewportUnits = true; }
1352     bool hasStyleWithViewportUnits() const { return m_hasStyleWithViewportUnits; }
1353     void updateViewportUnitsOnResize();
1354
1355     WEBCORE_EXPORT void addAudioProducer(MediaProducer&);
1356     WEBCORE_EXPORT void removeAudioProducer(MediaProducer&);
1357     MediaProducer::MediaStateFlags mediaState() const { return m_mediaState; }
1358     void noteUserInteractionWithMediaElement();
1359     bool isCapturing() const { return MediaProducer::isCapturing(m_mediaState); }
1360     WEBCORE_EXPORT void updateIsPlayingMedia(uint64_t = HTMLMediaElementInvalidID);
1361     void pageMutedStateDidChange();
1362
1363 #if ENABLE(WIRELESS_PLAYBACK_TARGET)
1364     void addPlaybackTargetPickerClient(MediaPlaybackTargetClient&);
1365     void removePlaybackTargetPickerClient(MediaPlaybackTargetClient&);
1366     void showPlaybackTargetPicker(MediaPlaybackTargetClient&, bool, RouteSharingPolicy, const String&);
1367     void playbackTargetPickerClientStateDidChange(MediaPlaybackTargetClient&, MediaProducer::MediaStateFlags);
1368
1369     void setPlaybackTarget(uint64_t, Ref<MediaPlaybackTarget>&&);
1370     void playbackTargetAvailabilityDidChange(uint64_t, bool);
1371     void setShouldPlayToPlaybackTarget(uint64_t, bool);
1372 #endif
1373
1374     ShouldOpenExternalURLsPolicy shouldOpenExternalURLsPolicyToPropagate() const;
1375     bool shouldEnforceContentDispositionAttachmentSandbox() const;
1376     void applyContentDispositionAttachmentSandbox();
1377
1378     void addViewportDependentPicture(HTMLPictureElement&);
1379     void removeViewportDependentPicture(HTMLPictureElement&);
1380
1381     void addAppearanceDependentPicture(HTMLPictureElement&);
1382     void removeAppearanceDependentPicture(HTMLPictureElement&);
1383
1384     void scheduleTimedRenderingUpdate();
1385
1386 #if ENABLE(INTERSECTION_OBSERVER)
1387     void addIntersectionObserver(IntersectionObserver&);
1388     void removeIntersectionObserver(IntersectionObserver&);
1389     unsigned numberOfIntersectionObservers() const { return m_intersectionObservers.size(); }
1390     void updateIntersectionObservations();
1391     void scheduleInitialIntersectionObservationUpdate();
1392 #endif
1393
1394 #if ENABLE(RESIZE_OBSERVER)
1395     void addResizeObserver(ResizeObserver&);
1396     void removeResizeObserver(ResizeObserver&);
1397     bool hasResizeObservers();
1398     // Return the minDepth of the active observations.
1399     size_t gatherResizeObservations(size_t deeperThan);
1400     void deliverResizeObservations();
1401     bool hasSkippedResizeObservations() const;
1402     void setHasSkippedResizeObservations(bool);
1403     void updateResizeObservations(Page&);
1404 #endif
1405
1406 #if ENABLE(MEDIA_STREAM)
1407     void setHasCaptureMediaStreamTrack() { m_hasHadCaptureMediaStreamTrack = true; }
1408     bool hasHadCaptureMediaStreamTrack() const { return m_hasHadCaptureMediaStreamTrack; }
1409     void setDeviceIDHashSalt(const String&);
1410     String deviceIDHashSalt() const { return m_idHashSalt; }
1411     void stopMediaCapture();
1412     void registerForMediaStreamStateChangeCallbacks(HTMLMediaElement&);
1413     void unregisterForMediaStreamStateChangeCallbacks(HTMLMediaElement&);
1414     void mediaStreamCaptureStateChanged();
1415 #endif
1416
1417 // FIXME: Find a better place for this functionality.
1418 #if ENABLE(TELEPHONE_NUMBER_DETECTION)
1419     // These functions provide a two-level setting:
1420     //    - A user-settable wantsTelephoneNumberParsing (at the Page / WebView level)
1421     //    - A read-only telephoneNumberParsingAllowed which is set by the
1422     //      document if it has the appropriate meta tag.
1423     //    - isTelephoneNumberParsingEnabled() == isTelephoneNumberParsingAllowed() && page()->settings()->isTelephoneNumberParsingEnabled()
1424     WEBCORE_EXPORT bool isTelephoneNumberParsingAllowed() const;
1425     WEBCORE_EXPORT bool isTelephoneNumberParsingEnabled() const;
1426 #endif
1427
1428     using ContainerNode::setAttributeEventListener;
1429     void setAttributeEventListener(const AtomString& eventType, const QualifiedName& attributeName, const AtomString& value, DOMWrapperWorld& isolatedWorld);
1430
1431     DOMSelection* getSelection();
1432
1433     void didInsertInDocumentShadowRoot(ShadowRoot&);
1434     void didRemoveInDocumentShadowRoot(ShadowRoot&);
1435     const HashSet<ShadowRoot*>& inDocumentShadowRoots() const { return m_inDocumentShadowRoots; }
1436
1437     void attachToCachedFrame(CachedFrameBase&);
1438     void detachFromCachedFrame(CachedFrameBase&);
1439
1440     ConstantPropertyMap& constantProperties() const { return *m_constantPropertyMap; }
1441
1442     void orientationChanged(int orientation);
1443     OrientationNotifier& orientationNotifier() { return m_orientationNotifier; }
1444
1445     WEBCORE_EXPORT const AtomString& bgColor() const;
1446     WEBCORE_EXPORT void setBgColor(const String&);
1447     WEBCORE_EXPORT const AtomString& fgColor() const;
1448     WEBCORE_EXPORT void setFgColor(const String&);
1449     WEBCORE_EXPORT const AtomString& alinkColor() const;
1450     WEBCORE_EXPORT void setAlinkColor(const String&);
1451     WEBCORE_EXPORT const AtomString& linkColorForBindings() const;
1452     WEBCORE_EXPORT void setLinkColorForBindings(const String&);
1453     WEBCORE_EXPORT const AtomString& vlinkColor() const;
1454     WEBCORE_EXPORT void setVlinkColor(const String&);
1455
1456     // Per https://html.spec.whatwg.org/multipage/obsolete.html#dom-document-clear, this method does nothing.
1457     void clear() { }
1458     // Per https://html.spec.whatwg.org/multipage/obsolete.html#dom-document-captureevents, this method does nothing.
1459     void captureEvents() { }
1460     // Per https://html.spec.whatwg.org/multipage/obsolete.html#dom-document-releaseevents, this method does nothing.
1461     void releaseEvents() { }
1462
1463 #if ENABLE(TEXT_AUTOSIZING)
1464     TextAutoSizing& textAutoSizing();
1465 #endif
1466
1467     // For debugging rdar://problem/49877867.
1468     void setMayBeDetachedFromFrame(bool mayBeDetachedFromFrame) { m_mayBeDetachedFromFrame = mayBeDetachedFromFrame; }
1469
1470     Logger& logger();
1471
1472     WEBCORE_EXPORT void setConsoleMessageListener(RefPtr<StringCallback>&&); // For testing.
1473
1474     WEBCORE_EXPORT DocumentTimeline& timeline();
1475     DocumentTimeline* existingTimeline() const { return m_timeline.get(); }
1476     Vector<RefPtr<WebAnimation>> getAnimations();
1477         
1478 #if ENABLE(ATTACHMENT_ELEMENT)
1479     void registerAttachmentIdentifier(const String&);
1480     void didInsertAttachmentElement(HTMLAttachmentElement&);
1481     void didRemoveAttachmentElement(HTMLAttachmentElement&);
1482     WEBCORE_EXPORT RefPtr<HTMLAttachmentElement> attachmentForIdentifier(const String&) const;
1483     const HashMap<String, Ref<HTMLAttachmentElement>>& attachmentElementsByIdentifier() const { return m_attachmentIdentifierToElementMap; }
1484 #endif
1485
1486 #if ENABLE(SERVICE_WORKER)
1487     void setServiceWorkerConnection(SWClientConnection*);
1488 #endif
1489
1490     void addApplicationStateChangeListener(ApplicationStateChangeListener&);
1491     void removeApplicationStateChangeListener(ApplicationStateChangeListener&);
1492     void forEachApplicationStateChangeListener(const Function<void(ApplicationStateChangeListener&)>&);
1493
1494 #if ENABLE(IOS_TOUCH_EVENTS)
1495     bool handlingTouchEvent() const { return m_handlingTouchEvent; }
1496 #endif
1497
1498 #if ENABLE(RESOURCE_LOAD_STATISTICS)
1499     WEBCORE_EXPORT bool hasRequestedPageSpecificStorageAccessWithUserInteraction(const RegistrableDomain&);
1500     WEBCORE_EXPORT void setHasRequestedPageSpecificStorageAccessWithUserInteraction(const RegistrableDomain&);
1501     WEBCORE_EXPORT void wasLoadedWithDataTransferFromPrevalentResource();
1502     void downgradeReferrerToRegistrableDomain();
1503 #endif
1504
1505     String signedPublicKeyAndChallengeString(unsigned keySizeIndex, const String& challengeString, const URL&);
1506
1507     void registerArticleElement(Element&);
1508     void unregisterArticleElement(Element&);
1509     void updateMainArticleElementAfterLayout();
1510     bool hasMainArticleElement() const { return !!m_mainArticleElement; }
1511
1512     const CSSRegisteredCustomPropertySet& getCSSRegisteredCustomPropertySet() const { return m_CSSRegisteredPropertySet; }
1513     bool registerCSSProperty(CSSRegisteredCustomProperty&&);
1514
1515 #if ENABLE(CSS_PAINTING_API)
1516     Worklet& ensurePaintWorklet();
1517     PaintWorkletGlobalScope* paintWorkletGlobalScopeForName(const String& name);
1518     void setPaintWorkletGlobalScopeForName(const String& name, Ref<PaintWorkletGlobalScope>&&);
1519 #endif
1520
1521     WEBCORE_EXPORT bool hasEvaluatedUserAgentScripts() const;
1522     WEBCORE_EXPORT bool isRunningUserScripts() const;
1523     WEBCORE_EXPORT void setAsRunningUserScripts();
1524     void setHasEvaluatedUserAgentScripts();
1525 #if ENABLE(APPLE_PAY)
1526     WEBCORE_EXPORT bool isApplePayActive() const;
1527     WEBCORE_EXPORT void setApplePayIsActive();
1528 #endif
1529
1530     void frameWasDisconnectedFromOwner();
1531
1532     WEBCORE_EXPORT bool hitTest(const HitTestRequest&, HitTestResult&);
1533     bool hitTest(const HitTestRequest&, const HitTestLocation&, HitTestResult&);
1534 #if !ASSERT_DISABLED
1535     bool inHitTesting() const { return m_inHitTesting; }
1536 #endif
1537
1538     MessagePortChannelProvider& messagePortChannelProvider();
1539
1540 #if USE(SYSTEM_PREVIEW)
1541     WEBCORE_EXPORT void dispatchSystemPreviewActionEvent(const String& message);
1542 #endif
1543
1544 protected:
1545     enum ConstructionFlags { Synthesized = 1, NonRenderedPlaceholder = 1 << 1 };
1546     Document(Frame*, const URL&, unsigned = DefaultDocumentClass, unsigned constructionFlags = 0);
1547
1548     void clearXMLVersion() { m_xmlVersion = String(); }
1549
1550     virtual Ref<Document> cloneDocumentWithoutChildren() const;
1551
1552 private:
1553     friend class DocumentParserYieldToken;
1554     friend class Node;
1555     friend class ThrowOnDynamicMarkupInsertionCountIncrementer;
1556     friend class IgnoreOpensDuringUnloadCountIncrementer;
1557     friend class IgnoreDestructiveWriteCountIncrementer;
1558
1559     void updateTitleElement(Element& changingTitleElement);
1560     void willDetachPage() final;
1561     void frameDestroyed() final;
1562
1563     void commonTeardown();
1564
1565     RenderObject* renderer() const = delete;
1566     void setRenderer(RenderObject*) = delete;
1567
1568     void createRenderTree();
1569     void detachParser();
1570
1571     // FontSelectorClient
1572     void fontsNeedUpdate(FontSelector&) final;
1573
1574     bool isDocument() const final { return true; }
1575
1576     void childrenChanged(const ChildChange&) final;
1577
1578     String nodeName() const final;
1579     NodeType nodeType() const final;
1580     bool childTypeAllowed(NodeType) const final;
1581     Ref<Node> cloneNodeInternal(Document&, CloningOperation) final;
1582     void cloneDataFromDocument(const Document&);
1583
1584     void refScriptExecutionContext() final { ref(); }
1585     void derefScriptExecutionContext() final { deref(); }
1586
1587     Seconds minimumDOMTimerInterval() const final;
1588
1589     Seconds domTimerAlignmentInterval(bool hasReachedMaxNestingLevel) const final;
1590
1591     void updateTitleFromTitleElement();
1592     void updateTitle(const StringWithDirection&);
1593     void updateBaseURL();
1594
1595     void invalidateAccessKeyCacheSlowCase();
1596     void buildAccessKeyCache();
1597
1598     void moveNodeIteratorsToNewDocumentSlowCase(Node&, Document&);
1599
1600     void loadEventDelayTimerFired();
1601
1602     void pendingTasksTimerFired();
1603     bool isCookieAverse() const;
1604
1605     void detachFromFrame();
1606
1607     template<CollectionType> Ref<HTMLCollection> ensureCachedCollection();
1608
1609     void dispatchDisabledAdaptationsDidChangeForMainFrame();
1610
1611     void setVisualUpdatesAllowed(ReadyState);
1612     void setVisualUpdatesAllowed(bool);
1613     void visualUpdatesSuppressionTimerFired();
1614
1615     void addListenerType(ListenerType listenerType) { m_listenerTypes |= listenerType; }
1616
1617     void didAssociateFormControlsTimerFired();
1618
1619     void wheelEventHandlersChanged();
1620
1621     HttpEquivPolicy httpEquivPolicy() const;
1622     AXObjectCache* existingAXObjectCacheSlow() const;
1623
1624     // DOM Cookies caching.
1625     const String& cachedDOMCookies() const { return m_cachedDOMCookies; }
1626     void setCachedDOMCookies(const String&);
1627     bool isDOMCookieCacheValid() const { return m_cookieCacheExpiryTimer.isActive(); }
1628     void invalidateDOMCookieCache();
1629     void didLoadResourceSynchronously() final;
1630
1631     void checkViewportDependentPictures();
1632     void checkAppearanceDependentPictures();
1633
1634     bool canNavigateInternal(Frame& targetFrame);
1635     bool isNavigationBlockedByThirdPartyIFrameRedirectBlocking(Frame& targetFrame, const URL& destinationURL);
1636
1637 #if ENABLE(INTERSECTION_OBSERVER)
1638     void notifyIntersectionObserversTimerFired();
1639 #endif
1640
1641 #if USE(QUICK_LOOK)
1642     bool shouldEnforceQuickLookSandbox() const;
1643     void applyQuickLookSandbox();
1644 #endif
1645
1646     bool shouldEnforceHTTP09Sandbox() const;
1647
1648     void platformSuspendOrStopActiveDOMObjects();
1649
1650     bool isBodyPotentiallyScrollable(HTMLBodyElement&);
1651
1652     const Ref<Settings> m_settings;
1653
1654     UniqueRef<Quirks> m_quirks;
1655
1656     std::unique_ptr<StyleResolver> m_userAgentShadowTreeStyleResolver;
1657
1658     RefPtr<DOMWindow> m_domWindow;
1659     WeakPtr<Document> m_contextDocument;
1660
1661     Ref<CachedResourceLoader> m_cachedResourceLoader;
1662     RefPtr<DocumentParser> m_parser;
1663
1664     unsigned m_parserYieldTokenCount { 0 };
1665
1666     // Document URLs.
1667     URL m_url; // Document.URL: The URL from which this document was retrieved.
1668     URL m_baseURL; // Node.baseURI: The URL to use when resolving relative URLs.
1669     URL m_baseURLOverride; // An alternative base URL that takes precedence over m_baseURL (but not m_baseElementURL).
1670     URL m_baseElementURL; // The URL set by the <base> element.
1671     URL m_cookieURL; // The URL to use for cookie access.
1672     URL m_firstPartyForCookies; // The policy URL for third-party cookie blocking.
1673     URL m_siteForCookies; // The policy URL for Same-Site cookies.
1674
1675     // Document.documentURI:
1676     // Although URL-like, Document.documentURI can actually be set to any
1677     // string by content.  Document.documentURI affects m_baseURL unless the
1678     // document contains a <base> element, in which case the <base> element
1679     // takes precedence.
1680     //
1681     // This property is read-only from JavaScript, but writable from Objective C.
1682     String m_documentURI;
1683
1684     String m_baseTarget;
1685
1686     // MIME type of the document in case it was cloned or created by XHR.
1687     String m_overriddenMIMEType;
1688
1689     std::unique_ptr<DOMImplementation> m_implementation;
1690
1691     RefPtr<Node> m_focusNavigationStartingNode;
1692     RefPtr<Element> m_focusedElement;
1693     RefPtr<Element> m_hoveredElement;
1694     RefPtr<Element> m_activeElement;
1695     RefPtr<Element> m_documentElement;
1696     UserActionElementSet m_userActionElements;
1697
1698     uint64_t m_domTreeVersion;
1699     static uint64_t s_globalTreeVersion;
1700
1701     mutable String m_uniqueIdentifier;
1702
1703     HashSet<NodeIterator*> m_nodeIterators;
1704     HashSet<Range*> m_ranges;
1705
1706     std::unique_ptr<Style::Scope> m_styleScope;
1707     std::unique_ptr<ExtensionStyleSheets> m_extensionStyleSheets;
1708     RefPtr<StyleSheetList> m_styleSheetList;
1709
1710     std::unique_ptr<FormController> m_formController;
1711
1712     Color m_textColor { Color::black };
1713     Color m_linkColor;
1714     Color m_visitedLinkColor;
1715     Color m_activeLinkColor;
1716     const std::unique_ptr<VisitedLinkState> m_visitedLinkState;
1717
1718     StringWithDirection m_title;
1719     StringWithDirection m_rawTitle;
1720     RefPtr<Element> m_titleElement;
1721
1722     std::unique_ptr<AXObjectCache> m_axObjectCache;
1723     const std::unique_ptr<DocumentMarkerController> m_markers;
1724     
1725     Timer m_styleRecalcTimer;
1726
1727     Element* m_cssTarget { nullptr };
1728
1729     RefPtr<SerializedScriptValue> m_pendingStateObject;
1730     MonotonicTime m_documentCreationTime;
1731     bool m_overMinimumLayoutThreshold { false };
1732     
1733     std::unique_ptr<ScriptRunner> m_scriptRunner;
1734     std::unique_ptr<ScriptModuleLoader> m_moduleLoader;
1735
1736     Vector<RefPtr<HTMLScriptElement>> m_currentScriptStack;
1737
1738 #if ENABLE(XSLT)
1739     void applyPendingXSLTransformsTimerFired();
1740
1741     std::unique_ptr<TransformSource> m_transformSource;
1742     RefPtr<Document> m_transformSourceDocument;
1743     Timer m_applyPendingXSLTransformsTimer;
1744     bool m_hasPendingXSLTransforms { false };
1745 #endif
1746
1747     String m_xmlEncoding;
1748     String m_xmlVersion;
1749     StandaloneStatus m_xmlStandalone { StandaloneStatus::Unspecified };
1750     bool m_hasXMLDeclaration { false };
1751
1752     String m_contentLanguage;
1753
1754     RefPtr<TextResourceDecoder> m_decoder;
1755
1756     HashSet<LiveNodeList*> m_listsInvalidatedAtDocument;
1757     HashSet<HTMLCollection*> m_collectionsInvalidatedAtDocument;
1758     unsigned m_nodeListAndCollectionCounts[numNodeListInvalidationTypes];
1759
1760     RefPtr<XPathEvaluator> m_xpathEvaluator;
1761
1762     std::unique_ptr<SVGDocumentExtensions> m_svgExtensions;
1763     HashSet<SVGUseElement*> m_svgUseElements;
1764
1765 #if ENABLE(DARK_MODE_CSS)
1766     OptionSet<ColorScheme> m_colorScheme;
1767     bool m_allowsColorSchemeTransformations { true };
1768 #endif
1769
1770     HashMap<String, RefPtr<HTMLCanvasElement>> m_cssCanvasElements;
1771
1772     HashSet<Element*> m_documentSuspensionCallbackElements;
1773     HashSet<Element*> m_mediaVolumeCallbackElements;
1774     HashSet<Element*> m_privateBrowsingStateChangedElements;
1775 #if ENABLE(VIDEO_TRACK)
1776     HashSet<Element*> m_captionPreferencesChangedElements;
1777 #endif
1778
1779     Element* m_mainArticleElement { nullptr };
1780     HashSet<Element*> m_articleElements;
1781
1782 #if ENABLE(MEDIA_CONTROLS_SCRIPT)
1783     HashSet<HTMLMediaElement*> m_pageScaleFactorChangedElements;
1784     HashSet<HTMLMediaElement*> m_userInterfaceLayoutDirectionChangedElements;
1785 #endif
1786
1787     HashSet<VisibilityChangeClient*> m_visibilityStateCallbackClients;
1788 #if ENABLE(VIDEO)
1789     HashSet<HTMLMediaElement*> m_allowsMediaDocumentInlinePlaybackElements;
1790 #endif
1791
1792     std::unique_ptr<HashMap<String, Element*, ASCIICaseInsensitiveHash>> m_accessKeyCache;
1793
1794     std::unique_ptr<ConstantPropertyMap> m_constantPropertyMap;
1795
1796     std::unique_ptr<SelectorQueryCache> m_selectorQueryCache;
1797
1798     DocumentClassFlags m_documentClasses;
1799
1800     RenderPtr<RenderView> m_renderView;
1801     mutable DocumentEventQueue m_eventQueue;
1802
1803     HashSet<MediaCanStartListener*> m_mediaCanStartListeners;
1804
1805 #if ENABLE(FULLSCREEN_API)
1806     UniqueRef<FullscreenManager> m_fullscreenManager;
1807 #endif
1808
1809     HashSet<HTMLPictureElement*> m_viewportDependentPictures;
1810     HashSet<HTMLPictureElement*> m_appearanceDependentPictures;
1811
1812 #if ENABLE(INTERSECTION_OBSERVER)
1813     Vector<WeakPtr<IntersectionObserver>> m_intersectionObservers;
1814     Vector<WeakPtr<IntersectionObserver>> m_intersectionObserversWithPendingNotifications;
1815     Timer m_intersectionObserversNotifyTimer;
1816     Timer m_intersectionObserversInitialUpdateTimer;
1817 #endif
1818
1819 #if ENABLE(RESIZE_OBSERVER)
1820     Vector<WeakPtr<ResizeObserver>> m_resizeObservers;
1821 #endif
1822
1823     Timer m_loadEventDelayTimer;
1824
1825     ViewportArguments m_viewportArguments;
1826     OptionSet<DisabledAdaptations> m_disabledAdaptations;
1827
1828     DocumentTiming m_documentTiming;
1829
1830     RefPtr<MediaQueryMatcher> m_mediaQueryMatcher;
1831     
1832 #if ENABLE(TOUCH_EVENTS)
1833     std::unique_ptr<EventTargetSet> m_touchEventTargets;
1834 #endif
1835 #if PLATFORM(IOS_FAMILY) && ENABLE(POINTER_EVENTS)
1836     bool m_mayHaveElementsWithNonAutoTouchAction { false };
1837 #endif
1838     std::unique_ptr<EventTargetSet> m_wheelEventTargets;
1839
1840     MonotonicTime m_lastHandledUserGestureTimestamp;
1841     MonotonicTime m_userActivatedMediaFinishedPlayingTimestamp;
1842
1843     void clearScriptedAnimationController();
1844     RefPtr<ScriptedAnimationController> m_scriptedAnimationController;
1845
1846     std::unique_ptr<IdleCallbackController> m_idleCallbackController;
1847
1848     void notifyMediaCaptureOfVisibilityChanged();
1849
1850     void didLogMessage(const WTFLogChannel&, WTFLogLevel, Vector<JSONLogValue>&&) final;
1851
1852 #if ENABLE(DEVICE_ORIENTATION)
1853 #if PLATFORM(IOS_FAMILY)
1854     std::unique_ptr<DeviceMotionClient> m_deviceMotionClient;
1855     std::unique_ptr<DeviceMotionController> m_deviceMotionController;
1856     std::unique_ptr<DeviceOrientationClient> m_deviceOrientationClient;
1857     std::unique_ptr<DeviceOrientationController> m_deviceOrientationController;
1858 #endif
1859     std::unique_ptr<DeviceOrientationAndMotionAccessController> m_deviceOrientationAndMotionAccessController;
1860 #endif
1861
1862     GenericTaskQueue<Timer> m_logMessageTaskQueue;
1863
1864     Timer m_pendingTasksTimer;
1865     Vector<Task> m_pendingTasks;
1866
1867 #if ENABLE(TEXT_AUTOSIZING)
1868     std::unique_ptr<TextAutoSizing> m_textAutoSizing;
1869 #endif
1870
1871     Timer m_visualUpdatesSuppressionTimer;
1872
1873     void clearSharedObjectPool();
1874     Timer m_sharedObjectPoolClearTimer;
1875
1876     std::unique_ptr<DocumentSharedObjectPool> m_sharedObjectPool;
1877
1878     typedef HashMap<AtomString, std::unique_ptr<Locale>> LocaleIdentifierToLocaleMap;
1879     LocaleIdentifierToLocaleMap m_localeCache;
1880
1881     RefPtr<Document> m_templateDocument;
1882     WeakPtr<Document> m_templateDocumentHost; // Manually managed weakref (backpointer from m_templateDocument).
1883
1884     Ref<CSSFontSelector> m_fontSelector;
1885
1886     WeakHashSet<MediaProducer> m_audioProducers;
1887
1888     HashSet<ShadowRoot*> m_inDocumentShadowRoots;
1889
1890 #if ENABLE(WIRELESS_PLAYBACK_TARGET)
1891     typedef HashMap<uint64_t, WebCore::MediaPlaybackTargetClient*> TargetIdToClientMap;
1892     TargetIdToClientMap m_idToClientMap;
1893     typedef HashMap<WebCore::MediaPlaybackTargetClient*, uint64_t> TargetClientToIdMap;
1894     TargetClientToIdMap m_clientToIDMap;
1895 #endif
1896
1897 #if ENABLE(MEDIA_SESSION)
1898     RefPtr<MediaSession> m_defaultMediaSession;
1899 #endif
1900
1901 #if ENABLE(INDEXED_DATABASE)
1902     RefPtr<IDBClient::IDBConnectionProxy> m_idbConnectionProxy;
1903 #endif
1904
1905 #if ENABLE(ATTACHMENT_ELEMENT)
1906     HashMap<String, Ref<HTMLAttachmentElement>> m_attachmentIdentifierToElementMap;
1907 #endif
1908
1909     Timer m_didAssociateFormControlsTimer;
1910     Timer m_cookieCacheExpiryTimer;
1911
1912     RefPtr<SocketProvider> m_socketProvider;
1913
1914     String m_cachedDOMCookies;
1915
1916     Optional<WallTime> m_overrideLastModified;
1917
1918     HashSet<RefPtr<Element>> m_associatedFormControls;
1919     unsigned m_disabledFieldsetElementsCount { 0 };
1920
1921     unsigned m_listenerTypes { 0 };
1922     unsigned m_referencingNodeCount { 0 };
1923     int m_loadEventDelayCount { 0 };
1924     unsigned m_lastStyleUpdateSizeForTesting { 0 };
1925
1926     // https://html.spec.whatwg.org/multipage/dynamic-markup-insertion.html#throw-on-dynamic-markup-insertion-counter
1927     unsigned m_throwOnDynamicMarkupInsertionCount { 0 };
1928
1929     // https://html.spec.whatwg.org/multipage/dynamic-markup-insertion.html#ignore-opens-during-unload-counter
1930     unsigned m_ignoreOpensDuringUnloadCount { 0 };
1931
1932     // https://html.spec.whatwg.org/multipage/dynamic-markup-insertion.html#ignore-destructive-writes-counter
1933     unsigned m_ignoreDestructiveWriteCount { 0 };
1934
1935     unsigned m_activeParserCount { 0 };
1936     unsigned m_styleRecalcCount { 0 };
1937
1938     unsigned m_writeRecursionDepth { 0 };
1939
1940     InheritedBool m_designMode { inherit };
1941     MediaProducer::MediaStateFlags m_mediaState { MediaProducer::IsNotPlaying };
1942     bool m_userHasInteractedWithMediaElement { false };
1943     PageCacheState m_pageCacheState { NotInPageCache };
1944     Optional<ReferrerPolicy> m_referrerPolicy;
1945     ReadyState m_readyState { Complete };
1946
1947     MutationObserverOptions m_mutationObserverTypes { 0 };
1948
1949     bool m_writeRecursionIsTooDeep { false };
1950     bool m_wellFormed { false };
1951     bool m_createRenderers { true };
1952
1953     bool m_hasNodesWithNonFinalStyle { false };
1954     bool m_hasNodesWithMissingStyle { false };
1955     // But sometimes you need to ignore pending stylesheet count to
1956     // force an immediate layout when requested by JS.
1957     bool m_ignorePendingStylesheets { false };
1958
1959     bool m_hasElementUsingStyleBasedEditability { false };
1960     bool m_focusNavigationStartingNodeIsRemoved { false };
1961
1962     bool m_printing { false };
1963     bool m_paginatedForScreen { false };
1964
1965     DocumentCompatibilityMode m_compatibilityMode { DocumentCompatibilityMode::NoQuirksMode };
1966     bool m_compatibilityModeLocked { false }; // This is cheaper than making setCompatibilityMode virtual.
1967
1968     // FIXME: Merge these 2 variables into an enum. Also, FrameLoader::m_didCallImplicitClose
1969     // is almost a duplication of this data, so that should probably get merged in too.
1970     // FIXME: Document::m_processingLoadEvent and DocumentLoader::m_wasOnloadDispatched are roughly the same
1971     // and should be merged.
1972     bool m_processingLoadEvent { false };
1973     bool m_loadEventFinished { false };
1974
1975     bool m_visuallyOrdered { false };
1976     bool m_bParsing { false }; // FIXME: rename
1977
1978     bool m_needsFullStyleRebuild { false };
1979     bool m_inStyleRecalc { false };
1980     bool m_closeAfterStyleRecalc { false };
1981     bool m_inRenderTreeUpdate { false };
1982     bool m_isResolvingTreeStyle { false };
1983
1984     bool m_gotoAnchorNeededAfterStylesheetsLoad { false };
1985     bool m_isDNSPrefetchEnabled { false };
1986     bool m_haveExplicitlyDisabledDNSPrefetch { false };
1987
1988     bool m_isSynthesized { false };
1989     bool m_isNonRenderedPlaceholder { false };
1990
1991     bool m_sawElementsInKnownNamespaces { false };
1992     bool m_isSrcdocDocument { false };
1993
1994     bool m_hasInjectedPlugInsScript { false };
1995     bool m_renderTreeBeingDestroyed { false };
1996     bool m_hasPreparedForDestruction { false };
1997
1998     bool m_hasStyleWithViewportUnits { false };
1999     bool m_isTimerThrottlingEnabled { false };
2000     bool m_isSuspended { false };
2001
2002     bool m_scheduledTasksAreSuspended { false };
2003     bool m_visualUpdatesAllowed { true };
2004
2005     bool m_areDeviceMotionAndOrientationUpdatesSuspended { false };
2006     bool m_userDidInteractWithPage { false };
2007 #if !ASSERT_DISABLED
2008     bool m_inHitTesting { false };
2009 #endif
2010
2011 #if ENABLE(TELEPHONE_NUMBER_DETECTION)
2012     bool m_isTelephoneNumberParsingAllowed { true };
2013 #endif
2014
2015 #if ENABLE(MEDIA_STREAM)
2016     HashSet<HTMLMediaElement*> m_mediaStreamStateChangeElements;
2017     String m_idHashSalt;
2018     bool m_hasHadCaptureMediaStreamTrack { false };
2019 #endif
2020
2021 #ifndef NDEBUG
2022     bool m_didDispatchViewportPropertiesChanged { false };
2023 #endif
2024
2025     OrientationNotifier m_orientationNotifier;
2026     mutable RefPtr<Logger> m_logger;
2027     RefPtr<StringCallback> m_consoleMessageListener;
2028
2029     static bool hasEverCreatedAnAXObjectCache;
2030
2031     RefPtr<DocumentTimeline> m_timeline;
2032     DocumentIdentifier m_identifier;
2033
2034 #if ENABLE(SERVICE_WORKER)
2035     RefPtr<SWClientConnection> m_serviceWorkerConnection;
2036 #endif
2037
2038     HashSet<ApplicationStateChangeListener*> m_applicationStateChangeListeners;
2039     
2040 #if ENABLE(RESOURCE_LOAD_STATISTICS)
2041     RegistrableDomain m_registrableDomainRequestedPageSpecificStorageAccessWithUserInteraction { };
2042     String m_referrerOverride;
2043 #endif
2044     
2045     CSSRegisteredCustomPropertySet m_CSSRegisteredPropertySet;
2046
2047 #if ENABLE(CSS_PAINTING_API)
2048     RefPtr<Worklet> m_paintWorklet;
2049     HashMap<String, Ref<PaintWorkletGlobalScope>> m_paintWorkletGlobalScopes;
2050 #endif
2051
2052     bool m_hasEvaluatedUserAgentScripts { false };
2053     bool m_isRunningUserScripts { false };
2054     bool m_mayBeDetachedFromFrame { true };
2055 #if ENABLE(APPLE_PAY)
2056     bool m_hasStartedApplePaySession { false };
2057 #endif
2058
2059     Ref<UndoManager> m_undoManager;
2060 #if PLATFORM(IOS_FAMILY)
2061     std::unique_ptr<ContentChangeObserver> m_contentChangeObserver;
2062     std::unique_ptr<DOMTimerHoldingTank> m_domTimerHoldingTank;
2063 #endif
2064
2065     HashMap<Element*, ElementIdentifier> m_identifiedElementsMap;
2066 };
2067
2068 Element* eventTargetElementForDocument(Document*);
2069
2070 inline TextEncoding Document::textEncoding() const
2071 {
2072     if (auto* decoder = this->decoder())
2073         return decoder->encoding();
2074     return TextEncoding();
2075 }
2076
2077 inline const Document* Document::templateDocument() const
2078 {
2079     return m_templateDocumentHost ? this : m_templateDocument.get();
2080 }
2081
2082 inline AXObjectCache* Document::existingAXObjectCache() const
2083 {
2084     if (!hasEverCreatedAnAXObjectCache)
2085         return nullptr;
2086     return existingAXObjectCacheSlow();
2087 }
2088
2089 inline Ref<Document> Document::create(const URL& url)
2090 {
2091     return adoptRef(*new Document(nullptr, url));
2092 }
2093
2094 inline void Document::invalidateAccessKeyCache()
2095 {
2096     if (UNLIKELY(m_accessKeyCache))
2097         invalidateAccessKeyCacheSlowCase();
2098 }
2099
2100 // These functions are here because they require the Document class definition and we want to inline them.
2101
2102 inline ScriptExecutionContext* Node::scriptExecutionContext() const
2103 {
2104     return &document().contextDocument();
2105 }
2106
2107 inline ActiveDOMObject::ActiveDOMObject(Document& document)
2108     : ActiveDOMObject(static_cast<ScriptExecutionContext*>(&document.contextDocument()))
2109 {
2110 }
2111
2112 } // namespace WebCore
2113
2114 SPECIALIZE_TYPE_TRAITS_BEGIN(WebCore::Document)
2115     static bool isType(const WebCore::ScriptExecutionContext& context) { return context.isDocument(); }
2116     static bool isType(const WebCore::Node& node) { return node.isDocumentNode(); }
2117 SPECIALIZE_TYPE_TRAITS_END()