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