4b758064718d2567898c5786820cce787a05fcb7
[WebKit-https.git] / Source / WebCore / page / Page.h
1 /*
2  * Copyright (C) 2006, 2007, 2008, 2009, 2010 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 "FrameLoaderTypes.h"
25 #include "FindOptions.h"
26 #include "LayoutTypes.h"
27 #include "PageSupplement.h"
28 #include "PageVisibilityState.h"
29 #include "PlatformScreen.h"
30 #include "PlatformString.h"
31 #include "ViewportArguments.h"
32 #include <wtf/Forward.h>
33 #include <wtf/HashMap.h>
34 #include <wtf/HashSet.h>
35 #include <wtf/Noncopyable.h>
36
37 #if OS(SOLARIS)
38 #include <sys/time.h> // For time_t structure.
39 #endif
40
41 #if PLATFORM(MAC)
42 #include "SchedulePair.h"
43 #endif
44
45 namespace JSC {
46     class Debugger;
47 }
48
49 namespace WebCore {
50
51     class BackForwardController;
52     class BackForwardList;
53     class Chrome;
54     class ChromeClient;
55     class ContextMenuClient;
56     class ContextMenuController;
57     class Document;
58     class DragCaretController;
59     class DragClient;
60     class DragController;
61     class EditorClient;
62     class FocusController;
63     class Frame;
64     class FrameSelection;
65     class GeolocationClient;
66     class GeolocationController;
67     class HaltablePlugin;
68     class HistoryItem;
69     class InspectorClient;
70     class InspectorController;
71     class MediaCanStartListener;
72     class Node;
73     class NotificationController;
74     class NotificationPresenter;
75     class PageGroup;
76     class PluginData;
77     class PointerLockController;
78     class ProgressTracker;
79     class Range;
80     class RenderObject;
81     class RenderTheme;
82     class VisibleSelection;
83     class ScrollableArea;
84     class ScrollingCoordinator;
85     class Settings;
86     class SpeechInput;
87     class SpeechInputClient;
88     class StorageNamespace;
89 #if ENABLE(NOTIFICATIONS)
90     class NotificationPresenter;
91 #endif
92
93     typedef uint64_t LinkHash;
94
95     enum FindDirection { FindDirectionForward, FindDirectionBackward };
96
97     float deviceScaleFactor(Frame*);
98
99     class Page {
100         WTF_MAKE_NONCOPYABLE(Page);
101         friend class Settings;
102     public:
103         static void scheduleForcedStyleRecalcForAllPages();
104
105         // It is up to the platform to ensure that non-null clients are provided where required.
106         struct PageClients {
107             WTF_MAKE_NONCOPYABLE(PageClients); WTF_MAKE_FAST_ALLOCATED;
108         public:
109             PageClients();
110             ~PageClients();
111
112             ChromeClient* chromeClient;
113             ContextMenuClient* contextMenuClient;
114             EditorClient* editorClient;
115             DragClient* dragClient;
116             InspectorClient* inspectorClient;
117             GeolocationClient* geolocationClient;
118             RefPtr<BackForwardList> backForwardClient;
119             SpeechInputClient* speechInputClient;
120             NotificationPresenter* notificationClient;
121         };
122
123         Page(PageClients&);
124         ~Page();
125
126         void setNeedsRecalcStyleInAllFrames();
127
128         RenderTheme* theme() const { return m_theme.get(); };
129
130         ViewportArguments viewportArguments() const;
131
132         static void refreshPlugins(bool reload);
133         PluginData* pluginData() const;
134
135         void setCanStartMedia(bool);
136         bool canStartMedia() const { return m_canStartMedia; }
137
138         EditorClient* editorClient() const { return m_editorClient; }
139
140         void setMainFrame(PassRefPtr<Frame>);
141         Frame* mainFrame() const { return m_mainFrame.get(); }
142
143         bool openedByDOM() const;
144         void setOpenedByDOM();
145
146         // DEPRECATED. Use backForward() instead of the following 6 functions.
147         BackForwardList* backForwardList() const;
148         bool goBack();
149         bool goForward();
150         bool canGoBackOrForward(int distance) const;
151         void goBackOrForward(int distance);
152         int getHistoryLength();
153
154         void goToItem(HistoryItem*, FrameLoadType);
155
156         void setGroupName(const String&);
157         const String& groupName() const;
158
159         PageGroup& group() { if (!m_group) initGroup(); return *m_group; }
160         PageGroup* groupPtr() { return m_group; } // can return 0
161
162         void incrementFrameCount() { ++m_frameCount; }
163         void decrementFrameCount() { ASSERT(m_frameCount); --m_frameCount; }
164         int frameCount() const { checkFrameCountConsistency(); return m_frameCount; }
165
166         Chrome* chrome() const { return m_chrome.get(); }
167         DragCaretController* dragCaretController() const { return m_dragCaretController.get(); }
168 #if ENABLE(DRAG_SUPPORT)
169         DragController* dragController() const { return m_dragController.get(); }
170 #endif
171         FocusController* focusController() const { return m_focusController.get(); }
172 #if ENABLE(CONTEXT_MENUS)
173         ContextMenuController* contextMenuController() const { return m_contextMenuController.get(); }
174 #endif
175 #if ENABLE(INSPECTOR)
176         InspectorController* inspectorController() const { return m_inspectorController.get(); }
177 #endif
178 #if ENABLE(CLIENT_BASED_GEOLOCATION)
179         GeolocationController* geolocationController() const { return m_geolocationController.get(); }
180 #endif
181 #if ENABLE(NOTIFICATIONS)
182         NotificationController* notificationController() const { return m_notificationController.get(); }
183 #endif
184 #if ENABLE(POINTER_LOCK)
185         PointerLockController* pointerLockController() const { return m_pointerLockController.get(); }
186 #endif
187 #if ENABLE(INPUT_SPEECH)
188         SpeechInput* speechInput();
189 #endif
190         ScrollingCoordinator* scrollingCoordinator();
191
192         Settings* settings() const { return m_settings.get(); }
193         ProgressTracker* progress() const { return m_progress.get(); }
194         BackForwardController* backForward() const { return m_backForwardController.get(); }
195
196         enum ViewMode {
197             ViewModeInvalid,
198             ViewModeWindowed,
199             ViewModeFloating,
200             ViewModeFullscreen,
201             ViewModeMaximized,
202             ViewModeMinimized
203         };
204         static ViewMode stringToViewMode(const String&);
205
206         ViewMode viewMode() const { return m_viewMode; }
207         void setViewMode(ViewMode);
208         
209         void setTabKeyCyclesThroughElements(bool b) { m_tabKeyCyclesThroughElements = b; }
210         bool tabKeyCyclesThroughElements() const { return m_tabKeyCyclesThroughElements; }
211
212         bool findString(const String&, FindOptions);
213         // FIXME: Switch callers over to the FindOptions version and retire this one.
214         bool findString(const String&, TextCaseSensitivity, FindDirection, bool shouldWrap);
215
216         PassRefPtr<Range> rangeOfString(const String&, Range*, FindOptions);
217
218         unsigned markAllMatchesForText(const String&, FindOptions, bool shouldHighlight, unsigned);
219         // FIXME: Switch callers over to the FindOptions version and retire this one.
220         unsigned markAllMatchesForText(const String&, TextCaseSensitivity, bool shouldHighlight, unsigned);
221         void unmarkAllTextMatches();
222
223 #if PLATFORM(MAC)
224         void addSchedulePair(PassRefPtr<SchedulePair>);
225         void removeSchedulePair(PassRefPtr<SchedulePair>);
226         SchedulePairHashSet* scheduledRunLoopPairs() { return m_scheduledRunLoopPairs.get(); }
227
228         OwnPtr<SchedulePairHashSet> m_scheduledRunLoopPairs;
229 #endif
230
231         const VisibleSelection& selection() const;
232
233         void setDefersLoading(bool);
234         bool defersLoading() const { return m_defersLoading; }
235         
236         void clearUndoRedoOperations();
237
238         bool inLowQualityImageInterpolationMode() const;
239         void setInLowQualityImageInterpolationMode(bool = true);
240
241         bool cookieEnabled() const { return m_cookieEnabled; }
242         void setCookieEnabled(bool enabled) { m_cookieEnabled = enabled; }
243
244         float mediaVolume() const { return m_mediaVolume; }
245         void setMediaVolume(float volume);
246
247         void setPageScaleFactor(float scale, const IntPoint& origin);
248         float pageScaleFactor() const { return m_pageScaleFactor; }
249
250         float deviceScaleFactor() const { return m_deviceScaleFactor; }
251         void setDeviceScaleFactor(float);
252
253         struct Pagination {
254             enum Mode { Unpaginated, HorizontallyPaginated, VerticallyPaginated };
255
256             Pagination()
257                 : mode(Unpaginated)
258                 , behavesLikeColumns(false)
259                 , pageLength(0)
260                 , gap(0)
261             {
262             };
263
264             bool operator==(const Pagination& other) const
265             {
266                 return mode == other.mode && behavesLikeColumns == other.behavesLikeColumns && pageLength == other.pageLength && gap == other.gap;
267             }
268
269             Mode mode;
270             bool behavesLikeColumns;
271             unsigned pageLength;
272             unsigned gap;
273         };
274
275         const Pagination& pagination() const { return m_pagination; }
276         void setPagination(const Pagination&);
277
278         unsigned pageCount() const;
279
280         // Notifications when the Page starts and stops being presented via a native window.
281         void didMoveOnscreen();
282         void willMoveOffscreen();
283
284         void windowScreenDidChange(PlatformDisplayID);
285         
286         void suspendScriptedAnimations();
287         void resumeScriptedAnimations();
288         
289         void userStyleSheetLocationChanged();
290         const String& userStyleSheet() const;
291
292         void dnsPrefetchingStateChanged();
293         void privateBrowsingStateChanged();
294
295         static void setDebuggerForAllPages(JSC::Debugger*);
296         void setDebugger(JSC::Debugger*);
297         JSC::Debugger* debugger() const { return m_debugger; }
298
299         static void removeAllVisitedLinks();
300
301         static void allVisitedStateChanged(PageGroup*);
302         static void visitedStateChanged(PageGroup*, LinkHash visitedHash);
303
304         StorageNamespace* sessionStorage(bool optionalCreate = true);
305         void setSessionStorage(PassRefPtr<StorageNamespace>);
306
307         void setCustomHTMLTokenizerTimeDelay(double);
308         bool hasCustomHTMLTokenizerTimeDelay() const { return m_customHTMLTokenizerTimeDelay != -1; }
309         double customHTMLTokenizerTimeDelay() const { ASSERT(m_customHTMLTokenizerTimeDelay != -1); return m_customHTMLTokenizerTimeDelay; }
310
311         void setCustomHTMLTokenizerChunkSize(int);
312         bool hasCustomHTMLTokenizerChunkSize() const { return m_customHTMLTokenizerChunkSize != -1; }
313         int customHTMLTokenizerChunkSize() const { ASSERT(m_customHTMLTokenizerChunkSize != -1); return m_customHTMLTokenizerChunkSize; }
314
315         void setMemoryCacheClientCallsEnabled(bool);
316         bool areMemoryCacheClientCallsEnabled() const { return m_areMemoryCacheClientCallsEnabled; }
317
318         void setJavaScriptURLsAreAllowed(bool);
319         bool javaScriptURLsAreAllowed() const;
320
321         // Don't allow more than a certain number of frames in a page.
322         // This seems like a reasonable upper bound, and otherwise mutually
323         // recursive frameset pages can quickly bring the program to its knees
324         // with exponential growth in the number of frames.
325         static const int maxNumberOfFrames = 1000;
326
327         void setEditable(bool isEditable) { m_isEditable = isEditable; }
328         bool isEditable() { return m_isEditable; }
329
330 #if ENABLE(PAGE_VISIBILITY_API)
331         PageVisibilityState visibilityState() const;
332         void setVisibilityState(PageVisibilityState, bool);
333 #endif
334
335         PlatformDisplayID displayID() const { return m_displayID; }
336
337         void setRelevantRepaintedObjectsCounterThreshold(uint64_t);
338         void startCountingRelevantRepaintedObjects();
339         void addRelevantRepaintedObject(RenderObject*, const IntRect& objectPaintRect);
340
341         void provideSupplement(const AtomicString&, PassOwnPtr<PageSupplement>);
342         PageSupplement* requireSupplement(const AtomicString&);
343
344     private:
345         void initGroup();
346
347         typedef HashMap<AtomicStringImpl*, OwnPtr<PageSupplement> > PageSupplementMap;
348         PageSupplementMap m_supplements;
349
350 #if ASSERT_DISABLED
351         void checkFrameCountConsistency() const { }
352 #else
353         void checkFrameCountConsistency() const;
354 #endif
355
356         MediaCanStartListener* takeAnyMediaCanStartListener();
357
358         void setMinimumTimerInterval(double);
359         double minimumTimerInterval() const;
360
361         OwnPtr<Chrome> m_chrome;
362         OwnPtr<DragCaretController> m_dragCaretController;
363
364 #if ENABLE(DRAG_SUPPORT)
365         OwnPtr<DragController> m_dragController;
366 #endif
367         OwnPtr<FocusController> m_focusController;
368 #if ENABLE(CONTEXT_MENUS)
369         OwnPtr<ContextMenuController> m_contextMenuController;
370 #endif
371 #if ENABLE(INSPECTOR)
372         OwnPtr<InspectorController> m_inspectorController;
373 #endif
374 #if ENABLE(CLIENT_BASED_GEOLOCATION)
375         OwnPtr<GeolocationController> m_geolocationController;
376 #endif
377 #if ENABLE(NOTIFICATIONS)
378         OwnPtr<NotificationController> m_notificationController;
379 #endif
380 #if ENABLE(POINTER_LOCK)
381         OwnPtr<PointerLockController> m_pointerLockController;
382 #endif
383 #if ENABLE(INPUT_SPEECH)
384         SpeechInputClient* m_speechInputClient;
385         OwnPtr<SpeechInput> m_speechInput;
386 #endif
387         RefPtr<ScrollingCoordinator> m_scrollingCoordinator;
388
389         OwnPtr<Settings> m_settings;
390         OwnPtr<ProgressTracker> m_progress;
391         
392         OwnPtr<BackForwardController> m_backForwardController;
393         RefPtr<Frame> m_mainFrame;
394
395         mutable RefPtr<PluginData> m_pluginData;
396
397         RefPtr<RenderTheme> m_theme;
398
399         EditorClient* m_editorClient;
400
401         int m_frameCount;
402         String m_groupName;
403         bool m_openedByDOM;
404
405         bool m_tabKeyCyclesThroughElements;
406         bool m_defersLoading;
407
408         bool m_inLowQualityInterpolationMode;
409         bool m_cookieEnabled;
410         bool m_areMemoryCacheClientCallsEnabled;
411         float m_mediaVolume;
412
413         float m_pageScaleFactor;
414         float m_deviceScaleFactor;
415
416         Pagination m_pagination;
417
418         bool m_javaScriptURLsAreAllowed;
419
420         String m_userStyleSheetPath;
421         mutable String m_userStyleSheet;
422         mutable bool m_didLoadUserStyleSheet;
423         mutable time_t m_userStyleSheetModificationTime;
424
425         OwnPtr<PageGroup> m_singlePageGroup;
426         PageGroup* m_group;
427
428         JSC::Debugger* m_debugger;
429
430         double m_customHTMLTokenizerTimeDelay;
431         int m_customHTMLTokenizerChunkSize;
432
433         bool m_canStartMedia;
434
435         RefPtr<StorageNamespace> m_sessionStorage;
436
437 #if ENABLE(NOTIFICATIONS)
438         NotificationPresenter* m_notificationPresenter;
439 #endif
440
441         ViewMode m_viewMode;
442
443         double m_minimumTimerInterval;
444
445         bool m_isEditable;
446
447 #if ENABLE(PAGE_VISIBILITY_API)
448         PageVisibilityState m_visibilityState;
449 #endif
450         PlatformDisplayID m_displayID;
451
452         HashSet<RenderObject*> m_relevantPaintedRenderObjects;
453         bool m_isCountingRelevantRepaintedObjects;
454     };
455
456 } // namespace WebCore
457     
458 #endif // Page_h