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