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