6212b524b60149090b1c9ea6c6136a88f5b58ef3
[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 "PlatformString.h"
27 #include "ViewportArguments.h"
28 #include <wtf/Forward.h>
29 #include <wtf/HashSet.h>
30 #include <wtf/Noncopyable.h>
31
32 #if OS(SOLARIS)
33 #include <sys/time.h> // For time_t structure.
34 #endif
35
36 #if PLATFORM(MAC)
37 #include "SchedulePair.h"
38 #endif
39
40 namespace JSC {
41     class Debugger;
42 }
43
44 namespace WebCore {
45
46     class BackForwardController;
47     class BackForwardList;
48     class Chrome;
49     class ChromeClient;
50     class ContextMenuClient;
51     class ContextMenuController;
52     class DeviceMotionClient;
53     class DeviceMotionController;
54     class DeviceOrientationClient;
55     class DeviceOrientationController;
56     class Document;
57     class DragCaretController;
58     class DragClient;
59     class DragController;
60     class EditorClient;
61     class FocusController;
62     class Frame;
63     class FrameSelection;
64     class GeolocationClient;
65     class GeolocationController;
66     class HaltablePlugin;
67     class HistoryItem;
68     class InspectorClient;
69     class InspectorController;
70     class MediaCanStartListener;
71     class MediaStreamClient;
72     class MediaStreamController;
73     class Node;
74     class PageGroup;
75     class PluginData;
76     class PluginHalter;
77     class PluginHalterClient;
78     class ProgressTracker;
79     class RenderTheme;
80     class VisibleSelection;
81     class ScrollableArea;
82     class Settings;
83     class SharedGraphicsContext3D;
84     class SpeechInput;
85     class SpeechInputClient;
86 #if ENABLE(DOM_STORAGE)
87     class StorageNamespace;
88 #endif
89 #if ENABLE(NOTIFICATIONS)
90     class NotificationPresenter;
91 #endif
92
93     typedef uint64_t LinkHash;
94
95     enum FindDirection { FindDirectionForward, FindDirectionBackward };
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             PluginHalterClient* pluginHalterClient;
116             GeolocationClient* geolocationClient;
117             DeviceMotionClient* deviceMotionClient;
118             DeviceOrientationClient* deviceOrientationClient;
119             RefPtr<BackForwardList> backForwardClient;
120             SpeechInputClient* speechInputClient;
121             MediaStreamClient* mediaStreamClient;
122         };
123
124         Page(const PageClients&);
125         ~Page();
126
127         void setNeedsRecalcStyleInAllFrames();
128
129         RenderTheme* theme() const { return m_theme.get(); };
130
131         ViewportArguments viewportArguments() const { return m_viewportArguments; }
132         void updateViewportArguments();
133
134         static void refreshPlugins(bool reload);
135         PluginData* pluginData() const;
136
137         void setCanStartMedia(bool);
138         bool canStartMedia() const { return m_canStartMedia; }
139
140         EditorClient* editorClient() const { return m_editorClient; }
141
142         void setMainFrame(PassRefPtr<Frame>);
143         Frame* mainFrame() const { return m_mainFrame.get(); }
144
145         bool openedByDOM() const;
146         void setOpenedByDOM();
147
148         // DEPRECATED. Use backForward() instead of the following 6 functions.
149         BackForwardList* backForwardList() const;
150         bool goBack();
151         bool goForward();
152         bool canGoBackOrForward(int distance) const;
153         void goBackOrForward(int distance);
154         int getHistoryLength();
155
156         void goToItem(HistoryItem*, FrameLoadType);
157
158         void setGroupName(const String&);
159         const String& groupName() const;
160
161         PageGroup& group() { if (!m_group) initGroup(); return *m_group; }
162         PageGroup* groupPtr() { return m_group; } // can return 0
163
164         void incrementFrameCount() { ++m_frameCount; }
165         void decrementFrameCount() { ASSERT(m_frameCount); --m_frameCount; }
166         int frameCount() const { checkFrameCountConsistency(); return m_frameCount; }
167
168         Chrome* chrome() const { return m_chrome.get(); }
169         DragCaretController* dragCaretController() const { return m_dragCaretController.get(); }
170 #if ENABLE(DRAG_SUPPORT)
171         DragController* dragController() const { return m_dragController.get(); }
172 #endif
173         FocusController* focusController() const { return m_focusController.get(); }
174 #if ENABLE(CONTEXT_MENUS)
175         ContextMenuController* contextMenuController() const { return m_contextMenuController.get(); }
176 #endif
177 #if ENABLE(INSPECTOR)
178         InspectorController* inspectorController() const { return m_inspectorController.get(); }
179 #endif
180 #if ENABLE(CLIENT_BASED_GEOLOCATION)
181         GeolocationController* geolocationController() const { return m_geolocationController.get(); }
182 #endif
183 #if ENABLE(DEVICE_ORIENTATION)
184         DeviceMotionController* deviceMotionController() const { return m_deviceMotionController.get(); }
185         DeviceOrientationController* deviceOrientationController() const { return m_deviceOrientationController.get(); }
186 #endif
187 #if ENABLE(MEDIA_STREAM)
188         MediaStreamController* mediaStreamController() const { return m_mediaStreamController.get(); }
189 #endif
190 #if ENABLE(INPUT_SPEECH)
191         SpeechInput* speechInput();
192 #endif
193         Settings* settings() const { return m_settings.get(); }
194         ProgressTracker* progress() const { return m_progress.get(); }
195         BackForwardController* backForward() const { return m_backForwardController.get(); }
196
197         enum ViewMode {
198             ViewModeInvalid,
199             ViewModeWindowed,
200             ViewModeFloating,
201             ViewModeFullscreen,
202             ViewModeMaximized,
203             ViewModeMinimized
204         };
205         static ViewMode stringToViewMode(const String&);
206
207         ViewMode viewMode() const { return m_viewMode; }
208         void setViewMode(ViewMode);
209         
210         void setTabKeyCyclesThroughElements(bool b) { m_tabKeyCyclesThroughElements = b; }
211         bool tabKeyCyclesThroughElements() const { return m_tabKeyCyclesThroughElements; }
212
213         bool findString(const String&, FindOptions);
214         // FIXME: Switch callers over to the FindOptions version and retire this one.
215         bool findString(const String&, TextCaseSensitivity, FindDirection, bool shouldWrap);
216         unsigned markAllMatchesForText(const String&, FindOptions, bool shouldHighlight, unsigned);
217         // FIXME: Switch callers over to the FindOptions version and retire this one.
218         unsigned markAllMatchesForText(const String&, TextCaseSensitivity, bool shouldHighlight, unsigned);
219         void unmarkAllTextMatches();
220
221 #if PLATFORM(MAC)
222         void addSchedulePair(PassRefPtr<SchedulePair>);
223         void removeSchedulePair(PassRefPtr<SchedulePair>);
224         SchedulePairHashSet* scheduledRunLoopPairs() { return m_scheduledRunLoopPairs.get(); }
225
226         OwnPtr<SchedulePairHashSet> m_scheduledRunLoopPairs;
227 #endif
228
229         const VisibleSelection& selection() const;
230
231         void setDefersLoading(bool);
232         bool defersLoading() const { return m_defersLoading; }
233         
234         void clearUndoRedoOperations();
235
236         bool inLowQualityImageInterpolationMode() const;
237         void setInLowQualityImageInterpolationMode(bool = true);
238
239         bool cookieEnabled() const { return m_cookieEnabled; }
240         void setCookieEnabled(bool enabled) { m_cookieEnabled = enabled; }
241
242         float mediaVolume() const { return m_mediaVolume; }
243         void setMediaVolume(float volume);
244
245         // Notifications when the Page starts and stops being presented via a native window.
246         void didMoveOnscreen();
247         void willMoveOffscreen();
248
249         void userStyleSheetLocationChanged();
250         const String& userStyleSheet() const;
251
252         void dnsPrefetchingStateChanged();
253         void privateBrowsingStateChanged();
254
255         void didStartPlugin(HaltablePlugin*);
256         void didStopPlugin(HaltablePlugin*);
257         void pluginAllowedRunTimeChanged();
258
259         static void setDebuggerForAllPages(JSC::Debugger*);
260         void setDebugger(JSC::Debugger*);
261         JSC::Debugger* debugger() const { return m_debugger; }
262
263         static void removeAllVisitedLinks();
264
265         static void allVisitedStateChanged(PageGroup*);
266         static void visitedStateChanged(PageGroup*, LinkHash visitedHash);
267
268         SharedGraphicsContext3D* sharedGraphicsContext3D();
269
270 #if ENABLE(DOM_STORAGE)
271         StorageNamespace* sessionStorage(bool optionalCreate = true);
272         void setSessionStorage(PassRefPtr<StorageNamespace>);
273 #endif
274
275         void setCustomHTMLTokenizerTimeDelay(double);
276         bool hasCustomHTMLTokenizerTimeDelay() const { return m_customHTMLTokenizerTimeDelay != -1; }
277         double customHTMLTokenizerTimeDelay() const { ASSERT(m_customHTMLTokenizerTimeDelay != -1); return m_customHTMLTokenizerTimeDelay; }
278
279         void setCustomHTMLTokenizerChunkSize(int);
280         bool hasCustomHTMLTokenizerChunkSize() const { return m_customHTMLTokenizerChunkSize != -1; }
281         int customHTMLTokenizerChunkSize() const { ASSERT(m_customHTMLTokenizerChunkSize != -1); return m_customHTMLTokenizerChunkSize; }
282
283         void setMemoryCacheClientCallsEnabled(bool);
284         bool areMemoryCacheClientCallsEnabled() const { return m_areMemoryCacheClientCallsEnabled; }
285
286         void setJavaScriptURLsAreAllowed(bool);
287         bool javaScriptURLsAreAllowed() const;
288
289         typedef HashSet<ScrollableArea*> ScrollableAreaSet;
290         void addScrollableArea(ScrollableArea*);
291         void removeScrollableArea(ScrollableArea*);
292         bool containsScrollableArea(ScrollableArea*) const;
293         const ScrollableAreaSet* scrollableAreaSet() const { return m_scrollableAreaSet.get(); }
294
295         // Don't allow more than a certain number of frames in a page.
296         // This seems like a reasonable upper bound, and otherwise mutually
297         // recursive frameset pages can quickly bring the program to its knees
298         // with exponential growth in the number of frames.
299         static const int maxNumberOfFrames = 1000;
300
301         void setEditable(bool isEditable) { m_isEditable = isEditable; }
302         bool isEditable() { return m_isEditable; }
303
304     private:
305         void initGroup();
306
307 #if ASSERT_DISABLED
308         void checkFrameCountConsistency() const { }
309 #else
310         void checkFrameCountConsistency() const;
311 #endif
312
313         MediaCanStartListener* takeAnyMediaCanStartListener();
314
315         void setMinimumTimerInterval(double);
316         double minimumTimerInterval() const;
317
318         OwnPtr<Chrome> m_chrome;
319         OwnPtr<DragCaretController> m_dragCaretController;
320
321 #if ENABLE(ACCELERATED_2D_CANVAS)
322         RefPtr<SharedGraphicsContext3D> m_sharedGraphicsContext3D;
323 #endif
324         
325 #if ENABLE(DRAG_SUPPORT)
326         OwnPtr<DragController> m_dragController;
327 #endif
328         OwnPtr<FocusController> m_focusController;
329 #if ENABLE(CONTEXT_MENUS)
330         OwnPtr<ContextMenuController> m_contextMenuController;
331 #endif
332 #if ENABLE(INSPECTOR)
333         OwnPtr<InspectorController> m_inspectorController;
334 #endif
335 #if ENABLE(CLIENT_BASED_GEOLOCATION)
336         OwnPtr<GeolocationController> m_geolocationController;
337 #endif
338 #if ENABLE(DEVICE_ORIENTATION)
339         OwnPtr<DeviceMotionController> m_deviceMotionController;
340         OwnPtr<DeviceOrientationController> m_deviceOrientationController;
341 #endif
342 #if ENABLE(MEDIA_STREAM)
343         OwnPtr<MediaStreamController> m_mediaStreamController;
344 #endif
345 #if ENABLE(INPUT_SPEECH)
346         SpeechInputClient* m_speechInputClient;
347         OwnPtr<SpeechInput> m_speechInput;
348 #endif
349         OwnPtr<Settings> m_settings;
350         OwnPtr<ProgressTracker> m_progress;
351         
352         OwnPtr<BackForwardController> m_backForwardController;
353         RefPtr<Frame> m_mainFrame;
354
355         mutable RefPtr<PluginData> m_pluginData;
356
357         RefPtr<RenderTheme> m_theme;
358
359         EditorClient* m_editorClient;
360
361         int m_frameCount;
362         String m_groupName;
363         bool m_openedByDOM;
364
365         bool m_tabKeyCyclesThroughElements;
366         bool m_defersLoading;
367
368         bool m_inLowQualityInterpolationMode;
369         bool m_cookieEnabled;
370         bool m_areMemoryCacheClientCallsEnabled;
371         float m_mediaVolume;
372
373         bool m_javaScriptURLsAreAllowed;
374
375         String m_userStyleSheetPath;
376         mutable String m_userStyleSheet;
377         mutable bool m_didLoadUserStyleSheet;
378         mutable time_t m_userStyleSheetModificationTime;
379
380         OwnPtr<PageGroup> m_singlePageGroup;
381         PageGroup* m_group;
382
383         JSC::Debugger* m_debugger;
384
385         double m_customHTMLTokenizerTimeDelay;
386         int m_customHTMLTokenizerChunkSize;
387
388         bool m_canStartMedia;
389
390         OwnPtr<PluginHalter> m_pluginHalter;
391
392 #if ENABLE(DOM_STORAGE)
393         RefPtr<StorageNamespace> m_sessionStorage;
394 #endif
395
396 #if ENABLE(NOTIFICATIONS)
397         NotificationPresenter* m_notificationPresenter;
398 #endif
399
400         ViewMode m_viewMode;
401
402         ViewportArguments m_viewportArguments;
403
404         double m_minimumTimerInterval;
405
406         OwnPtr<ScrollableAreaSet> m_scrollableAreaSet;
407
408         bool m_isEditable;
409     };
410
411 } // namespace WebCore
412     
413 #endif // Page_h