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