c9892cc159155e010fc054900e82fa193f8cf17e
[WebKit-https.git] / Source / WebKit / chromium / src / WebViewImpl.h
1 /*
2  * Copyright (C) 2010 Google 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 are
6  * met:
7  *
8  *     * Redistributions of source code must retain the above copyright
9  * notice, this list of conditions and the following disclaimer.
10  *     * Redistributions in binary form must reproduce the above
11  * copyright notice, this list of conditions and the following disclaimer
12  * in the documentation and/or other materials provided with the
13  * distribution.
14  *     * Neither the name of Google Inc. nor the names of its
15  * contributors may be used to endorse or promote products derived from
16  * this software without specific prior written permission.
17  *
18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
21  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
22  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
23  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
24  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
28  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29  */
30
31 #ifndef WebViewImpl_h
32 #define WebViewImpl_h
33
34 #include "WebNavigationPolicy.h"
35 #include "WebPoint.h"
36 #include "WebRect.h"
37 #include "WebSize.h"
38 #include "WebString.h"
39 #include "WebView.h"
40
41 #include "ChromeClientImpl.h"
42 #include "ContextMenuClientImpl.h"
43 #include "DragClientImpl.h"
44 #include "EditorClientImpl.h"
45 #include "GraphicsContext3D.h"
46 #include "GraphicsLayer.h"
47 #include "InspectorClientImpl.h"
48 #include "IntRect.h"
49 #include "NotificationPresenterImpl.h"
50 #include "PageOverlay.h"
51 #include "cc/CCLayerTreeHost.h"
52 #include <wtf/OwnPtr.h>
53 #include <wtf/RefCounted.h>
54
55 namespace WebCore {
56 class ChromiumDataObject;
57 class DocumentLoader;
58 class Frame;
59 class GraphicsContext3D;
60 class HistoryItem;
61 class HitTestResult;
62 class KeyboardEvent;
63 class NonCompositedContentHost;
64 class Page;
65 class PlatformKeyboardEvent;
66 class PopupContainer;
67 class PopupMenuClient;
68 class Range;
69 class RenderTheme;
70 class Widget;
71 #if ENABLE(GESTURE_RECOGNIZER)
72 class PlatformGestureRecognizer;
73 #endif
74 }
75
76 namespace WebKit {
77 class AutocompletePopupMenuClient;
78 class AutofillPopupMenuClient;
79 class ContextMenuClientImpl;
80 class DeviceOrientationClientProxy;
81 class DragScrollTimer;
82 class GeolocationClientProxy;
83 class SpeechInputClientImpl;
84 class WebAccessibilityObject;
85 class WebDevToolsAgentClient;
86 class WebDevToolsAgentPrivate;
87 class WebFrameImpl;
88 class WebGestureEvent;
89 class WebImage;
90 class WebKeyboardEvent;
91 class WebMouseEvent;
92 class WebMouseWheelEvent;
93 class WebSettingsImpl;
94 class WebTouchEvent;
95
96 class WebViewImpl : public WebView, public WebCore::CCLayerTreeHostClient, public RefCounted<WebViewImpl> {
97 public:
98     // WebWidget methods:
99     virtual void close();
100     virtual WebSize size() { return m_size; }
101     virtual void willStartLiveResize();
102     virtual void resize(const WebSize&);
103     virtual void willEndLiveResize();
104     virtual void animate(double frameBeginTime);
105     virtual void layout();
106     virtual void paint(WebCanvas*, const WebRect&);
107     virtual void themeChanged();
108     virtual void composite(bool finish);
109     virtual bool handleInputEvent(const WebInputEvent&);
110     virtual void mouseCaptureLost();
111     virtual void setFocus(bool enable);
112     virtual bool setComposition(
113         const WebString& text,
114         const WebVector<WebCompositionUnderline>& underlines,
115         int selectionStart,
116         int selectionEnd);
117     virtual bool confirmComposition();
118     virtual bool confirmComposition(const WebString& text);
119     virtual bool compositionRange(size_t* location, size_t* length);
120     virtual WebTextInputType textInputType();
121     virtual bool getSelectionOffsetsAndTextInEditableContent(WebString&, size_t& focus, size_t& anchor) const;
122     virtual WebRect caretOrSelectionBounds();
123     virtual bool selectionRange(WebPoint& start, WebPoint& end) const;
124     virtual bool caretOrSelectionRange(size_t* location, size_t* length);
125     virtual void setTextDirection(WebTextDirection direction);
126     virtual bool isAcceleratedCompositingActive() const;
127
128     // WebView methods:
129     virtual void initializeMainFrame(WebFrameClient*);
130     virtual void setAutofillClient(WebAutofillClient*);
131     virtual void setDevToolsAgentClient(WebDevToolsAgentClient*);
132     virtual void setPermissionClient(WebPermissionClient*);
133     virtual void setSpellCheckClient(WebSpellCheckClient*);
134     virtual WebSettings* settings();
135     virtual WebString pageEncoding() const;
136     virtual void setPageEncoding(const WebString& encoding);
137     virtual bool isTransparent() const;
138     virtual void setIsTransparent(bool value);
139     virtual bool tabsToLinks() const;
140     virtual void setTabsToLinks(bool value);
141     virtual bool tabKeyCyclesThroughElements() const;
142     virtual void setTabKeyCyclesThroughElements(bool value);
143     virtual bool isActive() const;
144     virtual void setIsActive(bool value);
145     virtual void setDomainRelaxationForbidden(bool, const WebString& scheme);
146     virtual bool dispatchBeforeUnloadEvent();
147     virtual void dispatchUnloadEvent();
148     virtual WebFrame* mainFrame();
149     virtual WebFrame* findFrameByName(
150         const WebString& name, WebFrame* relativeToFrame);
151     virtual WebFrame* focusedFrame();
152     virtual void setFocusedFrame(WebFrame* frame);
153     virtual void setInitialFocus(bool reverse);
154     virtual void clearFocusedNode();
155     virtual void scrollFocusedNodeIntoView();
156     virtual void scrollFocusedNodeIntoRect(const WebRect&);
157     virtual double zoomLevel();
158     virtual double setZoomLevel(bool textOnly, double zoomLevel);
159     virtual void zoomLimitsChanged(double minimumZoomLevel,
160                                    double maximumZoomLevel);
161     virtual float pageScaleFactor() const;
162     virtual void scalePage(float scaleFactor, WebPoint origin);
163     virtual bool isFixedLayoutModeEnabled() const;
164     virtual void enableFixedLayoutMode(bool enable);
165     virtual WebSize fixedLayoutSize() const;
166     virtual void setFixedLayoutSize(const WebSize&);
167     virtual void performMediaPlayerAction(
168         const WebMediaPlayerAction& action,
169         const WebPoint& location);
170     virtual void copyImageAt(const WebPoint& point);
171     virtual void dragSourceEndedAt(
172         const WebPoint& clientPoint,
173         const WebPoint& screenPoint,
174         WebDragOperation operation);
175     virtual void dragSourceMovedTo(
176         const WebPoint& clientPoint,
177         const WebPoint& screenPoint,
178         WebDragOperation operation);
179     virtual void dragSourceSystemDragEnded();
180     virtual WebDragOperation dragTargetDragEnter(
181         const WebDragData&,
182         const WebPoint& clientPoint,
183         const WebPoint& screenPoint,
184         WebDragOperationsMask operationsAllowed);
185     virtual WebDragOperation dragTargetDragOver(
186         const WebPoint& clientPoint,
187         const WebPoint& screenPoint,
188         WebDragOperationsMask operationsAllowed);
189     virtual void dragTargetDragLeave();
190     virtual void dragTargetDrop(
191         const WebPoint& clientPoint,
192         const WebPoint& screenPoint);
193     virtual unsigned long createUniqueIdentifierForRequest();
194     virtual void inspectElementAt(const WebPoint& point);
195     virtual WebString inspectorSettings() const;
196     virtual void setInspectorSettings(const WebString& settings);
197     virtual bool inspectorSetting(const WebString& key, WebString* value) const;
198     virtual void setInspectorSetting(const WebString& key,
199                                      const WebString& value);
200     virtual WebDevToolsAgent* devToolsAgent();
201     virtual WebAccessibilityObject accessibilityObject();
202     virtual void applyAutofillSuggestions(
203         const WebNode&,
204         const WebVector<WebString>& names,
205         const WebVector<WebString>& labels,
206         const WebVector<WebString>& icons,
207         const WebVector<int>& uniqueIDs,
208         int separatorIndex);
209     virtual void hidePopups();
210     virtual void setScrollbarColors(unsigned inactiveColor,
211                                     unsigned activeColor,
212                                     unsigned trackColor);
213     virtual void setSelectionColors(unsigned activeBackgroundColor,
214                                     unsigned activeForegroundColor,
215                                     unsigned inactiveBackgroundColor,
216                                     unsigned inactiveForegroundColor);
217     virtual void performCustomContextMenuAction(unsigned action);
218     virtual void exitFullscreen();
219
220     // CCLayerTreeHostClient
221     virtual void animateAndLayout(double frameBeginTime);
222     virtual PassOwnPtr<WebCore::CCThread> createCompositorThread();
223     virtual PassRefPtr<WebCore::GraphicsContext3D> createLayerTreeHostContext3D();
224     virtual PassOwnPtr<WebCore::LayerPainterChromium> createRootLayerPainter();
225     virtual void didRecreateGraphicsContext(bool success);
226 #if !USE(THREADED_COMPOSITING)
227     virtual void scheduleComposite();
228 #endif
229
230     // WebViewImpl
231
232     void setIgnoreInputEvents(bool newValue);
233     WebDevToolsAgentPrivate* devToolsAgentPrivate() { return m_devToolsAgent.get(); }
234
235     PageOverlay* pageOverlay() const { return m_pageOverlay.get(); }
236     void setPageOverlayClient(PageOverlay::PageOverlayClient*);
237
238     void setOverlayLayer(WebCore::GraphicsLayer*);
239
240     const WebPoint& lastMouseDownPoint() const
241     {
242         return m_lastMouseDownPoint;
243     }
244
245     WebCore::Frame* focusedWebCoreFrame() const;
246
247     // Returns the currently focused Node or null if no node has focus.
248     WebCore::Node* focusedWebCoreNode();
249
250     static WebViewImpl* fromPage(WebCore::Page*);
251
252     WebViewClient* client()
253     {
254         return m_client;
255     }
256
257     WebAutofillClient* autofillClient()
258     {
259         return m_autofillClient;
260     }
261
262     WebPermissionClient* permissionClient()
263     {
264         return m_permissionClient;
265     }
266
267     WebSpellCheckClient* spellCheckClient()
268     {
269         return m_spellCheckClient;
270     }
271
272     // Returns the page object associated with this view. This may be null when
273     // the page is shutting down, but will be valid at all other times.
274     WebCore::Page* page() const
275     {
276         return m_page.get();
277     }
278
279     WebCore::RenderTheme* theme() const;
280
281     // Returns the main frame associated with this view. This may be null when
282     // the page is shutting down, but will be valid at all other times.
283     WebFrameImpl* mainFrameImpl();
284
285     // History related methods:
286     void observeNewNavigation();
287
288     // Event related methods:
289     void mouseMove(const WebMouseEvent&);
290     void mouseLeave(const WebMouseEvent&);
291     void mouseDown(const WebMouseEvent&);
292     void mouseUp(const WebMouseEvent&);
293     void mouseContextMenu(const WebMouseEvent&);
294     void mouseDoubleClick(const WebMouseEvent&);
295     bool mouseWheel(const WebMouseWheelEvent&);
296     bool gestureEvent(const WebGestureEvent&);
297     bool keyEvent(const WebKeyboardEvent&);
298     bool charEvent(const WebKeyboardEvent&);
299     bool touchEvent(const WebTouchEvent&);
300
301     // Handles context menu events orignated via the the keyboard. These
302     // include the VK_APPS virtual key and the Shift+F10 combine. Code is
303     // based on the Webkit function bool WebView::handleContextMenuEvent(WPARAM
304     // wParam, LPARAM lParam) in webkit\webkit\win\WebView.cpp. The only
305     // significant change in this function is the code to convert from a
306     // Keyboard event to the Right Mouse button down event.
307     bool sendContextMenuEvent(const WebKeyboardEvent&);
308
309     // Notifies the WebView that a load has been committed. isNewNavigation
310     // will be true if a new session history item should be created for that
311     // load.
312     void didCommitLoad(bool* isNewNavigation);
313
314     // Returns true if popup menus should be rendered by the browser, false if
315     // they should be rendered by WebKit (which is the default).
316     static bool useExternalPopupMenus();
317
318     bool contextMenuAllowed() const
319     {
320         return m_contextMenuAllowed;
321     }
322
323     // Set the disposition for how this webview is to be initially shown.
324     void setInitialNavigationPolicy(WebNavigationPolicy policy)
325     {
326         m_initialNavigationPolicy = policy;
327     }
328     WebNavigationPolicy initialNavigationPolicy() const
329     {
330         return m_initialNavigationPolicy;
331     }
332
333     // Determines whether a page should e.g. be opened in a background tab.
334     // Returns false if it has no opinion, in which case it doesn't set *policy.
335     static bool navigationPolicyFromMouseEvent(
336         unsigned short button,
337         bool ctrl,
338         bool shift,
339         bool alt,
340         bool meta,
341         WebNavigationPolicy*);
342
343     // Start a system drag and drop operation.
344     void startDragging(
345         const WebDragData& dragData,
346         WebDragOperationsMask mask,
347         const WebImage& dragImage,
348         const WebPoint& dragImageOffset);
349
350     void autofillPopupDidHide()
351     {
352         m_autofillPopupShowing = false;
353     }
354
355 #if ENABLE(NOTIFICATIONS)
356     // Returns the provider of desktop notifications.
357     NotificationPresenterImpl* notificationPresenterImpl();
358 #endif
359
360     // Tries to scroll a frame or any parent of a frame. Returns true if the view
361     // was scrolled.
362     bool propagateScroll(WebCore::ScrollDirection, WebCore::ScrollGranularity);
363
364     // Notification that a popup was opened/closed.
365     void popupOpened(WebCore::PopupContainer* popupContainer);
366     void popupClosed(WebCore::PopupContainer* popupContainer);
367
368     void hideAutofillPopup();
369
370     // Returns the input event we're currently processing. This is used in some
371     // cases where the WebCore DOM event doesn't have the information we need.
372     static const WebInputEvent* currentInputEvent()
373     {
374         return m_currentInputEvent;
375     }
376
377 #if USE(ACCELERATED_COMPOSITING)
378     bool allowsAcceleratedCompositing();
379     bool pageHasRTLStyle() const;
380     void setRootGraphicsLayer(WebCore::GraphicsLayer*);
381     void setRootLayerNeedsDisplay();
382     void scrollRootLayerRect(const WebCore::IntSize& scrollDelta, const WebCore::IntRect& clipRect);
383     void invalidateRootLayerRect(const WebCore::IntRect&);
384     void doUpdateAndComposite();
385 #endif
386
387     // Returns the onscreen 3D context used by the compositor. This is
388     // used by the renderer's code to set up resource sharing between
389     // the compositor's context and subordinate contexts for APIs like
390     // WebGL. Returns 0 if compositing support is not compiled in.
391     virtual WebGraphicsContext3D* graphicsContext3D();
392
393     virtual void setVisibilityState(WebPageVisibilityState, bool);
394
395     WebCore::PopupContainer* selectPopup() const { return m_selectPopup.get(); }
396
397     // Returns true if the event leads to scrolling.
398     static bool mapKeyCodeForScroll(int keyCode,
399                                    WebCore::ScrollDirection* scrollDirection,
400                                    WebCore::ScrollGranularity* scrollGranularity);
401
402     // Called by a full frame plugin inside this view to inform it that its
403     // zoom level has been updated.  The plugin should only call this function
404     // if the zoom change was triggered by the browser, it's only needed in case
405     // a plugin can update its own zoom, say because of its own UI.
406     void fullFramePluginZoomLevelChanged(double zoomLevel);
407
408 #if ENABLE(GESTURE_RECOGNIZER)
409     void resetGestureRecognizer();
410 #endif
411
412     void loseCompositorContext(int numTimes);
413
414 private:
415     friend class WebView;  // So WebView::Create can call our constructor
416     friend class WTF::RefCounted<WebViewImpl>;
417
418     enum DragAction {
419       DragEnter,
420       DragOver
421     };
422
423     WebViewImpl(WebViewClient*);
424     virtual ~WebViewImpl();
425
426     // Returns true if the event was actually processed.
427     bool keyEventDefault(const WebKeyboardEvent&);
428
429     // Returns true if the autocomple has consumed the event.
430     bool autocompleteHandleKeyEvent(const WebKeyboardEvent&);
431
432     // Repaints the Autofill popup. Should be called when the suggestions
433     // have changed. Note that this should only be called when the Autofill
434     // popup is showing.
435     void refreshAutofillPopup();
436
437     // Returns true if the view was scrolled.
438     bool scrollViewWithKeyboard(int keyCode, int modifiers);
439
440     void hideSelectPopup();
441
442     // Converts |pos| from window coordinates to contents coordinates and gets
443     // the HitTestResult for it.
444     WebCore::HitTestResult hitTestResultForWindowPos(const WebCore::IntPoint&);
445
446     // Consolidate some common code between starting a drag over a target and
447     // updating a drag over a target. If we're starting a drag, |isEntering|
448     // should be true.
449     WebDragOperation dragTargetDragEnterOrOver(const WebPoint& clientPoint,
450                                                const WebPoint& screenPoint,
451                                                DragAction);
452
453 #if USE(ACCELERATED_COMPOSITING)
454     void setIsAcceleratedCompositingActive(bool);
455 #if !USE(THREADED_COMPOSITING)
456     void doComposite();
457 #endif
458     void doPixelReadbackToCanvas(WebCanvas*, const WebCore::IntRect&);
459     void reallocateRenderer();
460     void updateLayerTreeViewport();
461 #endif
462
463     WebViewClient* m_client;
464     WebAutofillClient* m_autofillClient;
465     WebPermissionClient* m_permissionClient;
466     WebSpellCheckClient* m_spellCheckClient;
467
468     ChromeClientImpl m_chromeClientImpl;
469     ContextMenuClientImpl m_contextMenuClientImpl;
470     DragClientImpl m_dragClientImpl;
471     EditorClientImpl m_editorClientImpl;
472     InspectorClientImpl m_inspectorClientImpl;
473
474     WebSize m_size;
475
476     WebPoint m_lastMousePosition;
477     OwnPtr<WebCore::Page> m_page;
478
479     // This flag is set when a new navigation is detected. It is used to satisfy
480     // the corresponding argument to WebFrameClient::didCommitProvisionalLoad.
481     bool m_observedNewNavigation;
482 #ifndef NDEBUG
483     // Used to assert that the new navigation we observed is the same navigation
484     // when we make use of m_observedNewNavigation.
485     const WebCore::DocumentLoader* m_newNavigationLoader;
486 #endif
487
488     // An object that can be used to manipulate m_page->settings() without linking
489     // against WebCore. This is lazily allocated the first time GetWebSettings()
490     // is called.
491     OwnPtr<WebSettingsImpl> m_webSettings;
492
493     // A copy of the web drop data object we received from the browser.
494     RefPtr<WebCore::ChromiumDataObject> m_currentDragData;
495
496     // The point relative to the client area where the mouse was last pressed
497     // down. This is used by the drag client to determine what was under the
498     // mouse when the drag was initiated. We need to track this here in
499     // WebViewImpl since DragClient::startDrag does not pass the position the
500     // mouse was at when the drag was initiated, only the current point, which
501     // can be misleading as it is usually not over the element the user actually
502     // dragged by the time a drag is initiated.
503     WebPoint m_lastMouseDownPoint;
504
505     // Keeps track of the current zoom level. 0 means no zoom, positive numbers
506     // mean zoom in, negative numbers mean zoom out.
507     double m_zoomLevel;
508
509     double m_minimumZoomLevel;
510
511     double m_maximumZoomLevel;
512
513     bool m_contextMenuAllowed;
514
515     bool m_doingDragAndDrop;
516
517     bool m_ignoreInputEvents;
518
519     // Webkit expects keyPress events to be suppressed if the associated keyDown
520     // event was handled. Safari implements this behavior by peeking out the
521     // associated WM_CHAR event if the keydown was handled. We emulate
522     // this behavior by setting this flag if the keyDown was handled.
523     bool m_suppressNextKeypressEvent;
524
525     // The policy for how this webview is to be initially shown.
526     WebNavigationPolicy m_initialNavigationPolicy;
527
528     // Represents whether or not this object should process incoming IME events.
529     bool m_imeAcceptEvents;
530
531     // The available drag operations (copy, move link...) allowed by the source.
532     WebDragOperation m_operationsAllowed;
533
534     // The current drag operation as negotiated by the source and destination.
535     // When not equal to DragOperationNone, the drag data can be dropped onto the
536     // current drop target in this WebView (the drop target can accept the drop).
537     WebDragOperation m_dragOperation;
538
539     // Whether an Autofill popup is currently showing.
540     bool m_autofillPopupShowing;
541
542     // The Autofill popup client.
543     OwnPtr<AutofillPopupMenuClient> m_autofillPopupClient;
544
545     // The Autofill popup.
546     RefPtr<WebCore::PopupContainer> m_autofillPopup;
547
548     // The popup associated with a select element.
549     RefPtr<WebCore::PopupContainer> m_selectPopup;
550
551     OwnPtr<WebDevToolsAgentPrivate> m_devToolsAgent;
552     OwnPtr<PageOverlay> m_pageOverlay;
553
554     // Whether the webview is rendering transparently.
555     bool m_isTransparent;
556
557     // Whether the user can press tab to focus links.
558     bool m_tabsToLinks;
559
560     // Inspector settings.
561     WebString m_inspectorSettings;
562
563     typedef HashMap<WTF::String, WTF::String> SettingsMap;
564     OwnPtr<SettingsMap> m_inspectorSettingsMap;
565     OwnPtr<DragScrollTimer> m_dragScrollTimer;
566
567 #if ENABLE(NOTIFICATIONS)
568     // The provider of desktop notifications;
569     NotificationPresenterImpl m_notificationPresenter;
570 #endif
571
572     // If set, the (plugin) node which has mouse capture.
573     RefPtr<WebCore::Node> m_mouseCaptureNode;
574
575 #if USE(ACCELERATED_COMPOSITING)
576     WebCore::IntRect m_rootLayerScrollDamage;
577     OwnPtr<WebCore::NonCompositedContentHost> m_nonCompositedContentHost;
578     RefPtr<WebCore::CCLayerTreeHost> m_layerTreeHost;
579     WebCore::GraphicsLayer* m_rootGraphicsLayer;
580     bool m_isAcceleratedCompositingActive;
581     bool m_compositorCreationFailed;
582     // If true, the graphics context is being restored.
583     bool m_recreatingGraphicsContext;
584 #endif
585     static const WebInputEvent* m_currentInputEvent;
586
587 #if ENABLE(INPUT_SPEECH)
588     OwnPtr<SpeechInputClientImpl> m_speechInputClient;
589 #endif
590     // If we attempt to fetch the on-screen GraphicsContext3D before
591     // the compositor has been turned on, we need to instantiate it
592     // early. This member holds on to the GC3D in this case.
593     RefPtr<WebCore::GraphicsContext3D> m_temporaryOnscreenGraphicsContext3D;
594     OwnPtr<DeviceOrientationClientProxy> m_deviceOrientationClientProxy;
595     OwnPtr<GeolocationClientProxy> m_geolocationClientProxy;
596
597 #if ENABLE(GESTURE_RECOGNIZER)
598     OwnPtr<WebCore::PlatformGestureRecognizer> m_gestureRecognizer;
599 #endif
600 };
601
602 } // namespace WebKit
603
604 #endif