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