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