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