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