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