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