2011-04-11 Ryosuke Niwa <rniwa@webkit.org>
[WebKit-https.git] / Source / WebKit / chromium / src / WebViewImpl.cpp
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 #include "config.h"
32 #include "WebViewImpl.h"
33
34 #include "AutoFillPopupMenuClient.h"
35 #include "AXObjectCache.h"
36 #include "BackForwardListChromium.h"
37 #include "CSSStyleSelector.h"
38 #include "CSSValueKeywords.h"
39 #include "Chrome.h"
40 #include "ColorSpace.h"
41 #include "CompositionUnderlineVectorBuilder.h"
42 #include "ContextMenu.h"
43 #include "ContextMenuController.h"
44 #include "ContextMenuItem.h"
45 #include "Cursor.h"
46 #include "DOMUtilitiesPrivate.h"
47 #include "DeviceOrientationClientProxy.h"
48 #include "Document.h"
49 #include "DocumentLoader.h"
50 #include "DragController.h"
51 #include "DragData.h"
52 #include "DragScrollTimer.h"
53 #include "Editor.h"
54 #include "EventHandler.h"
55 #include "Extensions3D.h"
56 #include "FocusController.h"
57 #include "FontDescription.h"
58 #include "FrameLoader.h"
59 #include "FrameTree.h"
60 #include "FrameView.h"
61 #include "GeolocationClientProxy.h"
62 #include "GraphicsContext.h"
63 #include "GraphicsContext3D.h"
64 #include "GraphicsContext3DInternal.h"
65 #include "HTMLInputElement.h"
66 #include "HTMLMediaElement.h"
67 #include "HTMLNames.h"
68 #include "HitTestResult.h"
69 #include "Image.h"
70 #include "ImageBuffer.h"
71 #include "InspectorController.h"
72 #include "KeyboardCodes.h"
73 #include "KeyboardEvent.h"
74 #include "MIMETypeRegistry.h"
75 #include "NodeRenderStyle.h"
76 #include "Page.h"
77 #include "PageGroup.h"
78 #include "PageGroupLoadDeferrer.h"
79 #include "Pasteboard.h"
80 #include "PlatformContextSkia.h"
81 #include "PlatformKeyboardEvent.h"
82 #include "PlatformMouseEvent.h"
83 #include "PlatformThemeChromiumGtk.h"
84 #include "PlatformWheelEvent.h"
85 #include "PopupMenuChromium.h"
86 #include "PopupMenuClient.h"
87 #include "ProgressTracker.h"
88 #include "RenderView.h"
89 #include "ResourceHandle.h"
90 #include "SecurityOrigin.h"
91 #include "SelectionController.h"
92 #include "Settings.h"
93 #include "SpeechInputClientImpl.h"
94 #include "Timer.h"
95 #include "TraceEvent.h"
96 #include "TypingCommand.h"
97 #include "UserGestureIndicator.h"
98 #include "Vector.h"
99 #include "WebAccessibilityObject.h"
100 #include "WebAutoFillClient.h"
101 #include "WebDevToolsAgentImpl.h"
102 #include "WebDevToolsAgentPrivate.h"
103 #include "WebDragData.h"
104 #include "WebFrameImpl.h"
105 #include "WebImage.h"
106 #include "WebInputElement.h"
107 #include "WebInputEvent.h"
108 #include "WebInputEventConversion.h"
109 #include "WebKit.h"
110 #include "WebKitClient.h"
111 #include "WebMediaPlayerAction.h"
112 #include "WebNode.h"
113 #include "WebPlugin.h"
114 #include "WebPluginContainerImpl.h"
115 #include "WebPoint.h"
116 #include "WebPopupMenuImpl.h"
117 #include "WebRect.h"
118 #include "WebRuntimeFeatures.h"
119 #include "WebSettingsImpl.h"
120 #include "WebString.h"
121 #include "WebVector.h"
122 #include "WebViewClient.h"
123 #include "cc/CCHeadsUpDisplay.h"
124 #include <wtf/ByteArray.h>
125 #include <wtf/CurrentTime.h>
126 #include <wtf/RefPtr.h>
127
128 #if PLATFORM(CG)
129 #include <CoreGraphics/CGBitmapContext.h>
130 #include <CoreGraphics/CGContext.h>
131 #endif
132
133 #if OS(WINDOWS)
134 #include "RenderThemeChromiumWin.h"
135 #else
136 #if OS(LINUX) || OS(FREEBSD)
137 #include "RenderThemeChromiumLinux.h"
138 #endif
139 #include "RenderTheme.h"
140 #endif
141
142 // Get rid of WTF's pow define so we can use std::pow.
143 #undef pow
144 #include <cmath> // for std::pow
145
146 using namespace WebCore;
147
148 namespace {
149
150 GraphicsContext3D::Attributes getCompositorContextAttributes()
151 {
152     // Explicitly disable antialiasing for the compositor. As of the time of
153     // this writing, the only platform that supported antialiasing for the
154     // compositor was Mac OS X, because the on-screen OpenGL context creation
155     // code paths on Windows and Linux didn't yet have multisampling support.
156     // Mac OS X essentially always behaves as though it's rendering offscreen.
157     // Multisampling has a heavy cost especially on devices with relatively low
158     // fill rate like most notebooks, and the Mac implementation would need to
159     // be optimized to resolve directly into the IOSurface shared between the
160     // GPU and browser processes. For these reasons and to avoid platform
161     // disparities we explicitly disable antialiasing.
162     GraphicsContext3D::Attributes attributes;
163     attributes.antialias = false;
164     return attributes;
165 }
166
167 } // anonymous namespace
168
169 namespace WebKit {
170
171 // Change the text zoom level by kTextSizeMultiplierRatio each time the user
172 // zooms text in or out (ie., change by 20%).  The min and max values limit
173 // text zoom to half and 3x the original text size.  These three values match
174 // those in Apple's port in WebKit/WebKit/WebView/WebView.mm
175 const double WebView::textSizeMultiplierRatio = 1.2;
176 const double WebView::minTextSizeMultiplier = 0.5;
177 const double WebView::maxTextSizeMultiplier = 3.0;
178
179
180 // The group name identifies a namespace of pages.  Page group is used on OSX
181 // for some programs that use HTML views to display things that don't seem like
182 // web pages to the user (so shouldn't have visited link coloring).  We only use
183 // one page group.
184 const char* pageGroupName = "default";
185
186 // Used to defer all page activity in cases where the embedder wishes to run
187 // a nested event loop. Using a stack enables nesting of message loop invocations.
188 static Vector<PageGroupLoadDeferrer*> pageGroupLoadDeferrerStack;
189
190 // Ensure that the WebDragOperation enum values stay in sync with the original
191 // DragOperation constants.
192 #define COMPILE_ASSERT_MATCHING_ENUM(coreName) \
193     COMPILE_ASSERT(int(coreName) == int(Web##coreName), dummy##coreName)
194 COMPILE_ASSERT_MATCHING_ENUM(DragOperationNone);
195 COMPILE_ASSERT_MATCHING_ENUM(DragOperationCopy);
196 COMPILE_ASSERT_MATCHING_ENUM(DragOperationLink);
197 COMPILE_ASSERT_MATCHING_ENUM(DragOperationGeneric);
198 COMPILE_ASSERT_MATCHING_ENUM(DragOperationPrivate);
199 COMPILE_ASSERT_MATCHING_ENUM(DragOperationMove);
200 COMPILE_ASSERT_MATCHING_ENUM(DragOperationDelete);
201 COMPILE_ASSERT_MATCHING_ENUM(DragOperationEvery);
202
203 static const PopupContainerSettings autoFillPopupSettings = {
204     false, // setTextOnIndexChange
205     false, // acceptOnAbandon
206     true, // loopSelectionNavigation
207     false // restrictWidthOfListBox (For security reasons show the entire entry
208           // so the user doesn't enter information he did not intend to.)
209 };
210
211 static bool shouldUseExternalPopupMenus = false;
212
213 // WebView ----------------------------------------------------------------
214
215 WebView* WebView::create(WebViewClient* client)
216 {
217     // Keep runtime flag for device motion turned off until it's implemented.
218     WebRuntimeFeatures::enableDeviceMotion(false);
219
220     // Pass the WebViewImpl's self-reference to the caller.
221     return adoptRef(new WebViewImpl(client)).leakRef();
222 }
223
224 void WebView::setUseExternalPopupMenus(bool useExternalPopupMenus)
225 {
226     shouldUseExternalPopupMenus = useExternalPopupMenus;
227 }
228
229 void WebView::updateVisitedLinkState(unsigned long long linkHash)
230 {
231     Page::visitedStateChanged(PageGroup::pageGroup(pageGroupName), linkHash);
232 }
233
234 void WebView::resetVisitedLinkState()
235 {
236     Page::allVisitedStateChanged(PageGroup::pageGroup(pageGroupName));
237 }
238
239 void WebView::willEnterModalLoop()
240 {
241     PageGroup* pageGroup = PageGroup::pageGroup(pageGroupName);
242     ASSERT(pageGroup);
243
244     if (pageGroup->pages().isEmpty())
245         pageGroupLoadDeferrerStack.append(static_cast<PageGroupLoadDeferrer*>(0));
246     else {
247         // Pick any page in the page group since we are deferring all pages.
248         pageGroupLoadDeferrerStack.append(new PageGroupLoadDeferrer(*pageGroup->pages().begin(), true));
249     }
250 }
251
252 void WebView::didExitModalLoop()
253 {
254     ASSERT(pageGroupLoadDeferrerStack.size());
255
256     delete pageGroupLoadDeferrerStack.last();
257     pageGroupLoadDeferrerStack.removeLast();
258 }
259
260 void WebViewImpl::initializeMainFrame(WebFrameClient* frameClient)
261 {
262     // NOTE: The WebFrameImpl takes a reference to itself within InitMainFrame
263     // and releases that reference once the corresponding Frame is destroyed.
264     RefPtr<WebFrameImpl> frame = WebFrameImpl::create(frameClient);
265
266     frame->initializeAsMainFrame(this);
267
268     // Restrict the access to the local file system
269     // (see WebView.mm WebView::_commonInitializationWithFrameName).
270     SecurityOrigin::setLocalLoadPolicy(SecurityOrigin::AllowLocalLoadsForLocalOnly);
271 }
272
273 void WebViewImpl::setDevToolsAgentClient(WebDevToolsAgentClient* devToolsClient) 
274 {
275     if (devToolsClient)
276         m_devToolsAgent = new WebDevToolsAgentImpl(this, devToolsClient);
277     else
278         m_devToolsAgent.clear();
279 }
280
281 void WebViewImpl::setAutoFillClient(WebAutoFillClient* autoFillClient)
282 {
283     m_autoFillClient = autoFillClient;
284 }
285
286 void WebViewImpl::setSpellCheckClient(WebSpellCheckClient* spellCheckClient)
287 {
288     m_spellCheckClient = spellCheckClient;
289 }
290
291 WebViewImpl::WebViewImpl(WebViewClient* client)
292     : m_client(client)
293     , m_autoFillClient(0)
294     , m_spellCheckClient(0)
295     , m_chromeClientImpl(this)
296     , m_contextMenuClientImpl(this)
297     , m_dragClientImpl(this)
298     , m_editorClientImpl(this)
299     , m_inspectorClientImpl(this)
300     , m_observedNewNavigation(false)
301 #ifndef NDEBUG
302     , m_newNavigationLoader(0)
303 #endif
304     , m_zoomLevel(0)
305     , m_minimumZoomLevel(zoomFactorToZoomLevel(minTextSizeMultiplier))
306     , m_maximumZoomLevel(zoomFactorToZoomLevel(maxTextSizeMultiplier))
307     , m_contextMenuAllowed(false)
308     , m_doingDragAndDrop(false)
309     , m_ignoreInputEvents(false)
310     , m_suppressNextKeypressEvent(false)
311     , m_initialNavigationPolicy(WebNavigationPolicyIgnore)
312     , m_imeAcceptEvents(true)
313     , m_operationsAllowed(WebDragOperationNone)
314     , m_dragOperation(WebDragOperationNone)
315     , m_autoFillPopupShowing(false)
316     , m_autoFillPopupClient(0)
317     , m_autoFillPopup(0)
318     , m_isTransparent(false)
319     , m_tabsToLinks(false)
320     , m_dragScrollTimer(new DragScrollTimer())
321 #if USE(ACCELERATED_COMPOSITING)
322     , m_layerRenderer(0)
323     , m_isAcceleratedCompositingActive(false)
324     , m_compositorCreationFailed(false)
325     , m_recreatingGraphicsContext(false)
326 #endif
327 #if ENABLE(INPUT_SPEECH)
328     , m_speechInputClient(SpeechInputClientImpl::create(client))
329 #endif
330     , m_deviceOrientationClientProxy(new DeviceOrientationClientProxy(client ? client->deviceOrientationClient() : 0))
331     , m_geolocationClientProxy(new GeolocationClientProxy(client ? client->geolocationClient() : 0))
332 {
333     // WebKit/win/WebView.cpp does the same thing, except they call the
334     // KJS specific wrapper around this method. We need to have threading
335     // initialized because CollatorICU requires it.
336     WTF::initializeThreading();
337     WTF::initializeMainThread();
338
339     // set to impossible point so we always get the first mouse pos
340     m_lastMousePosition = WebPoint(-1, -1);
341
342     Page::PageClients pageClients;
343     pageClients.chromeClient = &m_chromeClientImpl;
344     pageClients.contextMenuClient = &m_contextMenuClientImpl;
345     pageClients.editorClient = &m_editorClientImpl;
346     pageClients.dragClient = &m_dragClientImpl;
347     pageClients.inspectorClient = &m_inspectorClientImpl;
348 #if ENABLE(INPUT_SPEECH)
349     pageClients.speechInputClient = m_speechInputClient.get();
350 #endif
351     pageClients.deviceOrientationClient = m_deviceOrientationClientProxy.get();
352     pageClients.geolocationClient = m_geolocationClientProxy.get();
353     pageClients.backForwardClient = BackForwardListChromium::create(this);
354
355     m_page.set(new Page(pageClients));
356
357     m_geolocationClientProxy->setController(m_page->geolocationController());
358
359     m_page->setGroupName(pageGroupName);
360
361     m_inspectorSettingsMap.set(new SettingsMap);
362 }
363
364 WebViewImpl::~WebViewImpl()
365 {
366     ASSERT(!m_page);
367 }
368
369 RenderTheme* WebViewImpl::theme() const
370 {
371     return m_page.get() ? m_page->theme() : RenderTheme::defaultTheme().get();
372 }
373
374 WebFrameImpl* WebViewImpl::mainFrameImpl()
375 {
376     return m_page.get() ? WebFrameImpl::fromFrame(m_page->mainFrame()) : 0;
377 }
378
379 bool WebViewImpl::tabKeyCyclesThroughElements() const
380 {
381     ASSERT(m_page.get());
382     return m_page->tabKeyCyclesThroughElements();
383 }
384
385 void WebViewImpl::setTabKeyCyclesThroughElements(bool value)
386 {
387     if (m_page)
388         m_page->setTabKeyCyclesThroughElements(value);
389 }
390
391 void WebViewImpl::mouseMove(const WebMouseEvent& event)
392 {
393     if (!mainFrameImpl() || !mainFrameImpl()->frameView())
394         return;
395
396     m_lastMousePosition = WebPoint(event.x, event.y);
397
398     // We call mouseMoved here instead of handleMouseMovedEvent because we need
399     // our ChromeClientImpl to receive changes to the mouse position and
400     // tooltip text, and mouseMoved handles all of that.
401     mainFrameImpl()->frame()->eventHandler()->mouseMoved(
402         PlatformMouseEventBuilder(mainFrameImpl()->frameView(), event));
403 }
404
405 void WebViewImpl::mouseLeave(const WebMouseEvent& event)
406 {
407     // This event gets sent as the main frame is closing.  In that case, just
408     // ignore it.
409     if (!mainFrameImpl() || !mainFrameImpl()->frameView())
410         return;
411
412     m_client->setMouseOverURL(WebURL());
413
414     mainFrameImpl()->frame()->eventHandler()->handleMouseMoveEvent(
415         PlatformMouseEventBuilder(mainFrameImpl()->frameView(), event));
416 }
417
418 void WebViewImpl::mouseDown(const WebMouseEvent& event)
419 {
420     if (!mainFrameImpl() || !mainFrameImpl()->frameView())
421         return;
422
423     // If there is a select popup open, close it as the user is clicking on
424     // the page (outside of the popup).  We also save it so we can prevent a
425     // click on the select element from immediately reopening the popup.
426     RefPtr<WebCore::PopupContainer> selectPopup;
427     if (event.button == WebMouseEvent::ButtonLeft) {
428         selectPopup = m_selectPopup;
429         hideSelectPopup();
430         ASSERT(!m_selectPopup);
431     }
432
433     m_lastMouseDownPoint = WebPoint(event.x, event.y);
434
435     RefPtr<Node> clickedNode;
436     if (event.button == WebMouseEvent::ButtonLeft) {
437         IntPoint point(event.x, event.y);
438         point = m_page->mainFrame()->view()->windowToContents(point);
439         HitTestResult result(m_page->mainFrame()->eventHandler()->hitTestResultAtPoint(point, false));
440         Node* hitNode = result.innerNonSharedNode();
441
442         // Take capture on a mouse down on a plugin so we can send it mouse events.
443         if (hitNode && hitNode->renderer() && hitNode->renderer()->isEmbeddedObject())
444             m_mouseCaptureNode = hitNode;
445
446         // If a text field that has focus is clicked again, we should display the
447         // AutoFill popup.
448         RefPtr<Node> focusedNode = focusedWebCoreNode();
449         if (focusedNode.get() && toHTMLInputElement(focusedNode.get())) {
450             if (hitNode == focusedNode) {
451                 // Already focused text field was clicked, let's remember this.  If
452                 // focus has not changed after the mouse event is processed, we'll
453                 // trigger the autocomplete.
454                 clickedNode = focusedNode;
455             }
456         }
457     }
458
459     mainFrameImpl()->frame()->loader()->resetMultipleFormSubmissionProtection();
460
461     mainFrameImpl()->frame()->eventHandler()->handleMousePressEvent(
462         PlatformMouseEventBuilder(mainFrameImpl()->frameView(), event));
463
464     if (clickedNode.get() && clickedNode == focusedWebCoreNode()) {
465         // Focus has not changed, show the AutoFill popup.
466         static_cast<EditorClientImpl*>(m_page->editorClient())->
467             showFormAutofillForNode(clickedNode.get());
468     }
469     if (m_selectPopup && m_selectPopup == selectPopup) {
470         // That click triggered a select popup which is the same as the one that
471         // was showing before the click.  It means the user clicked the select
472         // while the popup was showing, and as a result we first closed then
473         // immediately reopened the select popup.  It needs to be closed.
474         hideSelectPopup();
475     }
476
477     // Dispatch the contextmenu event regardless of if the click was swallowed.
478     // On Windows, we handle it on mouse up, not down.
479 #if OS(DARWIN)
480     if (event.button == WebMouseEvent::ButtonRight
481         || (event.button == WebMouseEvent::ButtonLeft
482             && event.modifiers & WebMouseEvent::ControlKey))
483         mouseContextMenu(event);
484 #elif OS(LINUX) || OS(FREEBSD)
485     if (event.button == WebMouseEvent::ButtonRight)
486         mouseContextMenu(event);
487 #endif
488 }
489
490 void WebViewImpl::mouseContextMenu(const WebMouseEvent& event)
491 {
492     if (!mainFrameImpl() || !mainFrameImpl()->frameView())
493         return;
494
495     m_page->contextMenuController()->clearContextMenu();
496
497     PlatformMouseEventBuilder pme(mainFrameImpl()->frameView(), event);
498
499     // Find the right target frame. See issue 1186900.
500     HitTestResult result = hitTestResultForWindowPos(pme.pos());
501     Frame* targetFrame;
502     if (result.innerNonSharedNode())
503         targetFrame = result.innerNonSharedNode()->document()->frame();
504     else
505         targetFrame = m_page->focusController()->focusedOrMainFrame();
506
507 #if OS(WINDOWS)
508     targetFrame->view()->setCursor(pointerCursor());
509 #endif
510
511     m_contextMenuAllowed = true;
512     targetFrame->eventHandler()->sendContextMenuEvent(pme);
513     m_contextMenuAllowed = false;
514     // Actually showing the context menu is handled by the ContextMenuClient
515     // implementation...
516 }
517
518 void WebViewImpl::mouseUp(const WebMouseEvent& event)
519 {
520     if (!mainFrameImpl() || !mainFrameImpl()->frameView())
521         return;
522
523 #if OS(LINUX) || OS(FREEBSD)
524     // If the event was a middle click, attempt to copy text into the focused
525     // frame. We execute this before we let the page have a go at the event
526     // because the page may change what is focused during in its event handler.
527     //
528     // This code is in the mouse up handler. There is some debate about putting
529     // this here, as opposed to the mouse down handler.
530     //   xterm: pastes on up.
531     //   GTK: pastes on down.
532     //   Firefox: pastes on up.
533     //   Midori: couldn't paste at all with 0.1.2
534     //
535     // There is something of a webcompat angle to this well, as highlighted by
536     // crbug.com/14608. Pages can clear text boxes 'onclick' and, if we paste on
537     // down then the text is pasted just before the onclick handler runs and
538     // clears the text box. So it's important this happens after the
539     // handleMouseReleaseEvent() earlier in this function
540     if (event.button == WebMouseEvent::ButtonMiddle) {
541         Frame* focused = focusedWebCoreFrame();
542         FrameView* view = m_page->mainFrame()->view();
543         IntPoint clickPoint(m_lastMouseDownPoint.x, m_lastMouseDownPoint.y);
544         IntPoint contentPoint = view->windowToContents(clickPoint);
545         HitTestResult hitTestResult = focused->eventHandler()->hitTestResultAtPoint(contentPoint, false, false, ShouldHitTestScrollbars);
546         // We don't want to send a paste when middle clicking a scroll bar or a
547         // link (which will navigate later in the code).  The main scrollbars
548         // have to be handled separately.
549         if (!hitTestResult.scrollbar() && !hitTestResult.isLiveLink() && focused && !view->scrollbarAtPoint(clickPoint)) {
550             Editor* editor = focused->editor();
551             Pasteboard* pasteboard = Pasteboard::generalPasteboard();
552             bool oldSelectionMode = pasteboard->isSelectionMode();
553             pasteboard->setSelectionMode(true);
554             editor->command(AtomicString("Paste")).execute();
555             pasteboard->setSelectionMode(oldSelectionMode);
556         }
557     }
558 #endif
559
560     mainFrameImpl()->frame()->eventHandler()->handleMouseReleaseEvent(
561         PlatformMouseEventBuilder(mainFrameImpl()->frameView(), event));
562
563 #if OS(WINDOWS)
564     // Dispatch the contextmenu event regardless of if the click was swallowed.
565     // On Mac/Linux, we handle it on mouse down, not up.
566     if (event.button == WebMouseEvent::ButtonRight)
567         mouseContextMenu(event);
568 #endif
569 }
570
571 bool WebViewImpl::mouseWheel(const WebMouseWheelEvent& event)
572 {
573     PlatformWheelEventBuilder platformEvent(mainFrameImpl()->frameView(), event);
574     return mainFrameImpl()->frame()->eventHandler()->handleWheelEvent(platformEvent);
575 }
576
577 bool WebViewImpl::keyEvent(const WebKeyboardEvent& event)
578 {
579     ASSERT((event.type == WebInputEvent::RawKeyDown)
580         || (event.type == WebInputEvent::KeyDown)
581         || (event.type == WebInputEvent::KeyUp));
582
583     // Please refer to the comments explaining the m_suppressNextKeypressEvent
584     // member.
585     // The m_suppressNextKeypressEvent is set if the KeyDown is handled by
586     // Webkit. A keyDown event is typically associated with a keyPress(char)
587     // event and a keyUp event. We reset this flag here as this is a new keyDown
588     // event.
589     m_suppressNextKeypressEvent = false;
590
591     // Give any select popup a chance at consuming the key event.
592     if (selectPopupHandleKeyEvent(event))
593         return true;
594
595     // Give Autocomplete a chance to consume the key events it is interested in.
596     if (autocompleteHandleKeyEvent(event))
597         return true;
598
599     Frame* frame = focusedWebCoreFrame();
600     if (!frame)
601         return false;
602
603     EventHandler* handler = frame->eventHandler();
604     if (!handler)
605         return keyEventDefault(event);
606
607 #if OS(WINDOWS) || OS(LINUX) || OS(FREEBSD)
608     const WebInputEvent::Type contextMenuTriggeringEventType =
609 #if OS(WINDOWS)
610         WebInputEvent::KeyUp;
611 #elif OS(LINUX) || OS(FREEBSD)
612         WebInputEvent::RawKeyDown;
613 #endif
614
615     bool isUnmodifiedMenuKey = !(event.modifiers & WebInputEvent::InputModifiers) && event.windowsKeyCode == VKEY_APPS;
616     bool isShiftF10 = event.modifiers == WebInputEvent::ShiftKey && event.windowsKeyCode == VKEY_F10;
617     if ((isUnmodifiedMenuKey || isShiftF10) && event.type == contextMenuTriggeringEventType) {
618         sendContextMenuEvent(event);
619         return true;
620     }
621 #endif // OS(WINDOWS) || OS(LINUX) || OS(FREEBSD)
622
623     PlatformKeyboardEventBuilder evt(event);
624
625     if (handler->keyEvent(evt)) {
626         if (WebInputEvent::RawKeyDown == event.type) {
627             // Suppress the next keypress event unless the focused node is a plug-in node.
628             // (Flash needs these keypress events to handle non-US keyboards.)
629             Node* node = frame->document()->focusedNode();
630             if (!node || !node->renderer() || !node->renderer()->isEmbeddedObject())
631                 m_suppressNextKeypressEvent = true;
632         }
633         return true;
634     }
635
636     return keyEventDefault(event);
637 }
638
639 bool WebViewImpl::selectPopupHandleKeyEvent(const WebKeyboardEvent& event)
640 {
641     if (!m_selectPopup)
642         return false;
643
644     return m_selectPopup->handleKeyEvent(PlatformKeyboardEventBuilder(event));
645 }
646
647 bool WebViewImpl::autocompleteHandleKeyEvent(const WebKeyboardEvent& event)
648 {
649     if (!m_autoFillPopupShowing
650         // Home and End should be left to the text field to process.
651         || event.windowsKeyCode == VKEY_HOME
652         || event.windowsKeyCode == VKEY_END)
653       return false;
654
655     // Pressing delete triggers the removal of the selected suggestion from the DB.
656     if (event.windowsKeyCode == VKEY_DELETE
657         && m_autoFillPopup->selectedIndex() != -1) {
658         Node* node = focusedWebCoreNode();
659         if (!node || (node->nodeType() != Node::ELEMENT_NODE)) {
660             ASSERT_NOT_REACHED();
661             return false;
662         }
663         Element* element = static_cast<Element*>(node);
664         if (!element->hasLocalName(HTMLNames::inputTag)) {
665             ASSERT_NOT_REACHED();
666             return false;
667         }
668
669         int selectedIndex = m_autoFillPopup->selectedIndex();
670
671         if (!m_autoFillPopupClient->canRemoveSuggestionAtIndex(selectedIndex))
672             return false;
673
674         WebString name = WebInputElement(static_cast<HTMLInputElement*>(element)).nameForAutofill();
675         WebString value = m_autoFillPopupClient->itemText(selectedIndex);
676         m_autoFillClient->removeAutocompleteSuggestion(name, value);
677         // Update the entries in the currently showing popup to reflect the
678         // deletion.
679         m_autoFillPopupClient->removeSuggestionAtIndex(selectedIndex);
680         refreshAutoFillPopup();
681         return false;
682     }
683
684     if (!m_autoFillPopup->isInterestedInEventForKey(event.windowsKeyCode))
685         return false;
686
687     if (m_autoFillPopup->handleKeyEvent(PlatformKeyboardEventBuilder(event))) {
688         // We need to ignore the next Char event after this otherwise pressing
689         // enter when selecting an item in the menu will go to the page.
690         if (WebInputEvent::RawKeyDown == event.type)
691             m_suppressNextKeypressEvent = true;
692         return true;
693     }
694
695     return false;
696 }
697
698 bool WebViewImpl::charEvent(const WebKeyboardEvent& event)
699 {
700     ASSERT(event.type == WebInputEvent::Char);
701
702     // Please refer to the comments explaining the m_suppressNextKeypressEvent
703     // member.  The m_suppressNextKeypressEvent is set if the KeyDown is
704     // handled by Webkit. A keyDown event is typically associated with a
705     // keyPress(char) event and a keyUp event. We reset this flag here as it
706     // only applies to the current keyPress event.
707     bool suppress = m_suppressNextKeypressEvent;
708     m_suppressNextKeypressEvent = false;
709
710     Frame* frame = focusedWebCoreFrame();
711     if (!frame)
712         return suppress;
713
714     EventHandler* handler = frame->eventHandler();
715     if (!handler)
716         return suppress || keyEventDefault(event);
717
718     PlatformKeyboardEventBuilder evt(event);
719     if (!evt.isCharacterKey())
720         return true;
721
722     // Accesskeys are triggered by char events and can't be suppressed.
723     if (handler->handleAccessKey(evt))
724         return true;
725
726     // Safari 3.1 does not pass off windows system key messages (WM_SYSCHAR) to
727     // the eventHandler::keyEvent. We mimic this behavior on all platforms since
728     // for now we are converting other platform's key events to windows key
729     // events.
730     if (evt.isSystemKey())
731         return false;
732
733     if (!suppress && !handler->keyEvent(evt))
734         return keyEventDefault(event);
735
736     return true;
737 }
738
739 #if ENABLE(TOUCH_EVENTS)
740 bool WebViewImpl::touchEvent(const WebTouchEvent& event)
741 {
742     if (!mainFrameImpl() || !mainFrameImpl()->frameView())
743         return false;
744
745     PlatformTouchEventBuilder touchEventBuilder(mainFrameImpl()->frameView(), event);
746     return mainFrameImpl()->frame()->eventHandler()->handleTouchEvent(touchEventBuilder);
747 }
748 #endif
749
750 #if OS(WINDOWS) || OS(LINUX) || OS(FREEBSD)
751 // Mac has no way to open a context menu based on a keyboard event.
752 bool WebViewImpl::sendContextMenuEvent(const WebKeyboardEvent& event)
753 {
754     // The contextMenuController() holds onto the last context menu that was
755     // popped up on the page until a new one is created. We need to clear
756     // this menu before propagating the event through the DOM so that we can
757     // detect if we create a new menu for this event, since we won't create
758     // a new menu if the DOM swallows the event and the defaultEventHandler does
759     // not run.
760     page()->contextMenuController()->clearContextMenu();
761
762     m_contextMenuAllowed = true;
763     Frame* focusedFrame = page()->focusController()->focusedOrMainFrame();
764     bool handled = focusedFrame->eventHandler()->sendContextMenuEventForKey();
765     m_contextMenuAllowed = false;
766     return handled;
767 }
768 #endif
769
770 bool WebViewImpl::keyEventDefault(const WebKeyboardEvent& event)
771 {
772     Frame* frame = focusedWebCoreFrame();
773     if (!frame)
774         return false;
775
776     switch (event.type) {
777     case WebInputEvent::Char:
778         if (event.windowsKeyCode == VKEY_SPACE) {
779             int keyCode = ((event.modifiers & WebInputEvent::ShiftKey) ? VKEY_PRIOR : VKEY_NEXT);
780             return scrollViewWithKeyboard(keyCode, event.modifiers);
781         }
782         break;
783     case WebInputEvent::RawKeyDown:
784         if (event.modifiers == WebInputEvent::ControlKey) {
785             switch (event.windowsKeyCode) {
786 #if !OS(DARWIN)
787             case 'A':
788                 focusedFrame()->executeCommand(WebString::fromUTF8("SelectAll"));
789                 return true;
790             case VKEY_INSERT:
791             case 'C':
792                 focusedFrame()->executeCommand(WebString::fromUTF8("Copy"));
793                 return true;
794 #endif
795             // Match FF behavior in the sense that Ctrl+home/end are the only Ctrl
796             // key combinations which affect scrolling. Safari is buggy in the
797             // sense that it scrolls the page for all Ctrl+scrolling key
798             // combinations. For e.g. Ctrl+pgup/pgdn/up/down, etc.
799             case VKEY_HOME:
800             case VKEY_END:
801                 break;
802             default:
803                 return false;
804             }
805         }
806         if (!event.isSystemKey && !(event.modifiers & WebInputEvent::ShiftKey))
807             return scrollViewWithKeyboard(event.windowsKeyCode, event.modifiers);
808         break;
809     default:
810         break;
811     }
812     return false;
813 }
814
815 bool WebViewImpl::scrollViewWithKeyboard(int keyCode, int modifiers)
816 {
817     ScrollDirection scrollDirection;
818     ScrollGranularity scrollGranularity;
819 #if OS(DARWIN)
820     // Control-Up/Down should be PageUp/Down on Mac.
821     if (modifiers & WebMouseEvent::ControlKey) {
822       if (keyCode == VKEY_UP)
823         keyCode = VKEY_PRIOR;
824       else if (keyCode == VKEY_DOWN)
825         keyCode = VKEY_NEXT;
826     }
827 #endif
828     if (!mapKeyCodeForScroll(keyCode, &scrollDirection, &scrollGranularity))
829         return false;
830     return propagateScroll(scrollDirection, scrollGranularity);
831 }
832
833 bool WebViewImpl::mapKeyCodeForScroll(int keyCode,
834                                       WebCore::ScrollDirection* scrollDirection,
835                                       WebCore::ScrollGranularity* scrollGranularity)
836 {
837     switch (keyCode) {
838     case VKEY_LEFT:
839         *scrollDirection = ScrollLeft;
840         *scrollGranularity = ScrollByLine;
841         break;
842     case VKEY_RIGHT:
843         *scrollDirection = ScrollRight;
844         *scrollGranularity = ScrollByLine;
845         break;
846     case VKEY_UP:
847         *scrollDirection = ScrollUp;
848         *scrollGranularity = ScrollByLine;
849         break;
850     case VKEY_DOWN:
851         *scrollDirection = ScrollDown;
852         *scrollGranularity = ScrollByLine;
853         break;
854     case VKEY_HOME:
855         *scrollDirection = ScrollUp;
856         *scrollGranularity = ScrollByDocument;
857         break;
858     case VKEY_END:
859         *scrollDirection = ScrollDown;
860         *scrollGranularity = ScrollByDocument;
861         break;
862     case VKEY_PRIOR:  // page up
863         *scrollDirection = ScrollUp;
864         *scrollGranularity = ScrollByPage;
865         break;
866     case VKEY_NEXT:  // page down
867         *scrollDirection = ScrollDown;
868         *scrollGranularity = ScrollByPage;
869         break;
870     default:
871         return false;
872     }
873
874     return true;
875 }
876
877 void WebViewImpl::hideSelectPopup()
878 {
879     if (m_selectPopup.get())
880         m_selectPopup->hidePopup();
881 }
882
883 bool WebViewImpl::propagateScroll(ScrollDirection scrollDirection,
884                                   ScrollGranularity scrollGranularity)
885 {
886     Frame* frame = focusedWebCoreFrame();
887     if (!frame)
888         return false;
889
890     bool scrollHandled = frame->eventHandler()->scrollOverflow(scrollDirection, scrollGranularity);
891     Frame* currentFrame = frame;
892     while (!scrollHandled && currentFrame) {
893         scrollHandled = currentFrame->view()->scroll(scrollDirection, scrollGranularity);
894         currentFrame = currentFrame->tree()->parent();
895     }
896     return scrollHandled;
897 }
898
899 void  WebViewImpl::popupOpened(WebCore::PopupContainer* popupContainer)
900 {
901     if (popupContainer->popupType() == WebCore::PopupContainer::Select) {
902         ASSERT(!m_selectPopup);
903         m_selectPopup = popupContainer;
904     }
905 }
906
907 void  WebViewImpl::popupClosed(WebCore::PopupContainer* popupContainer)
908 {
909     if (popupContainer->popupType() == WebCore::PopupContainer::Select) {
910         ASSERT(m_selectPopup.get());
911         m_selectPopup = 0;
912     }
913 }
914
915 void WebViewImpl::hideAutoFillPopup()
916 {
917     if (m_autoFillPopupShowing) {
918         m_autoFillPopup->hidePopup();
919         m_autoFillPopupShowing = false;
920     }
921 }
922
923 Frame* WebViewImpl::focusedWebCoreFrame() const
924 {
925     return m_page.get() ? m_page->focusController()->focusedOrMainFrame() : 0;
926 }
927
928 WebViewImpl* WebViewImpl::fromPage(Page* page)
929 {
930     if (!page)
931         return 0;
932
933     return static_cast<ChromeClientImpl*>(page->chrome()->client())->webView();
934 }
935
936 // WebWidget ------------------------------------------------------------------
937
938 void WebViewImpl::close()
939 {
940     RefPtr<WebFrameImpl> mainFrameImpl;
941
942     if (m_page.get()) {
943         // Initiate shutdown for the entire frameset.  This will cause a lot of
944         // notifications to be sent.
945         if (m_page->mainFrame()) {
946             mainFrameImpl = WebFrameImpl::fromFrame(m_page->mainFrame());
947             m_page->mainFrame()->loader()->frameDetached();
948         }
949         m_page.clear();
950     }
951
952     // Should happen after m_page.clear().
953     if (m_devToolsAgent.get())
954         m_devToolsAgent.clear();
955
956     // Reset the delegate to prevent notifications being sent as we're being
957     // deleted.
958     m_client = 0;
959
960     deref();  // Balances ref() acquired in WebView::create
961 }
962
963 void WebViewImpl::resize(const WebSize& newSize)
964 {
965     if (m_size == newSize)
966         return;
967     m_size = newSize;
968
969     if (mainFrameImpl()->frameView()) {
970         mainFrameImpl()->frameView()->resize(m_size.width, m_size.height);
971         mainFrameImpl()->frame()->eventHandler()->sendResizeEvent();
972     }
973
974     if (m_client) {
975         if (isAcceleratedCompositingActive()) {
976 #if USE(ACCELERATED_COMPOSITING)
977             updateLayerRendererViewport();
978 #endif
979         } else {
980             WebRect damagedRect(0, 0, m_size.width, m_size.height);
981             m_client->didInvalidateRect(damagedRect);
982         }
983     }
984
985 #if USE(ACCELERATED_COMPOSITING)
986     if (m_layerRenderer && isAcceleratedCompositingActive()) {
987         m_layerRenderer->resizeOnscreenContent(IntSize(std::max(1, m_size.width),
988                                                        std::max(1, m_size.height)));
989     }
990 #endif
991 }
992
993 void WebViewImpl::animate()
994 {
995 #if ENABLE(REQUEST_ANIMATION_FRAME)
996     WebFrameImpl* webframe = mainFrameImpl();
997     if (webframe) {
998         FrameView* view = webframe->frameView();
999         if (view)
1000             view->serviceScriptedAnimations(convertSecondsToDOMTimeStamp(currentTime()));
1001     }
1002 #endif
1003 }
1004
1005 void WebViewImpl::layout()
1006 {
1007 #if USE(ACCELERATED_COMPOSITING)
1008     // FIXME: RTL style not supported by the compositor yet.
1009     if (isAcceleratedCompositingActive() && pageHasRTLStyle())
1010         setIsAcceleratedCompositingActive(false);
1011 #endif
1012
1013     WebFrameImpl* webframe = mainFrameImpl();
1014     if (webframe) {
1015         // In order for our child HWNDs (NativeWindowWidgets) to update properly,
1016         // they need to be told that we are updating the screen.  The problem is
1017         // that the native widgets need to recalculate their clip region and not
1018         // overlap any of our non-native widgets.  To force the resizing, call
1019         // setFrameRect().  This will be a quick operation for most frames, but
1020         // the NativeWindowWidgets will update a proper clipping region.
1021         FrameView* view = webframe->frameView();
1022         if (view)
1023             view->setFrameRect(view->frameRect());
1024
1025         // setFrameRect may have the side-effect of causing existing page
1026         // layout to be invalidated, so layout needs to be called last.
1027
1028         webframe->layout();
1029     }
1030 }
1031
1032 #if USE(ACCELERATED_COMPOSITING)
1033 void WebViewImpl::doPixelReadbackToCanvas(WebCanvas* canvas, const IntRect& rect)
1034 {
1035 #if USE(SKIA)
1036     PlatformContextSkia context(canvas);
1037
1038     // PlatformGraphicsContext is actually a pointer to PlatformContextSkia
1039     GraphicsContext gc(reinterpret_cast<PlatformGraphicsContext*>(&context));
1040     int bitmapHeight = canvas->getDevice()->accessBitmap(false).height();
1041 #elif PLATFORM(CG)
1042     GraphicsContext gc(canvas);
1043     int bitmapHeight = CGBitmapContextGetHeight(reinterpret_cast<CGContextRef>(canvas));
1044 #else
1045     notImplemented();
1046 #endif
1047     // Compute rect to sample from inverted GPU buffer.
1048     IntRect invertRect(rect.x(), bitmapHeight - rect.maxY(), rect.width(), rect.height());
1049
1050     OwnPtr<ImageBuffer> imageBuffer(ImageBuffer::create(rect.size()));
1051     RefPtr<ByteArray> pixelArray(ByteArray::create(rect.width() * rect.height() * 4));
1052     if (imageBuffer.get() && pixelArray.get()) {
1053         m_layerRenderer->getFramebufferPixels(pixelArray->data(), invertRect);
1054         imageBuffer->putPremultipliedImageData(pixelArray.get(), rect.size(), IntRect(IntPoint(), rect.size()), IntPoint());
1055         gc.save();
1056         gc.translate(IntSize(0, bitmapHeight));
1057         gc.scale(FloatSize(1.0f, -1.0f));
1058         // Use invertRect in next line, so that transform above inverts it back to
1059         // desired destination rect.
1060         gc.drawImageBuffer(imageBuffer.get(), ColorSpaceDeviceRGB, invertRect.location());
1061         gc.restore();
1062     }
1063 }
1064 #endif
1065
1066 void WebViewImpl::paint(WebCanvas* canvas, const WebRect& rect)
1067 {
1068     if (isAcceleratedCompositingActive()) {
1069 #if USE(ACCELERATED_COMPOSITING)
1070         doComposite();
1071
1072         // If a canvas was passed in, we use it to grab a copy of the
1073         // freshly-rendered pixels.
1074         if (canvas) {
1075             // Clip rect to the confines of the rootLayerTexture.
1076             IntRect resizeRect(rect);
1077             resizeRect.intersect(IntRect(IntPoint(), m_layerRenderer->viewportSize()));
1078             doPixelReadbackToCanvas(canvas, resizeRect);
1079         }
1080 #endif
1081     } else {
1082         WebFrameImpl* webframe = mainFrameImpl();
1083         if (webframe)
1084             webframe->paint(canvas, rect);
1085     }
1086 }
1087
1088 void WebViewImpl::themeChanged()
1089 {
1090     if (!page())
1091         return;
1092     FrameView* view = page()->mainFrame()->view();
1093
1094     WebRect damagedRect(0, 0, m_size.width, m_size.height);
1095     view->invalidateRect(damagedRect);
1096 }
1097
1098 void WebViewImpl::composite(bool finish)
1099 {
1100 #if USE(ACCELERATED_COMPOSITING)
1101     TRACE_EVENT("WebViewImpl::composite", this, 0);
1102     if (m_recreatingGraphicsContext) {
1103         // reallocateRenderer will request a repaint whether or not it succeeded
1104         // in creating a new context.
1105         reallocateRenderer();
1106         m_recreatingGraphicsContext = false;
1107         return;
1108     }
1109     doComposite();
1110
1111     // Finish if requested.
1112     if (finish)
1113         m_layerRenderer->finish();
1114
1115     // Put result onscreen.
1116     m_layerRenderer->present();
1117
1118     GraphicsContext3D* context = m_layerRenderer->context();
1119     if (context->getExtensions()->getGraphicsResetStatusARB() != GraphicsContext3D::NO_ERROR) {
1120         // Trying to recover the context right here will not work if GPU process
1121         // died. This is because GpuChannelHost::OnErrorMessage will only be
1122         // called at the next iteration of the message loop, reverting our
1123         // recovery attempts here. Instead, we detach the root layer from the
1124         // renderer, recreate the renderer at the next message loop iteration
1125         // and request a repaint yet again.
1126         m_recreatingGraphicsContext = true;
1127         setRootLayerNeedsDisplay();
1128     }
1129 #endif
1130 }
1131
1132 const WebInputEvent* WebViewImpl::m_currentInputEvent = 0;
1133
1134 bool WebViewImpl::handleInputEvent(const WebInputEvent& inputEvent)
1135 {
1136     UserGestureIndicator gestureIndicator(DefinitelyProcessingUserGesture);
1137
1138     // If we've started a drag and drop operation, ignore input events until
1139     // we're done.
1140     if (m_doingDragAndDrop)
1141         return true;
1142
1143     if (m_ignoreInputEvents)
1144         return true;
1145
1146     m_currentInputEvent = &inputEvent;
1147
1148     if (m_mouseCaptureNode.get() && WebInputEvent::isMouseEventType(inputEvent.type)) {
1149         const int mouseButtonModifierMask = WebInputEvent::LeftButtonDown | WebInputEvent::MiddleButtonDown | WebInputEvent::RightButtonDown;
1150         if (inputEvent.type == WebInputEvent::MouseDown ||
1151             (inputEvent.modifiers & mouseButtonModifierMask) == 0) {
1152             // It's possible the mouse was released and we didn't get the "up"
1153             // message. This can happen if a dialog pops up while the mouse is
1154             // held, for example. This will leave us "stuck" in capture mode.
1155             // If we get a new mouse down message or any other mouse message
1156             // where no "down" flags are set, we know the user is no longer
1157             // dragging and we can release the capture and fall through to the
1158             // regular event processing.
1159             mouseCaptureLost();
1160         } else {
1161             // Save m_mouseCaptureNode since mouseCaptureLost() will clear it.
1162             RefPtr<Node> node = m_mouseCaptureNode;
1163
1164             // Not all platforms call mouseCaptureLost() directly.
1165             if (inputEvent.type == WebInputEvent::MouseUp)
1166                 mouseCaptureLost();
1167
1168             AtomicString eventType;
1169             switch (inputEvent.type) {
1170             case WebInputEvent::MouseMove:
1171                 eventType = eventNames().mousemoveEvent;
1172                 break;
1173             case WebInputEvent::MouseLeave:
1174                 eventType = eventNames().mouseoutEvent;
1175                 break;
1176             case WebInputEvent::MouseDown:
1177                 eventType = eventNames().mousedownEvent;
1178                 break;
1179             case WebInputEvent::MouseUp:
1180                 eventType = eventNames().mouseupEvent;
1181                 break;
1182             default:
1183                 ASSERT_NOT_REACHED();
1184             }
1185
1186             node->dispatchMouseEvent(
1187                   PlatformMouseEventBuilder(mainFrameImpl()->frameView(), *static_cast<const WebMouseEvent*>(&inputEvent)),
1188                   eventType, static_cast<const WebMouseEvent*>(&inputEvent)->clickCount);
1189             m_currentInputEvent = 0;
1190             return true;
1191         }
1192     }
1193
1194     bool handled = true;
1195
1196     // FIXME: WebKit seems to always return false on mouse events processing
1197     // methods. For now we'll assume it has processed them (as we are only
1198     // interested in whether keyboard events are processed).
1199     switch (inputEvent.type) {
1200     case WebInputEvent::MouseMove:
1201         mouseMove(*static_cast<const WebMouseEvent*>(&inputEvent));
1202         break;
1203
1204     case WebInputEvent::MouseLeave:
1205         mouseLeave(*static_cast<const WebMouseEvent*>(&inputEvent));
1206         break;
1207
1208     case WebInputEvent::MouseWheel:
1209         handled = mouseWheel(*static_cast<const WebMouseWheelEvent*>(&inputEvent));
1210         break;
1211
1212     case WebInputEvent::MouseDown:
1213         mouseDown(*static_cast<const WebMouseEvent*>(&inputEvent));
1214         break;
1215
1216     case WebInputEvent::MouseUp:
1217         mouseUp(*static_cast<const WebMouseEvent*>(&inputEvent));
1218         break;
1219
1220     case WebInputEvent::RawKeyDown:
1221     case WebInputEvent::KeyDown:
1222     case WebInputEvent::KeyUp:
1223         handled = keyEvent(*static_cast<const WebKeyboardEvent*>(&inputEvent));
1224         break;
1225
1226     case WebInputEvent::Char:
1227         handled = charEvent(*static_cast<const WebKeyboardEvent*>(&inputEvent));
1228         break;
1229
1230 #if ENABLE(TOUCH_EVENTS)
1231     case WebInputEvent::TouchStart:
1232     case WebInputEvent::TouchMove:
1233     case WebInputEvent::TouchEnd:
1234     case WebInputEvent::TouchCancel:
1235         handled = touchEvent(*static_cast<const WebTouchEvent*>(&inputEvent));
1236         break;
1237 #endif
1238
1239     default:
1240         handled = false;
1241     }
1242
1243     m_currentInputEvent = 0;
1244
1245     return handled;
1246 }
1247
1248 void WebViewImpl::mouseCaptureLost()
1249 {
1250     m_mouseCaptureNode = 0;
1251 }
1252
1253 void WebViewImpl::setFocus(bool enable)
1254 {
1255     m_page->focusController()->setFocused(enable);
1256     if (enable) {
1257         // Note that we don't call setActive() when disabled as this cause extra
1258         // focus/blur events to be dispatched.
1259         m_page->focusController()->setActive(true);
1260         RefPtr<Frame> focusedFrame = m_page->focusController()->focusedFrame();
1261         if (focusedFrame) {
1262             Node* focusedNode = focusedFrame->document()->focusedNode();
1263             if (focusedNode && focusedNode->isElementNode()
1264                 && focusedFrame->selection()->selection().isNone()) {
1265                 // If the selection was cleared while the WebView was not
1266                 // focused, then the focus element shows with a focus ring but
1267                 // no caret and does respond to keyboard inputs.
1268                 Element* element = static_cast<Element*>(focusedNode);
1269                 if (element->isTextFormControl())
1270                     element->updateFocusAppearance(true);
1271                 else if (focusedNode->isContentEditable()) {
1272                     // updateFocusAppearance() selects all the text of
1273                     // contentseditable DIVs. So we set the selection explicitly
1274                     // instead. Note that this has the side effect of moving the
1275                     // caret back to the beginning of the text.
1276                     Position position(focusedNode, 0,
1277                                       Position::PositionIsOffsetInAnchor);
1278                     focusedFrame->selection()->setSelection(
1279                         VisibleSelection(position, SEL_DEFAULT_AFFINITY));
1280                 }
1281             }
1282         }
1283         m_imeAcceptEvents = true;
1284     } else {
1285         hideAutoFillPopup();
1286         hideSelectPopup();
1287
1288         // Clear focus on the currently focused frame if any.
1289         if (!m_page.get())
1290             return;
1291
1292         Frame* frame = m_page->mainFrame();
1293         if (!frame)
1294             return;
1295
1296         RefPtr<Frame> focusedFrame = m_page->focusController()->focusedFrame();
1297         if (focusedFrame.get()) {
1298             // Finish an ongoing composition to delete the composition node.
1299             Editor* editor = focusedFrame->editor();
1300             if (editor && editor->hasComposition())
1301                 editor->confirmComposition();
1302             m_imeAcceptEvents = false;
1303         }
1304     }
1305 }
1306
1307 bool WebViewImpl::setComposition(
1308     const WebString& text,
1309     const WebVector<WebCompositionUnderline>& underlines,
1310     int selectionStart,
1311     int selectionEnd)
1312 {
1313     Frame* focused = focusedWebCoreFrame();
1314     if (!focused || !m_imeAcceptEvents)
1315         return false;
1316     Editor* editor = focused->editor();
1317     if (!editor)
1318         return false;
1319
1320     // The input focus has been moved to another WebWidget object.
1321     // We should use this |editor| object only to complete the ongoing
1322     // composition.
1323     if (!editor->canEdit() && !editor->hasComposition())
1324         return false;
1325
1326     // We should verify the parent node of this IME composition node are
1327     // editable because JavaScript may delete a parent node of the composition
1328     // node. In this case, WebKit crashes while deleting texts from the parent
1329     // node, which doesn't exist any longer.
1330     PassRefPtr<Range> range = editor->compositionRange();
1331     if (range) {
1332         const Node* node = range->startContainer();
1333         if (!node || !node->isContentEditable())
1334             return false;
1335     }
1336
1337     // If we're not going to fire a keypress event, then the keydown event was
1338     // canceled.  In that case, cancel any existing composition.
1339     if (text.isEmpty() || m_suppressNextKeypressEvent) {
1340         // A browser process sent an IPC message which does not contain a valid
1341         // string, which means an ongoing composition has been canceled.
1342         // If the ongoing composition has been canceled, replace the ongoing
1343         // composition string with an empty string and complete it.
1344         String emptyString;
1345         Vector<CompositionUnderline> emptyUnderlines;
1346         editor->setComposition(emptyString, emptyUnderlines, 0, 0);
1347         return text.isEmpty();
1348     }
1349
1350     // When the range of composition underlines overlap with the range between
1351     // selectionStart and selectionEnd, WebKit somehow won't paint the selection
1352     // at all (see InlineTextBox::paint() function in InlineTextBox.cpp).
1353     // But the selection range actually takes effect.
1354     editor->setComposition(String(text),
1355                            CompositionUnderlineVectorBuilder(underlines),
1356                            selectionStart, selectionEnd);
1357
1358     return editor->hasComposition();
1359 }
1360
1361 bool WebViewImpl::confirmComposition()
1362 {
1363     return confirmComposition(WebString());
1364 }
1365
1366 bool WebViewImpl::confirmComposition(const WebString& text)
1367 {
1368     Frame* focused = focusedWebCoreFrame();
1369     if (!focused || !m_imeAcceptEvents)
1370         return false;
1371     Editor* editor = focused->editor();
1372     if (!editor || (!editor->hasComposition() && !text.length()))
1373         return false;
1374
1375     // We should verify the parent node of this IME composition node are
1376     // editable because JavaScript may delete a parent node of the composition
1377     // node. In this case, WebKit crashes while deleting texts from the parent
1378     // node, which doesn't exist any longer.
1379     PassRefPtr<Range> range = editor->compositionRange();
1380     if (range) {
1381         const Node* node = range->startContainer();
1382         if (!node || !node->isContentEditable())
1383             return false;
1384     }
1385
1386     if (editor->hasComposition()) {
1387         if (text.length())
1388             editor->confirmComposition(String(text));
1389         else
1390             editor->confirmComposition();
1391     } else
1392         editor->insertText(String(text), 0);
1393
1394     return true;
1395 }
1396
1397 WebTextInputType WebViewImpl::textInputType()
1398 {
1399     WebTextInputType type = WebTextInputTypeNone;
1400     const Frame* focused = focusedWebCoreFrame();
1401     if (!focused)
1402         return type;
1403
1404     const Editor* editor = focused->editor();
1405     if (!editor || !editor->canEdit())
1406         return type;
1407
1408     SelectionController* controller = focused->selection();
1409     if (!controller)
1410         return type;
1411
1412     const Node* node = controller->start().deprecatedNode();
1413     if (!node)
1414         return type;
1415
1416     // FIXME: Support more text input types when necessary, eg. Number,
1417     // Date, Email, URL, etc.
1418     if (controller->isInPasswordField())
1419         type = WebTextInputTypePassword;
1420     else if (node->shouldUseInputMethod())
1421         type = WebTextInputTypeText;
1422
1423     return type;
1424 }
1425
1426 WebRect WebViewImpl::caretOrSelectionBounds()
1427 {
1428     WebRect rect;
1429     const Frame* focused = focusedWebCoreFrame();
1430     if (!focused)
1431         return rect;
1432
1433     SelectionController* controller = focused->selection();
1434     if (!controller)
1435         return rect;
1436
1437     const FrameView* view = focused->view();
1438     if (!view)
1439         return rect;
1440
1441     const Node* node = controller->base().containerNode();
1442     if (!node || !node->renderer())
1443         return rect;
1444
1445     if (controller->isCaret())
1446         rect = view->contentsToWindow(controller->absoluteCaretBounds());
1447     else if (controller->isRange()) {
1448         node = controller->extent().containerNode();
1449         RefPtr<Range> range = controller->toNormalizedRange();
1450         if (!node || !node->renderer() || !range)
1451             return rect;
1452         rect = view->contentsToWindow(focused->editor()->firstRectForRange(range.get()));
1453     }
1454     return rect;
1455 }
1456
1457 bool WebViewImpl::selectionRange(WebPoint& start, WebPoint& end) const
1458 {
1459     const Frame* frame = focusedWebCoreFrame();
1460     if (!frame)
1461         return false;
1462     RefPtr<Range> selectedRange = frame->selection()->toNormalizedRange();
1463     RefPtr<Range> range(Range::create(selectedRange->startContainer()->document(),
1464                                       selectedRange->startContainer(),
1465                                       selectedRange->startOffset(),
1466                                       selectedRange->startContainer(),
1467                                       selectedRange->startOffset()));
1468
1469     IntRect rect = frame->editor()->firstRectForRange(range.get());
1470     start.x = rect.x();
1471     start.y = rect.y() + rect.height() - 1;
1472
1473     range = Range::create(selectedRange->endContainer()->document(),
1474                           selectedRange->endContainer(),
1475                           selectedRange->endOffset(),
1476                           selectedRange->endContainer(),
1477                           selectedRange->endOffset());
1478
1479     rect = frame->editor()->firstRectForRange(range.get());
1480     end.x = rect.x() + rect.width() - 1;
1481     end.y = rect.y() + rect.height() - 1;
1482
1483     start = frame->view()->contentsToWindow(start);
1484     end = frame->view()->contentsToWindow(end);
1485     return true;
1486 }
1487
1488 void WebViewImpl::setTextDirection(WebTextDirection direction)
1489 {
1490     // The Editor::setBaseWritingDirection() function checks if we can change
1491     // the text direction of the selected node and updates its DOM "dir"
1492     // attribute and its CSS "direction" property.
1493     // So, we just call the function as Safari does.
1494     const Frame* focused = focusedWebCoreFrame();
1495     if (!focused)
1496         return;
1497
1498     Editor* editor = focused->editor();
1499     if (!editor || !editor->canEdit())
1500         return;
1501
1502     switch (direction) {
1503     case WebTextDirectionDefault:
1504         editor->setBaseWritingDirection(NaturalWritingDirection);
1505         break;
1506
1507     case WebTextDirectionLeftToRight:
1508         editor->setBaseWritingDirection(LeftToRightWritingDirection);
1509         break;
1510
1511     case WebTextDirectionRightToLeft:
1512         editor->setBaseWritingDirection(RightToLeftWritingDirection);
1513         break;
1514
1515     default:
1516         notImplemented();
1517         break;
1518     }
1519 }
1520
1521 bool WebViewImpl::isAcceleratedCompositingActive() const
1522 {
1523 #if USE(ACCELERATED_COMPOSITING)
1524     return m_isAcceleratedCompositingActive;
1525 #else
1526     return false;
1527 #endif
1528 }
1529
1530 // WebView --------------------------------------------------------------------
1531
1532 WebSettings* WebViewImpl::settings()
1533 {
1534     if (!m_webSettings.get())
1535         m_webSettings.set(new WebSettingsImpl(m_page->settings()));
1536     ASSERT(m_webSettings.get());
1537     return m_webSettings.get();
1538 }
1539
1540 WebString WebViewImpl::pageEncoding() const
1541 {
1542     if (!m_page.get())
1543         return WebString();
1544
1545     return m_page->mainFrame()->document()->loader()->writer()->encoding();
1546 }
1547
1548 void WebViewImpl::setPageEncoding(const WebString& encodingName)
1549 {
1550     if (!m_page.get())
1551         return;
1552
1553     // Only change override encoding, don't change default encoding.
1554     // Note that the new encoding must be 0 if it isn't supposed to be set.
1555     String newEncodingName;
1556     if (!encodingName.isEmpty())
1557         newEncodingName = encodingName;
1558     m_page->mainFrame()->loader()->reloadWithOverrideEncoding(newEncodingName);
1559 }
1560
1561 bool WebViewImpl::dispatchBeforeUnloadEvent()
1562 {
1563     // FIXME: This should really cause a recursive depth-first walk of all
1564     // frames in the tree, calling each frame's onbeforeunload.  At the moment,
1565     // we're consistent with Safari 3.1, not IE/FF.
1566     Frame* frame = m_page->mainFrame();
1567     if (!frame)
1568         return true;
1569
1570     return frame->loader()->shouldClose();
1571 }
1572
1573 void WebViewImpl::dispatchUnloadEvent()
1574 {
1575     // Run unload handlers.
1576     m_page->mainFrame()->loader()->closeURL();
1577 }
1578
1579 WebFrame* WebViewImpl::mainFrame()
1580 {
1581     return mainFrameImpl();
1582 }
1583
1584 WebFrame* WebViewImpl::findFrameByName(
1585     const WebString& name, WebFrame* relativeToFrame)
1586 {
1587     if (!relativeToFrame)
1588         relativeToFrame = mainFrame();
1589     Frame* frame = static_cast<WebFrameImpl*>(relativeToFrame)->frame();
1590     frame = frame->tree()->find(name);
1591     return WebFrameImpl::fromFrame(frame);
1592 }
1593
1594 WebFrame* WebViewImpl::focusedFrame()
1595 {
1596     return WebFrameImpl::fromFrame(focusedWebCoreFrame());
1597 }
1598
1599 void WebViewImpl::setFocusedFrame(WebFrame* frame)
1600 {
1601     if (!frame) {
1602         // Clears the focused frame if any.
1603         Frame* frame = focusedWebCoreFrame();
1604         if (frame)
1605             frame->selection()->setFocused(false);
1606         return;
1607     }
1608     WebFrameImpl* frameImpl = static_cast<WebFrameImpl*>(frame);
1609     Frame* webcoreFrame = frameImpl->frame();
1610     webcoreFrame->page()->focusController()->setFocusedFrame(webcoreFrame);
1611 }
1612
1613 void WebViewImpl::setInitialFocus(bool reverse)
1614 {
1615     if (!m_page.get())
1616         return;
1617
1618     // Since we don't have a keyboard event, we'll create one.
1619     WebKeyboardEvent keyboardEvent;
1620     keyboardEvent.type = WebInputEvent::RawKeyDown;
1621     if (reverse)
1622         keyboardEvent.modifiers = WebInputEvent::ShiftKey;
1623
1624     // VK_TAB which is only defined on Windows.
1625     keyboardEvent.windowsKeyCode = 0x09;
1626     PlatformKeyboardEventBuilder platformEvent(keyboardEvent);
1627     RefPtr<KeyboardEvent> webkitEvent = KeyboardEvent::create(platformEvent, 0);
1628
1629     Frame* frame = page()->focusController()->focusedOrMainFrame();
1630     if (Document* document = frame->document())
1631         document->setFocusedNode(0);
1632     page()->focusController()->setInitialFocus(
1633         reverse ? FocusDirectionBackward : FocusDirectionForward,
1634         webkitEvent.get());
1635 }
1636
1637 void WebViewImpl::clearFocusedNode()
1638 {
1639     if (!m_page.get())
1640         return;
1641
1642     RefPtr<Frame> frame = m_page->mainFrame();
1643     if (!frame.get())
1644         return;
1645
1646     RefPtr<Document> document = frame->document();
1647     if (!document.get())
1648         return;
1649
1650     RefPtr<Node> oldFocusedNode = document->focusedNode();
1651
1652     // Clear the focused node.
1653     document->setFocusedNode(0);
1654
1655     if (!oldFocusedNode.get())
1656         return;
1657
1658     // If a text field has focus, we need to make sure the selection controller
1659     // knows to remove selection from it. Otherwise, the text field is still
1660     // processing keyboard events even though focus has been moved to the page and
1661     // keystrokes get eaten as a result.
1662     if (oldFocusedNode->hasTagName(HTMLNames::textareaTag)
1663         || (oldFocusedNode->hasTagName(HTMLNames::inputTag)
1664             && static_cast<HTMLInputElement*>(oldFocusedNode.get())->isTextField())) {
1665         // Clear the selection.
1666         SelectionController* selection = frame->selection();
1667         selection->clear();
1668     }
1669 }
1670
1671 void WebViewImpl::scrollFocusedNodeIntoView()
1672 {
1673     Node* focusedNode = focusedWebCoreNode();
1674     if (focusedNode && focusedNode->isElementNode()) {
1675         Element* elementNode = static_cast<Element*>(focusedNode);
1676         elementNode->scrollIntoViewIfNeeded(true);
1677     }
1678 }
1679
1680 double WebViewImpl::zoomLevel()
1681 {
1682     return m_zoomLevel;
1683 }
1684
1685 double WebViewImpl::setZoomLevel(bool textOnly, double zoomLevel)
1686 {
1687     if (zoomLevel < m_minimumZoomLevel)
1688         m_zoomLevel = m_minimumZoomLevel;
1689     else if (zoomLevel > m_maximumZoomLevel)
1690         m_zoomLevel = m_maximumZoomLevel;
1691     else
1692         m_zoomLevel = zoomLevel;
1693
1694     Frame* frame = mainFrameImpl()->frame();
1695     WebPluginContainerImpl* pluginContainer = WebFrameImpl::pluginContainerFromFrame(frame);
1696     if (pluginContainer)
1697         pluginContainer->plugin()->setZoomLevel(m_zoomLevel, textOnly);
1698     else {
1699         float zoomFactor = static_cast<float>(zoomLevelToZoomFactor(m_zoomLevel));
1700         if (textOnly)
1701             frame->setPageAndTextZoomFactors(1, zoomFactor);
1702         else
1703             frame->setPageAndTextZoomFactors(zoomFactor, 1);
1704     }
1705     return m_zoomLevel;
1706 }
1707
1708 void WebViewImpl::zoomLimitsChanged(double minimumZoomLevel,
1709                                     double maximumZoomLevel)
1710 {
1711     m_minimumZoomLevel = minimumZoomLevel;
1712     m_maximumZoomLevel = maximumZoomLevel;
1713     m_client->zoomLimitsChanged(m_minimumZoomLevel, m_maximumZoomLevel);
1714 }
1715
1716 void WebViewImpl::fullFramePluginZoomLevelChanged(double zoomLevel)
1717 {
1718     if (zoomLevel == m_zoomLevel)
1719         return;
1720
1721     m_zoomLevel = std::max(std::min(zoomLevel, m_maximumZoomLevel), m_minimumZoomLevel);
1722     m_client->zoomLevelChanged();
1723 }
1724
1725 double WebView::zoomLevelToZoomFactor(double zoomLevel)
1726 {
1727     return std::pow(textSizeMultiplierRatio, zoomLevel);
1728 }
1729
1730 double WebView::zoomFactorToZoomLevel(double factor)
1731 {
1732     // Since factor = 1.2^level, level = log(factor) / log(1.2)
1733     return log(factor) / log(textSizeMultiplierRatio);
1734 }
1735
1736 void WebViewImpl::performMediaPlayerAction(const WebMediaPlayerAction& action,
1737                                            const WebPoint& location)
1738 {
1739     HitTestResult result =
1740         hitTestResultForWindowPos(location);
1741     RefPtr<Node> node = result.innerNonSharedNode();
1742     if (!node->hasTagName(HTMLNames::videoTag) && !node->hasTagName(HTMLNames::audioTag))
1743       return;
1744
1745     RefPtr<HTMLMediaElement> mediaElement =
1746         static_pointer_cast<HTMLMediaElement>(node);
1747     switch (action.type) {
1748     case WebMediaPlayerAction::Play:
1749         if (action.enable)
1750             mediaElement->play(mediaElement->processingUserGesture());
1751         else
1752             mediaElement->pause(mediaElement->processingUserGesture());
1753         break;
1754     case WebMediaPlayerAction::Mute:
1755         mediaElement->setMuted(action.enable);
1756         break;
1757     case WebMediaPlayerAction::Loop:
1758         mediaElement->setLoop(action.enable);
1759         break;
1760     case WebMediaPlayerAction::Controls:
1761         mediaElement->setControls(action.enable);
1762         break;
1763     default:
1764         ASSERT_NOT_REACHED();
1765     }
1766 }
1767
1768 void WebViewImpl::copyImageAt(const WebPoint& point)
1769 {
1770     if (!m_page.get())
1771         return;
1772
1773     HitTestResult result = hitTestResultForWindowPos(point);
1774
1775     if (result.absoluteImageURL().isEmpty()) {
1776         // There isn't actually an image at these coordinates.  Might be because
1777         // the window scrolled while the context menu was open or because the page
1778         // changed itself between when we thought there was an image here and when
1779         // we actually tried to retreive the image.
1780         //
1781         // FIXME: implement a cache of the most recent HitTestResult to avoid having
1782         //        to do two hit tests.
1783         return;
1784     }
1785
1786     m_page->mainFrame()->editor()->copyImage(result);
1787 }
1788
1789 void WebViewImpl::dragSourceEndedAt(
1790     const WebPoint& clientPoint,
1791     const WebPoint& screenPoint,
1792     WebDragOperation operation)
1793 {
1794     PlatformMouseEvent pme(clientPoint,
1795                            screenPoint,
1796                            LeftButton, MouseEventMoved, 0, false, false, false,
1797                            false, 0);
1798     m_page->mainFrame()->eventHandler()->dragSourceEndedAt(pme,
1799         static_cast<DragOperation>(operation));
1800     m_dragScrollTimer->stop();
1801 }
1802
1803 void WebViewImpl::dragSourceMovedTo(
1804     const WebPoint& clientPoint,
1805     const WebPoint& screenPoint,
1806     WebDragOperation operation)
1807 {
1808     m_dragScrollTimer->triggerScroll(mainFrameImpl()->frameView(), clientPoint);
1809 }
1810
1811 void WebViewImpl::dragSourceSystemDragEnded()
1812 {
1813     // It's possible for us to get this callback while not doing a drag if
1814     // it's from a previous page that got unloaded.
1815     if (m_doingDragAndDrop) {
1816         m_page->dragController()->dragEnded();
1817         m_doingDragAndDrop = false;
1818     }
1819 }
1820
1821 WebDragOperation WebViewImpl::dragTargetDragEnter(
1822     const WebDragData& webDragData, int identity, // FIXME: remove identity from this function signature.
1823     const WebPoint& clientPoint,
1824     const WebPoint& screenPoint,
1825     WebDragOperationsMask operationsAllowed)
1826 {
1827     ASSERT(!m_currentDragData.get());
1828
1829     m_currentDragData = webDragData;
1830     UNUSED_PARAM(identity);
1831     m_operationsAllowed = operationsAllowed;
1832
1833     return dragTargetDragEnterOrOver(clientPoint, screenPoint, DragEnter);
1834 }
1835
1836 WebDragOperation WebViewImpl::dragTargetDragEnter(
1837     const WebDragData& webDragData,
1838     const WebPoint& clientPoint,
1839     const WebPoint& screenPoint,
1840     WebDragOperationsMask operationsAllowed)
1841 {
1842     ASSERT(!m_currentDragData.get());
1843
1844     m_currentDragData = webDragData;
1845     m_operationsAllowed = operationsAllowed;
1846
1847     return dragTargetDragEnterOrOver(clientPoint, screenPoint, DragEnter);
1848 }
1849
1850 WebDragOperation WebViewImpl::dragTargetDragOver(
1851     const WebPoint& clientPoint,
1852     const WebPoint& screenPoint,
1853     WebDragOperationsMask operationsAllowed)
1854 {
1855     m_operationsAllowed = operationsAllowed;
1856
1857     return dragTargetDragEnterOrOver(clientPoint, screenPoint, DragOver);
1858 }
1859
1860 void WebViewImpl::dragTargetDragLeave()
1861 {
1862     ASSERT(m_currentDragData.get());
1863
1864     DragData dragData(
1865         m_currentDragData.get(),
1866         IntPoint(),
1867         IntPoint(),
1868         static_cast<DragOperation>(m_operationsAllowed));
1869
1870     m_page->dragController()->dragExited(&dragData);
1871
1872     // FIXME: why is the drag scroll timer not stopped here?
1873
1874     m_dragOperation = WebDragOperationNone;
1875     m_currentDragData = 0;
1876 }
1877
1878 void WebViewImpl::dragTargetDrop(const WebPoint& clientPoint,
1879                                  const WebPoint& screenPoint)
1880 {
1881     ASSERT(m_currentDragData.get());
1882
1883     // If this webview transitions from the "drop accepting" state to the "not
1884     // accepting" state, then our IPC message reply indicating that may be in-
1885     // flight, or else delayed by javascript processing in this webview.  If a
1886     // drop happens before our IPC reply has reached the browser process, then
1887     // the browser forwards the drop to this webview.  So only allow a drop to
1888     // proceed if our webview m_dragOperation state is not DragOperationNone.
1889
1890     if (m_dragOperation == WebDragOperationNone) { // IPC RACE CONDITION: do not allow this drop.
1891         dragTargetDragLeave();
1892         return;
1893     }
1894
1895     DragData dragData(
1896         m_currentDragData.get(),
1897         clientPoint,
1898         screenPoint,
1899         static_cast<DragOperation>(m_operationsAllowed));
1900
1901     m_page->dragController()->performDrag(&dragData);
1902
1903     m_dragOperation = WebDragOperationNone;
1904     m_currentDragData = 0;
1905
1906     m_dragScrollTimer->stop();
1907 }
1908
1909 WebDragOperation WebViewImpl::dragTargetDragEnterOrOver(const WebPoint& clientPoint, const WebPoint& screenPoint, DragAction dragAction)
1910 {
1911     ASSERT(m_currentDragData.get());
1912
1913     DragData dragData(
1914         m_currentDragData.get(),
1915         clientPoint,
1916         screenPoint,
1917         static_cast<DragOperation>(m_operationsAllowed));
1918
1919     DragOperation dropEffect;
1920     if (dragAction == DragEnter)
1921         dropEffect = m_page->dragController()->dragEntered(&dragData);
1922     else
1923         dropEffect = m_page->dragController()->dragUpdated(&dragData);
1924
1925     // Mask the drop effect operation against the drag source's allowed operations.
1926     if (!(dropEffect & dragData.draggingSourceOperationMask()))
1927         dropEffect = DragOperationNone;
1928
1929      m_dragOperation = static_cast<WebDragOperation>(dropEffect);
1930
1931     if (dragAction == DragOver)
1932         m_dragScrollTimer->triggerScroll(mainFrameImpl()->frameView(), clientPoint);
1933     else
1934         m_dragScrollTimer->stop();
1935
1936     return m_dragOperation;
1937 }
1938
1939 unsigned long WebViewImpl::createUniqueIdentifierForRequest()
1940 {
1941     if (m_page)
1942         return m_page->progress()->createUniqueIdentifier();
1943     return 0;
1944 }
1945
1946 void WebViewImpl::inspectElementAt(const WebPoint& point)
1947 {
1948     if (!m_page.get())
1949         return;
1950
1951     if (point.x == -1 || point.y == -1)
1952         m_page->inspectorController()->inspect(0);
1953     else {
1954         HitTestResult result = hitTestResultForWindowPos(point);
1955
1956         if (!result.innerNonSharedNode())
1957             return;
1958
1959         m_page->inspectorController()->inspect(result.innerNonSharedNode());
1960     }
1961 }
1962
1963 WebString WebViewImpl::inspectorSettings() const
1964 {
1965     return m_inspectorSettings;
1966 }
1967
1968 void WebViewImpl::setInspectorSettings(const WebString& settings)
1969 {
1970     m_inspectorSettings = settings;
1971 }
1972
1973 bool WebViewImpl::inspectorSetting(const WebString& key, WebString* value) const
1974 {
1975     if (!m_inspectorSettingsMap->contains(key))
1976         return false;
1977     *value = m_inspectorSettingsMap->get(key);
1978     return true;
1979 }
1980
1981 void WebViewImpl::setInspectorSetting(const WebString& key,
1982                                       const WebString& value)
1983 {
1984     m_inspectorSettingsMap->set(key, value);
1985     client()->didUpdateInspectorSetting(key, value);
1986 }
1987
1988 WebDevToolsAgent* WebViewImpl::devToolsAgent()
1989 {
1990     return m_devToolsAgent.get();
1991 }
1992
1993 WebAccessibilityObject WebViewImpl::accessibilityObject()
1994 {
1995     if (!mainFrameImpl())
1996         return WebAccessibilityObject();
1997
1998     Document* document = mainFrameImpl()->frame()->document();
1999     return WebAccessibilityObject(
2000         document->axObjectCache()->getOrCreate(document->renderer()));
2001 }
2002
2003 void WebViewImpl::applyAutoFillSuggestions(
2004     const WebNode& node,
2005     const WebVector<WebString>& names,
2006     const WebVector<WebString>& labels,
2007     const WebVector<WebString>& icons,
2008     const WebVector<int>& uniqueIDs,
2009     int separatorIndex)
2010 {
2011     ASSERT(names.size() == labels.size());
2012     ASSERT(names.size() == uniqueIDs.size());
2013     ASSERT(separatorIndex < static_cast<int>(names.size()));
2014
2015     if (names.isEmpty()) {
2016         hideAutoFillPopup();
2017         return;
2018     }
2019
2020     RefPtr<Node> focusedNode = focusedWebCoreNode();
2021     // If the node for which we queried the AutoFill suggestions is not the
2022     // focused node, then we have nothing to do.  FIXME: also check the
2023     // caret is at the end and that the text has not changed.
2024     if (!focusedNode || focusedNode != PassRefPtr<Node>(node)) {
2025         hideAutoFillPopup();
2026         return;
2027     }
2028
2029     HTMLInputElement* inputElem =
2030         static_cast<HTMLInputElement*>(focusedNode.get());
2031
2032     // The first time the AutoFill popup is shown we'll create the client and
2033     // the popup.
2034     if (!m_autoFillPopupClient.get())
2035         m_autoFillPopupClient.set(new AutoFillPopupMenuClient);
2036
2037     m_autoFillPopupClient->initialize(
2038         inputElem, names, labels, icons, uniqueIDs, separatorIndex);
2039
2040     if (!m_autoFillPopup.get()) {
2041         m_autoFillPopup = PopupContainer::create(m_autoFillPopupClient.get(),
2042                                                  PopupContainer::Suggestion,
2043                                                  autoFillPopupSettings);
2044     }
2045
2046     if (m_autoFillPopupShowing) {
2047         refreshAutoFillPopup();
2048     } else {
2049         m_autoFillPopup->showInRect(focusedNode->getRect(), focusedNode->ownerDocument()->view(), 0);
2050         m_autoFillPopupShowing = true;
2051     }
2052 }
2053
2054 void WebViewImpl::hidePopups()
2055 {
2056     hideSelectPopup();
2057     hideAutoFillPopup();
2058 }
2059
2060 void WebViewImpl::performCustomContextMenuAction(unsigned action)
2061 {
2062     if (!m_page)
2063         return;
2064     ContextMenu* menu = m_page->contextMenuController()->contextMenu();
2065     if (!menu)
2066         return;
2067     ContextMenuItem* item = menu->itemWithAction(static_cast<ContextMenuAction>(ContextMenuItemBaseCustomTag + action));
2068     if (item)
2069         m_page->contextMenuController()->contextMenuItemSelected(item);
2070     m_page->contextMenuController()->clearContextMenu();
2071 }
2072
2073 // WebView --------------------------------------------------------------------
2074
2075 void WebViewImpl::setIsTransparent(bool isTransparent)
2076 {
2077     // Set any existing frames to be transparent.
2078     Frame* frame = m_page->mainFrame();
2079     while (frame) {
2080         frame->view()->setTransparent(isTransparent);
2081         frame = frame->tree()->traverseNext();
2082     }
2083
2084     // Future frames check this to know whether to be transparent.
2085     m_isTransparent = isTransparent;
2086 }
2087
2088 bool WebViewImpl::isTransparent() const
2089 {
2090     return m_isTransparent;
2091 }
2092
2093 void WebViewImpl::setIsActive(bool active)
2094 {
2095     if (page() && page()->focusController())
2096         page()->focusController()->setActive(active);
2097 }
2098
2099 bool WebViewImpl::isActive() const
2100 {
2101     return (page() && page()->focusController()) ? page()->focusController()->isActive() : false;
2102 }
2103
2104 void WebViewImpl::setDomainRelaxationForbidden(bool forbidden, const WebString& scheme)
2105 {
2106     SecurityOrigin::setDomainRelaxationForbiddenForURLScheme(forbidden, String(scheme));
2107 }
2108
2109 void WebViewImpl::setScrollbarColors(unsigned inactiveColor,
2110                                      unsigned activeColor,
2111                                      unsigned trackColor) {
2112 #if OS(LINUX) || OS(FREEBSD)
2113     PlatformThemeChromiumGtk::setScrollbarColors(inactiveColor,
2114                                                  activeColor,
2115                                                  trackColor);
2116 #endif
2117 }
2118
2119 void WebViewImpl::setSelectionColors(unsigned activeBackgroundColor,
2120                                      unsigned activeForegroundColor,
2121                                      unsigned inactiveBackgroundColor,
2122                                      unsigned inactiveForegroundColor) {
2123 #if OS(LINUX) || OS(FREEBSD)
2124     RenderThemeChromiumLinux::setSelectionColors(activeBackgroundColor,
2125                                                  activeForegroundColor,
2126                                                  inactiveBackgroundColor,
2127                                                  inactiveForegroundColor);
2128     theme()->platformColorsDidChange();
2129 #endif
2130 }
2131
2132 void WebView::addUserScript(const WebString& sourceCode,
2133                             const WebVector<WebString>& patternsIn,
2134                             WebView::UserScriptInjectAt injectAt,
2135                             WebView::UserContentInjectIn injectIn)
2136 {
2137     OwnPtr<Vector<String> > patterns(new Vector<String>);
2138     for (size_t i = 0; i < patternsIn.size(); ++i)
2139         patterns->append(patternsIn[i]);
2140
2141     PageGroup* pageGroup = PageGroup::pageGroup(pageGroupName);
2142     RefPtr<DOMWrapperWorld> world(DOMWrapperWorld::create());
2143     pageGroup->addUserScriptToWorld(world.get(), sourceCode, WebURL(), patterns.release(), 0,
2144                                     static_cast<UserScriptInjectionTime>(injectAt),
2145                                     static_cast<UserContentInjectedFrames>(injectIn));
2146 }
2147
2148 void WebView::addUserStyleSheet(const WebString& sourceCode,
2149                                 const WebVector<WebString>& patternsIn,
2150                                 WebView::UserContentInjectIn injectIn,
2151                                 WebView::UserStyleInjectionTime injectionTime)
2152 {
2153     OwnPtr<Vector<String> > patterns(new Vector<String>);
2154     for (size_t i = 0; i < patternsIn.size(); ++i)
2155         patterns->append(patternsIn[i]);
2156
2157     PageGroup* pageGroup = PageGroup::pageGroup(pageGroupName);
2158     RefPtr<DOMWrapperWorld> world(DOMWrapperWorld::create());
2159
2160     // FIXME: Current callers always want the level to be "author". It probably makes sense to let
2161     // callers specify this though, since in other cases the caller will probably want "user" level.
2162     //
2163     // FIXME: It would be nice to populate the URL correctly, instead of passing an empty URL.
2164     pageGroup->addUserStyleSheetToWorld(world.get(), sourceCode, WebURL(), patterns.release(), 0,
2165                                         static_cast<UserContentInjectedFrames>(injectIn),
2166                                         UserStyleAuthorLevel,
2167                                         static_cast<WebCore::UserStyleInjectionTime>(injectionTime));
2168 }
2169
2170 void WebView::removeAllUserContent()
2171 {
2172     PageGroup* pageGroup = PageGroup::pageGroup(pageGroupName);
2173     pageGroup->removeAllUserContent();
2174 }
2175
2176 void WebViewImpl::didCommitLoad(bool* isNewNavigation)
2177 {
2178     if (isNewNavigation)
2179         *isNewNavigation = m_observedNewNavigation;
2180
2181 #ifndef NDEBUG
2182     ASSERT(!m_observedNewNavigation
2183         || m_page->mainFrame()->loader()->documentLoader() == m_newNavigationLoader);
2184     m_newNavigationLoader = 0;
2185 #endif
2186     m_observedNewNavigation = false;
2187 }
2188
2189 bool WebViewImpl::useExternalPopupMenus()
2190 {
2191     return shouldUseExternalPopupMenus;
2192 }
2193
2194 bool WebViewImpl::navigationPolicyFromMouseEvent(unsigned short button,
2195                                                  bool ctrl, bool shift,
2196                                                  bool alt, bool meta,
2197                                                  WebNavigationPolicy* policy)
2198 {
2199 #if OS(WINDOWS) || OS(LINUX) || OS(FREEBSD) || OS(SOLARIS)
2200     const bool newTabModifier = (button == 1) || ctrl;
2201 #elif OS(DARWIN)
2202     const bool newTabModifier = (button == 1) || meta;
2203 #endif
2204     if (!newTabModifier && !shift && !alt)
2205       return false;
2206
2207     ASSERT(policy);
2208     if (newTabModifier) {
2209         if (shift)
2210           *policy = WebNavigationPolicyNewForegroundTab;
2211         else
2212           *policy = WebNavigationPolicyNewBackgroundTab;
2213     } else {
2214         if (shift)
2215           *policy = WebNavigationPolicyNewWindow;
2216         else
2217           *policy = WebNavigationPolicyDownload;
2218     }
2219     return true;
2220 }
2221
2222 void WebViewImpl::startDragging(const WebDragData& dragData,
2223                                 WebDragOperationsMask mask,
2224                                 const WebImage& dragImage,
2225                                 const WebPoint& dragImageOffset)
2226 {
2227     if (!m_client)
2228         return;
2229     ASSERT(!m_doingDragAndDrop);
2230     m_doingDragAndDrop = true;
2231     m_client->startDragging(dragData, mask, dragImage, dragImageOffset);
2232 }
2233
2234 void WebViewImpl::observeNewNavigation()
2235 {
2236     m_observedNewNavigation = true;
2237 #ifndef NDEBUG
2238     m_newNavigationLoader = m_page->mainFrame()->loader()->documentLoader();
2239 #endif
2240 }
2241
2242 void WebViewImpl::setIgnoreInputEvents(bool newValue)
2243 {
2244     ASSERT(m_ignoreInputEvents != newValue);
2245     m_ignoreInputEvents = newValue;
2246 }
2247
2248 #if ENABLE(NOTIFICATIONS)
2249 NotificationPresenterImpl* WebViewImpl::notificationPresenterImpl()
2250 {
2251     if (!m_notificationPresenter.isInitialized() && m_client)
2252         m_notificationPresenter.initialize(m_client->notificationPresenter());
2253     return &m_notificationPresenter;
2254 }
2255 #endif
2256
2257 void WebViewImpl::refreshAutoFillPopup()
2258 {
2259     ASSERT(m_autoFillPopupShowing);
2260
2261     // Hide the popup if it has become empty.
2262     if (!m_autoFillPopupClient->listSize()) {
2263         hideAutoFillPopup();
2264         return;
2265     }
2266
2267     IntRect oldBounds = m_autoFillPopup->frameRect();
2268     m_autoFillPopup->refresh(focusedWebCoreNode()->getRect());
2269     IntRect newBounds = m_autoFillPopup->frameRect();
2270     // Let's resize the backing window if necessary.
2271     if (oldBounds != newBounds) {
2272         WebPopupMenuImpl* popupMenu =
2273             static_cast<WebPopupMenuImpl*>(m_autoFillPopup->client());
2274         if (popupMenu)
2275             popupMenu->client()->setWindowRect(newBounds);
2276     }
2277 }
2278
2279 Node* WebViewImpl::focusedWebCoreNode()
2280 {
2281     Frame* frame = m_page->focusController()->focusedFrame();
2282     if (!frame)
2283         return 0;
2284
2285     Document* document = frame->document();
2286     if (!document)
2287         return 0;
2288
2289     return document->focusedNode();
2290 }
2291
2292 HitTestResult WebViewImpl::hitTestResultForWindowPos(const IntPoint& pos)
2293 {
2294     IntPoint docPoint(m_page->mainFrame()->view()->windowToContents(pos));
2295     return m_page->mainFrame()->eventHandler()->hitTestResultAtPoint(docPoint, false);
2296 }
2297
2298 void WebViewImpl::setTabsToLinks(bool enable)
2299 {
2300     m_tabsToLinks = enable;
2301 }
2302
2303 bool WebViewImpl::tabsToLinks() const
2304 {
2305     return m_tabsToLinks;
2306 }
2307
2308 #if USE(ACCELERATED_COMPOSITING)
2309 bool WebViewImpl::allowsAcceleratedCompositing()
2310 {
2311     return !m_compositorCreationFailed;
2312 }
2313
2314 bool WebViewImpl::pageHasRTLStyle() const
2315 {
2316     if (!page())
2317         return false;
2318     Document* document = page()->mainFrame()->document();
2319     if (!document)
2320         return false;
2321     RenderView* renderView = document->renderView();
2322     if (!renderView)
2323         return false;
2324     RenderStyle* style = renderView->style();
2325     if (!style)
2326         return false;
2327     return (style->direction() == RTL);
2328 }
2329
2330 void WebViewImpl::setRootGraphicsLayer(WebCore::PlatformLayer* layer)
2331 {
2332     // FIXME: RTL style not supported by the compositor yet.
2333     setIsAcceleratedCompositingActive(layer && !pageHasRTLStyle() ? true : false);
2334     if (m_layerRenderer)
2335         m_layerRenderer->setRootLayer(layer);
2336
2337     IntRect damagedRect(0, 0, m_size.width, m_size.height);
2338     if (m_isAcceleratedCompositingActive)
2339         invalidateRootLayerRect(damagedRect);
2340     else
2341         m_client->didInvalidateRect(damagedRect);
2342 }
2343
2344 void WebViewImpl::setRootLayerNeedsDisplay()
2345 {
2346     m_client->scheduleComposite();
2347 }
2348
2349
2350 void WebViewImpl::scrollRootLayerRect(const IntSize& scrollDelta, const IntRect& clipRect)
2351 {
2352     updateLayerRendererViewport();
2353     setRootLayerNeedsDisplay();
2354 }
2355
2356 void WebViewImpl::invalidateRootLayerRect(const IntRect& rect)
2357 {
2358     ASSERT(m_layerRenderer);
2359
2360     if (!page())
2361         return;
2362
2363     FrameView* view = page()->mainFrame()->view();
2364     IntRect dirtyRect = view->windowToContents(rect);
2365     updateLayerRendererViewport();
2366     m_layerRenderer->invalidateRootLayerRect(dirtyRect);
2367     setRootLayerNeedsDisplay();
2368 }
2369
2370 class WebViewImplContentPainter : public TilePaintInterface {
2371     WTF_MAKE_NONCOPYABLE(WebViewImplContentPainter);
2372 public:
2373     static PassOwnPtr<WebViewImplContentPainter*> create(WebViewImpl* webViewImpl)
2374     {
2375         return adoptPtr(new WebViewImplContentPainter(webViewImpl));
2376     }
2377
2378     virtual void paint(GraphicsContext& context, const IntRect& contentRect)
2379     {
2380         Page* page = m_webViewImpl->page();
2381         if (!page)
2382             return;
2383         FrameView* view = page->mainFrame()->view();
2384         view->paintContents(&context, contentRect);
2385     }
2386
2387 private:
2388     explicit WebViewImplContentPainter(WebViewImpl* webViewImpl)
2389         : m_webViewImpl(webViewImpl)
2390     {
2391     }
2392
2393     WebViewImpl* m_webViewImpl;
2394 };
2395
2396 class WebViewImplScrollbarPainter : public TilePaintInterface {
2397     WTF_MAKE_NONCOPYABLE(WebViewImplScrollbarPainter);
2398 public:
2399     static PassOwnPtr<WebViewImplScrollbarPainter> create(WebViewImpl* webViewImpl)
2400     {
2401         return adoptPtr(new WebViewImplScrollbarPainter(webViewImpl));
2402     }
2403
2404     virtual void paint(GraphicsContext& context, const IntRect& contentRect)
2405     {
2406         Page* page = m_webViewImpl->page();
2407         if (!page)
2408             return;
2409         FrameView* view = page->mainFrame()->view();
2410
2411         context.translate(static_cast<float>(view->scrollX()), static_cast<float>(view->scrollY()));
2412         IntRect windowRect = view->contentsToWindow(contentRect);
2413         view->paintScrollbars(&context, windowRect);
2414     }
2415
2416 private:
2417     explicit WebViewImplScrollbarPainter(WebViewImpl* webViewImpl)
2418         : m_webViewImpl(webViewImpl)
2419     {
2420     }
2421
2422     WebViewImpl* m_webViewImpl;
2423 };
2424
2425 void WebViewImpl::setIsAcceleratedCompositingActive(bool active)
2426 {
2427     PlatformBridge::histogramEnumeration("GPU.setIsAcceleratedCompositingActive", active * 2 + m_isAcceleratedCompositingActive, 4);
2428
2429     if (m_isAcceleratedCompositingActive == active)
2430         return;
2431
2432     if (!active) {
2433         m_isAcceleratedCompositingActive = false;
2434         // We need to finish all GL rendering before sending
2435         // didActivateAcceleratedCompositing(false) to prevent
2436         // flickering when compositing turns off.
2437         if (m_layerRenderer)
2438             m_layerRenderer->finish();
2439         m_client->didActivateAcceleratedCompositing(false);
2440     } else if (m_layerRenderer) {
2441         m_isAcceleratedCompositingActive = true;
2442         m_layerRenderer->resizeOnscreenContent(WebCore::IntSize(std::max(1, m_size.width),
2443                                                                 std::max(1, m_size.height)));
2444
2445         m_client->didActivateAcceleratedCompositing(true);
2446     } else {
2447         RefPtr<GraphicsContext3D> context = m_temporaryOnscreenGraphicsContext3D.release();
2448         if (!context) {
2449             context = GraphicsContext3D::create(getCompositorContextAttributes(), m_page->chrome(), GraphicsContext3D::RenderDirectlyToHostWindow);
2450             if (context)
2451                 context->reshape(std::max(1, m_size.width), std::max(1, m_size.height));
2452         }
2453
2454         m_layerRenderer = LayerRendererChromium::create(context.release(), WebViewImplContentPainter::create(this), WebViewImplScrollbarPainter::create(this));
2455         if (m_layerRenderer) {
2456             m_client->didActivateAcceleratedCompositing(true);
2457             m_isAcceleratedCompositingActive = true;
2458             m_compositorCreationFailed = false;
2459         } else {
2460             m_isAcceleratedCompositingActive = false;
2461             m_client->didActivateAcceleratedCompositing(false);
2462             m_compositorCreationFailed = true;
2463         }
2464     }
2465     if (page())
2466         page()->mainFrame()->view()->setClipsRepaints(!m_isAcceleratedCompositingActive);
2467 }
2468
2469 void WebViewImpl::doComposite()
2470 {
2471     ASSERT(m_layerRenderer);
2472     if (!m_layerRenderer) {
2473         setIsAcceleratedCompositingActive(false);
2474         return;
2475     }
2476
2477     ASSERT(isAcceleratedCompositingActive());
2478     if (!page())
2479         return;
2480
2481     m_layerRenderer->setCompositeOffscreen(settings()->compositeToTextureEnabled());
2482
2483     CCHeadsUpDisplay* hud = m_layerRenderer->headsUpDisplay();
2484     hud->setShowFPSCounter(settings()->showFPSCounter());
2485     hud->setShowPlatformLayerTree(settings()->showPlatformLayerTree());
2486
2487     m_layerRenderer->updateAndDrawLayers();
2488 }
2489
2490 void WebViewImpl::reallocateRenderer()
2491 {
2492     RefPtr<GraphicsContext3D> newContext = GraphicsContext3D::create(
2493             getCompositorContextAttributes(), m_page->chrome(), GraphicsContext3D::RenderDirectlyToHostWindow);
2494     // GraphicsContext3D::create might fail and return 0, in that case LayerRendererChromium::create will also return 0.
2495     RefPtr<LayerRendererChromium> layerRenderer = LayerRendererChromium::create(newContext, WebViewImplContentPainter::create(this), WebViewImplScrollbarPainter::create(this));
2496
2497     // Reattach the root layer.  Child layers will get reattached as a side effect of updateLayersRecursive.
2498     if (layerRenderer) {
2499         m_layerRenderer->transferRootLayer(layerRenderer.get());
2500         m_layerRenderer = layerRenderer;
2501         // FIXME: In MacOS newContext->reshape method needs to be called to
2502         // allocate IOSurfaces. All calls to create a context followed by
2503         // reshape should really be extracted into one function; it is not
2504         // immediately obvious that GraphicsContext3D object will not
2505         // function properly until its reshape method is called.
2506         newContext->reshape(std::max(1, m_size.width), std::max(1, m_size.height));
2507         setRootGraphicsLayer(m_layerRenderer->rootLayer());
2508         // Forces ViewHostMsg_DidActivateAcceleratedCompositing to be sent so
2509         // that the browser process can reacquire surfaces.
2510         m_client->didActivateAcceleratedCompositing(true);
2511     } else
2512         setRootGraphicsLayer(0);
2513 }
2514 #endif
2515
2516 void WebViewImpl::updateLayerRendererViewport()
2517 {
2518     ASSERT(m_layerRenderer);
2519
2520     if (!page())
2521         return;
2522
2523     FrameView* view = page()->mainFrame()->view();
2524     IntRect contentRect = view->visibleContentRect(false);
2525     IntRect visibleRect = view->visibleContentRect(true);
2526     IntPoint scroll(view->scrollX(), view->scrollY());
2527
2528     m_layerRenderer->setViewport(visibleRect, contentRect, scroll);
2529 }
2530
2531 WebGraphicsContext3D* WebViewImpl::graphicsContext3D()
2532 {
2533 #if USE(ACCELERATED_COMPOSITING)
2534     if (m_page->settings()->acceleratedCompositingEnabled() && allowsAcceleratedCompositing()) {
2535         GraphicsContext3D* context = 0;
2536         if (m_layerRenderer)
2537             context = m_layerRenderer->context();
2538         else if (m_temporaryOnscreenGraphicsContext3D)
2539             context = m_temporaryOnscreenGraphicsContext3D.get();
2540         else {
2541             m_temporaryOnscreenGraphicsContext3D = GraphicsContext3D::create(getCompositorContextAttributes(), m_page->chrome(), GraphicsContext3D::RenderDirectlyToHostWindow);
2542             if (m_temporaryOnscreenGraphicsContext3D)
2543                 m_temporaryOnscreenGraphicsContext3D->reshape(std::max(1, m_size.width), std::max(1, m_size.height));
2544             context = m_temporaryOnscreenGraphicsContext3D.get();
2545         }
2546         return GraphicsContext3DInternal::extractWebGraphicsContext3D(context);
2547     }
2548 #endif
2549     return 0;
2550 }
2551
2552 } // namespace WebKit