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