afd5dc05053885ab2c93efda6d38f0ab4152e1f2
[WebKit-https.git] / Source / WebCore / page / Page.h
1 /*
2  * Copyright (C) 2006, 2007, 2008, 2009, 2010, 2013 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 #ifndef Page_h
22 #define Page_h
23
24 #include "FindOptions.h"
25 #include "FrameLoaderTypes.h"
26 #include "LayoutMilestones.h"
27 #include "LayoutRect.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 <memory>
39 #include <wtf/Forward.h>
40 #include <wtf/HashMap.h>
41 #include <wtf/HashSet.h>
42 #include <wtf/Noncopyable.h>
43 #include <wtf/Ref.h>
44 #include <wtf/RefCounted.h>
45 #include <wtf/text/WTFString.h>
46
47 #if OS(SOLARIS)
48 #include <sys/time.h> // For time_t structure.
49 #endif
50
51 #if PLATFORM(COCOA)
52 #include <wtf/SchedulePair.h>
53 #endif
54
55 namespace JSC {
56 class Debugger;
57 }
58
59 namespace WebCore {
60
61 class AlternativeTextClient;
62 class BackForwardController;
63 class BackForwardClient;
64 class Chrome;
65 class ChromeClient;
66 class ClientRectList;
67 class Color;
68 class ContextMenuClient;
69 class ContextMenuController;
70 class DatabaseProvider;
71 class DragCaretController;
72 class DragClient;
73 class DragController;
74 class EditorClient;
75 class FocusController;
76 class Frame;
77 class FrameLoaderClient;
78 class HistoryItem;
79 class HTMLMediaElement;
80 class UserInputBridge;
81 class InspectorClient;
82 class InspectorController;
83 class MainFrame;
84 class MediaCanStartListener;
85 class MediaPlaybackTarget;
86 class PageConfiguration;
87 class PageConsoleClient;
88 class PageDebuggable;
89 class PageGroup;
90 class PageThrottler;
91 class PlugInClient;
92 class PluginData;
93 class PluginViewBase;
94 class PointerLockController;
95 class ProgressTracker;
96 class ProgressTrackerClient;
97 class Range;
98 class RenderObject;
99 class RenderTheme;
100 class ReplayController;
101 class VisibleSelection;
102 class ScrollableArea;
103 class ScrollingCoordinator;
104 class Settings;
105 class StorageNamespace;
106 class StorageNamespaceProvider;
107 class UserContentController;
108 class ValidationMessageClient;
109 class ViewStateChangeObserver;
110 class VisitedLinkStore;
111
112 typedef uint64_t LinkHash;
113 class SharedBuffer;
114
115 enum FindDirection { FindDirectionForward, FindDirectionBackward };
116
117 class Page : public Supplementable<Page> {
118     WTF_MAKE_NONCOPYABLE(Page);
119     WTF_MAKE_FAST_ALLOCATED;
120     friend class Settings;
121     friend class PageThrottler;
122
123 public:
124     WEBCORE_EXPORT static void updateStyleForAllPagesAfterGlobalChangeInEnvironment();
125     WEBCORE_EXPORT static void clearPreviousItemFromAllPages(HistoryItem*);
126
127     WEBCORE_EXPORT explicit Page(PageConfiguration&);
128     WEBCORE_EXPORT ~Page();
129
130     WEBCORE_EXPORT uint64_t renderTreeSize() const;
131     
132     static std::unique_ptr<Page> createPageFromBuffer(PageConfiguration&, const SharedBuffer*, const String& mimeType, bool canHaveScrollbars, bool transparent);
133
134     void setNeedsRecalcStyleInAllFrames();
135
136     RenderTheme& theme() const { return *m_theme; }
137
138     WEBCORE_EXPORT ViewportArguments viewportArguments() const;
139
140     static void refreshPlugins(bool reload);
141     WEBCORE_EXPORT PluginData& pluginData() const;
142
143     WEBCORE_EXPORT void setCanStartMedia(bool);
144     bool canStartMedia() const { return m_canStartMedia; }
145
146     EditorClient& editorClient() { return m_editorClient; }
147     PlugInClient* plugInClient() const { return m_plugInClient; }
148
149     MainFrame& mainFrame() { ASSERT(m_mainFrame); return *m_mainFrame; }
150     const MainFrame& mainFrame() const { ASSERT(m_mainFrame); return *m_mainFrame; }
151
152     bool openedByDOM() const;
153     void setOpenedByDOM();
154
155     WEBCORE_EXPORT void goToItem(HistoryItem&, FrameLoadType);
156
157     WEBCORE_EXPORT void setGroupName(const String&);
158     WEBCORE_EXPORT const String& groupName() const;
159
160     PageGroup& group();
161     PageGroup* groupPtr() { return m_group; } // can return 0
162
163     void incrementSubframeCount() { ++m_subframeCount; }
164     void decrementSubframeCount() { ASSERT(m_subframeCount); --m_subframeCount; }
165     int subframeCount() const { checkSubframeCountConsistency(); return m_subframeCount; }
166
167 #if ENABLE(REMOTE_INSPECTOR)
168     WEBCORE_EXPORT bool remoteInspectionAllowed() const;
169     WEBCORE_EXPORT void setRemoteInspectionAllowed(bool);
170     void remoteInspectorInformationDidChange() const;
171 #endif
172
173     Chrome& chrome() const { return *m_chrome; }
174     DragCaretController& dragCaretController() const { return *m_dragCaretController; }
175 #if ENABLE(DRAG_SUPPORT)
176     DragController& dragController() const { return *m_dragController; }
177 #endif
178     FocusController& focusController() const { return *m_focusController; }
179 #if ENABLE(CONTEXT_MENUS)
180     ContextMenuController& contextMenuController() const { return *m_contextMenuController; }
181 #endif
182     UserInputBridge& userInputBridge() const { return *m_userInputBridge; }
183 #if ENABLE(WEB_REPLAY)
184     ReplayController& replayController() const { return *m_replayController; }
185 #endif
186     InspectorController& inspectorController() const { return *m_inspectorController; }
187 #if ENABLE(POINTER_LOCK)
188     PointerLockController& pointerLockController() const { return *m_pointerLockController; }
189 #endif
190     ValidationMessageClient* validationMessageClient() const { return m_validationMessageClient; }
191
192     WEBCORE_EXPORT ScrollingCoordinator* scrollingCoordinator();
193
194     WEBCORE_EXPORT String scrollingStateTreeAsText();
195     WEBCORE_EXPORT String synchronousScrollingReasonsAsText();
196     WEBCORE_EXPORT Ref<ClientRectList> nonFastScrollableRects(const Frame*);
197
198     Settings& settings() const { return *m_settings; }
199     ProgressTracker& progress() const { return *m_progress; }
200     BackForwardController& backForward() const { return *m_backForwardController; }
201
202 #if ENABLE(VIEW_MODE_CSS_MEDIA)
203     enum ViewMode {
204         ViewModeInvalid,
205         ViewModeWindowed,
206         ViewModeFloating,
207         ViewModeFullscreen,
208         ViewModeMaximized,
209         ViewModeMinimized
210     };
211     static ViewMode stringToViewMode(const String&);
212
213     ViewMode viewMode() const { return m_viewMode; }
214     WEBCORE_EXPORT void setViewMode(ViewMode);
215 #endif // ENABLE(VIEW_MODE_CSS_MEDIA)
216
217     void setTabKeyCyclesThroughElements(bool b) { m_tabKeyCyclesThroughElements = b; }
218     bool tabKeyCyclesThroughElements() const { return m_tabKeyCyclesThroughElements; }
219
220     WEBCORE_EXPORT bool findString(const String&, FindOptions);
221
222     WEBCORE_EXPORT RefPtr<Range> rangeOfString(const String&, Range*, FindOptions);
223
224     WEBCORE_EXPORT unsigned countFindMatches(const String&, FindOptions, unsigned maxMatchCount);
225     WEBCORE_EXPORT unsigned markAllMatchesForText(const String&, FindOptions, bool shouldHighlight, unsigned maxMatchCount);
226
227     WEBCORE_EXPORT void unmarkAllTextMatches();
228
229     // find all the Ranges for the matching text.
230     // Upon return, indexForSelection will be one of the following:
231     // 0 if there is no user selection
232     // the index of the first range after the user selection
233     // NoMatchAfterUserSelection if there is no matching text after the user selection.
234     enum { NoMatchAfterUserSelection = -1 };
235     WEBCORE_EXPORT void findStringMatchingRanges(const String&, FindOptions, int maxCount, Vector<RefPtr<Range>>&, int& indexForSelection);
236 #if PLATFORM(COCOA)
237     WEBCORE_EXPORT void addSchedulePair(Ref<SchedulePair>&&);
238     WEBCORE_EXPORT void removeSchedulePair(Ref<SchedulePair>&&);
239     SchedulePairHashSet* scheduledRunLoopPairs() { return m_scheduledRunLoopPairs.get(); }
240
241     std::unique_ptr<SchedulePairHashSet> m_scheduledRunLoopPairs;
242 #endif
243
244     WEBCORE_EXPORT const VisibleSelection& selection() const;
245
246     WEBCORE_EXPORT void setDefersLoading(bool);
247     bool defersLoading() const { return m_defersLoading; }
248
249     WEBCORE_EXPORT void clearUndoRedoOperations();
250
251     WEBCORE_EXPORT bool inLowQualityImageInterpolationMode() const;
252     WEBCORE_EXPORT void setInLowQualityImageInterpolationMode(bool = true);
253
254     float mediaVolume() const { return m_mediaVolume; }
255     WEBCORE_EXPORT void setMediaVolume(float);
256
257     WEBCORE_EXPORT void setPageScaleFactor(float scale, const IntPoint& origin, bool inStableState = true);
258     float pageScaleFactor() const { return m_pageScaleFactor; }
259
260     WEBCORE_EXPORT void setZoomedOutPageScaleFactor(float);
261     float zoomedOutPageScaleFactor() const { return m_zoomedOutPageScaleFactor; }
262
263     float deviceScaleFactor() const { return m_deviceScaleFactor; }
264     WEBCORE_EXPORT void setDeviceScaleFactor(float);
265
266     float topContentInset() const { return m_topContentInset; }
267     WEBCORE_EXPORT void setTopContentInset(float);
268     
269 #if ENABLE(IOS_TEXT_AUTOSIZING)
270     float textAutosizingWidth() const { return m_textAutosizingWidth; }
271     void setTextAutosizingWidth(float textAutosizingWidth) { m_textAutosizingWidth = textAutosizingWidth; }
272 #endif
273     
274     bool shouldSuppressScrollbarAnimations() const { return m_suppressScrollbarAnimations; }
275     WEBCORE_EXPORT void setShouldSuppressScrollbarAnimations(bool suppressAnimations);
276     void lockAllOverlayScrollbarsToHidden(bool lockOverlayScrollbars);
277     
278     WEBCORE_EXPORT void setVerticalScrollElasticity(ScrollElasticity);
279     ScrollElasticity verticalScrollElasticity() const { return static_cast<ScrollElasticity>(m_verticalScrollElasticity); }
280
281     WEBCORE_EXPORT void setHorizontalScrollElasticity(ScrollElasticity);
282     ScrollElasticity horizontalScrollElasticity() const { return static_cast<ScrollElasticity>(m_horizontalScrollElasticity); }
283     
284     // Page and FrameView both store a Pagination value. Page::pagination() is set only by API,
285     // and FrameView::pagination() is set only by CSS. Page::pagination() will affect all
286     // FrameViews in the page cache, but FrameView::pagination() only affects the current
287     // FrameView.
288     const Pagination& pagination() const { return m_pagination; }
289     WEBCORE_EXPORT void setPagination(const Pagination&);
290
291     WEBCORE_EXPORT unsigned pageCount() const;
292
293     // Notifications when the Page starts and stops being presented via a native window.
294     WEBCORE_EXPORT void setViewState(ViewState::Flags);
295     void setPageActivityState(PageActivityState::Flags);
296     WEBCORE_EXPORT void setIsVisible(bool);
297     WEBCORE_EXPORT void setIsPrerender();
298     bool isVisible() const { return m_viewState & ViewState::IsVisible; }
299
300     // Notification that this Page was moved into or out of a native window.
301     WEBCORE_EXPORT void setIsInWindow(bool);
302     bool isInWindow() const { return m_viewState & ViewState::IsInWindow; }
303
304     void setIsClosing() { m_isClosing = true; }
305     bool isClosing() const { return m_isClosing; }
306
307     void addViewStateChangeObserver(ViewStateChangeObserver&);
308     void removeViewStateChangeObserver(ViewStateChangeObserver&);
309
310     WEBCORE_EXPORT void suspendScriptedAnimations();
311     WEBCORE_EXPORT void resumeScriptedAnimations();
312     bool scriptedAnimationsSuspended() const { return m_scriptedAnimationsSuspended; }
313
314     void userStyleSheetLocationChanged();
315     const String& userStyleSheet() const;
316
317     void dnsPrefetchingStateChanged();
318     void storageBlockingStateChanged();
319
320     void setDebugger(JSC::Debugger*);
321     JSC::Debugger* debugger() const { return m_debugger; }
322
323     WEBCORE_EXPORT void invalidateStylesForAllLinks();
324     WEBCORE_EXPORT void invalidateStylesForLink(LinkHash);
325
326     StorageNamespace* sessionStorage(bool optionalCreate = true);
327     void setSessionStorage(RefPtr<StorageNamespace>&&);
328
329     bool hasCustomHTMLTokenizerTimeDelay() const;
330     double customHTMLTokenizerTimeDelay() const;
331
332     WEBCORE_EXPORT void setMemoryCacheClientCallsEnabled(bool);
333     bool areMemoryCacheClientCallsEnabled() const { return m_areMemoryCacheClientCallsEnabled; }
334
335     // Don't allow more than a certain number of frames in a page.
336     // This seems like a reasonable upper bound, and otherwise mutually
337     // recursive frameset pages can quickly bring the program to its knees
338     // with exponential growth in the number of frames.
339     static const int maxNumberOfFrames = 1000;
340
341     void setEditable(bool isEditable) { m_isEditable = isEditable; }
342     bool isEditable() { return m_isEditable; }
343
344     WEBCORE_EXPORT PageVisibilityState visibilityState() const;
345     WEBCORE_EXPORT void resumeAnimatingImages();
346
347     WEBCORE_EXPORT void addLayoutMilestones(LayoutMilestones);
348     WEBCORE_EXPORT void removeLayoutMilestones(LayoutMilestones);
349     LayoutMilestones requestedLayoutMilestones() const { return m_requestedLayoutMilestones; }
350
351 #if ENABLE(RUBBER_BANDING)
352     WEBCORE_EXPORT void addHeaderWithHeight(int);
353     WEBCORE_EXPORT void addFooterWithHeight(int);
354 #endif
355
356     int headerHeight() const { return m_headerHeight; }
357     int footerHeight() const { return m_footerHeight; }
358
359     WEBCORE_EXPORT Color pageExtendedBackgroundColor() const;
360
361     bool isCountingRelevantRepaintedObjects() const;
362     void startCountingRelevantRepaintedObjects();
363     void resetRelevantPaintedObjectCounter();
364     void addRelevantRepaintedObject(RenderObject*, const LayoutRect& objectPaintRect);
365     void addRelevantUnpaintedObject(RenderObject*, const LayoutRect& objectPaintRect);
366
367     WEBCORE_EXPORT void suspendActiveDOMObjectsAndAnimations();
368     WEBCORE_EXPORT void resumeActiveDOMObjectsAndAnimations();
369 #ifndef NDEBUG
370     void setIsPainting(bool painting) { m_isPainting = painting; }
371     bool isPainting() const { return m_isPainting; }
372 #endif
373
374     AlternativeTextClient* alternativeTextClient() const { return m_alternativeTextClient; }
375
376     bool hasSeenPlugin(const String& serviceType) const;
377     WEBCORE_EXPORT bool hasSeenAnyPlugin() const;
378     void sawPlugin(const String& serviceType);
379     void resetSeenPlugins();
380
381     bool hasSeenMediaEngine(const String& engineName) const;
382     bool hasSeenAnyMediaEngine() const;
383     void sawMediaEngine(const String& engineName);
384     void resetSeenMediaEngines();
385
386     PageThrottler& pageThrottler() { return m_pageThrottler; }
387
388     PageConsoleClient& console() { return *m_consoleClient; }
389
390 #if ENABLE(REMOTE_INSPECTOR)
391     PageDebuggable& inspectorDebuggable() const { return *m_inspectorDebuggable.get(); }
392 #endif
393
394     void hiddenPageCSSAnimationSuspensionStateChanged();
395
396 #if ENABLE(VIDEO_TRACK)
397     void captionPreferencesChanged();
398 #endif
399
400     void incrementFrameHandlingBeforeUnloadEventCount();
401     void decrementFrameHandlingBeforeUnloadEventCount();
402     bool isAnyFrameHandlingBeforeUnloadEvent();
403     void setLastSpatialNavigationCandidateCount(unsigned count) { m_lastSpatialNavigationCandidatesCount = count; }
404     unsigned lastSpatialNavigationCandidateCount() const { return m_lastSpatialNavigationCandidatesCount; }
405
406     DatabaseProvider& databaseProvider() { return m_databaseProvider; }
407
408     StorageNamespaceProvider& storageNamespaceProvider() { return m_storageNamespaceProvider.get(); }
409     void setStorageNamespaceProvider(Ref<StorageNamespaceProvider>&&);
410
411     UserContentController* userContentController() { return m_userContentController.get(); }
412     WEBCORE_EXPORT void setUserContentController(UserContentController*);
413
414     VisitedLinkStore& visitedLinkStore();
415     WEBCORE_EXPORT void setVisitedLinkStore(Ref<VisitedLinkStore>&&);
416
417     WEBCORE_EXPORT SessionID sessionID() const;
418     WEBCORE_EXPORT void setSessionID(SessionID);
419     WEBCORE_EXPORT void enableLegacyPrivateBrowsing(bool privateBrowsingEnabled);
420     bool usesEphemeralSession() const { return m_sessionID.isEphemeral(); }
421
422     bool isPlayingAudio() const { return m_isPlayingAudio; }
423     void updateIsPlayingAudio();
424     bool isMuted() const { return m_muted; }
425     WEBCORE_EXPORT void setMuted(bool);
426
427 #if ENABLE(WIRELESS_PLAYBACK_TARGET)
428     void showPlaybackTargetPicker(Document*, const WebCore::IntPoint&, bool);
429     bool hasWirelessPlaybackTarget() const { return m_hasWirelessPlaybackTarget; }
430     MediaPlaybackTarget& playbackTarget() const { return *m_playbackTarget.get(); }
431     void configurePlaybackTargetMonitoring();
432
433     WEBCORE_EXPORT void didChoosePlaybackTarget(MediaPlaybackTarget&);
434     WEBCORE_EXPORT void playbackTargetAvailabilityDidChange(bool);
435 #endif
436
437 private:
438     WEBCORE_EXPORT void initGroup();
439
440     void setIsInWindowInternal(bool);
441     void setIsVisibleInternal(bool);
442     void setIsVisuallyIdleInternal(bool);
443
444 #if ASSERT_DISABLED
445     void checkSubframeCountConsistency() const { }
446 #else
447     void checkSubframeCountConsistency() const;
448 #endif
449
450     enum ShouldHighlightMatches { DoNotHighlightMatches, HighlightMatches };
451     enum ShouldMarkMatches { DoNotMarkMatches, MarkMatches };
452
453     unsigned findMatchesForText(const String&, FindOptions, unsigned maxMatchCount, ShouldHighlightMatches, ShouldMarkMatches);
454
455     MediaCanStartListener* takeAnyMediaCanStartListener();
456
457     void setMinimumTimerInterval(double);
458     double minimumTimerInterval() const;
459
460     double timerAlignmentInterval() const { return m_timerAlignmentInterval; }
461
462     Vector<Ref<PluginViewBase>> pluginViews();
463
464     void hiddenPageDOMTimerThrottlingStateChanged();
465     void setTimerThrottlingEnabled(bool);
466
467     const std::unique_ptr<Chrome> m_chrome;
468     const std::unique_ptr<DragCaretController> m_dragCaretController;
469
470 #if ENABLE(DRAG_SUPPORT)
471     const std::unique_ptr<DragController> m_dragController;
472 #endif
473     const std::unique_ptr<FocusController> m_focusController;
474 #if ENABLE(CONTEXT_MENUS)
475     const std::unique_ptr<ContextMenuController> m_contextMenuController;
476 #endif
477     const std::unique_ptr<UserInputBridge> m_userInputBridge;
478 #if ENABLE(WEB_REPLAY)
479     const std::unique_ptr<ReplayController> m_replayController;
480 #endif
481     const std::unique_ptr<InspectorController> m_inspectorController;
482 #if ENABLE(POINTER_LOCK)
483     const std::unique_ptr<PointerLockController> m_pointerLockController;
484 #endif
485     RefPtr<ScrollingCoordinator> m_scrollingCoordinator;
486
487     const RefPtr<Settings> m_settings;
488     const std::unique_ptr<ProgressTracker> m_progress;
489
490     const std::unique_ptr<BackForwardController> m_backForwardController;
491     const RefPtr<MainFrame> m_mainFrame;
492
493     mutable RefPtr<PluginData> m_pluginData;
494
495     RefPtr<RenderTheme> m_theme;
496
497     EditorClient& m_editorClient;
498     PlugInClient* m_plugInClient;
499     ValidationMessageClient* m_validationMessageClient;
500
501     int m_subframeCount;
502     String m_groupName;
503     bool m_openedByDOM;
504
505     bool m_tabKeyCyclesThroughElements;
506     bool m_defersLoading;
507     unsigned m_defersLoadingCallCount;
508
509     bool m_inLowQualityInterpolationMode;
510     bool m_areMemoryCacheClientCallsEnabled;
511     float m_mediaVolume;
512     bool m_muted;
513
514     float m_pageScaleFactor;
515     float m_zoomedOutPageScaleFactor;
516     float m_deviceScaleFactor;
517
518     float m_topContentInset;
519     
520 #if ENABLE(IOS_TEXT_AUTOSIZING)
521     float m_textAutosizingWidth;
522 #endif
523     
524     bool m_suppressScrollbarAnimations;
525     
526     unsigned m_verticalScrollElasticity : 2; // ScrollElasticity
527     unsigned m_horizontalScrollElasticity : 2; // ScrollElasticity    
528
529     Pagination m_pagination;
530
531     String m_userStyleSheetPath;
532     mutable String m_userStyleSheet;
533     mutable bool m_didLoadUserStyleSheet;
534     mutable time_t m_userStyleSheetModificationTime;
535
536     std::unique_ptr<PageGroup> m_singlePageGroup;
537     PageGroup* m_group;
538
539     JSC::Debugger* m_debugger;
540
541     bool m_canStartMedia;
542
543     RefPtr<StorageNamespace> m_sessionStorage;
544
545 #if ENABLE(VIEW_MODE_CSS_MEDIA)
546     ViewMode m_viewMode;
547 #endif // ENABLE(VIEW_MODE_CSS_MEDIA)
548
549     double m_minimumTimerInterval;
550
551     bool m_timerThrottlingEnabled;
552     double m_timerAlignmentInterval;
553
554     bool m_isEditable;
555     bool m_isPrerender;
556     ViewState::Flags m_viewState;
557
558     LayoutMilestones m_requestedLayoutMilestones;
559
560     int m_headerHeight;
561     int m_footerHeight;
562
563     HashSet<RenderObject*> m_relevantUnpaintedRenderObjects;
564     Region m_topRelevantPaintedRegion;
565     Region m_bottomRelevantPaintedRegion;
566     Region m_relevantUnpaintedRegion;
567     bool m_isCountingRelevantRepaintedObjects;
568 #ifndef NDEBUG
569     bool m_isPainting;
570 #endif
571     AlternativeTextClient* m_alternativeTextClient;
572
573     bool m_scriptedAnimationsSuspended;
574     PageThrottler m_pageThrottler;
575     const std::unique_ptr<PageConsoleClient> m_consoleClient;
576
577 #if ENABLE(REMOTE_INSPECTOR)
578     const std::unique_ptr<PageDebuggable> m_inspectorDebuggable;
579 #endif
580
581     HashSet<String> m_seenPlugins;
582     HashSet<String> m_seenMediaEngines;
583
584     unsigned m_lastSpatialNavigationCandidatesCount;
585     unsigned m_framesHandlingBeforeUnloadEvent;
586
587     Ref<DatabaseProvider> m_databaseProvider;
588     Ref<StorageNamespaceProvider> m_storageNamespaceProvider;
589     RefPtr<UserContentController> m_userContentController;
590     Ref<VisitedLinkStore> m_visitedLinkStore;
591
592     HashSet<ViewStateChangeObserver*> m_viewStateChangeObservers;
593
594     SessionID m_sessionID;
595
596 #if ENABLE(WIRELESS_PLAYBACK_TARGET)
597     Document* m_documentRequestingPlaybackTargetPicker { nullptr };
598     std::unique_ptr<MediaPlaybackTarget> m_playbackTarget;
599     bool m_requiresPlaybackTargetMonitoring { false };
600     bool m_hasWirelessPlaybackTarget { false };
601 #endif
602
603     bool m_isClosing;
604
605     bool m_isPlayingAudio;
606 };
607
608 inline PageGroup& Page::group()
609 {
610     if (!m_group)
611         initGroup();
612     return *m_group;
613 }
614
615 } // namespace WebCore
616     
617 #endif // Page_h