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