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