963d93d4903aad5a0f8f0059304934a3e6f6c866
[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 <wtf/Forward.h>
39 #include <wtf/HashMap.h>
40 #include <wtf/HashSet.h>
41 #include <wtf/Noncopyable.h>
42 #include <wtf/Ref.h>
43 #include <wtf/RefCounted.h>
44 #include <wtf/text/WTFString.h>
45
46 #if OS(SOLARIS)
47 #include <sys/time.h> // For time_t structure.
48 #endif
49
50 #if PLATFORM(COCOA)
51 #include <wtf/SchedulePair.h>
52 #endif
53
54 namespace JSC {
55 class Debugger;
56 }
57
58 namespace WebCore {
59
60 class AlternativeTextClient;
61 class BackForwardController;
62 class BackForwardClient;
63 class Chrome;
64 class ChromeClient;
65 class ClientRectList;
66 class Color;
67 class ContextMenuClient;
68 class ContextMenuController;
69 class Document;
70 class DragCaretController;
71 class DragClient;
72 class DragController;
73 class EditorClient;
74 class FocusController;
75 class Frame;
76 class FrameLoaderClient;
77 class FrameSelection;
78 class HaltablePlugin;
79 class HistoryItem;
80 class UserInputBridge;
81 class InspectorClient;
82 class InspectorController;
83 class MainFrame;
84 class MediaCanStartListener;
85 class Node;
86 class PageActivityAssertionToken;
87 class PageConsole;
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 UserContentController;
107 class ValidationMessageClient;
108 class VisitedLinkStore;
109
110 typedef uint64_t LinkHash;
111
112 enum FindDirection { FindDirectionForward, FindDirectionBackward };
113
114 class Page : public Supplementable<Page> {
115     WTF_MAKE_NONCOPYABLE(Page);
116     friend class Settings;
117     friend class PageThrottler;
118
119 public:
120     static void updateStyleForAllPagesAfterGlobalChangeInEnvironment();
121
122     // It is up to the platform to ensure that non-null clients are provided where required.
123     struct PageClients {
124         WTF_MAKE_NONCOPYABLE(PageClients); WTF_MAKE_FAST_ALLOCATED;
125     public:
126         PageClients();
127         ~PageClients();
128
129         AlternativeTextClient* alternativeTextClient;
130         ChromeClient* chromeClient;
131 #if ENABLE(CONTEXT_MENUS)
132         ContextMenuClient* contextMenuClient;
133 #endif
134         EditorClient* editorClient;
135         DragClient* dragClient;
136         InspectorClient* inspectorClient;
137         PlugInClient* plugInClient;
138         ProgressTrackerClient* progressTrackerClient;
139         RefPtr<BackForwardClient> backForwardClient;
140         ValidationMessageClient* validationMessageClient;
141         FrameLoaderClient* loaderClientForMainFrame;
142
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     OwnPtr<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);
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     bool shouldSuppressScrollbarAnimations() const { return m_suppressScrollbarAnimations; }
289     void setShouldSuppressScrollbarAnimations(bool suppressAnimations);
290     void lockAllOverlayScrollbarsToHidden(bool lockOverlayScrollbars);
291     
292     void setVerticalScrollElasticity(ScrollElasticity);
293     ScrollElasticity verticalScrollElasticity() const { return static_cast<ScrollElasticity>(m_verticalScrollElasticity); }
294
295     void setHorizontalScrollElasticity(ScrollElasticity);
296     ScrollElasticity horizontalScrollElasticity() const { return static_cast<ScrollElasticity>(m_horizontalScrollElasticity); }
297     
298     // Page and FrameView both store a Pagination value. Page::pagination() is set only by API,
299     // and FrameView::pagination() is set only by CSS. Page::pagination() will affect all
300     // FrameViews in the page cache, but FrameView::pagination() only affects the current
301     // FrameView.
302     const Pagination& pagination() const { return m_pagination; }
303     void setPagination(const Pagination&);
304
305     unsigned pageCount() const;
306
307     // Notifications when the Page starts and stops being presented via a native window.
308     void setViewState(ViewState::Flags);
309     void setIsVisible(bool);
310     void setIsPrerender();
311     bool isVisible() const { return m_viewState & ViewState::IsVisible; }
312
313     // Notification that this Page was moved into or out of a native window.
314     void setIsInWindow(bool);
315     bool isInWindow() const { return m_viewState & ViewState::IsInWindow; }
316
317     void suspendScriptedAnimations();
318     void resumeScriptedAnimations();
319     bool scriptedAnimationsSuspended() const { return m_scriptedAnimationsSuspended; }
320
321     void userStyleSheetLocationChanged();
322     const String& userStyleSheet() const;
323
324     void dnsPrefetchingStateChanged();
325     void storageBlockingStateChanged();
326
327     void setDebugger(JSC::Debugger*);
328     JSC::Debugger* debugger() const { return m_debugger; }
329
330     static void removeAllVisitedLinks();
331
332     void invalidateStylesForAllLinks();
333     void invalidateStylesForLink(LinkHash);
334
335     StorageNamespace* sessionStorage(bool optionalCreate = true);
336     void setSessionStorage(PassRefPtr<StorageNamespace>);
337
338     bool hasCustomHTMLTokenizerTimeDelay() const;
339     double customHTMLTokenizerTimeDelay() const;
340
341     void setMemoryCacheClientCallsEnabled(bool);
342     bool areMemoryCacheClientCallsEnabled() const { return m_areMemoryCacheClientCallsEnabled; }
343
344     // Don't allow more than a certain number of frames in a page.
345     // This seems like a reasonable upper bound, and otherwise mutually
346     // recursive frameset pages can quickly bring the program to its knees
347     // with exponential growth in the number of frames.
348     static const int maxNumberOfFrames = 1000;
349
350     void setEditable(bool isEditable) { m_isEditable = isEditable; }
351     bool isEditable() { return m_isEditable; }
352
353 #if ENABLE(PAGE_VISIBILITY_API)
354     PageVisibilityState visibilityState() const;
355 #endif
356     void resumeAnimatingImages();
357
358     void addLayoutMilestones(LayoutMilestones);
359     void removeLayoutMilestones(LayoutMilestones);
360     LayoutMilestones requestedLayoutMilestones() const { return m_requestedLayoutMilestones; }
361
362 #if ENABLE(RUBBER_BANDING)
363     void addHeaderWithHeight(int);
364     void addFooterWithHeight(int);
365 #endif
366
367     int headerHeight() const { return m_headerHeight; }
368     int footerHeight() const { return m_footerHeight; }
369
370     Color pageExtendedBackgroundColor() const;
371
372     bool isCountingRelevantRepaintedObjects() const;
373     void startCountingRelevantRepaintedObjects();
374     void resetRelevantPaintedObjectCounter();
375     void addRelevantRepaintedObject(RenderObject*, const LayoutRect& objectPaintRect);
376     void addRelevantUnpaintedObject(RenderObject*, const LayoutRect& objectPaintRect);
377
378     void suspendActiveDOMObjectsAndAnimations();
379     void resumeActiveDOMObjectsAndAnimations();
380 #ifndef NDEBUG
381     void setIsPainting(bool painting) { m_isPainting = painting; }
382     bool isPainting() const { return m_isPainting; }
383 #endif
384
385     AlternativeTextClient* alternativeTextClient() const { return m_alternativeTextClient; }
386
387     bool hasSeenPlugin(const String& serviceType) const;
388     bool hasSeenAnyPlugin() const;
389     void sawPlugin(const String& serviceType);
390     void resetSeenPlugins();
391
392     bool hasSeenMediaEngine(const String& engineName) const;
393     bool hasSeenAnyMediaEngine() const;
394     void sawMediaEngine(const String& engineName);
395     void resetSeenMediaEngines();
396
397     PageThrottler* pageThrottler() { return m_pageThrottler.get(); }
398     void createPageThrottler();
399
400     PageConsole& console() { return *m_console; }
401
402 #if ENABLE(PAGE_VISIBILITY_API)
403     void hiddenPageCSSAnimationSuspensionStateChanged();
404 #endif
405
406 #if ENABLE(VIDEO_TRACK)
407     void captionPreferencesChanged();
408 #endif
409
410     void incrementFrameHandlingBeforeUnloadEventCount();
411     void decrementFrameHandlingBeforeUnloadEventCount();
412     bool isAnyFrameHandlingBeforeUnloadEvent();
413     void setLastSpatialNavigationCandidateCount(unsigned count) { m_lastSpatialNavigationCandidatesCount = count; }
414     unsigned lastSpatialNavigationCandidateCount() const { return m_lastSpatialNavigationCandidatesCount; }
415
416     void setUserContentController(UserContentController*);
417     UserContentController* userContentController() { return m_userContentController.get(); }
418
419     VisitedLinkStore& visitedLinkStore();
420
421     SessionID sessionID() const;
422     void setSessionID(SessionID);
423     void enableLegacyPrivateBrowsing(bool privateBrowsingEnabled);
424     bool usesEphemeralSession() const { return m_sessionID.isEphemeral(); }
425
426 private:
427     void initGroup();
428
429     void setIsInWindowInternal(bool);
430     void setIsVisibleInternal(bool);
431     void setIsVisuallyIdleInternal(bool);
432
433 #if ASSERT_DISABLED
434     void checkSubframeCountConsistency() const { }
435 #else
436     void checkSubframeCountConsistency() const;
437 #endif
438
439     enum ShouldHighlightMatches { DoNotHighlightMatches, HighlightMatches };
440     enum ShouldMarkMatches { DoNotMarkMatches, MarkMatches };
441
442     unsigned findMatchesForText(const String&, FindOptions, unsigned maxMatchCount, ShouldHighlightMatches, ShouldMarkMatches);
443
444     MediaCanStartListener* takeAnyMediaCanStartListener();
445
446     void setMinimumTimerInterval(double);
447     double minimumTimerInterval() const;
448
449     double timerAlignmentInterval() const { return m_timerAlignmentInterval; }
450
451     Vector<Ref<PluginViewBase>> pluginViews();
452
453     void hiddenPageDOMTimerThrottlingStateChanged();
454     void setTimerThrottlingEnabled(bool);
455
456     const std::unique_ptr<Chrome> m_chrome;
457     const std::unique_ptr<DragCaretController> m_dragCaretController;
458
459 #if ENABLE(DRAG_SUPPORT)
460     const std::unique_ptr<DragController> m_dragController;
461 #endif
462     const std::unique_ptr<FocusController> m_focusController;
463 #if ENABLE(CONTEXT_MENUS)
464     const std::unique_ptr<ContextMenuController> m_contextMenuController;
465 #endif
466     const std::unique_ptr<UserInputBridge> m_userInputBridge;
467 #if ENABLE(WEB_REPLAY)
468     const std::unique_ptr<ReplayController> m_replayController;
469 #endif
470 #if ENABLE(INSPECTOR)
471     const std::unique_ptr<InspectorController> m_inspectorController;
472 #endif
473 #if ENABLE(POINTER_LOCK)
474     const std::unique_ptr<PointerLockController> m_pointerLockController;
475 #endif
476     RefPtr<ScrollingCoordinator> m_scrollingCoordinator;
477
478     const RefPtr<Settings> m_settings;
479     const std::unique_ptr<ProgressTracker> m_progress;
480
481     const std::unique_ptr<BackForwardController> m_backForwardController;
482     const RefPtr<MainFrame> m_mainFrame;
483
484     mutable RefPtr<PluginData> m_pluginData;
485
486     RefPtr<RenderTheme> m_theme;
487
488     EditorClient* m_editorClient;
489     PlugInClient* m_plugInClient;
490     ValidationMessageClient* m_validationMessageClient;
491
492     int m_subframeCount;
493     String m_groupName;
494     bool m_openedByDOM;
495
496     bool m_tabKeyCyclesThroughElements;
497     bool m_defersLoading;
498     unsigned m_defersLoadingCallCount;
499
500     bool m_inLowQualityInterpolationMode;
501     bool m_areMemoryCacheClientCallsEnabled;
502     float m_mediaVolume;
503
504     float m_pageScaleFactor;
505     float m_zoomedOutPageScaleFactor;
506     float m_deviceScaleFactor;
507
508     float m_topContentInset;
509
510     bool m_suppressScrollbarAnimations;
511     
512     unsigned m_verticalScrollElasticity : 2; // ScrollElasticity
513     unsigned m_horizontalScrollElasticity : 2; // ScrollElasticity    
514
515     Pagination m_pagination;
516
517     String m_userStyleSheetPath;
518     mutable String m_userStyleSheet;
519     mutable bool m_didLoadUserStyleSheet;
520     mutable time_t m_userStyleSheetModificationTime;
521
522     std::unique_ptr<PageGroup> m_singlePageGroup;
523     PageGroup* m_group;
524
525     JSC::Debugger* m_debugger;
526
527     bool m_canStartMedia;
528
529     RefPtr<StorageNamespace> m_sessionStorage;
530
531 #if ENABLE(VIEW_MODE_CSS_MEDIA)
532     ViewMode m_viewMode;
533 #endif // ENABLE(VIEW_MODE_CSS_MEDIA)
534
535     double m_minimumTimerInterval;
536
537     bool m_timerThrottlingEnabled;
538     double m_timerAlignmentInterval;
539
540     bool m_isEditable;
541     bool m_isPrerender;
542     ViewState::Flags m_viewState;
543
544     LayoutMilestones m_requestedLayoutMilestones;
545
546     int m_headerHeight;
547     int m_footerHeight;
548
549     HashSet<RenderObject*> m_relevantUnpaintedRenderObjects;
550     Region m_topRelevantPaintedRegion;
551     Region m_bottomRelevantPaintedRegion;
552     Region m_relevantUnpaintedRegion;
553     bool m_isCountingRelevantRepaintedObjects;
554 #ifndef NDEBUG
555     bool m_isPainting;
556 #endif
557     AlternativeTextClient* m_alternativeTextClient;
558
559     bool m_scriptedAnimationsSuspended;
560     std::unique_ptr<PageThrottler> m_pageThrottler;
561     const std::unique_ptr<PageConsole> m_console;
562
563 #if ENABLE(REMOTE_INSPECTOR)
564     const std::unique_ptr<PageDebuggable> m_inspectorDebuggable;
565 #endif
566
567     HashSet<String> m_seenPlugins;
568     HashSet<String> m_seenMediaEngines;
569
570     unsigned m_lastSpatialNavigationCandidatesCount;
571     unsigned m_framesHandlingBeforeUnloadEvent;
572
573     RefPtr<UserContentController> m_userContentController;
574     RefPtr<VisitedLinkStore> m_visitedLinkStore;
575
576     SessionID m_sessionID;
577 };
578
579 inline PageGroup& Page::group()
580 {
581     if (!m_group)
582         initGroup();
583     return *m_group;
584 }
585
586 } // namespace WebCore
587     
588 #endif // Page_h