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