Move URL from WebCore to WTF
[WebKit-https.git] / Source / WebCore / page / Page.h
1 /*
2  * Copyright (C) 2006-2017 Apple Inc. All rights reserved.
3  * Copyright (C) 2008 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
4  *
5  * This library is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU Library General Public
7  * License as published by the Free Software Foundation; either
8  * version 2 of the License, or (at your option) any later version.
9  *
10  * This library is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * Library General Public License for more details.
14  *
15  * You should have received a copy of the GNU Library General Public License
16  * along with this library; see the file COPYING.LIB.  If not, write to
17  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
18  * Boston, MA 02110-1301, USA.
19  */
20
21 #pragma once
22
23 #include "ActivityState.h"
24 #include "DisabledAdaptations.h"
25 #include "Document.h"
26 #include "FindOptions.h"
27 #include "FrameLoaderTypes.h"
28 #include "LayoutMilestone.h"
29 #include "LayoutRect.h"
30 #include "LengthBox.h"
31 #include "MediaProducer.h"
32 #include "Pagination.h"
33 #include "RTCController.h"
34 #include "Region.h"
35 #include "ScrollTypes.h"
36 #include "Supplementable.h"
37 #include "Timer.h"
38 #include "UserInterfaceLayoutDirection.h"
39 #include "ViewportArguments.h"
40 #include "VisibilityState.h"
41 #include "WheelEventTestTrigger.h"
42 #include <memory>
43 #include <pal/SessionID.h>
44 #include <wtf/Forward.h>
45 #include <wtf/Function.h>
46 #include <wtf/HashSet.h>
47 #include <wtf/Noncopyable.h>
48 #include <wtf/Ref.h>
49 #include <wtf/UniqueRef.h>
50 #include <wtf/text/WTFString.h>
51
52 #if PLATFORM(COCOA)
53 #include <wtf/SchedulePair.h>
54 #endif
55
56 #if ENABLE(APPLICATION_MANIFEST)
57 #include "ApplicationManifest.h"
58 #endif
59
60 #if ENABLE(MEDIA_SESSION)
61 #include "MediaSessionEvents.h"
62 #endif
63
64 #if ENABLE(WIRELESS_PLAYBACK_TARGET)
65 #include "MediaPlaybackTargetContext.h"
66 #endif
67
68 namespace JSC {
69 class Debugger;
70 }
71
72 namespace WebCore {
73
74 namespace IDBClient {
75 class IDBConnectionToServer;
76 }
77
78 class AlternativeTextClient;
79 class ApplicationCacheStorage;
80 class AuthenticatorCoordinator;
81 class BackForwardController;
82 class BackForwardClient;
83 class CacheStorageProvider;
84 class Chrome;
85 class ChromeClient;
86 class Color;
87 class ContextMenuClient;
88 class ContextMenuController;
89 class DOMRect;
90 class DOMRectList;
91 class DatabaseProvider;
92 class DiagnosticLoggingClient;
93 class DragCaretController;
94 class DragClient;
95 class DragController;
96 class EditorClient;
97 class Element;
98 class FocusController;
99 class Frame;
100 class FrameLoaderClient;
101 class HistoryItem;
102 class HTMLMediaElement;
103 class UserInputBridge;
104 class InspectorClient;
105 class InspectorController;
106 class LibWebRTCProvider;
107 class LowPowerModeNotifier;
108 class MediaCanStartListener;
109 class MediaPlaybackTarget;
110 class PageConfiguration;
111 class PageConsoleClient;
112 class PageDebuggable;
113 class PageGroup;
114 class PageOverlayController;
115 class PaymentCoordinator;
116 class PerformanceLogging;
117 class PerformanceLoggingClient;
118 class PerformanceMonitor;
119 class PlugInClient;
120 class PluginData;
121 class PluginInfoProvider;
122 class PluginViewBase;
123 class PointerLockController;
124 class ProgressTracker;
125 class ProgressTrackerClient;
126 class Range;
127 class RenderObject;
128 class RenderTheme;
129 class ResourceUsageOverlay;
130 class VisibleSelection;
131 class ScrollLatchingState;
132 class ScrollableArea;
133 class ScrollingCoordinator;
134 class ServicesOverlayController;
135 class Settings;
136 class SocketProvider;
137 class StorageNamespace;
138 class StorageNamespaceProvider;
139 class UserContentProvider;
140 class ValidationMessageClient;
141 class ActivityStateChangeObserver;
142 class VisitedLinkStore;
143 class WebGLStateTracker;
144 class WheelEventDeltaFilter;
145
146 typedef uint64_t SharedStringHash;
147
148 enum FindDirection {
149     FindDirectionForward,
150     FindDirectionBackward
151 };
152
153 enum class EventThrottlingBehavior {
154     Responsive,
155     Unresponsive
156 };
157
158 enum class CompositingPolicy : uint8_t {
159     Normal,
160     Conservative, // Used in low memory situations.
161 };
162
163 enum class CanWrap : bool;
164 enum class DidWrap : bool;
165 enum class RouteSharingPolicy : uint8_t;
166 enum class ShouldTreatAsContinuingLoad : bool;
167
168 class Page : public Supplementable<Page> {
169     WTF_MAKE_NONCOPYABLE(Page);
170     WTF_MAKE_FAST_ALLOCATED;
171     friend class SettingsBase;
172
173 public:
174     WEBCORE_EXPORT static void updateStyleForAllPagesAfterGlobalChangeInEnvironment();
175     WEBCORE_EXPORT static void clearPreviousItemFromAllPages(HistoryItem*);
176
177     void updateStyleAfterChangeInEnvironment();
178
179     WEBCORE_EXPORT explicit Page(PageConfiguration&&);
180     WEBCORE_EXPORT ~Page();
181
182     WEBCORE_EXPORT uint64_t renderTreeSize() const;
183
184     WEBCORE_EXPORT void setNeedsRecalcStyleInAllFrames();
185
186     WEBCORE_EXPORT OptionSet<DisabledAdaptations> disabledAdaptations() const;
187     WEBCORE_EXPORT ViewportArguments viewportArguments() const;
188
189     static void refreshPlugins(bool reload);
190     WEBCORE_EXPORT PluginData& pluginData();
191     void clearPluginData();
192
193     WEBCORE_EXPORT void setCanStartMedia(bool);
194     bool canStartMedia() const { return m_canStartMedia; }
195
196     EditorClient& editorClient() { return m_editorClient.get(); }
197     PlugInClient* plugInClient() const { return m_plugInClient; }
198
199     Frame& mainFrame() { return m_mainFrame.get(); }
200     const Frame& mainFrame() const { return m_mainFrame.get(); }
201
202     bool openedByDOM() const;
203     void setOpenedByDOM();
204
205     bool openedViaWindowOpenWithOpener() const { return m_openedViaWindowOpenWithOpener; }
206     void setOpenedViaWindowOpenWithOpener() { m_openedViaWindowOpenWithOpener = true; }
207
208     WEBCORE_EXPORT void goToItem(HistoryItem&, FrameLoadType, ShouldTreatAsContinuingLoad);
209
210     WEBCORE_EXPORT void setGroupName(const String&);
211     WEBCORE_EXPORT const String& groupName() const;
212
213     PageGroup& group();
214
215     WEBCORE_EXPORT static void forEachPage(const WTF::Function<void(Page&)>&);
216
217     void incrementSubframeCount() { ++m_subframeCount; }
218     void decrementSubframeCount() { ASSERT(m_subframeCount); --m_subframeCount; }
219     int subframeCount() const { checkSubframeCountConsistency(); return m_subframeCount; }
220
221     void incrementNestedRunLoopCount();
222     void decrementNestedRunLoopCount();
223     bool insideNestedRunLoop() const { return m_nestedRunLoopCount > 0; }
224     WEBCORE_EXPORT void whenUnnested(WTF::Function<void()>&&);
225
226 #if ENABLE(REMOTE_INSPECTOR)
227     WEBCORE_EXPORT bool remoteInspectionAllowed() const;
228     WEBCORE_EXPORT void setRemoteInspectionAllowed(bool);
229     WEBCORE_EXPORT String remoteInspectionNameOverride() const;
230     WEBCORE_EXPORT void setRemoteInspectionNameOverride(const String&);
231     void remoteInspectorInformationDidChange() const;
232 #endif
233
234     Chrome& chrome() const { return *m_chrome; }
235     DragCaretController& dragCaretController() const { return *m_dragCaretController; }
236 #if ENABLE(DRAG_SUPPORT)
237     DragController& dragController() const { return *m_dragController; }
238 #endif
239     FocusController& focusController() const { return *m_focusController; }
240 #if ENABLE(CONTEXT_MENUS)
241     ContextMenuController& contextMenuController() const { return *m_contextMenuController; }
242 #endif
243     UserInputBridge& userInputBridge() const { return *m_userInputBridge; }
244     InspectorController& inspectorController() const { return *m_inspectorController; }
245 #if ENABLE(POINTER_LOCK)
246     PointerLockController& pointerLockController() const { return *m_pointerLockController; }
247 #endif
248     LibWebRTCProvider& libWebRTCProvider() { return m_libWebRTCProvider.get(); }
249     RTCController& rtcController() { return m_rtcController; }
250     WEBCORE_EXPORT void disableICECandidateFiltering();
251     WEBCORE_EXPORT void enableICECandidateFiltering();
252     bool shouldEnableICECandidateFilteringByDefault() const { return m_shouldEnableICECandidateFilteringByDefault; }
253
254     void didChangeMainDocument();
255
256     PerformanceMonitor* performanceMonitor() { return m_performanceMonitor.get(); }
257
258     ValidationMessageClient* validationMessageClient() const { return m_validationMessageClient.get(); }
259     void updateValidationBubbleStateIfNeeded();
260
261     WEBCORE_EXPORT ScrollingCoordinator* scrollingCoordinator();
262
263     WEBCORE_EXPORT String scrollingStateTreeAsText();
264     WEBCORE_EXPORT String synchronousScrollingReasonsAsText();
265     WEBCORE_EXPORT Ref<DOMRectList> nonFastScrollableRects();
266
267     WEBCORE_EXPORT Ref<DOMRectList> touchEventRectsForEvent(const String& eventName);
268     WEBCORE_EXPORT Ref<DOMRectList> passiveTouchEventListenerRects();
269
270     Settings& settings() const { return *m_settings; }
271     ProgressTracker& progress() const { return *m_progress; }
272     BackForwardController& backForward() const { return *m_backForwardController; }
273
274     Seconds domTimerAlignmentInterval() const { return m_domTimerAlignmentInterval; }
275
276     void setTabKeyCyclesThroughElements(bool b) { m_tabKeyCyclesThroughElements = b; }
277     bool tabKeyCyclesThroughElements() const { return m_tabKeyCyclesThroughElements; }
278
279     WEBCORE_EXPORT bool findString(const String&, FindOptions, DidWrap* = nullptr);
280     WEBCORE_EXPORT uint32_t replaceRangesWithText(const Vector<Ref<Range>>& rangesToReplace, const String& replacementText, bool selectionOnly);
281     WEBCORE_EXPORT uint32_t replaceSelectionWithText(const String& replacementText);
282
283     WEBCORE_EXPORT RefPtr<Range> rangeOfString(const String&, Range*, FindOptions);
284
285     WEBCORE_EXPORT unsigned countFindMatches(const String&, FindOptions, unsigned maxMatchCount);
286     WEBCORE_EXPORT unsigned markAllMatchesForText(const String&, FindOptions, bool shouldHighlight, unsigned maxMatchCount);
287
288     WEBCORE_EXPORT void unmarkAllTextMatches();
289
290     // find all the Ranges for the matching text.
291     // Upon return, indexForSelection will be one of the following:
292     // 0 if there is no user selection
293     // the index of the first range after the user selection
294     // NoMatchAfterUserSelection if there is no matching text after the user selection.
295     enum { NoMatchAfterUserSelection = -1 };
296     WEBCORE_EXPORT void findStringMatchingRanges(const String&, FindOptions, int maxCount, Vector<RefPtr<Range>>&, int& indexForSelection);
297 #if PLATFORM(COCOA)
298     void platformInitialize();
299     WEBCORE_EXPORT void addSchedulePair(Ref<SchedulePair>&&);
300     WEBCORE_EXPORT void removeSchedulePair(Ref<SchedulePair>&&);
301     SchedulePairHashSet* scheduledRunLoopPairs() { return m_scheduledRunLoopPairs.get(); }
302
303     std::unique_ptr<SchedulePairHashSet> m_scheduledRunLoopPairs;
304 #endif
305
306     WEBCORE_EXPORT const VisibleSelection& selection() const;
307
308     WEBCORE_EXPORT void setDefersLoading(bool);
309     bool defersLoading() const { return m_defersLoading; }
310
311     WEBCORE_EXPORT void clearUndoRedoOperations();
312
313     WEBCORE_EXPORT bool inLowQualityImageInterpolationMode() const;
314     WEBCORE_EXPORT void setInLowQualityImageInterpolationMode(bool = true);
315
316     float mediaVolume() const { return m_mediaVolume; }
317     WEBCORE_EXPORT void setMediaVolume(float);
318
319     WEBCORE_EXPORT void setPageScaleFactor(float scale, const IntPoint& origin, bool inStableState = true);
320     float pageScaleFactor() const { return m_pageScaleFactor; }
321
322     UserInterfaceLayoutDirection userInterfaceLayoutDirection() const { return m_userInterfaceLayoutDirection; }
323     WEBCORE_EXPORT void setUserInterfaceLayoutDirection(UserInterfaceLayoutDirection);
324
325     WEBCORE_EXPORT void updateMediaElementRateChangeRestrictions();
326
327     void didStartProvisionalLoad();
328     void didFinishLoad(); // Called when the load has been committed in the main frame.
329
330     WEBCORE_EXPORT void willDisplayPage();
331
332     // The view scale factor is multiplied into the page scale factor by all
333     // callers of setPageScaleFactor.
334     WEBCORE_EXPORT void setViewScaleFactor(float);
335     float viewScaleFactor() const { return m_viewScaleFactor; }
336
337     WEBCORE_EXPORT void setZoomedOutPageScaleFactor(float);
338     float zoomedOutPageScaleFactor() const { return m_zoomedOutPageScaleFactor; }
339
340     float deviceScaleFactor() const { return m_deviceScaleFactor; }
341     WEBCORE_EXPORT void setDeviceScaleFactor(float);
342
343     float topContentInset() const { return m_topContentInset; }
344     WEBCORE_EXPORT void setTopContentInset(float);
345
346     const FloatBoxExtent& obscuredInsets() const { return m_obscuredInsets; }
347     void setObscuredInsets(const FloatBoxExtent& obscuredInsets) { m_obscuredInsets = obscuredInsets; }
348
349     const FloatBoxExtent& unobscuredSafeAreaInsets() const { return m_unobscuredSafeAreaInsets; }
350     WEBCORE_EXPORT void setUnobscuredSafeAreaInsets(const FloatBoxExtent&);
351
352 #if PLATFORM(IOS_FAMILY)
353     bool enclosedInScrollableAncestorView() const { return m_enclosedInScrollableAncestorView; }
354     void setEnclosedInScrollableAncestorView(bool f) { m_enclosedInScrollableAncestorView = f; }
355 #endif
356     
357     bool useSystemAppearance() const { return m_useSystemAppearance; }
358     WEBCORE_EXPORT void setUseSystemAppearance(bool);
359     
360     WEBCORE_EXPORT bool useDarkAppearance() const;
361     WEBCORE_EXPORT void setUseDarkAppearance(bool);
362     bool defaultUseDarkAppearance() const { return m_useDarkAppearance; }
363     void setUseDarkAppearanceOverride(std::optional<bool>);
364
365 #if ENABLE(TEXT_AUTOSIZING)
366     float textAutosizingWidth() const { return m_textAutosizingWidth; }
367     void setTextAutosizingWidth(float textAutosizingWidth) { m_textAutosizingWidth = textAutosizingWidth; }
368 #endif
369
370     const FloatBoxExtent& fullscreenInsets() const { return m_fullscreenInsets; }
371     WEBCORE_EXPORT void setFullscreenInsets(const FloatBoxExtent&);
372
373     const Seconds fullscreenAutoHideDuration() const { return m_fullscreenAutoHideDuration; }
374     WEBCORE_EXPORT void setFullscreenAutoHideDuration(Seconds);
375     WEBCORE_EXPORT void setFullscreenControlsHidden(bool);
376
377     bool shouldSuppressScrollbarAnimations() const { return m_suppressScrollbarAnimations; }
378     WEBCORE_EXPORT void setShouldSuppressScrollbarAnimations(bool suppressAnimations);
379     void lockAllOverlayScrollbarsToHidden(bool lockOverlayScrollbars);
380     
381     WEBCORE_EXPORT void setVerticalScrollElasticity(ScrollElasticity);
382     ScrollElasticity verticalScrollElasticity() const { return static_cast<ScrollElasticity>(m_verticalScrollElasticity); }
383
384     WEBCORE_EXPORT void setHorizontalScrollElasticity(ScrollElasticity);
385     ScrollElasticity horizontalScrollElasticity() const { return static_cast<ScrollElasticity>(m_horizontalScrollElasticity); }
386
387     WEBCORE_EXPORT void accessibilitySettingsDidChange();
388     WEBCORE_EXPORT void appearanceDidChange();
389
390     // Page and FrameView both store a Pagination value. Page::pagination() is set only by API,
391     // and FrameView::pagination() is set only by CSS. Page::pagination() will affect all
392     // FrameViews in the page cache, but FrameView::pagination() only affects the current
393     // FrameView.
394     const Pagination& pagination() const { return m_pagination; }
395     WEBCORE_EXPORT void setPagination(const Pagination&);
396     bool paginationLineGridEnabled() const { return m_paginationLineGridEnabled; }
397     WEBCORE_EXPORT void setPaginationLineGridEnabled(bool flag);
398
399     WEBCORE_EXPORT unsigned pageCount() const;
400
401     WEBCORE_EXPORT DiagnosticLoggingClient& diagnosticLoggingClient() const;
402
403     PerformanceLoggingClient* performanceLoggingClient() const { return m_performanceLoggingClient.get(); }
404
405     WheelEventDeltaFilter* wheelEventDeltaFilter() { return m_recentWheelEventDeltaFilter.get(); }
406     PageOverlayController& pageOverlayController() { return *m_pageOverlayController; }
407
408 #if PLATFORM(MAC)
409 #if ENABLE(SERVICE_CONTROLS) || ENABLE(TELEPHONE_NUMBER_DETECTION)
410     ServicesOverlayController& servicesOverlayController() { return *m_servicesOverlayController; }
411 #endif // ENABLE(SERVICE_CONTROLS) || ENABLE(TELEPHONE_NUMBER_DETECTION)
412     ScrollLatchingState* latchingState();
413     void pushNewLatchingState();
414     void popLatchingState();
415     void resetLatchingState();
416     void removeLatchingStateForTarget(Element&);
417 #endif // PLATFORM(MAC)
418
419 #if ENABLE(APPLE_PAY)
420     PaymentCoordinator& paymentCoordinator() const { return *m_paymentCoordinator; }
421     WEBCORE_EXPORT void setPaymentCoordinator(std::unique_ptr<PaymentCoordinator>&&);
422 #endif
423
424 #if ENABLE(WEB_AUTHN)
425     AuthenticatorCoordinator& authenticatorCoordinator() { return m_authenticatorCoordinator.get(); }
426 #endif
427
428 #if ENABLE(APPLICATION_MANIFEST)
429     const std::optional<ApplicationManifest>& applicationManifest() const { return m_applicationManifest; }
430 #endif
431
432     // Notifications when the Page starts and stops being presented via a native window.
433     WEBCORE_EXPORT void setActivityState(OptionSet<ActivityState::Flag>);
434     OptionSet<ActivityState::Flag> activityState() const { return m_activityState; }
435
436     bool isWindowActive() const;
437     bool isVisibleAndActive() const;
438     WEBCORE_EXPORT void setIsVisible(bool);
439     WEBCORE_EXPORT void setIsPrerender();
440     bool isVisible() const { return m_activityState.contains(ActivityState::IsVisible); }
441
442     // Notification that this Page was moved into or out of a native window.
443     WEBCORE_EXPORT void setIsInWindow(bool);
444     bool isInWindow() const { return m_activityState.contains(ActivityState::IsInWindow); }
445
446     void setIsClosing() { m_isClosing = true; }
447     bool isClosing() const { return m_isClosing; }
448
449     void setIsRestoringCachedPage(bool value) { m_isRestoringCachedPage = value; }
450     bool isRestoringCachedPage() const { return m_isRestoringCachedPage; }
451
452     WEBCORE_EXPORT void addActivityStateChangeObserver(ActivityStateChangeObserver&);
453     WEBCORE_EXPORT void removeActivityStateChangeObserver(ActivityStateChangeObserver&);
454
455 #if ENABLE(INTERSECTION_OBSERVER)
456     void addDocumentNeedingIntersectionObservationUpdate(Document&);
457     void scheduleForcedIntersectionObservationUpdate(Document&);
458     void updateIntersectionObservations();
459 #endif
460
461     WEBCORE_EXPORT void suspendScriptedAnimations();
462     WEBCORE_EXPORT void resumeScriptedAnimations();
463     bool scriptedAnimationsSuspended() const { return m_scriptedAnimationsSuspended; }
464
465     void userStyleSheetLocationChanged();
466     const String& userStyleSheet() const;
467
468     WEBCORE_EXPORT void userAgentChanged();
469
470     void dnsPrefetchingStateChanged();
471     void storageBlockingStateChanged();
472
473 #if ENABLE(RESOURCE_USAGE)
474     void setResourceUsageOverlayVisible(bool);
475 #endif
476
477     void setDebugger(JSC::Debugger*);
478     JSC::Debugger* debugger() const { return m_debugger; }
479
480     WEBCORE_EXPORT void invalidateStylesForAllLinks();
481     WEBCORE_EXPORT void invalidateStylesForLink(SharedStringHash);
482
483     void invalidateInjectedStyleSheetCacheInAllFrames();
484
485     StorageNamespace* sessionStorage(bool optionalCreate = true);
486     void setSessionStorage(RefPtr<StorageNamespace>&&);
487
488     StorageNamespace* ephemeralLocalStorage(bool optionalCreate = true);
489     void setEphemeralLocalStorage(RefPtr<StorageNamespace>&&);
490
491     bool hasCustomHTMLTokenizerTimeDelay() const;
492     double customHTMLTokenizerTimeDelay() const;
493
494     WEBCORE_EXPORT void setMemoryCacheClientCallsEnabled(bool);
495     bool areMemoryCacheClientCallsEnabled() const { return m_areMemoryCacheClientCallsEnabled; }
496
497     // Don't allow more than a certain number of frames in a page.
498     // This seems like a reasonable upper bound, and otherwise mutually
499     // recursive frameset pages can quickly bring the program to its knees
500     // with exponential growth in the number of frames.
501     static const int maxNumberOfFrames = 1000;
502
503     void setEditable(bool isEditable) { m_isEditable = isEditable; }
504     bool isEditable() { return m_isEditable; }
505
506     WEBCORE_EXPORT VisibilityState visibilityState() const;
507     WEBCORE_EXPORT void resumeAnimatingImages();
508
509     WEBCORE_EXPORT void addLayoutMilestones(OptionSet<LayoutMilestone>);
510     WEBCORE_EXPORT void removeLayoutMilestones(OptionSet<LayoutMilestone>);
511     OptionSet<LayoutMilestone> requestedLayoutMilestones() const { return m_requestedLayoutMilestones; }
512
513 #if ENABLE(RUBBER_BANDING)
514     WEBCORE_EXPORT void addHeaderWithHeight(int);
515     WEBCORE_EXPORT void addFooterWithHeight(int);
516 #endif
517
518     int headerHeight() const { return m_headerHeight; }
519     int footerHeight() const { return m_footerHeight; }
520
521     WEBCORE_EXPORT Color pageExtendedBackgroundColor() const;
522
523     bool isCountingRelevantRepaintedObjects() const;
524     void setIsCountingRelevantRepaintedObjects(bool isCounting) { m_isCountingRelevantRepaintedObjects = isCounting; }
525     void startCountingRelevantRepaintedObjects();
526     void resetRelevantPaintedObjectCounter();
527     void addRelevantRepaintedObject(RenderObject*, const LayoutRect& objectPaintRect);
528     void addRelevantUnpaintedObject(RenderObject*, const LayoutRect& objectPaintRect);
529
530     WEBCORE_EXPORT void suspendActiveDOMObjectsAndAnimations();
531     WEBCORE_EXPORT void resumeActiveDOMObjectsAndAnimations();
532     void suspendDeviceMotionAndOrientationUpdates();
533     void resumeDeviceMotionAndOrientationUpdates();
534
535 #ifndef NDEBUG
536     void setIsPainting(bool painting) { m_isPainting = painting; }
537     bool isPainting() const { return m_isPainting; }
538 #endif
539
540     AlternativeTextClient* alternativeTextClient() const { return m_alternativeTextClient; }
541
542     bool hasSeenPlugin(const String& serviceType) const;
543     WEBCORE_EXPORT bool hasSeenAnyPlugin() const;
544     void sawPlugin(const String& serviceType);
545     void resetSeenPlugins();
546
547     bool hasSeenMediaEngine(const String& engineName) const;
548     bool hasSeenAnyMediaEngine() const;
549     void sawMediaEngine(const String& engineName);
550     void resetSeenMediaEngines();
551
552     PageConsoleClient& console() { return *m_consoleClient; }
553
554 #if ENABLE(REMOTE_INSPECTOR)
555     PageDebuggable& inspectorDebuggable() const { return *m_inspectorDebuggable.get(); }
556 #endif
557
558     void hiddenPageCSSAnimationSuspensionStateChanged();
559
560 #if ENABLE(VIDEO_TRACK)
561     void captionPreferencesChanged();
562 #endif
563
564     void forbidPrompts();
565     void allowPrompts();
566     bool arePromptsAllowed();
567
568     void mainFrameLoadStarted(const URL&, FrameLoadType);
569
570     void setLastSpatialNavigationCandidateCount(unsigned count) { m_lastSpatialNavigationCandidatesCount = count; }
571     unsigned lastSpatialNavigationCandidateCount() const { return m_lastSpatialNavigationCandidatesCount; }
572
573     ApplicationCacheStorage& applicationCacheStorage() { return m_applicationCacheStorage; }
574     DatabaseProvider& databaseProvider() { return m_databaseProvider; }
575     CacheStorageProvider& cacheStorageProvider() { return m_cacheStorageProvider; }
576     SocketProvider& socketProvider() { return m_socketProvider; }
577
578     StorageNamespaceProvider& storageNamespaceProvider() { return m_storageNamespaceProvider.get(); }
579     void setStorageNamespaceProvider(Ref<StorageNamespaceProvider>&&);
580
581     PluginInfoProvider& pluginInfoProvider();
582
583     WEBCORE_EXPORT UserContentProvider& userContentProvider();
584     WEBCORE_EXPORT void setUserContentProvider(Ref<UserContentProvider>&&);
585
586     VisitedLinkStore& visitedLinkStore();
587     WEBCORE_EXPORT void setVisitedLinkStore(Ref<VisitedLinkStore>&&);
588
589     WEBCORE_EXPORT PAL::SessionID sessionID() const;
590     WEBCORE_EXPORT void setSessionID(PAL::SessionID);
591     WEBCORE_EXPORT void enableLegacyPrivateBrowsing(bool privateBrowsingEnabled);
592     bool usesEphemeralSession() const { return m_sessionID.isEphemeral(); }
593
594     MediaProducer::MediaStateFlags mediaState() const { return m_mediaState; }
595     void updateIsPlayingMedia(uint64_t);
596     MediaProducer::MutedStateFlags mutedState() const { return m_mutedState; }
597     bool isAudioMuted() const { return m_mutedState & MediaProducer::AudioIsMuted; }
598     bool isMediaCaptureMuted() const { return m_mutedState & MediaProducer::CaptureDevicesAreMuted; };
599     void schedulePlaybackControlsManagerUpdate();
600     WEBCORE_EXPORT void setMuted(MediaProducer::MutedStateFlags);
601     WEBCORE_EXPORT void stopMediaCapture();
602
603 #if ENABLE(MEDIA_SESSION)
604     WEBCORE_EXPORT void handleMediaEvent(MediaEventType);
605     WEBCORE_EXPORT void setVolumeOfMediaElement(double, uint64_t);
606 #endif
607
608 #if ENABLE(WIRELESS_PLAYBACK_TARGET)
609     void addPlaybackTargetPickerClient(uint64_t);
610     void removePlaybackTargetPickerClient(uint64_t);
611     void showPlaybackTargetPicker(uint64_t, const IntPoint&, bool, RouteSharingPolicy, const String&);
612     void playbackTargetPickerClientStateDidChange(uint64_t, MediaProducer::MediaStateFlags);
613     WEBCORE_EXPORT void setMockMediaPlaybackTargetPickerEnabled(bool);
614     WEBCORE_EXPORT void setMockMediaPlaybackTargetPickerState(const String&, MediaPlaybackTargetContext::State);
615
616     WEBCORE_EXPORT void setPlaybackTarget(uint64_t, Ref<MediaPlaybackTarget>&&);
617     WEBCORE_EXPORT void playbackTargetAvailabilityDidChange(uint64_t, bool);
618     WEBCORE_EXPORT void setShouldPlayToPlaybackTarget(uint64_t, bool);
619 #endif
620
621     RefPtr<WheelEventTestTrigger> testTrigger() const { return m_testTrigger; }
622     WEBCORE_EXPORT WheelEventTestTrigger& ensureTestTrigger();
623     void clearTrigger() { m_testTrigger = nullptr; }
624     bool expectsWheelEventTriggers() const { return !!m_testTrigger; }
625
626 #if ENABLE(VIDEO)
627     bool allowsMediaDocumentInlinePlayback() const { return m_allowsMediaDocumentInlinePlayback; }
628     WEBCORE_EXPORT void setAllowsMediaDocumentInlinePlayback(bool);
629 #endif
630
631     bool allowsPlaybackControlsForAutoplayingAudio() const { return m_allowsPlaybackControlsForAutoplayingAudio; }
632     void setAllowsPlaybackControlsForAutoplayingAudio(bool allowsPlaybackControlsForAutoplayingAudio) { m_allowsPlaybackControlsForAutoplayingAudio = allowsPlaybackControlsForAutoplayingAudio; }
633
634 #if ENABLE(INDEXED_DATABASE)
635     IDBClient::IDBConnectionToServer& idbConnection();
636     WEBCORE_EXPORT IDBClient::IDBConnectionToServer* optionalIDBConnection();
637     WEBCORE_EXPORT void clearIDBConnection();
638 #endif
639
640     void setShowAllPlugins(bool showAll) { m_showAllPlugins = showAll; }
641     bool showAllPlugins() const;
642
643     WEBCORE_EXPORT void setDOMTimerAlignmentIntervalIncreaseLimit(Seconds);
644
645     bool isControlledByAutomation() const { return m_controlledByAutomation; }
646     void setControlledByAutomation(bool controlled) { m_controlledByAutomation = controlled; }
647
648     WEBCORE_EXPORT bool isAlwaysOnLoggingAllowed() const;
649
650     String captionUserPreferencesStyleSheet();
651     void setCaptionUserPreferencesStyleSheet(const String&);
652
653     bool isResourceCachingDisabled() const { return m_resourceCachingDisabled || m_resourceCachingDisabledOverride; }
654     void setResourceCachingDisabled(bool disabled) { m_resourceCachingDisabled = disabled; }
655
656     // Web Inspector can override whatever value is set via WebKit SPI, but only while it is open.
657     void setResourceCachingDisabledOverride(bool disabled) { m_resourceCachingDisabledOverride = disabled; }
658
659     std::optional<EventThrottlingBehavior> eventThrottlingBehaviorOverride() const { return m_eventThrottlingBehaviorOverride; }
660     void setEventThrottlingBehaviorOverride(std::optional<EventThrottlingBehavior> throttling) { m_eventThrottlingBehaviorOverride = throttling; }
661
662     std::optional<CompositingPolicy> compositingPolicyOverride() const { return m_compositingPolicyOverride; }
663     void setCompositingPolicyOverride(std::optional<CompositingPolicy> policy) { m_compositingPolicyOverride = policy; }
664
665     WebGLStateTracker* webGLStateTracker() const { return m_webGLStateTracker.get(); }
666
667     bool isOnlyNonUtilityPage() const;
668     bool isUtilityPage() const { return m_isUtilityPage; }
669
670 #if ENABLE(DATA_INTERACTION)
671     WEBCORE_EXPORT bool hasSelectionAtPosition(const FloatPoint&) const;
672 #endif
673
674     bool isLowPowerModeEnabled() const;
675     WEBCORE_EXPORT void setLowPowerModeEnabledOverrideForTesting(std::optional<bool>);
676
677     WEBCORE_EXPORT void applicationWillResignActive();
678     WEBCORE_EXPORT void applicationDidEnterBackground();
679     WEBCORE_EXPORT void applicationWillEnterForeground();
680     WEBCORE_EXPORT void applicationDidBecomeActive();
681
682     PerformanceLogging& performanceLogging() const { return *m_performanceLogging; }
683
684 private:
685     struct Navigation {
686         String domain;
687         FrameLoadType type;
688     };
689     void logNavigation(const Navigation&);
690
691     WEBCORE_EXPORT void initGroup();
692
693     void setIsInWindowInternal(bool);
694     void setIsVisibleInternal(bool);
695     void setIsVisuallyIdleInternal(bool);
696
697 #if ASSERT_DISABLED
698     void checkSubframeCountConsistency() const { }
699 #else
700     void checkSubframeCountConsistency() const;
701 #endif
702
703     enum ShouldHighlightMatches { DoNotHighlightMatches, HighlightMatches };
704     enum ShouldMarkMatches { DoNotMarkMatches, MarkMatches };
705
706     unsigned findMatchesForText(const String&, FindOptions, unsigned maxMatchCount, ShouldHighlightMatches, ShouldMarkMatches);
707
708     std::optional<std::pair<MediaCanStartListener&, Document&>> takeAnyMediaCanStartListener();
709
710 #if ENABLE(VIDEO)
711     void playbackControlsManagerUpdateTimerFired();
712 #endif
713
714     Vector<Ref<PluginViewBase>> pluginViews();
715
716     void handleLowModePowerChange(bool);
717
718     void forEachDocument(const WTF::Function<void(Document&)>&);
719
720     enum class TimerThrottlingState { Disabled, Enabled, EnabledIncreasing };
721     void hiddenPageDOMTimerThrottlingStateChanged();
722     void setTimerThrottlingState(TimerThrottlingState);
723     void updateTimerThrottlingState();
724     void updateDOMTimerAlignmentInterval();
725     void domTimerAlignmentIntervalIncreaseTimerFired();
726
727     const std::unique_ptr<Chrome> m_chrome;
728     const std::unique_ptr<DragCaretController> m_dragCaretController;
729
730 #if ENABLE(DRAG_SUPPORT)
731     const std::unique_ptr<DragController> m_dragController;
732 #endif
733     const std::unique_ptr<FocusController> m_focusController;
734 #if ENABLE(CONTEXT_MENUS)
735     const std::unique_ptr<ContextMenuController> m_contextMenuController;
736 #endif
737     const std::unique_ptr<UserInputBridge> m_userInputBridge;
738     const std::unique_ptr<InspectorController> m_inspectorController;
739 #if ENABLE(POINTER_LOCK)
740     const std::unique_ptr<PointerLockController> m_pointerLockController;
741 #endif
742     RefPtr<ScrollingCoordinator> m_scrollingCoordinator;
743
744     const RefPtr<Settings> m_settings;
745     const std::unique_ptr<ProgressTracker> m_progress;
746
747     const std::unique_ptr<BackForwardController> m_backForwardController;
748     Ref<Frame> m_mainFrame;
749
750     RefPtr<PluginData> m_pluginData;
751
752     UniqueRef<EditorClient> m_editorClient;
753     PlugInClient* m_plugInClient;
754     std::unique_ptr<ValidationMessageClient> m_validationMessageClient;
755     std::unique_ptr<DiagnosticLoggingClient> m_diagnosticLoggingClient;
756     std::unique_ptr<PerformanceLoggingClient> m_performanceLoggingClient;
757     
758     std::unique_ptr<WebGLStateTracker> m_webGLStateTracker;
759
760     UniqueRef<LibWebRTCProvider> m_libWebRTCProvider;
761     RTCController m_rtcController;
762
763     int m_nestedRunLoopCount { 0 };
764     WTF::Function<void()> m_unnestCallback;
765
766     int m_subframeCount { 0 };
767     String m_groupName;
768     bool m_openedByDOM { false };
769     bool m_openedViaWindowOpenWithOpener { false };
770
771     bool m_tabKeyCyclesThroughElements { true };
772     bool m_defersLoading { false };
773     unsigned m_defersLoadingCallCount { 0 };
774
775     bool m_inLowQualityInterpolationMode { false };
776     bool m_areMemoryCacheClientCallsEnabled { true };
777     float m_mediaVolume { 1 };
778     MediaProducer::MutedStateFlags m_mutedState { MediaProducer::NoneMuted };
779
780     float m_pageScaleFactor { 1 };
781     float m_zoomedOutPageScaleFactor { 0 };
782     float m_deviceScaleFactor { 1 };
783     float m_viewScaleFactor { 1 };
784
785     float m_topContentInset { 0 };
786     FloatBoxExtent m_obscuredInsets;
787     FloatBoxExtent m_unobscuredSafeAreaInsets;
788     FloatBoxExtent m_fullscreenInsets;
789     Seconds m_fullscreenAutoHideDuration { 0_s };
790
791 #if PLATFORM(IOS_FAMILY)
792     bool m_enclosedInScrollableAncestorView { false };
793 #endif
794     
795     bool m_useSystemAppearance { false };
796     bool m_useDarkAppearance { false };
797     std::optional<bool> m_useDarkAppearanceOverride;
798
799 #if ENABLE(TEXT_AUTOSIZING)
800     float m_textAutosizingWidth { 0 };
801 #endif
802     
803     bool m_suppressScrollbarAnimations { false };
804     
805     unsigned m_verticalScrollElasticity : 2; // ScrollElasticity
806     unsigned m_horizontalScrollElasticity : 2; // ScrollElasticity    
807
808     Pagination m_pagination;
809     bool m_paginationLineGridEnabled { false };
810
811     String m_userStyleSheetPath;
812     mutable String m_userStyleSheet;
813     mutable bool m_didLoadUserStyleSheet { false };
814     mutable time_t m_userStyleSheetModificationTime { 0 };
815
816     String m_captionUserPreferencesStyleSheet;
817
818     std::unique_ptr<PageGroup> m_singlePageGroup;
819     PageGroup* m_group { nullptr };
820
821     JSC::Debugger* m_debugger { nullptr };
822
823     bool m_canStartMedia { true };
824
825     RefPtr<StorageNamespace> m_sessionStorage;
826     RefPtr<StorageNamespace> m_ephemeralLocalStorage;
827
828     TimerThrottlingState m_timerThrottlingState { TimerThrottlingState::Disabled };
829     MonotonicTime m_timerThrottlingStateLastChangedTime;
830     Seconds m_domTimerAlignmentInterval;
831     Timer m_domTimerAlignmentIntervalIncreaseTimer;
832     Seconds m_domTimerAlignmentIntervalIncreaseLimit;
833
834     bool m_isEditable { false };
835     bool m_isPrerender { false };
836     OptionSet<ActivityState::Flag> m_activityState;
837
838     OptionSet<LayoutMilestone> m_requestedLayoutMilestones;
839
840     int m_headerHeight { 0 };
841     int m_footerHeight { 0 };
842
843     HashSet<RenderObject*> m_relevantUnpaintedRenderObjects;
844     Region m_topRelevantPaintedRegion;
845     Region m_bottomRelevantPaintedRegion;
846     Region m_relevantUnpaintedRegion;
847     bool m_isCountingRelevantRepaintedObjects { false };
848 #ifndef NDEBUG
849     bool m_isPainting { false };
850 #endif
851     AlternativeTextClient* m_alternativeTextClient;
852
853     bool m_scriptedAnimationsSuspended { false };
854     const std::unique_ptr<PageConsoleClient> m_consoleClient;
855
856 #if ENABLE(REMOTE_INSPECTOR)
857     const std::unique_ptr<PageDebuggable> m_inspectorDebuggable;
858 #endif
859
860 #if ENABLE(INDEXED_DATABASE)
861     RefPtr<IDBClient::IDBConnectionToServer> m_idbConnectionToServer;
862 #endif
863
864     HashSet<String> m_seenPlugins;
865     HashSet<String> m_seenMediaEngines;
866
867     unsigned m_lastSpatialNavigationCandidatesCount { 0 };
868     unsigned m_forbidPromptsDepth { 0 };
869
870     Ref<SocketProvider> m_socketProvider;
871     Ref<ApplicationCacheStorage> m_applicationCacheStorage;
872     Ref<CacheStorageProvider> m_cacheStorageProvider;
873     Ref<DatabaseProvider> m_databaseProvider;
874     Ref<PluginInfoProvider> m_pluginInfoProvider;
875     Ref<StorageNamespaceProvider> m_storageNamespaceProvider;
876     Ref<UserContentProvider> m_userContentProvider;
877     Ref<VisitedLinkStore> m_visitedLinkStore;
878     RefPtr<WheelEventTestTrigger> m_testTrigger;
879
880     HashSet<ActivityStateChangeObserver*> m_activityStateChangeObservers;
881
882 #if ENABLE(INTERSECTION_OBSERVER)
883     Vector<WeakPtr<Document>> m_documentsNeedingIntersectionObservationUpdate;
884
885     // FIXME: Schedule intersection observation updates in a way that fits into the HTML
886     // EventLoop. See https://bugs.webkit.org/show_bug.cgi?id=160711.
887     Timer m_intersectionObservationUpdateTimer;
888 #endif
889
890 #if ENABLE(RESOURCE_USAGE)
891     std::unique_ptr<ResourceUsageOverlay> m_resourceUsageOverlay;
892 #endif
893
894     PAL::SessionID m_sessionID;
895
896     bool m_isClosing { false };
897     bool m_isRestoringCachedPage { false };
898
899     MediaProducer::MediaStateFlags m_mediaState { MediaProducer::IsNotPlaying };
900
901 #if ENABLE(VIDEO)
902     Timer m_playbackControlsManagerUpdateTimer;
903 #endif
904
905     bool m_allowsMediaDocumentInlinePlayback { false };
906     bool m_allowsPlaybackControlsForAutoplayingAudio { false };
907     bool m_showAllPlugins { false };
908     bool m_controlledByAutomation { false };
909     bool m_resourceCachingDisabled { false };
910     bool m_resourceCachingDisabledOverride { false };
911     bool m_isUtilityPage;
912     UserInterfaceLayoutDirection m_userInterfaceLayoutDirection { UserInterfaceLayoutDirection::LTR };
913     
914     // For testing.
915     std::optional<EventThrottlingBehavior> m_eventThrottlingBehaviorOverride;
916     std::optional<CompositingPolicy> m_compositingPolicyOverride;
917
918     std::unique_ptr<PerformanceMonitor> m_performanceMonitor;
919     std::unique_ptr<LowPowerModeNotifier> m_lowPowerModeNotifier;
920     std::optional<bool> m_lowPowerModeEnabledOverrideForTesting;
921
922     std::optional<Navigation> m_navigationToLogWhenVisible;
923
924     std::unique_ptr<PerformanceLogging> m_performanceLogging;
925 #if PLATFORM(MAC)
926     Vector<ScrollLatchingState> m_latchingState;
927 #if ENABLE(SERVICE_CONTROLS) || ENABLE(TELEPHONE_NUMBER_DETECTION)
928     std::unique_ptr<ServicesOverlayController> m_servicesOverlayController;
929 #endif
930 #endif
931
932     std::unique_ptr<WheelEventDeltaFilter> m_recentWheelEventDeltaFilter;
933     std::unique_ptr<PageOverlayController> m_pageOverlayController;
934
935 #if ENABLE(APPLE_PAY)
936     std::unique_ptr<PaymentCoordinator> m_paymentCoordinator;
937 #endif
938
939 #if ENABLE(WEB_AUTHN)
940     UniqueRef<AuthenticatorCoordinator> m_authenticatorCoordinator;
941 #endif
942
943 #if ENABLE(APPLICATION_MANIFEST)
944     std::optional<ApplicationManifest> m_applicationManifest;
945 #endif
946
947     bool m_shouldEnableICECandidateFilteringByDefault { true };
948 };
949
950 inline PageGroup& Page::group()
951 {
952     if (!m_group)
953         initGroup();
954     return *m_group;
955 }
956
957 } // namespace WebCore