Add new webkit API to invoke a context menu.
[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 "ChromeClientImpl.h"
35 #include "ContextMenuClientImpl.h"
36 #include "DragClientImpl.h"
37 #include "EditorClientImpl.h"
38 #include "FloatSize.h"
39 #include "GraphicsContext3D.h"
40 #include "GraphicsLayer.h"
41 #include "InspectorClientImpl.h"
42 #include "IntPoint.h"
43 #include "IntRect.h"
44 #include "NotificationPresenterImpl.h"
45 #include "PageOverlayList.h"
46 #include "PagePopupDriver.h"
47 #include "PageWidgetDelegate.h"
48 #include "UserMediaClientImpl.h"
49 #include "WebInputEvent.h"
50 #include "WebNavigationPolicy.h"
51 #include "WebView.h"
52 #include "WebViewBenchmarkSupportImpl.h"
53 #include <public/WebFloatQuad.h>
54 #include <public/WebGestureCurveTarget.h>
55 #include <public/WebLayer.h>
56 #include <public/WebLayerTreeViewClient.h>
57 #include <public/WebPoint.h>
58 #include <public/WebRect.h>
59 #include <public/WebSize.h>
60 #include <public/WebString.h>
61 #include <wtf/OwnPtr.h>
62 #include <wtf/RefCounted.h>
63
64 namespace WebCore {
65 class ChromiumDataObject;
66 class Color;
67 class DocumentLoader;
68 class FloatSize;
69 class Frame;
70 class GraphicsContext3D;
71 class GraphicsLayerFactory;
72 class HistoryItem;
73 class HitTestResult;
74 class KeyboardEvent;
75 class Page;
76 class PageGroup;
77 class PagePopup;
78 class PagePopupClient;
79 class PlatformKeyboardEvent;
80 class PopupContainer;
81 class PopupMenuClient;
82 class Range;
83 class RenderTheme;
84 class TextFieldDecorator;
85 class Widget;
86 }
87
88 namespace WebKit {
89 class AutocompletePopupMenuClient;
90 class AutofillPopupMenuClient;
91 class BatteryClientImpl;
92 class ContextFeaturesClientImpl;
93 class ContextMenuClientImpl;
94 class DeviceOrientationClientProxy;
95 class GeolocationClientProxy;
96 class LinkHighlight;
97 class NonCompositedContentHost;
98 class PrerendererClientImpl;
99 class SpeechInputClientImpl;
100 class SpeechRecognitionClientProxy;
101 class UserMediaClientImpl;
102 class ValidationMessageClientImpl;
103 class WebAccessibilityObject;
104 class WebActiveGestureAnimation;
105 class WebCompositorImpl;
106 class WebDevToolsAgentClient;
107 class WebDevToolsAgentPrivate;
108 class WebFrameImpl;
109 class WebGestureEvent;
110 class WebHelperPluginImpl;
111 class WebImage;
112 class WebKeyboardEvent;
113 class WebLayerTreeView;
114 class WebMouseEvent;
115 class WebMouseWheelEvent;
116 class WebPagePopupImpl;
117 class WebPrerendererClient;
118 class WebSettingsImpl;
119 class WebTouchEvent;
120 class WebViewBenchmarkSupport;
121
122 class WebViewImpl : public WebView
123     , public WebLayerTreeViewClient
124     , public RefCounted<WebViewImpl>
125     , public WebGestureCurveTarget
126 #if ENABLE(PAGE_POPUP)
127     , public WebCore::PagePopupDriver
128 #endif
129     , public PageWidgetEventHandler {
130 public:
131     enum AutoZoomType {
132         DoubleTap,
133         FindInPage,
134     };
135
136     // WebWidget methods:
137     virtual void close();
138     virtual WebSize size();
139     virtual void willStartLiveResize();
140     virtual void resize(const WebSize&);
141     virtual void willEndLiveResize();
142     virtual void willEnterFullScreen();
143     virtual void didEnterFullScreen();
144     virtual void willExitFullScreen();
145     virtual void didExitFullScreen();
146     virtual void animate(double);
147     virtual void layout(); // Also implements WebLayerTreeViewClient::layout()
148     virtual void enterForceCompositingMode(bool enable) OVERRIDE;
149     virtual void paint(WebCanvas*, const WebRect&, PaintOptions = ReadbackFromCompositorIfAvailable);
150     virtual bool isTrackingRepaints() const OVERRIDE;
151     virtual void themeChanged();
152     virtual void composite(bool finish);
153     virtual void setNeedsRedraw();
154     virtual bool handleInputEvent(const WebInputEvent&);
155     virtual bool hasTouchEventHandlersAt(const WebPoint&);
156     virtual void mouseCaptureLost();
157     virtual void setFocus(bool enable);
158     virtual bool setComposition(
159         const WebString& text,
160         const WebVector<WebCompositionUnderline>& underlines,
161         int selectionStart,
162         int selectionEnd);
163     virtual bool confirmComposition();
164     virtual bool confirmComposition(const WebString& text);
165     virtual bool compositionRange(size_t* location, size_t* length);
166     virtual WebTextInputInfo textInputInfo();
167     virtual WebTextInputType textInputType();
168     virtual bool setEditableSelectionOffsets(int start, int end);
169     virtual bool setCompositionFromExistingText(int compositionStart, int compositionEnd, const WebVector<WebCompositionUnderline>& underlines);
170     virtual void extendSelectionAndDelete(int before, int after);
171     virtual bool isSelectionEditable() const;
172     virtual WebColor backgroundColor() const;
173     virtual bool selectionBounds(WebRect& anchor, WebRect& focus) const;
174     virtual bool selectionTextDirection(WebTextDirection& start, WebTextDirection& end) const;
175     virtual bool isSelectionAnchorFirst() const;
176     virtual bool caretOrSelectionRange(size_t* location, size_t* length);
177     virtual void setTextDirection(WebTextDirection direction);
178     virtual bool isAcceleratedCompositingActive() const;
179     virtual void willCloseLayerTreeView();
180     virtual void didAcquirePointerLock();
181     virtual void didNotAcquirePointerLock();
182     virtual void didLosePointerLock();
183     virtual void didChangeWindowResizerRect();
184
185     // WebView methods:
186     virtual void initializeMainFrame(WebFrameClient*);
187     virtual void initializeHelperPluginFrame(WebFrameClient*);
188     virtual void setAutofillClient(WebAutofillClient*);
189     virtual void setDevToolsAgentClient(WebDevToolsAgentClient*);
190     virtual void setPermissionClient(WebPermissionClient*);
191     virtual void setPrerendererClient(WebPrerendererClient*) OVERRIDE;
192     virtual void setSpellCheckClient(WebSpellCheckClient*);
193     virtual void addTextFieldDecoratorClient(WebTextFieldDecoratorClient*) OVERRIDE;
194     virtual WebSettings* settings();
195     virtual WebString pageEncoding() const;
196     virtual void setPageEncoding(const WebString& encoding);
197     virtual bool isTransparent() const;
198     virtual void setIsTransparent(bool value);
199     virtual bool tabsToLinks() const;
200     virtual void setTabsToLinks(bool value);
201     virtual bool tabKeyCyclesThroughElements() const;
202     virtual void setTabKeyCyclesThroughElements(bool value);
203     virtual bool isActive() const;
204     virtual void setIsActive(bool value);
205     virtual void setDomainRelaxationForbidden(bool, const WebString& scheme);
206     virtual bool dispatchBeforeUnloadEvent();
207     virtual void dispatchUnloadEvent();
208     virtual WebFrame* mainFrame();
209     virtual WebFrame* findFrameByName(
210         const WebString& name, WebFrame* relativeToFrame);
211     virtual WebFrame* focusedFrame();
212     virtual void setFocusedFrame(WebFrame* frame);
213     virtual void setInitialFocus(bool reverse);
214     virtual void clearFocusedNode();
215     virtual void scrollFocusedNodeIntoView();
216     virtual void scrollFocusedNodeIntoRect(const WebRect&);
217     virtual void zoomToFindInPageRect(const WebRect&);
218     virtual void advanceFocus(bool reverse);
219     virtual double zoomLevel();
220     virtual double setZoomLevel(bool textOnly, double zoomLevel);
221     virtual void zoomLimitsChanged(double minimumZoomLevel,
222                                    double maximumZoomLevel);
223     virtual void setInitialPageScaleOverride(float);
224     virtual float pageScaleFactor() const;
225     virtual bool isPageScaleFactorSet() const;
226     virtual void setPageScaleFactorPreservingScrollOffset(float);
227     virtual void setPageScaleFactor(float scaleFactor, const WebPoint& origin);
228     virtual void setPageScaleFactorLimits(float minPageScale, float maxPageScale);
229     virtual float minimumPageScaleFactor() const;
230     virtual float maximumPageScaleFactor() const;
231     virtual void saveScrollAndScaleState();
232     virtual void restoreScrollAndScaleState();
233     virtual void resetScrollAndScaleState();
234     virtual void setIgnoreViewportTagMaximumScale(bool);
235
236     virtual float deviceScaleFactor() const;
237     virtual void setDeviceScaleFactor(float);
238     virtual bool isFixedLayoutModeEnabled() const;
239     virtual void enableFixedLayoutMode(bool enable);
240     virtual WebSize fixedLayoutSize() const;
241     virtual void setFixedLayoutSize(const WebSize&);
242     virtual void enableAutoResizeMode(
243         const WebSize& minSize,
244         const WebSize& maxSize);
245     virtual void disableAutoResizeMode();
246     virtual void performMediaPlayerAction(
247         const WebMediaPlayerAction& action,
248         const WebPoint& location);
249     virtual void performPluginAction(
250         const WebPluginAction&,
251         const WebPoint&);
252     virtual WebHitTestResult hitTestResultAt(const WebPoint&);
253     virtual void copyImageAt(const WebPoint& point);
254     virtual void dragSourceEndedAt(
255         const WebPoint& clientPoint,
256         const WebPoint& screenPoint,
257         WebDragOperation operation);
258     virtual void dragSourceMovedTo(
259         const WebPoint& clientPoint,
260         const WebPoint& screenPoint,
261         WebDragOperation operation);
262     virtual void dragSourceSystemDragEnded();
263     virtual WebDragOperation dragTargetDragEnter(
264         const WebDragData&,
265         const WebPoint& clientPoint,
266         const WebPoint& screenPoint,
267         WebDragOperationsMask operationsAllowed,
268         int keyModifiers);
269     virtual WebDragOperation dragTargetDragOver(
270         const WebPoint& clientPoint,
271         const WebPoint& screenPoint,
272         WebDragOperationsMask operationsAllowed,
273         int keyModifiers);
274     virtual void dragTargetDragLeave();
275     virtual void dragTargetDrop(
276         const WebPoint& clientPoint,
277         const WebPoint& screenPoint,
278         int keyModifiers);
279     virtual unsigned long createUniqueIdentifierForRequest();
280     virtual void inspectElementAt(const WebPoint& point);
281     virtual WebString inspectorSettings() const;
282     virtual void setInspectorSettings(const WebString& settings);
283     virtual bool inspectorSetting(const WebString& key, WebString* value) const;
284     virtual void setInspectorSetting(const WebString& key,
285                                      const WebString& value);
286     virtual WebDevToolsAgent* devToolsAgent();
287     virtual WebAccessibilityObject accessibilityObject();
288     virtual void applyAutofillSuggestions(
289         const WebNode&,
290         const WebVector<WebString>& names,
291         const WebVector<WebString>& labels,
292         const WebVector<WebString>& icons,
293         const WebVector<int>& itemIDs,
294         int separatorIndex);
295     virtual void hidePopups();
296     virtual void selectAutofillSuggestionAtIndex(unsigned listIndex);
297     virtual void setScrollbarColors(unsigned inactiveColor,
298                                     unsigned activeColor,
299                                     unsigned trackColor);
300     virtual void setSelectionColors(unsigned activeBackgroundColor,
301                                     unsigned activeForegroundColor,
302                                     unsigned inactiveBackgroundColor,
303                                     unsigned inactiveForegroundColor);
304     virtual void performCustomContextMenuAction(unsigned action);
305     virtual void showContextMenu();
306     virtual void addPageOverlay(WebPageOverlay*, int /* zOrder */);
307     virtual void removePageOverlay(WebPageOverlay*);
308 #if ENABLE(BATTERY_STATUS)
309     virtual void updateBatteryStatus(const WebBatteryStatus&);
310 #endif
311     virtual void transferActiveWheelFlingAnimation(const WebActiveWheelFlingParameters&);
312     virtual WebViewBenchmarkSupport* benchmarkSupport();
313     virtual void setShowPaintRects(bool);
314     virtual void setShowDebugBorders(bool);
315     virtual void setShowFPSCounter(bool);
316     virtual void setContinuousPaintingEnabled(bool);
317
318     // WebLayerTreeViewClient
319     virtual void willBeginFrame();
320     virtual void didBeginFrame();
321     virtual void updateAnimations(double monotonicFrameBeginTime);
322     virtual void applyScrollAndScale(const WebSize&, float);
323     virtual WebCompositorOutputSurface* createOutputSurface() OVERRIDE;
324     virtual void didRecreateOutputSurface(bool success) OVERRIDE;
325     virtual WebInputHandler* createInputHandler() OVERRIDE;
326     virtual void scheduleComposite();
327
328     // WebViewImpl
329
330     void suppressInvalidations(bool enable);
331     void invalidateRect(const WebCore::IntRect&);
332
333     void setIgnoreInputEvents(bool newValue);
334     WebDevToolsAgentPrivate* devToolsAgentPrivate() { return m_devToolsAgent.get(); }
335
336     PageOverlayList* pageOverlays() const { return m_pageOverlays.get(); }
337
338     void setOverlayLayer(WebCore::GraphicsLayer*);
339
340     const WebPoint& lastMouseDownPoint() const
341     {
342         return m_lastMouseDownPoint;
343     }
344
345     WebCore::Frame* focusedWebCoreFrame() const;
346
347     // Returns the currently focused Node or null if no node has focus.
348     WebCore::Node* focusedWebCoreNode();
349
350     static WebViewImpl* fromPage(WebCore::Page*);
351
352     // A pageGroup identifies a namespace of pages. Page groups are used on PLATFORM(MAC)
353     // for some programs that use HTML views to display things that don't seem like
354     // web pages to the user (so shouldn't have visited link coloring). We only use
355     // one page group.
356     static WebCore::PageGroup* defaultPageGroup();
357
358     WebViewClient* client()
359     {
360         return m_client;
361     }
362
363     WebAutofillClient* autofillClient()
364     {
365         return m_autofillClient;
366     }
367
368     WebPermissionClient* permissionClient()
369     {
370         return m_permissionClient;
371     }
372
373     WebSpellCheckClient* spellCheckClient()
374     {
375         return m_spellCheckClient;
376     }
377
378     const Vector<OwnPtr<WebCore::TextFieldDecorator> >& textFieldDecorators() const { return m_textFieldDecorators; }
379
380     // Returns the page object associated with this view. This may be null when
381     // the page is shutting down, but will be valid at all other times.
382     WebCore::Page* page() const
383     {
384         return m_page.get();
385     }
386
387     WebCore::RenderTheme* theme() const;
388
389     // Returns the main frame associated with this view. This may be null when
390     // the page is shutting down, but will be valid at all other times.
391     WebFrameImpl* mainFrameImpl();
392
393     // History related methods:
394     void observeNewNavigation();
395
396     // Event related methods:
397     void mouseContextMenu(const WebMouseEvent&);
398     void mouseDoubleClick(const WebMouseEvent&);
399
400     bool detectContentOnTouch(const WebPoint&);
401     bool startPageScaleAnimation(const WebCore::IntPoint& targetPosition, bool useAnchor, float newScale, double durationInSeconds);
402
403     void numberOfWheelEventHandlersChanged(unsigned);
404     void hasTouchEventHandlers(bool);
405
406     // WebGestureCurveTarget implementation for fling.
407     virtual void scrollBy(const WebPoint&);
408
409     // Handles context menu events orignated via the the keyboard. These
410     // include the VK_APPS virtual key and the Shift+F10 combine. Code is
411     // based on the Webkit function bool WebView::handleContextMenuEvent(WPARAM
412     // wParam, LPARAM lParam) in webkit\webkit\win\WebView.cpp. The only
413     // significant change in this function is the code to convert from a
414     // Keyboard event to the Right Mouse button down event.
415     bool sendContextMenuEvent(const WebKeyboardEvent&);
416
417     // Notifies the WebView that a load has been committed. isNewNavigation
418     // will be true if a new session history item should be created for that
419     // load. isNavigationWithinPage will be true if the navigation does
420     // not take the user away from the current page.
421     void didCommitLoad(bool* isNewNavigation, bool isNavigationWithinPage);
422
423     // Indicates two things:
424     //   1) This view may have a new layout now.
425     //   2) Calling layout() is a no-op.
426     // After calling WebWidget::layout(), expect to get this notification
427     // unless the view did not need a layout.
428     void layoutUpdated(WebFrameImpl*);
429
430     void didChangeContentsSize();
431
432     // Returns true if popup menus should be rendered by the browser, false if
433     // they should be rendered by WebKit (which is the default).
434     static bool useExternalPopupMenus();
435
436     bool contextMenuAllowed() const
437     {
438         return m_contextMenuAllowed;
439     }
440
441     bool shouldAutoResize() const
442     {
443         return m_shouldAutoResize;
444     }
445
446     WebCore::IntSize minAutoSize() const
447     {
448         return m_minAutoSize;
449     }
450
451     WebCore::IntSize maxAutoSize() const
452     {
453         return m_maxAutoSize;
454     }
455
456     WebCore::IntSize dipSize() const;
457     WebCore::IntSize layoutSize() const;
458     WebCore::IntSize scaledSize(float) const;
459
460     // Set the disposition for how this webview is to be initially shown.
461     void setInitialNavigationPolicy(WebNavigationPolicy policy)
462     {
463         m_initialNavigationPolicy = policy;
464     }
465     WebNavigationPolicy initialNavigationPolicy() const
466     {
467         return m_initialNavigationPolicy;
468     }
469
470     // Sets the emulated text zoom factor
471     // (may not be 1 in the device metrics emulation mode).
472     void setEmulatedTextZoomFactor(float);
473
474     // Returns the emulated text zoom factor
475     // (which may not be 1 in the device metrics emulation mode).
476     float emulatedTextZoomFactor() const
477     {
478         return m_emulatedTextZoomFactor;
479     }
480
481     void setInitialPageScaleFactor(float initialPageScaleFactor) { m_initialPageScaleFactor = initialPageScaleFactor; }
482     bool ignoreViewportTagMaximumScale() const { return m_ignoreViewportTagMaximumScale; }
483
484     // Determines whether a page should e.g. be opened in a background tab.
485     // Returns false if it has no opinion, in which case it doesn't set *policy.
486     static bool navigationPolicyFromMouseEvent(
487         unsigned short button,
488         bool ctrl,
489         bool shift,
490         bool alt,
491         bool meta,
492         WebNavigationPolicy*);
493
494     // Start a system drag and drop operation.
495     void startDragging(
496         WebCore::Frame*,
497         const WebDragData& dragData,
498         WebDragOperationsMask mask,
499         const WebImage& dragImage,
500         const WebPoint& dragImageOffset);
501
502     void autofillPopupDidHide()
503     {
504         m_autofillPopupShowing = false;
505     }
506
507 #if ENABLE(NOTIFICATIONS) || ENABLE(LEGACY_NOTIFICATIONS)
508     // Returns the provider of desktop notifications.
509     NotificationPresenterImpl* notificationPresenterImpl();
510 #endif
511
512     // Tries to scroll a frame or any parent of a frame. Returns true if the view
513     // was scrolled.
514     bool propagateScroll(WebCore::ScrollDirection, WebCore::ScrollGranularity);
515
516     // Notification that a popup was opened/closed.
517     void popupOpened(WebCore::PopupContainer* popupContainer);
518     void popupClosed(WebCore::PopupContainer* popupContainer);
519 #if ENABLE(PAGE_POPUP)
520     // PagePopupDriver functions.
521     virtual WebCore::PagePopup* openPagePopup(WebCore::PagePopupClient*, const WebCore::IntRect& originBoundsInRootView) OVERRIDE;
522     virtual void closePagePopup(WebCore::PagePopup*) OVERRIDE;
523 #endif
524
525     void hideAutofillPopup();
526
527     WebHelperPluginImpl* createHelperPlugin(const String& pluginType);
528
529     // Returns the input event we're currently processing. This is used in some
530     // cases where the WebCore DOM event doesn't have the information we need.
531     static const WebInputEvent* currentInputEvent()
532     {
533         return m_currentInputEvent;
534     }
535
536     WebCore::GraphicsLayer* rootGraphicsLayer();
537 #if USE(ACCELERATED_COMPOSITING)
538     bool allowsAcceleratedCompositing();
539     void setRootGraphicsLayer(WebCore::GraphicsLayer*);
540     void scheduleCompositingLayerSync();
541     void scrollRootLayerRect(const WebCore::IntSize& scrollDelta, const WebCore::IntRect& clipRect);
542     void paintRootLayer(WebCore::GraphicsContext&, const WebCore::IntRect& contentRect);
543     NonCompositedContentHost* nonCompositedContentHost();
544     void setBackgroundColor(const WebCore::Color&);
545     WebCore::GraphicsLayerFactory* graphicsLayerFactory() const;
546     void registerForAnimations(WebLayer*);
547 #endif
548 #if ENABLE(REQUEST_ANIMATION_FRAME)
549     void scheduleAnimation();
550 #endif
551
552     virtual WebGraphicsContext3D* sharedGraphicsContext3D();
553
554     virtual void setVisibilityState(WebPageVisibilityState, bool);
555
556     WebCore::PopupContainer* selectPopup() const { return m_selectPopup.get(); }
557 #if ENABLE(PAGE_POPUP)
558     bool hasOpenedPopup() const { return m_selectPopup || m_pagePopup; }
559 #else
560     bool hasOpenedPopup() const { return m_selectPopup; }
561 #endif
562
563     // Returns true if the event leads to scrolling.
564     static bool mapKeyCodeForScroll(int keyCode,
565                                    WebCore::ScrollDirection* scrollDirection,
566                                    WebCore::ScrollGranularity* scrollGranularity);
567
568     // Called by a full frame plugin inside this view to inform it that its
569     // zoom level has been updated.  The plugin should only call this function
570     // if the zoom change was triggered by the browser, it's only needed in case
571     // a plugin can update its own zoom, say because of its own UI.
572     void fullFramePluginZoomLevelChanged(double zoomLevel);
573
574 #if ENABLE(GESTURE_EVENTS)
575     void computeScaleAndScrollForHitRect(const WebRect& hitRect, AutoZoomType, float& scale, WebPoint& scroll, bool& isAnchor);
576     WebCore::Node* bestTapNode(const WebCore::PlatformGestureEvent& tapEvent);
577     void enableTapHighlight(const WebCore::PlatformGestureEvent& tapEvent);
578     void computeScaleAndScrollForFocusedNode(WebCore::Node* focusedNode, float& scale, WebCore::IntPoint& scroll, bool& needAnimation);
579 #endif
580     void animateZoomAroundPoint(const WebCore::IntPoint&, AutoZoomType);
581
582     void enableFakeDoubleTapAnimationForTesting(bool);
583     bool fakeDoubleTapAnimationPendingForTesting() const { return m_doubleTapZoomPending; }
584     WebCore::IntPoint fakeDoubleTapTargetPositionForTesting() const { return m_fakeDoubleTapTargetPosition; }
585     float fakeDoubleTapPageScaleFactorForTesting() const { return m_fakeDoubleTapPageScaleFactor; }
586     bool fakeDoubleTapUseAnchorForTesting() const { return m_fakeDoubleTapUseAnchor; }
587
588     void enterFullScreenForElement(WebCore::Element*);
589     void exitFullScreenForElement(WebCore::Element*);
590
591     // Exposed for the purpose of overriding device metrics.
592     void sendResizeEventAndRepaint();
593
594     // Exposed for testing purposes.
595     bool hasHorizontalScrollbar();
596     bool hasVerticalScrollbar();
597
598     // Pointer Lock calls allow a page to capture all mouse events and
599     // disable the system cursor.
600 #if ENABLE(POINTER_LOCK)
601     virtual bool requestPointerLock();
602     virtual void requestPointerUnlock();
603     virtual bool isPointerLocked();
604 #endif
605
606     // Heuristic-based function for determining if we should disable workarounds
607     // for viewing websites that are not optimized for mobile devices.
608     bool shouldDisableDesktopWorkarounds();
609
610 #if ENABLE(GESTURE_EVENTS)
611     // Exposed for tests.
612     LinkHighlight* linkHighlight() { return m_linkHighlight.get(); }
613 #endif
614
615     WebSettingsImpl* settingsImpl();
616
617 private:
618     void computePageScaleFactorLimits();
619     float clampPageScaleFactorToLimits(float scale);
620     WebCore::IntPoint clampOffsetAtScale(const WebCore::IntPoint& offset, float scale) const;
621     WebCore::IntSize contentsSize() const;
622
623     void resetSavedScrollAndScaleState();
624
625     friend class WebView;  // So WebView::Create can call our constructor
626     friend class WTF::RefCounted<WebViewImpl>;
627     friend void setCurrentInputEventForTest(const WebInputEvent*);
628
629     enum DragAction {
630       DragEnter,
631       DragOver
632     };
633
634     WebViewImpl(WebViewClient*);
635     virtual ~WebViewImpl();
636
637     // Returns true if the event was actually processed.
638     bool keyEventDefault(const WebKeyboardEvent&);
639
640     // Returns true if the autocomple has consumed the event.
641     bool autocompleteHandleKeyEvent(const WebKeyboardEvent&);
642
643     // Repaints the Autofill popup. Should be called when the suggestions
644     // have changed. Note that this should only be called when the Autofill
645     // popup is showing.
646     void refreshAutofillPopup();
647
648     // Returns true if the view was scrolled.
649     bool scrollViewWithKeyboard(int keyCode, int modifiers);
650
651     void hideSelectPopup();
652
653     // Converts |pos| from window coordinates to contents coordinates and gets
654     // the HitTestResult for it.
655     WebCore::HitTestResult hitTestResultForWindowPos(const WebCore::IntPoint&);
656
657     // Consolidate some common code between starting a drag over a target and
658     // updating a drag over a target. If we're starting a drag, |isEntering|
659     // should be true.
660     WebDragOperation dragTargetDragEnterOrOver(const WebPoint& clientPoint,
661                                                const WebPoint& screenPoint,
662                                                DragAction,
663                                                int keyModifiers);
664
665     void configureAutoResizeMode();
666
667 #if USE(ACCELERATED_COMPOSITING)
668     void setIsAcceleratedCompositingActive(bool);
669     void doComposite();
670     void doPixelReadbackToCanvas(WebCanvas*, const WebCore::IntRect&);
671     void reallocateRenderer();
672     void updateLayerTreeViewport();
673 #endif
674
675 #if ENABLE(GESTURE_EVENTS)
676     // Returns the bounding box of the block type node touched by the WebRect.
677     WebRect computeBlockBounds(const WebRect&, AutoZoomType);
678
679     // Helper function: Widens the width of |source| by the specified margins
680     // while keeping it smaller than page width.
681     WebRect widenRectWithinPageBounds(const WebRect& source, int targetMargin, int minimumMargin);
682 #endif
683
684 #if ENABLE(POINTER_LOCK)
685     void pointerLockMouseEvent(const WebInputEvent&);
686 #endif
687
688     // PageWidgetEventHandler functions
689     virtual void handleMouseLeave(WebCore::Frame&, const WebMouseEvent&) OVERRIDE;
690     virtual void handleMouseDown(WebCore::Frame&, const WebMouseEvent&) OVERRIDE;
691     virtual void handleMouseUp(WebCore::Frame&, const WebMouseEvent&) OVERRIDE;
692     virtual bool handleMouseWheel(WebCore::Frame&, const WebMouseWheelEvent&) OVERRIDE;
693     virtual bool handleGestureEvent(const WebGestureEvent&) OVERRIDE;
694     virtual bool handleKeyEvent(const WebKeyboardEvent&) OVERRIDE;
695     virtual bool handleCharEvent(const WebKeyboardEvent&) OVERRIDE;
696
697     WebViewClient* m_client;
698     WebAutofillClient* m_autofillClient;
699     WebPermissionClient* m_permissionClient;
700     WebSpellCheckClient* m_spellCheckClient;
701     Vector<OwnPtr<WebCore::TextFieldDecorator> > m_textFieldDecorators;
702
703     ChromeClientImpl m_chromeClientImpl;
704     ContextMenuClientImpl m_contextMenuClientImpl;
705     DragClientImpl m_dragClientImpl;
706     EditorClientImpl m_editorClientImpl;
707     InspectorClientImpl m_inspectorClientImpl;
708
709     WebSize m_size;
710     // If true, automatically resize the render view around its content.
711     bool m_shouldAutoResize;
712     // The lower bound on the size when auto-resizing.
713     WebCore::IntSize m_minAutoSize;
714     // The upper bound on the size when auto-resizing.
715     WebCore::IntSize m_maxAutoSize;
716
717     OwnPtr<WebCore::Page> m_page;
718
719     // This flag is set when a new navigation is detected. It is used to satisfy
720     // the corresponding argument to WebFrameClient::didCommitProvisionalLoad.
721     bool m_observedNewNavigation;
722 #ifndef NDEBUG
723     // Used to assert that the new navigation we observed is the same navigation
724     // when we make use of m_observedNewNavigation.
725     const WebCore::DocumentLoader* m_newNavigationLoader;
726 #endif
727
728     // An object that can be used to manipulate m_page->settings() without linking
729     // against WebCore. This is lazily allocated the first time GetWebSettings()
730     // is called.
731     OwnPtr<WebSettingsImpl> m_webSettings;
732
733     // A copy of the web drop data object we received from the browser.
734     RefPtr<WebCore::ChromiumDataObject> m_currentDragData;
735
736     // The point relative to the client area where the mouse was last pressed
737     // down. This is used by the drag client to determine what was under the
738     // mouse when the drag was initiated. We need to track this here in
739     // WebViewImpl since DragClient::startDrag does not pass the position the
740     // mouse was at when the drag was initiated, only the current point, which
741     // can be misleading as it is usually not over the element the user actually
742     // dragged by the time a drag is initiated.
743     WebPoint m_lastMouseDownPoint;
744
745     // Keeps track of the current zoom level. 0 means no zoom, positive numbers
746     // mean zoom in, negative numbers mean zoom out.
747     double m_zoomLevel;
748
749     double m_minimumZoomLevel;
750
751     double m_maximumZoomLevel;
752
753     // State related to the page scale
754     float m_pageDefinedMinimumPageScaleFactor;
755     float m_pageDefinedMaximumPageScaleFactor;
756     float m_minimumPageScaleFactor;
757     float m_maximumPageScaleFactor;
758     float m_initialPageScaleFactorOverride;
759     float m_initialPageScaleFactor;
760     bool m_ignoreViewportTagMaximumScale;
761     bool m_pageScaleFactorIsSet;
762
763     // Saved page scale state.
764     float m_savedPageScaleFactor; // 0 means that no page scale factor is saved.
765     WebCore::IntSize m_savedScrollOffset;
766
767     // The scale moved to by the latest double tap zoom, if any.
768     float m_doubleTapZoomPageScaleFactor;
769     // Have we sent a double-tap zoom and not yet heard back the scale?
770     bool m_doubleTapZoomPending;
771
772     // Used for testing purposes.
773     bool m_enableFakeDoubleTapAnimationForTesting;
774     WebCore::IntPoint m_fakeDoubleTapTargetPosition;
775     float m_fakeDoubleTapPageScaleFactor;
776     bool m_fakeDoubleTapUseAnchor;
777
778     bool m_contextMenuAllowed;
779
780     bool m_doingDragAndDrop;
781
782     bool m_ignoreInputEvents;
783
784     // Webkit expects keyPress events to be suppressed if the associated keyDown
785     // event was handled. Safari implements this behavior by peeking out the
786     // associated WM_CHAR event if the keydown was handled. We emulate
787     // this behavior by setting this flag if the keyDown was handled.
788     bool m_suppressNextKeypressEvent;
789
790     // The policy for how this webview is to be initially shown.
791     WebNavigationPolicy m_initialNavigationPolicy;
792
793     // Represents whether or not this object should process incoming IME events.
794     bool m_imeAcceptEvents;
795
796     // The available drag operations (copy, move link...) allowed by the source.
797     WebDragOperation m_operationsAllowed;
798
799     // The current drag operation as negotiated by the source and destination.
800     // When not equal to DragOperationNone, the drag data can be dropped onto the
801     // current drop target in this WebView (the drop target can accept the drop).
802     WebDragOperation m_dragOperation;
803
804     // Context-based feature switches.
805     OwnPtr<ContextFeaturesClientImpl> m_featureSwitchClient;
806
807     // Whether an Autofill popup is currently showing.
808     bool m_autofillPopupShowing;
809
810     // The Autofill popup client.
811     OwnPtr<AutofillPopupMenuClient> m_autofillPopupClient;
812
813     // The Autofill popup.
814     RefPtr<WebCore::PopupContainer> m_autofillPopup;
815
816     // The popup associated with a select element.
817     RefPtr<WebCore::PopupContainer> m_selectPopup;
818
819 #if ENABLE(PAGE_POPUP)
820     // The popup associated with an input element.
821     RefPtr<WebPagePopupImpl> m_pagePopup;
822 #endif
823
824     OwnPtr<WebDevToolsAgentPrivate> m_devToolsAgent;
825     OwnPtr<PageOverlayList> m_pageOverlays;
826
827     // Whether the webview is rendering transparently.
828     bool m_isTransparent;
829
830     // Whether the user can press tab to focus links.
831     bool m_tabsToLinks;
832
833     // Inspector settings.
834     WebString m_inspectorSettings;
835
836     typedef HashMap<WTF::String, WTF::String> SettingsMap;
837     OwnPtr<SettingsMap> m_inspectorSettingsMap;
838
839 #if ENABLE(NOTIFICATIONS) || ENABLE(LEGACY_NOTIFICATIONS)
840     // The provider of desktop notifications;
841     NotificationPresenterImpl m_notificationPresenter;
842 #endif
843
844     // If set, the (plugin) node which has mouse capture.
845     RefPtr<WebCore::Node> m_mouseCaptureNode;
846
847     // If set, the WebView is transitioning to fullscreen for this element.
848     RefPtr<WebCore::Element> m_provisionalFullScreenElement;
849
850     // If set, the WebView is in fullscreen mode for an element in this frame.
851     RefPtr<WebCore::Frame> m_fullScreenFrame;
852     bool m_isCancelingFullScreen;
853
854     WebViewBenchmarkSupportImpl m_benchmarkSupport;
855
856 #if USE(ACCELERATED_COMPOSITING)
857     WebCore::IntRect m_rootLayerScrollDamage;
858     OwnPtr<NonCompositedContentHost> m_nonCompositedContentHost;
859     WebLayerTreeView* m_layerTreeView;
860     WebLayer* m_rootLayer;
861     WebCore::GraphicsLayer* m_rootGraphicsLayer;
862     OwnPtr<WebCore::GraphicsLayerFactory> m_graphicsLayerFactory;
863     bool m_isAcceleratedCompositingActive;
864     bool m_layerTreeViewCommitsDeferred;
865     bool m_compositorCreationFailed;
866     // If true, the graphics context is being restored.
867     bool m_recreatingGraphicsContext;
868     int m_inputHandlerIdentifier;
869 #endif
870     static const WebInputEvent* m_currentInputEvent;
871
872 #if ENABLE(INPUT_SPEECH)
873     OwnPtr<SpeechInputClientImpl> m_speechInputClient;
874 #endif
875 #if ENABLE(SCRIPTED_SPEECH)
876     OwnPtr<SpeechRecognitionClientProxy> m_speechRecognitionClient;
877 #endif
878
879     OwnPtr<DeviceOrientationClientProxy> m_deviceOrientationClientProxy;
880     OwnPtr<GeolocationClientProxy> m_geolocationClientProxy;
881 #if ENABLE(BATTERY_STATUS)
882     OwnPtr<BatteryClientImpl> m_batteryClient;
883 #endif
884
885     float m_emulatedTextZoomFactor;
886
887 #if ENABLE(MEDIA_STREAM)
888     UserMediaClientImpl m_userMediaClientImpl;
889 #endif
890 #if ENABLE(NAVIGATOR_CONTENT_UTILS)
891     OwnPtr<NavigatorContentUtilsClientImpl> m_navigatorContentUtilsClient;
892 #endif
893     OwnPtr<WebActiveGestureAnimation> m_gestureAnimation;
894     WebPoint m_positionOnFlingStart;
895     WebPoint m_globalPositionOnFlingStart;
896     int m_flingModifier;
897     bool m_flingSourceDevice;
898 #if ENABLE(GESTURE_EVENTS)
899     OwnPtr<LinkHighlight> m_linkHighlight;
900 #endif
901     OwnPtr<ValidationMessageClientImpl> m_validationMessage;
902
903     bool m_showFPSCounter;
904     bool m_showPaintRects;
905     bool m_showDebugBorders;
906     bool m_continuousPaintingEnabled;
907 };
908
909 } // namespace WebKit
910
911 #endif