Reviewed and landed by Sam Weinig.
[WebKit-https.git] / Source / WebKit2 / WebProcess / WebPage / WebPage.h
1 /*
2  * Copyright (C) 2010, 2011 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
14  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
15  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
17  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
18  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
19  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
20  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
21  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
22  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
23  * THE POSSIBILITY OF SUCH DAMAGE.
24  */
25
26 #ifndef WebPage_h
27 #define WebPage_h
28
29 #include "APIObject.h"
30 #include "DrawingArea.h"
31 #include "FindController.h"
32 #include "GeolocationPermissionRequestManager.h"
33 #include "ImageOptions.h"
34 #include "InjectedBundlePageContextMenuClient.h"
35 #include "InjectedBundlePageEditorClient.h"
36 #include "InjectedBundlePageFormClient.h"
37 #include "InjectedBundlePageLoaderClient.h"
38 #include "InjectedBundlePagePolicyClient.h"
39 #include "InjectedBundlePageResourceLoadClient.h"
40 #include "InjectedBundlePageUIClient.h"
41 #include "MessageSender.h"
42 #include "Plugin.h"
43 #include "SandboxExtension.h"
44 #include "WebEditCommand.h"
45 #include <WebCore/DragData.h>
46 #include <WebCore/Editor.h>
47 #include <WebCore/FrameLoaderTypes.h>
48 #include <WebCore/IntRect.h>
49 #include <wtf/HashMap.h>
50 #include <wtf/OwnPtr.h>
51 #include <wtf/PassRefPtr.h>
52 #include <wtf/RefPtr.h>
53 #include <wtf/text/WTFString.h>
54
55 #if ENABLE(TOUCH_EVENTS)
56 #include <WebCore/PlatformTouchEvent.h>
57 #endif
58
59 #if PLATFORM(MAC)
60 #include <wtf/RetainPtr.h>
61 OBJC_CLASS AccessibilityWebPageObject;
62 #endif
63
64 namespace CoreIPC {
65     class ArgumentDecoder;
66     class Connection;
67     class MessageID;
68 }
69
70 namespace WebCore {
71     class GraphicsContext;
72     class KeyboardEvent;
73     class Page;
74     class PrintContext;
75     class ResourceRequest;
76     class SharedBuffer;
77 }
78
79 namespace WebKit {
80
81 class DrawingArea;
82 class InjectedBundleBackForwardList;
83 class PageOverlay;
84 class PluginView;
85 class SessionState;
86 class WebContextMenu;
87 class WebContextMenuItemData;
88 class WebEvent;
89 class WebFrame;
90 class WebImage;
91 class WebInspector;
92 class WebKeyboardEvent;
93 class WebMouseEvent;
94 class WebOpenPanelResultListener;
95 class WebPageGroupProxy;
96 class WebPopupMenu;
97 class WebWheelEvent;
98 struct PrintInfo;
99 struct WebPageCreationParameters;
100 struct WebPreferencesStore;
101
102 #if ENABLE(GESTURE_EVENTS)
103 class WebGestureEvent;
104 #endif
105
106 #if ENABLE(TOUCH_EVENTS)
107 class WebTouchEvent;
108 #endif
109
110 class WebPage : public APIObject, public CoreIPC::MessageSender<WebPage> {
111 public:
112     static const Type APIType = TypeBundlePage;
113
114     static PassRefPtr<WebPage> create(uint64_t pageID, const WebPageCreationParameters&);
115     virtual ~WebPage();
116
117     // Used by MessageSender.
118     CoreIPC::Connection* connection() const;
119     uint64_t destinationID() const { return pageID(); }
120
121     void close();
122
123     WebCore::Page* corePage() const { return m_page.get(); }
124     uint64_t pageID() const { return m_pageID; }
125
126     void setSize(const WebCore::IntSize&);
127     const WebCore::IntSize& size() const { return m_viewSize; }
128     WebCore::IntRect bounds() const { return WebCore::IntRect(WebCore::IntPoint(), size()); }
129     
130     InjectedBundleBackForwardList* backForwardList();
131     DrawingArea* drawingArea() const { return m_drawingArea.get(); }
132
133     WebPageGroupProxy* pageGroup() const { return m_pageGroup.get(); }
134
135     void scrollMainFrameIfNotAtMaxScrollPosition(const WebCore::IntSize& scrollOffset);
136
137 #if ENABLE(INSPECTOR)
138     WebInspector* inspector();
139 #endif
140
141     // -- Called by the DrawingArea.
142     // FIXME: We could genericize these into a DrawingArea client interface. Would that be beneficial?
143     void drawRect(WebCore::GraphicsContext&, const WebCore::IntRect&);
144     void drawPageOverlay(WebCore::GraphicsContext&, const WebCore::IntRect&);
145     void layoutIfNeeded();
146
147     // -- Called from WebCore clients.
148 #if !PLATFORM(MAC)
149     bool handleEditingKeyboardEvent(WebCore::KeyboardEvent*);
150 #endif
151     void show();
152     String userAgent() const { return m_userAgent; }
153     WebCore::IntRect windowResizerRect() const;
154     bool tabsToLinks() const { return m_tabToLinks; }
155
156     WebEditCommand* webEditCommand(uint64_t);
157     void addWebEditCommand(uint64_t, WebEditCommand*);
158     void removeWebEditCommand(uint64_t);
159     bool isInRedo() const { return m_isInRedo; }
160
161     void setActivePopupMenu(WebPopupMenu*);
162     
163     WebOpenPanelResultListener* activeOpenPanelResultListener() const { return m_activeOpenPanelResultListener.get(); }
164     void setActiveOpenPanelResultListener(PassRefPtr<WebOpenPanelResultListener>);
165
166     // -- Called from WebProcess.
167     void didReceiveMessage(CoreIPC::Connection*, CoreIPC::MessageID, CoreIPC::ArgumentDecoder*);
168     CoreIPC::SyncReplyMode didReceiveSyncMessage(CoreIPC::Connection*, CoreIPC::MessageID, CoreIPC::ArgumentDecoder*, CoreIPC::ArgumentEncoder*);
169
170     // -- InjectedBundle methods
171     void initializeInjectedBundleContextMenuClient(WKBundlePageContextMenuClient*);
172     void initializeInjectedBundleEditorClient(WKBundlePageEditorClient*);
173     void initializeInjectedBundleFormClient(WKBundlePageFormClient*);
174     void initializeInjectedBundleLoaderClient(WKBundlePageLoaderClient*);
175     void initializeInjectedBundlePolicyClient(WKBundlePagePolicyClient*);
176     void initializeInjectedBundleResourceLoadClient(WKBundlePageResourceLoadClient*);
177     void initializeInjectedBundleUIClient(WKBundlePageUIClient*);
178
179     InjectedBundlePageContextMenuClient& injectedBundleContextMenuClient() { return m_contextMenuClient; }
180     InjectedBundlePageEditorClient& injectedBundleEditorClient() { return m_editorClient; }
181     InjectedBundlePageFormClient& injectedBundleFormClient() { return m_formClient; }
182     InjectedBundlePageLoaderClient& injectedBundleLoaderClient() { return m_loaderClient; }
183     InjectedBundlePagePolicyClient& injectedBundlePolicyClient() { return m_policyClient; }
184     InjectedBundlePageResourceLoadClient& injectedBundleResourceLoadClient() { return m_resourceLoadClient; }
185     InjectedBundlePageUIClient& injectedBundleUIClient() { return m_uiClient; }
186
187     bool findStringFromInjectedBundle(const String&, FindOptions);
188
189     WebFrame* mainFrame() const { return m_mainFrame.get(); }
190     PassRefPtr<Plugin> createPlugin(const Plugin::Parameters&);
191
192     String renderTreeExternalRepresentation() const;
193     void executeEditingCommand(const String& commandName, const String& argument);
194     bool isEditingCommandEnabled(const String& commandName);
195     void clearMainFrameName();
196     void sendClose();
197
198     double textZoomFactor() const;
199     void setTextZoomFactor(double);
200     double pageZoomFactor() const;
201     void setPageZoomFactor(double);
202     void setPageAndTextZoomFactors(double pageZoomFactor, double textZoomFactor);
203
204     void scaleWebView(double scale, const WebCore::IntPoint& origin);
205     double viewScaleFactor() const;
206
207     void setUseFixedLayout(bool);
208     void setFixedLayoutSize(const WebCore::IntSize&);
209
210     bool drawsBackground() const { return m_drawsBackground; }
211     bool drawsTransparentBackground() const { return m_drawsTransparentBackground; }
212
213     void stopLoading();
214     void stopLoadingFrame(uint64_t frameID);
215     void setDefersLoading(bool deferLoading);
216
217 #if USE(ACCELERATED_COMPOSITING)
218     void changeAcceleratedCompositingMode(WebCore::GraphicsLayer*);
219     void enterAcceleratedCompositingMode(WebCore::GraphicsLayer*);
220     void exitAcceleratedCompositingMode();
221 #endif
222
223 #if PLATFORM(MAC)
224     void addPluginView(PluginView*);
225     void removePluginView(PluginView*);
226
227     bool windowIsVisible() const { return m_windowIsVisible; }
228     const WebCore::IntRect& windowFrameInScreenCoordinates() const { return m_windowFrameInScreenCoordinates; }
229     const WebCore::IntRect& viewFrameInWindowCoordinates() const { return m_viewFrameInWindowCoordinates; }
230     bool windowIsFocused() const;
231     bool interceptEditingKeyboardEvent(WebCore::KeyboardEvent*, bool);
232 #elif PLATFORM(WIN)
233     HWND nativeWindow() const { return m_nativeWindow; }
234 #endif
235
236     void installPageOverlay(PassRefPtr<PageOverlay>);
237     void uninstallPageOverlay(PageOverlay*);
238     bool hasPageOverlay() const { return m_pageOverlay; }
239
240     PassRefPtr<WebImage> snapshotInViewCoordinates(const WebCore::IntRect&, ImageOptions);
241     PassRefPtr<WebImage> snapshotInDocumentCoordinates(const WebCore::IntRect&, ImageOptions);
242     PassRefPtr<WebImage> scaledSnapshotInDocumentCoordinates(const WebCore::IntRect&, double scaleFactor, ImageOptions);
243
244     static const WebEvent* currentEvent();
245
246     FindController& findController() { return m_findController; }
247     GeolocationPermissionRequestManager& geolocationPermissionRequestManager() { return m_geolocationPermissionRequestManager; }
248
249     void pageDidScroll();
250 #if ENABLE(TILED_BACKING_STORE)
251     void pageDidRequestScroll(const WebCore::IntSize& delta);
252     void setActualVisibleContentRect(const WebCore::IntRect&);
253
254     bool resizesToContentsEnabled() const { return !m_resizesToContentsLayoutSize.isEmpty(); }
255     WebCore::IntSize resizesToContentsLayoutSize() const { return m_resizesToContentsLayoutSize; }
256     void setResizesToContentsUsingLayoutSize(const WebCore::IntSize& targetLayoutSize);
257     void resizeToContentsIfNeeded();
258 #endif
259
260     WebContextMenu* contextMenu();
261     
262     bool hasLocalDataForURL(const WebCore::KURL&);
263     String cachedResponseMIMETypeForURL(const WebCore::KURL&);
264     
265     static bool canHandleRequest(const WebCore::ResourceRequest&);
266
267     class SandboxExtensionTracker {
268     public:
269         ~SandboxExtensionTracker();
270
271         void invalidate();
272
273         void beginLoad(WebFrame*, const SandboxExtension::Handle& handle);
274         void didStartProvisionalLoad(WebFrame*);
275         void didCommitProvisionalLoad(WebFrame*);
276         void didFailProvisionalLoad(WebFrame*);
277     private:
278         RefPtr<SandboxExtension> m_pendingProvisionalSandboxExtension;
279         RefPtr<SandboxExtension> m_provisionalSandboxExtension;
280         RefPtr<SandboxExtension> m_committedSandboxExtension;
281     };
282
283     SandboxExtensionTracker& sandboxExtensionTracker() { return m_sandboxExtensionTracker; }
284
285     static void getLocationAndLengthFromRange(WebCore::Range*, uint64_t& location, uint64_t& length);
286
287 #if PLATFORM(MAC)
288     void registerUIProcessAccessibilityTokens(const CoreIPC::DataReference& elemenToken, const CoreIPC::DataReference& windowToken);
289     AccessibilityWebPageObject* accessibilityRemoteObject();
290     WebCore::IntPoint accessibilityPosition() const { return m_accessibilityPosition; }    
291     
292     void sendComplexTextInputToPlugin(uint64_t pluginComplexTextInputIdentifier, const String& textInput);
293
294     void getMarkedRange(uint64_t& location, uint64_t& length);
295     void characterIndexForPoint(const WebCore::IntPoint point, uint64_t& result);
296     void firstRectForCharacterRange(uint64_t location, uint64_t length, WebCore::IntRect& resultRect);
297 #elif PLATFORM(WIN)
298     void confirmComposition(const String& compositionString);
299     void setComposition(const WTF::String& compositionString, const WTF::Vector<WebCore::CompositionUnderline>& underlines, uint64_t cursorPosition);
300     void firstRectForCharacterInSelectedRange(const uint64_t characterPosition, WebCore::IntRect& resultRect);
301     void getSelectedText(WTF::String&);
302 #endif
303
304     // FIXME: This a dummy message, to avoid breaking the build for platforms that don't require
305     // any synchronous messages, and should be removed when <rdar://problem/8775115> is fixed.
306     void dummy(bool&);
307
308 #if PLATFORM(MAC)
309     bool isSpeaking();
310     void speak(const String&);
311     void stopSpeaking();
312
313     bool isSmartInsertDeleteEnabled() const { return m_isSmartInsertDeleteEnabled; }
314 #endif
315
316     void replaceSelectionWithText(WebCore::Frame*, const String&);
317 #if PLATFORM(WIN)
318     void performDragControllerAction(uint64_t action, WebCore::IntPoint clientPosition, WebCore::IntPoint globalPosition, uint64_t draggingSourceOperationMask, const WebCore::DragDataMap&, uint32_t flags);
319 #else
320     void performDragControllerAction(uint64_t action, WebCore::IntPoint clientPosition, WebCore::IntPoint globalPosition, uint64_t draggingSourceOperationMask, const WTF::String& dragStorageName, uint32_t flags);
321 #endif
322     void dragEnded(WebCore::IntPoint clientPosition, WebCore::IntPoint globalPosition, uint64_t operation);
323
324     void beginPrinting(uint64_t frameID, const PrintInfo&);
325     void endPrinting();
326     void computePagesForPrinting(uint64_t frameID, const PrintInfo&, uint64_t callbackID);
327 #if PLATFORM(MAC)
328     void drawRectToPDF(uint64_t frameID, const WebCore::IntRect&, uint64_t callbackID);
329     void drawPagesToPDF(uint64_t frameID, uint32_t first, uint32_t count, uint64_t callbackID);
330 #endif
331
332     bool mainFrameHasCustomRepresentation() const;
333
334     bool canRunModal() const { return m_canRunModal; }
335     void runModal();
336
337 private:
338     WebPage(uint64_t pageID, const WebPageCreationParameters&);
339
340     virtual Type type() const { return APIType; }
341
342     void platformInitialize();
343
344     void didReceiveWebPageMessage(CoreIPC::Connection*, CoreIPC::MessageID, CoreIPC::ArgumentDecoder*);
345     CoreIPC::SyncReplyMode didReceiveSyncWebPageMessage(CoreIPC::Connection*, CoreIPC::MessageID, CoreIPC::ArgumentDecoder*, CoreIPC::ArgumentEncoder*);
346
347     static const char* interpretKeyEvent(const WebCore::KeyboardEvent*);
348     bool performDefaultBehaviorForKeyEvent(const WebKeyboardEvent&);
349
350     String sourceForFrame(WebFrame*);
351
352     void loadData(PassRefPtr<WebCore::SharedBuffer>, const String& MIMEType, const String& encodingName, const WebCore::KURL& baseURL, const WebCore::KURL& failingURL);
353
354     bool platformHasLocalDataForURL(const WebCore::KURL&);
355
356     // Actions
357     void tryClose();
358     void loadURL(const String&, const SandboxExtension::Handle&);
359     void loadURLRequest(const WebCore::ResourceRequest&, const SandboxExtension::Handle&);
360     void loadHTMLString(const String& htmlString, const String& baseURL);
361     void loadAlternateHTMLString(const String& htmlString, const String& baseURL, const String& unreachableURL);
362     void loadPlainTextString(const String&);
363     void reload(bool reloadFromOrigin);
364     void goForward(uint64_t, const SandboxExtension::Handle&);
365     void goBack(uint64_t, const SandboxExtension::Handle&);
366     void goToBackForwardItem(uint64_t, const SandboxExtension::Handle&);
367     void setActive(bool);
368     void setFocused(bool);
369     void setInitialFocus(bool);
370     void setWindowResizerSize(const WebCore::IntSize&);
371     void setIsInWindow(bool);
372     void validateMenuItem(const String&);
373     void executeEditCommand(const String&);
374
375     void mouseEvent(const WebMouseEvent&);
376     void wheelEvent(const WebWheelEvent&);
377     void keyEvent(const WebKeyboardEvent&);
378 #if ENABLE(GESTURE_EVENTS)
379     void gestureEvent(const WebGestureEvent&);
380 #endif
381 #if ENABLE(TOUCH_EVENTS)
382     void touchEvent(const WebTouchEvent&);
383 #endif
384
385     uint64_t restoreSession(const SessionState&);
386     void restoreSessionAndNavigateToCurrentItem(const SessionState&, const SandboxExtension::Handle&);
387
388     void didRemoveBackForwardItem(uint64_t);
389
390     void setDrawsBackground(bool);
391     void setDrawsTransparentBackground(bool);
392
393     void viewWillStartLiveResize();
394     void viewWillEndLiveResize();
395
396     void getContentsAsString(uint64_t callbackID);
397     void getMainResourceDataOfFrame(uint64_t frameID, uint64_t callbackID);
398     void getResourceDataFromFrame(uint64_t frameID, const String& resourceURL, uint64_t callbackID);
399     void getRenderTreeExternalRepresentation(uint64_t callbackID);
400     void getSelectionOrContentsAsString(uint64_t callbackID);
401     void getSourceForFrame(uint64_t frameID, uint64_t callbackID);
402     void getWebArchiveOfFrame(uint64_t frameID, uint64_t callbackID);
403     void runJavaScriptInMainFrame(const String&, uint64_t callbackID);
404     void forceRepaint(uint64_t callbackID);
405
406     void preferencesDidChange(const WebPreferencesStore&);
407     void platformPreferencesDidChange(const WebPreferencesStore&);
408     void updatePreferences(const WebPreferencesStore&);
409
410     void didReceivePolicyDecision(uint64_t frameID, uint64_t listenerID, uint32_t policyAction, uint64_t downloadID);
411     void setUserAgent(const String&);
412     void setCustomTextEncodingName(const String&);
413
414 #if PLATFORM(MAC)
415     void setWindowIsVisible(bool windowIsVisible);
416     void windowAndViewFramesChanged(const WebCore::IntRect& windowFrameInScreenCoordinates, const WebCore::IntRect& viewFrameInWindowCoordinates, const WebCore::IntPoint& accessibilityViewCoordinates);
417 #endif
418
419     void unapplyEditCommand(uint64_t commandID);
420     void reapplyEditCommand(uint64_t commandID);
421     void didRemoveEditCommand(uint64_t commandID);
422
423     void findString(const String&, uint32_t findOptions, uint32_t maxMatchCount);
424     void hideFindUI();
425     void countStringMatches(const String&, uint32_t findOptions, uint32_t maxMatchCount);
426
427 #if PLATFORM(QT)
428     void findZoomableAreaForPoint(const WebCore::IntPoint&);
429 #endif
430
431     void didChangeSelectedIndexForActivePopupMenu(int32_t newIndex);
432     void setTextForActivePopupMenu(int32_t index);
433
434     void didChooseFilesForOpenPanel(const Vector<String>&);
435     void didCancelForOpenPanel();
436 #if ENABLE(WEB_PROCESS_SANDBOX)
437     void extendSandboxForFileFromOpenPanel(const SandboxExtension::Handle&);
438 #endif
439
440     void didReceiveGeolocationPermissionDecision(uint64_t geolocationID, bool allowed);
441
442     void advanceToNextMisspelling(bool startBeforeSelection);
443     void changeSpellingToWord(const String& word);
444     void unmarkAllMisspellings();
445     void unmarkAllBadGrammar();
446 #if PLATFORM(MAC)
447     void uppercaseWord();
448     void lowercaseWord();
449     void capitalizeWord();
450
451     void setSmartInsertDeleteEnabled(bool isSmartInsertDeleteEnabled) { m_isSmartInsertDeleteEnabled = isSmartInsertDeleteEnabled; }
452 #endif
453
454 #if ENABLE(CONTEXT_MENUS)
455     void didSelectItemFromActiveContextMenu(const WebContextMenuItemData&);
456 #endif
457
458     OwnPtr<WebCore::Page> m_page;
459     RefPtr<WebFrame> m_mainFrame;
460     RefPtr<InjectedBundleBackForwardList> m_backForwardList;
461
462     RefPtr<WebPageGroupProxy> m_pageGroup;
463
464     String m_userAgent;
465
466     WebCore::IntSize m_viewSize;
467     RefPtr<DrawingArea> m_drawingArea;
468
469     bool m_drawsBackground;
470     bool m_drawsTransparentBackground;
471
472     bool m_isInRedo;
473     bool m_isClosed;
474
475     bool m_tabToLinks;
476
477 #if PLATFORM(MAC)
478     // Whether the containing window is visible or not.
479     bool m_windowIsVisible;
480
481     // Whether smart insert/delete is enabled or not.
482     bool m_isSmartInsertDeleteEnabled;
483
484     // The frame of the containing window in screen coordinates.
485     WebCore::IntRect m_windowFrameInScreenCoordinates;
486
487     // The frame of the view in window coordinates.
488     WebCore::IntRect m_viewFrameInWindowCoordinates;
489
490     // The accessibility position of the view.
491     WebCore::IntPoint m_accessibilityPosition;
492     
493     // All plug-in views on this web page.
494     HashSet<PluginView*> m_pluginViews;
495     
496     RetainPtr<AccessibilityWebPageObject> m_mockAccessibilityElement;
497 #elif PLATFORM(WIN)
498     // Our view's window (in the UI process).
499     HWND m_nativeWindow;
500 #endif
501     
502     HashMap<uint64_t, RefPtr<WebEditCommand> > m_editCommandMap;
503
504     WebCore::IntSize m_windowResizerSize;
505
506     InjectedBundlePageContextMenuClient m_contextMenuClient;
507     InjectedBundlePageEditorClient m_editorClient;
508     InjectedBundlePageFormClient m_formClient;
509     InjectedBundlePageLoaderClient m_loaderClient;
510     InjectedBundlePagePolicyClient m_policyClient;
511     InjectedBundlePageResourceLoadClient m_resourceLoadClient;
512     InjectedBundlePageUIClient m_uiClient;
513
514 #if ENABLE(TILED_BACKING_STORE)
515     WebCore::IntSize m_resizesToContentsLayoutSize;
516 #endif
517
518     FindController m_findController;
519     RefPtr<PageOverlay> m_pageOverlay;
520
521 #if ENABLE(INSPECTOR)
522     RefPtr<WebInspector> m_inspector;
523 #endif
524     RefPtr<WebPopupMenu> m_activePopupMenu;
525     RefPtr<WebContextMenu> m_contextMenu;
526     RefPtr<WebOpenPanelResultListener> m_activeOpenPanelResultListener;
527     GeolocationPermissionRequestManager m_geolocationPermissionRequestManager;
528
529     OwnPtr<WebCore::PrintContext> m_printContext;
530
531     SandboxExtensionTracker m_sandboxExtensionTracker;
532     uint64_t m_pageID;
533
534     bool m_canRunModal;
535     bool m_isRunningModal;
536 };
537
538 } // namespace WebKit
539
540 #endif // WebPage_h