23aa381bb0519ebc3f67ea887432894cdcd778e6
[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 addPageOverlay(WebPageOverlay*, int /* zOrder */);
306     virtual void removePageOverlay(WebPageOverlay*);
307 #if ENABLE(BATTERY_STATUS)
308     virtual void updateBatteryStatus(const WebBatteryStatus&);
309 #endif
310     virtual void transferActiveWheelFlingAnimation(const WebActiveWheelFlingParameters&);
311     virtual WebViewBenchmarkSupport* benchmarkSupport();
312     virtual void setShowPaintRects(bool);
313     virtual void setShowDebugBorders(bool);
314     virtual void setShowFPSCounter(bool);
315     virtual void setContinuousPaintingEnabled(bool);
316
317     // WebLayerTreeViewClient
318     virtual void willBeginFrame();
319     virtual void didBeginFrame();
320     virtual void updateAnimations(double monotonicFrameBeginTime);
321     virtual void applyScrollAndScale(const WebSize&, float);
322     virtual WebCompositorOutputSurface* createOutputSurface() OVERRIDE;
323     virtual void didRecreateOutputSurface(bool success) OVERRIDE;
324     virtual WebInputHandler* createInputHandler() OVERRIDE;
325     virtual void scheduleComposite();
326
327     // WebViewImpl
328
329     void suppressInvalidations(bool enable);
330     void invalidateRect(const WebCore::IntRect&);
331
332     void setIgnoreInputEvents(bool newValue);
333     WebDevToolsAgentPrivate* devToolsAgentPrivate() { return m_devToolsAgent.get(); }
334
335     PageOverlayList* pageOverlays() const { return m_pageOverlays.get(); }
336
337     void setOverlayLayer(WebCore::GraphicsLayer*);
338
339     const WebPoint& lastMouseDownPoint() const
340     {
341         return m_lastMouseDownPoint;
342     }
343
344     WebCore::Frame* focusedWebCoreFrame() const;
345
346     // Returns the currently focused Node or null if no node has focus.
347     WebCore::Node* focusedWebCoreNode();
348
349     static WebViewImpl* fromPage(WebCore::Page*);
350
351     // A pageGroup identifies a namespace of pages. Page groups are used on PLATFORM(MAC)
352     // for some programs that use HTML views to display things that don't seem like
353     // web pages to the user (so shouldn't have visited link coloring). We only use
354     // one page group.
355     static WebCore::PageGroup* defaultPageGroup();
356
357     WebViewClient* client()
358     {
359         return m_client;
360     }
361
362     WebAutofillClient* autofillClient()
363     {
364         return m_autofillClient;
365     }
366
367     WebPermissionClient* permissionClient()
368     {
369         return m_permissionClient;
370     }
371
372     WebSpellCheckClient* spellCheckClient()
373     {
374         return m_spellCheckClient;
375     }
376
377     const Vector<OwnPtr<WebCore::TextFieldDecorator> >& textFieldDecorators() const { return m_textFieldDecorators; }
378
379     // Returns the page object associated with this view. This may be null when
380     // the page is shutting down, but will be valid at all other times.
381     WebCore::Page* page() const
382     {
383         return m_page.get();
384     }
385
386     WebCore::RenderTheme* theme() const;
387
388     // Returns the main frame associated with this view. This may be null when
389     // the page is shutting down, but will be valid at all other times.
390     WebFrameImpl* mainFrameImpl();
391
392     // History related methods:
393     void observeNewNavigation();
394
395     // Event related methods:
396     void mouseContextMenu(const WebMouseEvent&);
397     void mouseDoubleClick(const WebMouseEvent&);
398
399     bool detectContentOnTouch(const WebPoint&);
400     bool startPageScaleAnimation(const WebCore::IntPoint& targetPosition, bool useAnchor, float newScale, double durationInSeconds);
401
402     void numberOfWheelEventHandlersChanged(unsigned);
403     void hasTouchEventHandlers(bool);
404
405     // WebGestureCurveTarget implementation for fling.
406     virtual void scrollBy(const WebPoint&);
407
408     // Handles context menu events orignated via the the keyboard. These
409     // include the VK_APPS virtual key and the Shift+F10 combine. Code is
410     // based on the Webkit function bool WebView::handleContextMenuEvent(WPARAM
411     // wParam, LPARAM lParam) in webkit\webkit\win\WebView.cpp. The only
412     // significant change in this function is the code to convert from a
413     // Keyboard event to the Right Mouse button down event.
414     bool sendContextMenuEvent(const WebKeyboardEvent&);
415
416     // Notifies the WebView that a load has been committed. isNewNavigation
417     // will be true if a new session history item should be created for that
418     // load. isNavigationWithinPage will be true if the navigation does
419     // not take the user away from the current page.
420     void didCommitLoad(bool* isNewNavigation, bool isNavigationWithinPage);
421
422     // Indicates two things:
423     //   1) This view may have a new layout now.
424     //   2) Calling layout() is a no-op.
425     // After calling WebWidget::layout(), expect to get this notification
426     // unless the view did not need a layout.
427     void layoutUpdated(WebFrameImpl*);
428
429     void didChangeContentsSize();
430
431     // Returns true if popup menus should be rendered by the browser, false if
432     // they should be rendered by WebKit (which is the default).
433     static bool useExternalPopupMenus();
434
435     bool contextMenuAllowed() const
436     {
437         return m_contextMenuAllowed;
438     }
439
440     bool shouldAutoResize() const
441     {
442         return m_shouldAutoResize;
443     }
444
445     WebCore::IntSize minAutoSize() const
446     {
447         return m_minAutoSize;
448     }
449
450     WebCore::IntSize maxAutoSize() const
451     {
452         return m_maxAutoSize;
453     }
454
455     WebCore::IntSize dipSize() const;
456     WebCore::IntSize layoutSize() const;
457     WebCore::IntSize scaledSize(float) const;
458
459     // Set the disposition for how this webview is to be initially shown.
460     void setInitialNavigationPolicy(WebNavigationPolicy policy)
461     {
462         m_initialNavigationPolicy = policy;
463     }
464     WebNavigationPolicy initialNavigationPolicy() const
465     {
466         return m_initialNavigationPolicy;
467     }
468
469     // Sets the emulated text zoom factor
470     // (may not be 1 in the device metrics emulation mode).
471     void setEmulatedTextZoomFactor(float);
472
473     // Returns the emulated text zoom factor
474     // (which may not be 1 in the device metrics emulation mode).
475     float emulatedTextZoomFactor() const
476     {
477         return m_emulatedTextZoomFactor;
478     }
479
480     void setInitialPageScaleFactor(float initialPageScaleFactor) { m_initialPageScaleFactor = initialPageScaleFactor; }
481     bool ignoreViewportTagMaximumScale() const { return m_ignoreViewportTagMaximumScale; }
482
483     // Determines whether a page should e.g. be opened in a background tab.
484     // Returns false if it has no opinion, in which case it doesn't set *policy.
485     static bool navigationPolicyFromMouseEvent(
486         unsigned short button,
487         bool ctrl,
488         bool shift,
489         bool alt,
490         bool meta,
491         WebNavigationPolicy*);
492
493     // Start a system drag and drop operation.
494     void startDragging(
495         WebCore::Frame*,
496         const WebDragData& dragData,
497         WebDragOperationsMask mask,
498         const WebImage& dragImage,
499         const WebPoint& dragImageOffset);
500
501     void autofillPopupDidHide()
502     {
503         m_autofillPopupShowing = false;
504     }
505
506 #if ENABLE(NOTIFICATIONS) || ENABLE(LEGACY_NOTIFICATIONS)
507     // Returns the provider of desktop notifications.
508     NotificationPresenterImpl* notificationPresenterImpl();
509 #endif
510
511     // Tries to scroll a frame or any parent of a frame. Returns true if the view
512     // was scrolled.
513     bool propagateScroll(WebCore::ScrollDirection, WebCore::ScrollGranularity);
514
515     // Notification that a popup was opened/closed.
516     void popupOpened(WebCore::PopupContainer* popupContainer);
517     void popupClosed(WebCore::PopupContainer* popupContainer);
518 #if ENABLE(PAGE_POPUP)
519     // PagePopupDriver functions.
520     virtual WebCore::PagePopup* openPagePopup(WebCore::PagePopupClient*, const WebCore::IntRect& originBoundsInRootView) OVERRIDE;
521     virtual void closePagePopup(WebCore::PagePopup*) OVERRIDE;
522 #endif
523
524     void hideAutofillPopup();
525
526     WebHelperPluginImpl* createHelperPlugin(const String& pluginType);
527
528     // Returns the input event we're currently processing. This is used in some
529     // cases where the WebCore DOM event doesn't have the information we need.
530     static const WebInputEvent* currentInputEvent()
531     {
532         return m_currentInputEvent;
533     }
534
535     WebCore::GraphicsLayer* rootGraphicsLayer();
536 #if USE(ACCELERATED_COMPOSITING)
537     bool allowsAcceleratedCompositing();
538     void setRootGraphicsLayer(WebCore::GraphicsLayer*);
539     void scheduleCompositingLayerSync();
540     void scrollRootLayerRect(const WebCore::IntSize& scrollDelta, const WebCore::IntRect& clipRect);
541     void paintRootLayer(WebCore::GraphicsContext&, const WebCore::IntRect& contentRect);
542     NonCompositedContentHost* nonCompositedContentHost();
543     void setBackgroundColor(const WebCore::Color&);
544     WebCore::GraphicsLayerFactory* graphicsLayerFactory() const;
545     void registerForAnimations(WebLayer*);
546 #endif
547 #if ENABLE(REQUEST_ANIMATION_FRAME)
548     void scheduleAnimation();
549 #endif
550
551     virtual WebGraphicsContext3D* sharedGraphicsContext3D();
552
553     virtual void setVisibilityState(WebPageVisibilityState, bool);
554
555     WebCore::PopupContainer* selectPopup() const { return m_selectPopup.get(); }
556 #if ENABLE(PAGE_POPUP)
557     bool hasOpenedPopup() const { return m_selectPopup || m_pagePopup; }
558 #else
559     bool hasOpenedPopup() const { return m_selectPopup; }
560 #endif
561
562     // Returns true if the event leads to scrolling.
563     static bool mapKeyCodeForScroll(int keyCode,
564                                    WebCore::ScrollDirection* scrollDirection,
565                                    WebCore::ScrollGranularity* scrollGranularity);
566
567     // Called by a full frame plugin inside this view to inform it that its
568     // zoom level has been updated.  The plugin should only call this function
569     // if the zoom change was triggered by the browser, it's only needed in case
570     // a plugin can update its own zoom, say because of its own UI.
571     void fullFramePluginZoomLevelChanged(double zoomLevel);
572
573 #if ENABLE(GESTURE_EVENTS)
574     void computeScaleAndScrollForHitRect(const WebRect& hitRect, AutoZoomType, float& scale, WebPoint& scroll, bool& isAnchor);
575     WebCore::Node* bestTapNode(const WebCore::PlatformGestureEvent& tapEvent);
576     void enableTapHighlight(const WebCore::PlatformGestureEvent& tapEvent);
577     void computeScaleAndScrollForFocusedNode(WebCore::Node* focusedNode, float& scale, WebCore::IntPoint& scroll, bool& needAnimation);
578 #endif
579     void animateZoomAroundPoint(const WebCore::IntPoint&, AutoZoomType);
580
581     void enableFakeDoubleTapAnimationForTesting(bool);
582     bool fakeDoubleTapAnimationPendingForTesting() const { return m_doubleTapZoomPending; }
583     WebCore::IntPoint fakeDoubleTapTargetPositionForTesting() const { return m_fakeDoubleTapTargetPosition; }
584     float fakeDoubleTapPageScaleFactorForTesting() const { return m_fakeDoubleTapPageScaleFactor; }
585     bool fakeDoubleTapUseAnchorForTesting() const { return m_fakeDoubleTapUseAnchor; }
586
587     void enterFullScreenForElement(WebCore::Element*);
588     void exitFullScreenForElement(WebCore::Element*);
589
590     // Exposed for the purpose of overriding device metrics.
591     void sendResizeEventAndRepaint();
592
593     // Exposed for testing purposes.
594     bool hasHorizontalScrollbar();
595     bool hasVerticalScrollbar();
596
597     // Pointer Lock calls allow a page to capture all mouse events and
598     // disable the system cursor.
599 #if ENABLE(POINTER_LOCK)
600     virtual bool requestPointerLock();
601     virtual void requestPointerUnlock();
602     virtual bool isPointerLocked();
603 #endif
604
605     // Heuristic-based function for determining if we should disable workarounds
606     // for viewing websites that are not optimized for mobile devices.
607     bool shouldDisableDesktopWorkarounds();
608
609 #if ENABLE(GESTURE_EVENTS)
610     // Exposed for tests.
611     LinkHighlight* linkHighlight() { return m_linkHighlight.get(); }
612 #endif
613
614     WebSettingsImpl* settingsImpl();
615
616 private:
617     void computePageScaleFactorLimits();
618     float clampPageScaleFactorToLimits(float scale);
619     WebCore::IntPoint clampOffsetAtScale(const WebCore::IntPoint& offset, float scale) const;
620     WebCore::IntSize contentsSize() const;
621
622     void resetSavedScrollAndScaleState();
623
624     friend class WebView;  // So WebView::Create can call our constructor
625     friend class WTF::RefCounted<WebViewImpl>;
626     friend void setCurrentInputEventForTest(const WebInputEvent*);
627
628     enum DragAction {
629       DragEnter,
630       DragOver
631     };
632
633     WebViewImpl(WebViewClient*);
634     virtual ~WebViewImpl();
635
636     // Returns true if the event was actually processed.
637     bool keyEventDefault(const WebKeyboardEvent&);
638
639     // Returns true if the autocomple has consumed the event.
640     bool autocompleteHandleKeyEvent(const WebKeyboardEvent&);
641
642     // Repaints the Autofill popup. Should be called when the suggestions
643     // have changed. Note that this should only be called when the Autofill
644     // popup is showing.
645     void refreshAutofillPopup();
646
647     // Returns true if the view was scrolled.
648     bool scrollViewWithKeyboard(int keyCode, int modifiers);
649
650     void hideSelectPopup();
651
652     // Converts |pos| from window coordinates to contents coordinates and gets
653     // the HitTestResult for it.
654     WebCore::HitTestResult hitTestResultForWindowPos(const WebCore::IntPoint&);
655
656     // Consolidate some common code between starting a drag over a target and
657     // updating a drag over a target. If we're starting a drag, |isEntering|
658     // should be true.
659     WebDragOperation dragTargetDragEnterOrOver(const WebPoint& clientPoint,
660                                                const WebPoint& screenPoint,
661                                                DragAction,
662                                                int keyModifiers);
663
664     void configureAutoResizeMode();
665
666 #if USE(ACCELERATED_COMPOSITING)
667     void setIsAcceleratedCompositingActive(bool);
668     void doComposite();
669     void doPixelReadbackToCanvas(WebCanvas*, const WebCore::IntRect&);
670     void reallocateRenderer();
671     void updateLayerTreeViewport();
672 #endif
673
674 #if ENABLE(GESTURE_EVENTS)
675     // Returns the bounding box of the block type node touched by the WebRect.
676     WebRect computeBlockBounds(const WebRect&, AutoZoomType);
677
678     // Helper function: Widens the width of |source| by the specified margins
679     // while keeping it smaller than page width.
680     WebRect widenRectWithinPageBounds(const WebRect& source, int targetMargin, int minimumMargin);
681 #endif
682
683 #if ENABLE(POINTER_LOCK)
684     void pointerLockMouseEvent(const WebInputEvent&);
685 #endif
686
687     // PageWidgetEventHandler functions
688     virtual void handleMouseLeave(WebCore::Frame&, const WebMouseEvent&) OVERRIDE;
689     virtual void handleMouseDown(WebCore::Frame&, const WebMouseEvent&) OVERRIDE;
690     virtual void handleMouseUp(WebCore::Frame&, const WebMouseEvent&) OVERRIDE;
691     virtual bool handleMouseWheel(WebCore::Frame&, const WebMouseWheelEvent&) OVERRIDE;
692     virtual bool handleGestureEvent(const WebGestureEvent&) OVERRIDE;
693     virtual bool handleKeyEvent(const WebKeyboardEvent&) OVERRIDE;
694     virtual bool handleCharEvent(const WebKeyboardEvent&) OVERRIDE;
695
696     WebViewClient* m_client;
697     WebAutofillClient* m_autofillClient;
698     WebPermissionClient* m_permissionClient;
699     WebSpellCheckClient* m_spellCheckClient;
700     Vector<OwnPtr<WebCore::TextFieldDecorator> > m_textFieldDecorators;
701
702     ChromeClientImpl m_chromeClientImpl;
703     ContextMenuClientImpl m_contextMenuClientImpl;
704     DragClientImpl m_dragClientImpl;
705     EditorClientImpl m_editorClientImpl;
706     InspectorClientImpl m_inspectorClientImpl;
707
708     WebSize m_size;
709     // If true, automatically resize the render view around its content.
710     bool m_shouldAutoResize;
711     // The lower bound on the size when auto-resizing.
712     WebCore::IntSize m_minAutoSize;
713     // The upper bound on the size when auto-resizing.
714     WebCore::IntSize m_maxAutoSize;
715
716     OwnPtr<WebCore::Page> m_page;
717
718     // This flag is set when a new navigation is detected. It is used to satisfy
719     // the corresponding argument to WebFrameClient::didCommitProvisionalLoad.
720     bool m_observedNewNavigation;
721 #ifndef NDEBUG
722     // Used to assert that the new navigation we observed is the same navigation
723     // when we make use of m_observedNewNavigation.
724     const WebCore::DocumentLoader* m_newNavigationLoader;
725 #endif
726
727     // An object that can be used to manipulate m_page->settings() without linking
728     // against WebCore. This is lazily allocated the first time GetWebSettings()
729     // is called.
730     OwnPtr<WebSettingsImpl> m_webSettings;
731
732     // A copy of the web drop data object we received from the browser.
733     RefPtr<WebCore::ChromiumDataObject> m_currentDragData;
734
735     // The point relative to the client area where the mouse was last pressed
736     // down. This is used by the drag client to determine what was under the
737     // mouse when the drag was initiated. We need to track this here in
738     // WebViewImpl since DragClient::startDrag does not pass the position the
739     // mouse was at when the drag was initiated, only the current point, which
740     // can be misleading as it is usually not over the element the user actually
741     // dragged by the time a drag is initiated.
742     WebPoint m_lastMouseDownPoint;
743
744     // Keeps track of the current zoom level. 0 means no zoom, positive numbers
745     // mean zoom in, negative numbers mean zoom out.
746     double m_zoomLevel;
747
748     double m_minimumZoomLevel;
749
750     double m_maximumZoomLevel;
751
752     // State related to the page scale
753     float m_pageDefinedMinimumPageScaleFactor;
754     float m_pageDefinedMaximumPageScaleFactor;
755     float m_minimumPageScaleFactor;
756     float m_maximumPageScaleFactor;
757     float m_initialPageScaleFactorOverride;
758     float m_initialPageScaleFactor;
759     bool m_ignoreViewportTagMaximumScale;
760     bool m_pageScaleFactorIsSet;
761
762     // Saved page scale state.
763     float m_savedPageScaleFactor; // 0 means that no page scale factor is saved.
764     WebCore::IntSize m_savedScrollOffset;
765
766     // The scale moved to by the latest double tap zoom, if any.
767     float m_doubleTapZoomPageScaleFactor;
768     // Have we sent a double-tap zoom and not yet heard back the scale?
769     bool m_doubleTapZoomPending;
770
771     // Used for testing purposes.
772     bool m_enableFakeDoubleTapAnimationForTesting;
773     WebCore::IntPoint m_fakeDoubleTapTargetPosition;
774     float m_fakeDoubleTapPageScaleFactor;
775     bool m_fakeDoubleTapUseAnchor;
776
777     bool m_contextMenuAllowed;
778
779     bool m_doingDragAndDrop;
780
781     bool m_ignoreInputEvents;
782
783     // Webkit expects keyPress events to be suppressed if the associated keyDown
784     // event was handled. Safari implements this behavior by peeking out the
785     // associated WM_CHAR event if the keydown was handled. We emulate
786     // this behavior by setting this flag if the keyDown was handled.
787     bool m_suppressNextKeypressEvent;
788
789     // The policy for how this webview is to be initially shown.
790     WebNavigationPolicy m_initialNavigationPolicy;
791
792     // Represents whether or not this object should process incoming IME events.
793     bool m_imeAcceptEvents;
794
795     // The available drag operations (copy, move link...) allowed by the source.
796     WebDragOperation m_operationsAllowed;
797
798     // The current drag operation as negotiated by the source and destination.
799     // When not equal to DragOperationNone, the drag data can be dropped onto the
800     // current drop target in this WebView (the drop target can accept the drop).
801     WebDragOperation m_dragOperation;
802
803     // Context-based feature switches.
804     OwnPtr<ContextFeaturesClientImpl> m_featureSwitchClient;
805
806     // Whether an Autofill popup is currently showing.
807     bool m_autofillPopupShowing;
808
809     // The Autofill popup client.
810     OwnPtr<AutofillPopupMenuClient> m_autofillPopupClient;
811
812     // The Autofill popup.
813     RefPtr<WebCore::PopupContainer> m_autofillPopup;
814
815     // The popup associated with a select element.
816     RefPtr<WebCore::PopupContainer> m_selectPopup;
817
818 #if ENABLE(PAGE_POPUP)
819     // The popup associated with an input element.
820     RefPtr<WebPagePopupImpl> m_pagePopup;
821 #endif
822
823     OwnPtr<WebDevToolsAgentPrivate> m_devToolsAgent;
824     OwnPtr<PageOverlayList> m_pageOverlays;
825
826     // Whether the webview is rendering transparently.
827     bool m_isTransparent;
828
829     // Whether the user can press tab to focus links.
830     bool m_tabsToLinks;
831
832     // Inspector settings.
833     WebString m_inspectorSettings;
834
835     typedef HashMap<WTF::String, WTF::String> SettingsMap;
836     OwnPtr<SettingsMap> m_inspectorSettingsMap;
837
838 #if ENABLE(NOTIFICATIONS) || ENABLE(LEGACY_NOTIFICATIONS)
839     // The provider of desktop notifications;
840     NotificationPresenterImpl m_notificationPresenter;
841 #endif
842
843     // If set, the (plugin) node which has mouse capture.
844     RefPtr<WebCore::Node> m_mouseCaptureNode;
845
846     // If set, the WebView is transitioning to fullscreen for this element.
847     RefPtr<WebCore::Element> m_provisionalFullScreenElement;
848
849     // If set, the WebView is in fullscreen mode for an element in this frame.
850     RefPtr<WebCore::Frame> m_fullScreenFrame;
851     bool m_isCancelingFullScreen;
852
853     WebViewBenchmarkSupportImpl m_benchmarkSupport;
854
855 #if USE(ACCELERATED_COMPOSITING)
856     WebCore::IntRect m_rootLayerScrollDamage;
857     OwnPtr<NonCompositedContentHost> m_nonCompositedContentHost;
858     WebLayerTreeView* m_layerTreeView;
859     WebLayer* m_rootLayer;
860     WebCore::GraphicsLayer* m_rootGraphicsLayer;
861     OwnPtr<WebCore::GraphicsLayerFactory> m_graphicsLayerFactory;
862     bool m_isAcceleratedCompositingActive;
863     bool m_layerTreeViewCommitsDeferred;
864     bool m_compositorCreationFailed;
865     // If true, the graphics context is being restored.
866     bool m_recreatingGraphicsContext;
867     int m_inputHandlerIdentifier;
868 #endif
869     static const WebInputEvent* m_currentInputEvent;
870
871 #if ENABLE(INPUT_SPEECH)
872     OwnPtr<SpeechInputClientImpl> m_speechInputClient;
873 #endif
874 #if ENABLE(SCRIPTED_SPEECH)
875     OwnPtr<SpeechRecognitionClientProxy> m_speechRecognitionClient;
876 #endif
877
878     OwnPtr<DeviceOrientationClientProxy> m_deviceOrientationClientProxy;
879     OwnPtr<GeolocationClientProxy> m_geolocationClientProxy;
880 #if ENABLE(BATTERY_STATUS)
881     OwnPtr<BatteryClientImpl> m_batteryClient;
882 #endif
883
884     float m_emulatedTextZoomFactor;
885
886 #if ENABLE(MEDIA_STREAM)
887     UserMediaClientImpl m_userMediaClientImpl;
888 #endif
889 #if ENABLE(NAVIGATOR_CONTENT_UTILS)
890     OwnPtr<NavigatorContentUtilsClientImpl> m_navigatorContentUtilsClient;
891 #endif
892     OwnPtr<WebActiveGestureAnimation> m_gestureAnimation;
893     WebPoint m_positionOnFlingStart;
894     WebPoint m_globalPositionOnFlingStart;
895     int m_flingModifier;
896     bool m_flingSourceDevice;
897 #if ENABLE(GESTURE_EVENTS)
898     OwnPtr<LinkHighlight> m_linkHighlight;
899 #endif
900     OwnPtr<ValidationMessageClientImpl> m_validationMessage;
901
902     bool m_showFPSCounter;
903     bool m_showPaintRects;
904     bool m_showDebugBorders;
905     bool m_continuousPaintingEnabled;
906 };
907
908 } // namespace WebKit
909
910 #endif