c6040c0858cf0b9b4706ceba181f6ac69fcd091d
[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 "WebPoint.h"
36 #include "WebRect.h"
37 #include "WebSize.h"
38 #include "WebString.h"
39 #include "WebView.h"
40
41 #include "ChromeClientImpl.h"
42 #include "ContextMenuClientImpl.h"
43 #include "DragClientImpl.h"
44 #include "EditorClientImpl.h"
45 #include "GraphicsContext3D.h"
46 #include "GraphicsLayer.h"
47 #include "InspectorClientImpl.h"
48 #include "IntRect.h"
49 #include "NotificationPresenterImpl.h"
50 #include "PageOverlay.h"
51 #include "cc/CCLayerTreeHost.h"
52 #include <wtf/OwnPtr.h>
53 #include <wtf/RefCounted.h>
54
55 namespace WebCore {
56 class ChromiumDataObject;
57 class DocumentLoader;
58 class Frame;
59 class GraphicsContext3D;
60 class HistoryItem;
61 class HitTestResult;
62 class KeyboardEvent;
63 class Page;
64 class PlatformKeyboardEvent;
65 class PopupContainer;
66 class PopupMenuClient;
67 class Range;
68 class RenderTheme;
69 class Widget;
70 #if ENABLE(GESTURE_RECOGNIZER)
71 class PlatformGestureRecognizer;
72 #endif
73 }
74
75 namespace WebKit {
76 class AutocompletePopupMenuClient;
77 class AutofillPopupMenuClient;
78 class ContextMenuClientImpl;
79 class DeviceOrientationClientProxy;
80 class DragScrollTimer;
81 class GeolocationClientProxy;
82 class SpeechInputClientImpl;
83 class WebAccessibilityObject;
84 class WebDevToolsAgentClient;
85 class WebDevToolsAgentPrivate;
86 class WebFrameImpl;
87 class WebGestureEvent;
88 class WebImage;
89 class WebKeyboardEvent;
90 class WebMouseEvent;
91 class WebMouseWheelEvent;
92 class WebSettingsImpl;
93 class WebTouchEvent;
94
95 class WebViewImpl : public WebView, public WebCore::CCLayerTreeHostClient, public RefCounted<WebViewImpl> {
96 public:
97     // WebWidget methods:
98     virtual void close();
99     virtual WebSize size() { return m_size; }
100     virtual void willStartLiveResize();
101     virtual void resize(const WebSize&);
102     virtual void willEndLiveResize();
103     virtual void animate(double frameBeginTime);
104     virtual void layout();
105     virtual void paint(WebCanvas*, const WebRect&);
106     virtual void themeChanged();
107     virtual void composite(bool finish);
108     virtual bool handleInputEvent(const WebInputEvent&);
109     virtual void mouseCaptureLost();
110     virtual void setFocus(bool enable);
111     virtual bool setComposition(
112         const WebString& text,
113         const WebVector<WebCompositionUnderline>& underlines,
114         int selectionStart,
115         int selectionEnd);
116     virtual bool confirmComposition();
117     virtual bool confirmComposition(const WebString& text);
118     virtual bool compositionRange(size_t* location, size_t* length);
119     virtual WebTextInputType textInputType();
120     virtual WebRect caretOrSelectionBounds();
121     virtual bool selectionRange(WebPoint& start, WebPoint& end) const;
122     virtual bool caretOrSelectionRange(size_t* location, size_t* length);
123     virtual void setTextDirection(WebTextDirection direction);
124     virtual bool isAcceleratedCompositingActive() const;
125
126     // WebView methods:
127     virtual void initializeMainFrame(WebFrameClient*);
128     virtual void setAutofillClient(WebAutofillClient*);
129     virtual void setDevToolsAgentClient(WebDevToolsAgentClient*);
130     virtual void setPermissionClient(WebPermissionClient*);
131     virtual void setSpellCheckClient(WebSpellCheckClient*);
132     virtual WebSettings* settings();
133     virtual WebString pageEncoding() const;
134     virtual void setPageEncoding(const WebString& encoding);
135     virtual bool isTransparent() const;
136     virtual void setIsTransparent(bool value);
137     virtual bool tabsToLinks() const;
138     virtual void setTabsToLinks(bool value);
139     virtual bool tabKeyCyclesThroughElements() const;
140     virtual void setTabKeyCyclesThroughElements(bool value);
141     virtual bool isActive() const;
142     virtual void setIsActive(bool value);
143     virtual void setDomainRelaxationForbidden(bool, const WebString& scheme);
144     virtual bool dispatchBeforeUnloadEvent();
145     virtual void dispatchUnloadEvent();
146     virtual WebFrame* mainFrame();
147     virtual WebFrame* findFrameByName(
148         const WebString& name, WebFrame* relativeToFrame);
149     virtual WebFrame* focusedFrame();
150     virtual void setFocusedFrame(WebFrame* frame);
151     virtual void setInitialFocus(bool reverse);
152     virtual void clearFocusedNode();
153     virtual void scrollFocusedNodeIntoView();
154     virtual double zoomLevel();
155     virtual double setZoomLevel(bool textOnly, double zoomLevel);
156     virtual void zoomLimitsChanged(double minimumZoomLevel,
157                                    double maximumZoomLevel);
158     virtual float pageScaleFactor() const;
159     virtual void scalePage(float scaleFactor, WebPoint origin);
160     virtual void performMediaPlayerAction(
161         const WebMediaPlayerAction& action,
162         const WebPoint& location);
163     virtual void copyImageAt(const WebPoint& point);
164     virtual void dragSourceEndedAt(
165         const WebPoint& clientPoint,
166         const WebPoint& screenPoint,
167         WebDragOperation operation);
168     virtual void dragSourceMovedTo(
169         const WebPoint& clientPoint,
170         const WebPoint& screenPoint,
171         WebDragOperation operation);
172     virtual void dragSourceSystemDragEnded();
173     virtual WebDragOperation dragTargetDragEnter(
174         const WebDragData&,
175         const WebPoint& clientPoint,
176         const WebPoint& screenPoint,
177         WebDragOperationsMask operationsAllowed);
178     virtual WebDragOperation dragTargetDragOver(
179         const WebPoint& clientPoint,
180         const WebPoint& screenPoint,
181         WebDragOperationsMask operationsAllowed);
182     virtual void dragTargetDragLeave();
183     virtual void dragTargetDrop(
184         const WebPoint& clientPoint,
185         const WebPoint& screenPoint);
186     virtual unsigned long createUniqueIdentifierForRequest();
187     virtual void inspectElementAt(const WebPoint& point);
188     virtual WebString inspectorSettings() const;
189     virtual void setInspectorSettings(const WebString& settings);
190     virtual bool inspectorSetting(const WebString& key, WebString* value) const;
191     virtual void setInspectorSetting(const WebString& key,
192                                      const WebString& value);
193     virtual WebDevToolsAgent* devToolsAgent();
194     virtual WebAccessibilityObject accessibilityObject();
195     virtual void applyAutofillSuggestions(
196         const WebNode&,
197         const WebVector<WebString>& names,
198         const WebVector<WebString>& labels,
199         const WebVector<WebString>& icons,
200         const WebVector<int>& uniqueIDs,
201         int separatorIndex);
202     virtual void hidePopups();
203     virtual void setScrollbarColors(unsigned inactiveColor,
204                                     unsigned activeColor,
205                                     unsigned trackColor);
206     virtual void setSelectionColors(unsigned activeBackgroundColor,
207                                     unsigned activeForegroundColor,
208                                     unsigned inactiveBackgroundColor,
209                                     unsigned inactiveForegroundColor);
210     virtual void performCustomContextMenuAction(unsigned action);
211
212     // CCLayerTreeHostClient
213     virtual void animateAndLayout(double frameBeginTime);
214     virtual PassRefPtr<WebCore::GraphicsContext3D> createLayerTreeHostContext3D();
215     virtual PassOwnPtr<WebCore::LayerPainterChromium> createRootLayerPainter();
216     virtual void didRecreateGraphicsContext(bool success);
217 #if !USE(THREADED_COMPOSITING)
218     virtual void scheduleComposite();
219 #endif
220
221     // WebViewImpl
222
223     void setIgnoreInputEvents(bool newValue);
224     WebDevToolsAgentPrivate* devToolsAgentPrivate() { return m_devToolsAgent.get(); }
225
226     PageOverlay* pageOverlay() const { return m_pageOverlay.get(); }
227     void setPageOverlayClient(PageOverlay::PageOverlayClient*);
228
229     void setOverlayLayer(WebCore::GraphicsLayer*);
230
231     const WebPoint& lastMouseDownPoint() const
232     {
233         return m_lastMouseDownPoint;
234     }
235
236     WebCore::Frame* focusedWebCoreFrame() const;
237
238     // Returns the currently focused Node or null if no node has focus.
239     WebCore::Node* focusedWebCoreNode();
240
241     static WebViewImpl* fromPage(WebCore::Page*);
242
243     WebViewClient* client()
244     {
245         return m_client;
246     }
247
248     WebAutofillClient* autofillClient()
249     {
250         return m_autofillClient;
251     }
252
253     WebPermissionClient* permissionClient()
254     {
255         return m_permissionClient;
256     }
257
258     WebSpellCheckClient* spellCheckClient()
259     {
260         return m_spellCheckClient;
261     }
262
263     // Returns the page object associated with this view. This may be null when
264     // the page is shutting down, but will be valid at all other times.
265     WebCore::Page* page() const
266     {
267         return m_page.get();
268     }
269
270     WebCore::RenderTheme* theme() const;
271
272     // Returns the main frame associated with this view. This may be null when
273     // the page is shutting down, but will be valid at all other times.
274     WebFrameImpl* mainFrameImpl();
275
276     // History related methods:
277     void observeNewNavigation();
278
279     // Event related methods:
280     void mouseMove(const WebMouseEvent&);
281     void mouseLeave(const WebMouseEvent&);
282     void mouseDown(const WebMouseEvent&);
283     void mouseUp(const WebMouseEvent&);
284     void mouseContextMenu(const WebMouseEvent&);
285     void mouseDoubleClick(const WebMouseEvent&);
286     bool mouseWheel(const WebMouseWheelEvent&);
287     bool gestureEvent(const WebGestureEvent&);
288     bool keyEvent(const WebKeyboardEvent&);
289     bool charEvent(const WebKeyboardEvent&);
290     bool touchEvent(const WebTouchEvent&);
291
292     // Handles context menu events orignated via the the keyboard. These
293     // include the VK_APPS virtual key and the Shift+F10 combine. Code is
294     // based on the Webkit function bool WebView::handleContextMenuEvent(WPARAM
295     // wParam, LPARAM lParam) in webkit\webkit\win\WebView.cpp. The only
296     // significant change in this function is the code to convert from a
297     // Keyboard event to the Right Mouse button down event.
298     bool sendContextMenuEvent(const WebKeyboardEvent&);
299
300     // Notifies the WebView that a load has been committed. isNewNavigation
301     // will be true if a new session history item should be created for that
302     // load.
303     void didCommitLoad(bool* isNewNavigation);
304
305     // Returns true if popup menus should be rendered by the browser, false if
306     // they should be rendered by WebKit (which is the default).
307     static bool useExternalPopupMenus();
308
309     bool contextMenuAllowed() const
310     {
311         return m_contextMenuAllowed;
312     }
313
314     // Set the disposition for how this webview is to be initially shown.
315     void setInitialNavigationPolicy(WebNavigationPolicy policy)
316     {
317         m_initialNavigationPolicy = policy;
318     }
319     WebNavigationPolicy initialNavigationPolicy() const
320     {
321         return m_initialNavigationPolicy;
322     }
323
324     // Determines whether a page should e.g. be opened in a background tab.
325     // Returns false if it has no opinion, in which case it doesn't set *policy.
326     static bool navigationPolicyFromMouseEvent(
327         unsigned short button,
328         bool ctrl,
329         bool shift,
330         bool alt,
331         bool meta,
332         WebNavigationPolicy*);
333
334     // Start a system drag and drop operation.
335     void startDragging(
336         const WebDragData& dragData,
337         WebDragOperationsMask mask,
338         const WebImage& dragImage,
339         const WebPoint& dragImageOffset);
340
341     void autofillPopupDidHide()
342     {
343         m_autofillPopupShowing = false;
344     }
345
346 #if ENABLE(NOTIFICATIONS)
347     // Returns the provider of desktop notifications.
348     NotificationPresenterImpl* notificationPresenterImpl();
349 #endif
350
351     // Tries to scroll a frame or any parent of a frame. Returns true if the view
352     // was scrolled.
353     bool propagateScroll(WebCore::ScrollDirection, WebCore::ScrollGranularity);
354
355     // Notification that a popup was opened/closed.
356     void popupOpened(WebCore::PopupContainer* popupContainer);
357     void popupClosed(WebCore::PopupContainer* popupContainer);
358
359     void hideAutofillPopup();
360
361     // Returns the input event we're currently processing. This is used in some
362     // cases where the WebCore DOM event doesn't have the information we need.
363     static const WebInputEvent* currentInputEvent()
364     {
365         return m_currentInputEvent;
366     }
367
368 #if USE(ACCELERATED_COMPOSITING)
369     bool allowsAcceleratedCompositing();
370     bool pageHasRTLStyle() const;
371     void setRootGraphicsLayer(WebCore::GraphicsLayer*);
372     void setRootPlatformLayer(WebCore::PlatformLayer*);
373     void setRootLayerNeedsDisplay();
374     void scrollRootLayerRect(const WebCore::IntSize& scrollDelta, const WebCore::IntRect& clipRect);
375     void invalidateRootLayerRect(const WebCore::IntRect&);
376     void doUpdateAndComposite();
377 #endif
378
379     // Returns the onscreen 3D context used by the compositor. This is
380     // used by the renderer's code to set up resource sharing between
381     // the compositor's context and subordinate contexts for APIs like
382     // WebGL. Returns 0 if compositing support is not compiled in.
383     virtual WebGraphicsContext3D* graphicsContext3D();
384
385     virtual void setVisibilityState(WebPageVisibilityState, bool);
386
387     WebCore::PopupContainer* selectPopup() const { return m_selectPopup.get(); }
388
389     // Returns true if the event leads to scrolling.
390     static bool mapKeyCodeForScroll(int keyCode,
391                                    WebCore::ScrollDirection* scrollDirection,
392                                    WebCore::ScrollGranularity* scrollGranularity);
393
394     // Called by a full frame plugin inside this view to inform it that its
395     // zoom level has been updated.  The plugin should only call this function
396     // if the zoom change was triggered by the browser, it's only needed in case
397     // a plugin can update its own zoom, say because of its own UI.
398     void fullFramePluginZoomLevelChanged(double zoomLevel);
399
400 #if ENABLE(GESTURE_RECOGNIZER)
401     void resetGestureRecognizer();
402 #endif
403
404 private:
405     friend class WebView;  // So WebView::Create can call our constructor
406     friend class WTF::RefCounted<WebViewImpl>;
407
408     enum DragAction {
409       DragEnter,
410       DragOver
411     };
412
413     WebViewImpl(WebViewClient*);
414     virtual ~WebViewImpl();
415
416     // Returns true if the event was actually processed.
417     bool keyEventDefault(const WebKeyboardEvent&);
418
419     // Returns true if the autocomple has consumed the event.
420     bool autocompleteHandleKeyEvent(const WebKeyboardEvent&);
421
422     // Repaints the Autofill popup. Should be called when the suggestions
423     // have changed. Note that this should only be called when the Autofill
424     // popup is showing.
425     void refreshAutofillPopup();
426
427     // Returns true if the view was scrolled.
428     bool scrollViewWithKeyboard(int keyCode, int modifiers);
429
430     void hideSelectPopup();
431
432     // Converts |pos| from window coordinates to contents coordinates and gets
433     // the HitTestResult for it.
434     WebCore::HitTestResult hitTestResultForWindowPos(const WebCore::IntPoint&);
435
436     // Consolidate some common code between starting a drag over a target and
437     // updating a drag over a target. If we're starting a drag, |isEntering|
438     // should be true.
439     WebDragOperation dragTargetDragEnterOrOver(const WebPoint& clientPoint,
440                                                const WebPoint& screenPoint,
441                                                DragAction);
442
443 #if USE(ACCELERATED_COMPOSITING)
444     void setIsAcceleratedCompositingActive(bool);
445 #if !USE(THREADED_COMPOSITING)
446     void doComposite();
447 #endif
448     void doPixelReadbackToCanvas(WebCanvas*, const WebCore::IntRect&);
449     void reallocateRenderer();
450     void updateLayerTreeViewport();
451 #endif
452
453     WebViewClient* m_client;
454     WebAutofillClient* m_autofillClient;
455     WebPermissionClient* m_permissionClient;
456     WebSpellCheckClient* m_spellCheckClient;
457
458     ChromeClientImpl m_chromeClientImpl;
459     ContextMenuClientImpl m_contextMenuClientImpl;
460     DragClientImpl m_dragClientImpl;
461     EditorClientImpl m_editorClientImpl;
462     InspectorClientImpl m_inspectorClientImpl;
463
464     WebSize m_size;
465
466     WebPoint m_lastMousePosition;
467     OwnPtr<WebCore::Page> m_page;
468
469     // This flag is set when a new navigation is detected. It is used to satisfy
470     // the corresponding argument to WebFrameClient::didCommitProvisionalLoad.
471     bool m_observedNewNavigation;
472 #ifndef NDEBUG
473     // Used to assert that the new navigation we observed is the same navigation
474     // when we make use of m_observedNewNavigation.
475     const WebCore::DocumentLoader* m_newNavigationLoader;
476 #endif
477
478     // An object that can be used to manipulate m_page->settings() without linking
479     // against WebCore. This is lazily allocated the first time GetWebSettings()
480     // is called.
481     OwnPtr<WebSettingsImpl> m_webSettings;
482
483     // A copy of the web drop data object we received from the browser.
484     RefPtr<WebCore::ChromiumDataObject> m_currentDragData;
485
486     // The point relative to the client area where the mouse was last pressed
487     // down. This is used by the drag client to determine what was under the
488     // mouse when the drag was initiated. We need to track this here in
489     // WebViewImpl since DragClient::startDrag does not pass the position the
490     // mouse was at when the drag was initiated, only the current point, which
491     // can be misleading as it is usually not over the element the user actually
492     // dragged by the time a drag is initiated.
493     WebPoint m_lastMouseDownPoint;
494
495     // Keeps track of the current zoom level. 0 means no zoom, positive numbers
496     // mean zoom in, negative numbers mean zoom out.
497     double m_zoomLevel;
498
499     double m_minimumZoomLevel;
500
501     double m_maximumZoomLevel;
502
503     bool m_contextMenuAllowed;
504
505     bool m_doingDragAndDrop;
506
507     bool m_ignoreInputEvents;
508
509     // Webkit expects keyPress events to be suppressed if the associated keyDown
510     // event was handled. Safari implements this behavior by peeking out the
511     // associated WM_CHAR event if the keydown was handled. We emulate
512     // this behavior by setting this flag if the keyDown was handled.
513     bool m_suppressNextKeypressEvent;
514
515     // The policy for how this webview is to be initially shown.
516     WebNavigationPolicy m_initialNavigationPolicy;
517
518     // Represents whether or not this object should process incoming IME events.
519     bool m_imeAcceptEvents;
520
521     // The available drag operations (copy, move link...) allowed by the source.
522     WebDragOperation m_operationsAllowed;
523
524     // The current drag operation as negotiated by the source and destination.
525     // When not equal to DragOperationNone, the drag data can be dropped onto the
526     // current drop target in this WebView (the drop target can accept the drop).
527     WebDragOperation m_dragOperation;
528
529     // Whether an Autofill popup is currently showing.
530     bool m_autofillPopupShowing;
531
532     // The Autofill popup client.
533     OwnPtr<AutofillPopupMenuClient> m_autofillPopupClient;
534
535     // The Autofill popup.
536     RefPtr<WebCore::PopupContainer> m_autofillPopup;
537
538     // The popup associated with a select element.
539     RefPtr<WebCore::PopupContainer> m_selectPopup;
540
541     OwnPtr<WebDevToolsAgentPrivate> m_devToolsAgent;
542     OwnPtr<PageOverlay> m_pageOverlay;
543
544     // Whether the webview is rendering transparently.
545     bool m_isTransparent;
546
547     // Whether the user can press tab to focus links.
548     bool m_tabsToLinks;
549
550     // Inspector settings.
551     WebString m_inspectorSettings;
552
553     typedef HashMap<WTF::String, WTF::String> SettingsMap;
554     OwnPtr<SettingsMap> m_inspectorSettingsMap;
555     OwnPtr<DragScrollTimer> m_dragScrollTimer;
556
557 #if ENABLE(NOTIFICATIONS)
558     // The provider of desktop notifications;
559     NotificationPresenterImpl m_notificationPresenter;
560 #endif
561
562     // If set, the (plugin) node which has mouse capture.
563     RefPtr<WebCore::Node> m_mouseCaptureNode;
564
565 #if USE(ACCELERATED_COMPOSITING)
566     WebCore::IntRect m_rootLayerScrollDamage;
567     RefPtr<WebCore::CCLayerTreeHost> m_layerTreeHost;
568     WebCore::GraphicsLayer* m_rootGraphicsLayer;
569     bool m_isAcceleratedCompositingActive;
570     bool m_compositorCreationFailed;
571     // If true, the graphics context is being restored.
572     bool m_recreatingGraphicsContext;
573 #endif
574     static const WebInputEvent* m_currentInputEvent;
575
576 #if ENABLE(INPUT_SPEECH)
577     OwnPtr<SpeechInputClientImpl> m_speechInputClient;
578 #endif
579     // If we attempt to fetch the on-screen GraphicsContext3D before
580     // the compositor has been turned on, we need to instantiate it
581     // early. This member holds on to the GC3D in this case.
582     RefPtr<WebCore::GraphicsContext3D> m_temporaryOnscreenGraphicsContext3D;
583     OwnPtr<DeviceOrientationClientProxy> m_deviceOrientationClientProxy;
584     OwnPtr<GeolocationClientProxy> m_geolocationClientProxy;
585
586 #if ENABLE(GESTURE_RECOGNIZER)
587     OwnPtr<WebCore::PlatformGestureRecognizer> m_gestureRecognizer;
588 #endif
589 };
590
591 } // namespace WebKit
592
593 #endif