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 "Chrome.h"

    37 #include "CompositionUnderlineVectorBuilder.h"

    38 #include "ContextMenu.h"

    39 #include "ContextMenuController.h"

    40 #include "ContextMenuItem.h"

    41 #include "CSSStyleSelector.h"

    42 #include "CSSValueKeywords.h"

    43 #include "Cursor.h"

    44 #include "Document.h"

    45 #include "DocumentLoader.h"

    46 #include "DOMUtilitiesPrivate.h"

    47 #include "DragController.h"

    48 #include "DragScrollTimer.h"

    49 #include "DragData.h"

    50 #include "Editor.h"

    51 #include "EventHandler.h"

    52 #include "FocusController.h"

    53 #include "FontDescription.h"

    54 #include "FrameLoader.h"

    55 #include "FrameTree.h"

    56 #include "FrameView.h"

    57 #include "GLES2Context.h"

    58 #include "GLES2ContextInternal.h"

    59 #include "GraphicsContext.h"

    60 #include "HTMLInputElement.h"

    61 #include "HTMLMediaElement.h"

    62 #include "HitTestResult.h"

    63 #include "HTMLNames.h"

    64 #include "Image.h"

    65 #include "InspectorController.h"

    66 #include "IntRect.h"

    67 #include "KeyboardCodes.h"

    68 #include "KeyboardEvent.h"

    69 #include "MIMETypeRegistry.h"

    70 #include "NodeRenderStyle.h"

    71 #include "Page.h"

    72 #include "PageGroup.h"

    73 #include "PageGroupLoadDeferrer.h"

    74 #include "Pasteboard.h"

    75 #include "PlatformContextSkia.h"

    76 #include "PlatformKeyboardEvent.h"

    77 #include "PlatformMouseEvent.h"

    78 #include "PlatformThemeChromiumGtk.h"

    79 #include "PlatformWheelEvent.h"

    80 #include "PopupMenuChromium.h"

    81 #include "PopupMenuClient.h"

    82 #include "ProgressTracker.h"

    83 #include "RenderView.h"

    84 #include "ResourceHandle.h"

    85 #include "SecurityOrigin.h"

    86 #include "SelectionController.h"

    87 #include "Settings.h"

    88 #include "Timer.h"

    89 #include "TypingCommand.h"

    90 #include "Vector.h"

    91 #include "WebAccessibilityObject.h"

    92 #include "WebDevToolsAgentPrivate.h"

    93 #include "WebDevToolsAgentImpl.h"

    94 #include "WebDragData.h"

    95 #include "WebFrameImpl.h"

    96 #include "WebImage.h"

    97 #include "WebInputElement.h"

    98 #include "WebInputEvent.h"

    99 #include "WebInputEventConversion.h"

   100 #include "WebKit.h"

   101 #include "WebKitClient.h"

   102 #include "WebMediaPlayerAction.h"

   103 #include "WebNode.h"

   104 #include "WebPlugin.h"

   105 #include "WebPluginContainerImpl.h"

   106 #include "WebPoint.h"

   107 #include "WebPopupMenuImpl.h"

   108 #include "WebRect.h"

   109 #include "WebSettingsImpl.h"

   110 #include "WebString.h"

   111 #include "WebVector.h"

   112 #include "WebViewClient.h"

   113 #include "wtf/OwnPtr.h"

   114 

   115 #if OS(WINDOWS)

   116 #include "RenderThemeChromiumWin.h"

   117 #else

   118 #if OS(LINUX)

   119 #include "RenderThemeChromiumLinux.h"

   120 #endif

   121 #include "RenderTheme.h"

   122 #endif

   123 

   124 // Get rid of WTF's pow define so we can use std::pow.

   125 #undef pow

   126 #include <cmath> // for std::pow

   127 

   128 using namespace WebCore;

   129 

   130 namespace WebKit {

   131 

   132 // Change the text zoom level by kTextSizeMultiplierRatio each time the user

   133 // zooms text in or out (ie., change by 20%).  The min and max values limit

   134 // text zoom to half and 3x the original text size.  These three values match

   135 // those in Apple's port in WebKit/WebKit/WebView/WebView.mm

   136 static const double textSizeMultiplierRatio = 1.2;

   137 static const double minTextSizeMultiplier = 0.5;

   138 static const double maxTextSizeMultiplier = 3.0;

   139 

   140 // The group name identifies a namespace of pages.  Page group is used on OSX

   141 // for some programs that use HTML views to display things that don't seem like

   142 // web pages to the user (so shouldn't have visited link coloring).  We only use

   143 // one page group.

   144 const char* pageGroupName = "default";

   145 

   146 // Used to defer all page activity in cases where the embedder wishes to run

   147 // a nested event loop. Using a stack enables nesting of message loop invocations.

   148 static Vector<PageGroupLoadDeferrer*> pageGroupLoadDeferrerStack;

   149 

   150 // Ensure that the WebDragOperation enum values stay in sync with the original

   151 // DragOperation constants.

   152 #define COMPILE_ASSERT_MATCHING_ENUM(coreName) \

   153     COMPILE_ASSERT(int(coreName) == int(Web##coreName), dummy##coreName)

   154 COMPILE_ASSERT_MATCHING_ENUM(DragOperationNone);

   155 COMPILE_ASSERT_MATCHING_ENUM(DragOperationCopy);

   156 COMPILE_ASSERT_MATCHING_ENUM(DragOperationLink);

   157 COMPILE_ASSERT_MATCHING_ENUM(DragOperationGeneric);

   158 COMPILE_ASSERT_MATCHING_ENUM(DragOperationPrivate);

   159 COMPILE_ASSERT_MATCHING_ENUM(DragOperationMove);

   160 COMPILE_ASSERT_MATCHING_ENUM(DragOperationDelete);

   161 COMPILE_ASSERT_MATCHING_ENUM(DragOperationEvery);

   162 

   163 static const PopupContainerSettings autoFillPopupSettings = {

   164     false, // setTextOnIndexChange

   165     false, // acceptOnAbandon

   166     true,  // loopSelectionNavigation

   167     false, // restrictWidthOfListBox (For security reasons show the entire entry

   168            // so the user doesn't enter information it did not intend to.)

   169     // For suggestions, we use the direction of the input field as the direction

   170     // of the popup items. The main reason is to keep the display of items in

   171     // drop-down the same as the items in the input field.

   172     PopupContainerSettings::DOMElementDirection,

   173 };

   174 

   175 // WebView ----------------------------------------------------------------

   176 

   177 WebView* WebView::create(WebViewClient* client, WebDevToolsAgentClient* devToolsClient)

   178 {

   179     // Pass the WebViewImpl's self-reference to the caller.

   180     return adoptRef(new WebViewImpl(client, devToolsClient)).leakRef();

   181 }

   182 

   183 void WebView::updateVisitedLinkState(unsigned long long linkHash)

   184 {

   185     Page::visitedStateChanged(PageGroup::pageGroup(pageGroupName), linkHash);

   186 }

   187 

   188 void WebView::resetVisitedLinkState()

   189 {

   190     Page::allVisitedStateChanged(PageGroup::pageGroup(pageGroupName));

   191 }

   192 

   193 void WebView::willEnterModalLoop()

   194 {

   195     PageGroup* pageGroup = PageGroup::pageGroup(pageGroupName);

   196     ASSERT(pageGroup);

   197 

   198     if (pageGroup->pages().isEmpty())

   199         pageGroupLoadDeferrerStack.append(static_cast<PageGroupLoadDeferrer*>(0));

   200     else {

   201         // Pick any page in the page group since we are deferring all pages.

   202         pageGroupLoadDeferrerStack.append(new PageGroupLoadDeferrer(*pageGroup->pages().begin(), true));

   203     }

   204 }

   205 

   206 void WebView::didExitModalLoop()

   207 {

   208     ASSERT(pageGroupLoadDeferrerStack.size());

   209 

   210     delete pageGroupLoadDeferrerStack.last();

   211     pageGroupLoadDeferrerStack.removeLast();

   212 }

   213 

   214 void WebViewImpl::initializeMainFrame(WebFrameClient* frameClient)

   215 {

   216     // NOTE: The WebFrameImpl takes a reference to itself within InitMainFrame

   217     // and releases that reference once the corresponding Frame is destroyed.

   218     RefPtr<WebFrameImpl> frame = WebFrameImpl::create(frameClient);

   219 

   220     frame->initializeAsMainFrame(this);

   221 

   222     // Restrict the access to the local file system

   223     // (see WebView.mm WebView::_commonInitializationWithFrameName).

   224     SecurityOrigin::setLocalLoadPolicy(SecurityOrigin::AllowLocalLoadsForLocalOnly);

   225 }

   226 

   227 WebViewImpl::WebViewImpl(WebViewClient* client, WebDevToolsAgentClient* devToolsClient)

   228     : m_client(client)

   229     , m_backForwardListClientImpl(this)

   230     , m_chromeClientImpl(this)

   231     , m_contextMenuClientImpl(this)

   232     , m_dragClientImpl(this)

   233     , m_editorClientImpl(this)

   234     , m_inspectorClientImpl(this)

   235     , m_observedNewNavigation(false)

   236 #ifndef NDEBUG

   237     , m_newNavigationLoader(0)

   238 #endif

   239     , m_zoomLevel(0)

   240     , m_contextMenuAllowed(false)

   241     , m_doingDragAndDrop(false)

   242     , m_ignoreInputEvents(false)

   243     , m_suppressNextKeypressEvent(false)

   244     , m_initialNavigationPolicy(WebNavigationPolicyIgnore)

   245     , m_imeAcceptEvents(true)

   246     , m_dragTargetDispatch(false)

   247     , m_dragIdentity(0)

   248     , m_dropEffect(DropEffectDefault)

   249     , m_operationsAllowed(WebDragOperationNone)

   250     , m_dragOperation(WebDragOperationNone)

   251     , m_autoFillPopupShowing(false)

   252     , m_autoFillPopupClient(0)

   253     , m_autoFillPopup(0)

   254     , m_isTransparent(false)

   255     , m_tabsToLinks(false)

   256     , m_dragScrollTimer(new DragScrollTimer())

   257 #if USE(ACCELERATED_COMPOSITING)

   258     , m_layerRenderer(0)

   259     , m_isAcceleratedCompositingActive(false)

   260 #endif

   261     , m_gles2Context(0)

   262 {

   263     // WebKit/win/WebView.cpp does the same thing, except they call the

   264     // KJS specific wrapper around this method. We need to have threading

   265     // initialized because CollatorICU requires it.

   266     WTF::initializeThreading();

   267     WTF::initializeMainThread();

   268 

   269     // set to impossible point so we always get the first mouse pos

   270     m_lastMousePosition = WebPoint(-1, -1);

   271 

   272     if (devToolsClient)

   273         m_devToolsAgent = new WebDevToolsAgentImpl(this, devToolsClient);

   274 

   275     m_page.set(new Page(&m_chromeClientImpl, &m_contextMenuClientImpl, &m_editorClientImpl, &m_dragClientImpl, &m_inspectorClientImpl, 0, 0, 0, 0));

   276 

   277     // the page will take ownership of the various clients

   278 

   279     m_page->backForwardList()->setClient(&m_backForwardListClientImpl);

   280     m_page->setGroupName(pageGroupName);

   281 

   282     m_inspectorSettingsMap.set(new SettingsMap);

   283 }

   284 

   285 WebViewImpl::~WebViewImpl()

   286 {

   287     ASSERT(!m_page);

   288 }

   289 

   290 RenderTheme* WebViewImpl::theme() const

   291 {

   292     return m_page.get() ? m_page->theme() : RenderTheme::defaultTheme().get();

   293 }

   294 

   295 WebFrameImpl* WebViewImpl::mainFrameImpl()

   296 {

   297     return m_page.get() ? WebFrameImpl::fromFrame(m_page->mainFrame()) : 0;

   298 }

   299 

   300 bool WebViewImpl::tabKeyCyclesThroughElements() const

   301 {

   302     ASSERT(m_page.get());

   303     return m_page->tabKeyCyclesThroughElements();

   304 }

   305 

   306 void WebViewImpl::setTabKeyCyclesThroughElements(bool value)

   307 {

   308     if (m_page)

   309         m_page->setTabKeyCyclesThroughElements(value);

   310 }

   311 

   312 void WebViewImpl::mouseMove(const WebMouseEvent& event)

   313 {

   314     if (!mainFrameImpl() || !mainFrameImpl()->frameView())

   315         return;

   316 

   317     m_lastMousePosition = WebPoint(event.x, event.y);

   318 

   319     // We call mouseMoved here instead of handleMouseMovedEvent because we need

   320     // our ChromeClientImpl to receive changes to the mouse position and

   321     // tooltip text, and mouseMoved handles all of that.

   322     mainFrameImpl()->frame()->eventHandler()->mouseMoved(

   323         PlatformMouseEventBuilder(mainFrameImpl()->frameView(), event));

   324 }

   325 

   326 void WebViewImpl::mouseLeave(const WebMouseEvent& event)

   327 {

   328     // This event gets sent as the main frame is closing.  In that case, just

   329     // ignore it.

   330     if (!mainFrameImpl() || !mainFrameImpl()->frameView())

   331         return;

   332 

   333     m_client->setMouseOverURL(WebURL());

   334 

   335     mainFrameImpl()->frame()->eventHandler()->handleMouseMoveEvent(

   336         PlatformMouseEventBuilder(mainFrameImpl()->frameView(), event));

   337 }

   338 

   339 void WebViewImpl::mouseDown(const WebMouseEvent& event)

   340 {

   341     if (!mainFrameImpl() || !mainFrameImpl()->frameView())

   342         return;

   343 

   344     // If there is a select popup open, close it as the user is clicking on

   345     // the page (outside of the popup).  We also save it so we can prevent a

   346     // click on the select element from immediately reopening the popup.

   347     RefPtr<WebCore::PopupContainer> selectPopup;

   348     if (event.button == WebMouseEvent::ButtonLeft) {

   349         selectPopup = m_selectPopup;

   350         hideSelectPopup();

   351         ASSERT(!m_selectPopup);

   352     }

   353 

   354     m_lastMouseDownPoint = WebPoint(event.x, event.y);

   355 

   356     RefPtr<Node> clickedNode;

   357     if (event.button == WebMouseEvent::ButtonLeft) {

   358         IntPoint point(event.x, event.y);

   359         point = m_page->mainFrame()->view()->windowToContents(point);

   360         HitTestResult result(m_page->mainFrame()->eventHandler()->hitTestResultAtPoint(point, false));

   361         Node* hitNode = result.innerNonSharedNode();

   362 

   363         // Take capture on a mouse down on a plugin so we can send it mouse events.

   364         if (hitNode && hitNode->renderer() && hitNode->renderer()->isEmbeddedObject())

   365             m_mouseCaptureNode = hitNode;

   366 

   367         // If a text field that has focus is clicked again, we should display the

   368         // AutoFill popup.

   369         RefPtr<Node> focusedNode = focusedWebCoreNode();

   370         if (focusedNode.get() && toHTMLInputElement(focusedNode.get())) {

   371             if (hitNode == focusedNode) {

   372                 // Already focused text field was clicked, let's remember this.  If

   373                 // focus has not changed after the mouse event is processed, we'll

   374                 // trigger the autocomplete.

   375                 clickedNode = focusedNode;

   376             }

   377         }

   378     }

   379 

   380     mainFrameImpl()->frame()->loader()->resetMultipleFormSubmissionProtection();

   381 

   382     mainFrameImpl()->frame()->eventHandler()->handleMousePressEvent(

   383         PlatformMouseEventBuilder(mainFrameImpl()->frameView(), event));

   384 

   385     if (clickedNode.get() && clickedNode == focusedWebCoreNode()) {

   386         // Focus has not changed, show the AutoFill popup.

   387         static_cast<EditorClientImpl*>(m_page->editorClient())->

   388             showFormAutofillForNode(clickedNode.get());

   389     }

   390     if (m_selectPopup && m_selectPopup == selectPopup) {

   391         // That click triggered a select popup which is the same as the one that

   392         // was showing before the click.  It means the user clicked the select

   393         // while the popup was showing, and as a result we first closed then

   394         // immediately reopened the select popup.  It needs to be closed.

   395         hideSelectPopup();

   396     }

   397 

   398     // Dispatch the contextmenu event regardless of if the click was swallowed.

   399     // On Windows, we handle it on mouse up, not down.

   400 #if OS(DARWIN)

   401     if (event.button == WebMouseEvent::ButtonRight

   402         || (event.button == WebMouseEvent::ButtonLeft

   403             && event.modifiers & WebMouseEvent::ControlKey))

   404         mouseContextMenu(event);

   405 #elif OS(LINUX)

   406     if (event.button == WebMouseEvent::ButtonRight)

   407         mouseContextMenu(event);

   408 #endif

   409 }

   410 

   411 void WebViewImpl::mouseContextMenu(const WebMouseEvent& event)

   412 {

   413     if (!mainFrameImpl() || !mainFrameImpl()->frameView())

   414         return;

   415 

   416     m_page->contextMenuController()->clearContextMenu();

   417 

   418     PlatformMouseEventBuilder pme(mainFrameImpl()->frameView(), event);

   419 

   420     // Find the right target frame. See issue 1186900.

   421     HitTestResult result = hitTestResultForWindowPos(pme.pos());

   422     Frame* targetFrame;

   423     if (result.innerNonSharedNode())

   424         targetFrame = result.innerNonSharedNode()->document()->frame();

   425     else

   426         targetFrame = m_page->focusController()->focusedOrMainFrame();

   427 

   428 #if OS(WINDOWS)

   429     targetFrame->view()->setCursor(pointerCursor());

   430 #endif

   431 

   432     m_contextMenuAllowed = true;

   433     targetFrame->eventHandler()->sendContextMenuEvent(pme);

   434     m_contextMenuAllowed = false;

   435     // Actually showing the context menu is handled by the ContextMenuClient

   436     // implementation...

   437 }

   438 

   439 void WebViewImpl::mouseUp(const WebMouseEvent& event)

   440 {

   441     if (!mainFrameImpl() || !mainFrameImpl()->frameView())

   442         return;

   443 

   444 #if OS(LINUX)

   445     // If the event was a middle click, attempt to copy text into the focused

   446     // frame. We execute this before we let the page have a go at the event

   447     // because the page may change what is focused during in its event handler.

   448     //

   449     // This code is in the mouse up handler. There is some debate about putting

   450     // this here, as opposed to the mouse down handler.

   451     //   xterm: pastes on up.

   452     //   GTK: pastes on down.

   453     //   Firefox: pastes on up.

   454     //   Midori: couldn't paste at all with 0.1.2

   455     //

   456     // There is something of a webcompat angle to this well, as highlighted by

   457     // crbug.com/14608. Pages can clear text boxes 'onclick' and, if we paste on

   458     // down then the text is pasted just before the onclick handler runs and

   459     // clears the text box. So it's important this happens after the

   460     // handleMouseReleaseEvent() earlier in this function

   461     if (event.button == WebMouseEvent::ButtonMiddle) {

   462         Frame* focused = focusedWebCoreFrame();

   463         FrameView* view = m_page->mainFrame()->view();

   464         IntPoint clickPoint(m_lastMouseDownPoint.x, m_lastMouseDownPoint.y);

   465         IntPoint contentPoint = view->windowToContents(clickPoint);

   466         HitTestResult hitTestResult = focused->eventHandler()->hitTestResultAtPoint(contentPoint, false, false, ShouldHitTestScrollbars);

   467         // We don't want to send a paste when middle clicking a scroll bar or a

   468         // link (which will navigate later in the code).  The main scrollbars

   469         // have to be handled separately.

   470         if (!hitTestResult.scrollbar() && !hitTestResult.isLiveLink() && focused && !view->scrollbarAtPoint(clickPoint)) {

   471             Editor* editor = focused->editor();

   472             Pasteboard* pasteboard = Pasteboard::generalPasteboard();

   473             bool oldSelectionMode = pasteboard->isSelectionMode();

   474             pasteboard->setSelectionMode(true);

   475             editor->command(AtomicString("Paste")).execute();

   476             pasteboard->setSelectionMode(oldSelectionMode);

   477         }

   478     }

   479 #endif

   480 

   481     mainFrameImpl()->frame()->eventHandler()->handleMouseReleaseEvent(

   482         PlatformMouseEventBuilder(mainFrameImpl()->frameView(), event));

   483 

   484 #if OS(WINDOWS)

   485     // Dispatch the contextmenu event regardless of if the click was swallowed.

   486     // On Mac/Linux, we handle it on mouse down, not up.

   487     if (event.button == WebMouseEvent::ButtonRight)

   488         mouseContextMenu(event);

   489 #endif

   490 }

   491 

   492 void WebViewImpl::mouseWheel(const WebMouseWheelEvent& event)

   493 {

   494     PlatformWheelEventBuilder platformEvent(mainFrameImpl()->frameView(), event);

   495     mainFrameImpl()->frame()->eventHandler()->handleWheelEvent(platformEvent);

   496 }

   497 

   498 bool WebViewImpl::keyEvent(const WebKeyboardEvent& event)

   499 {

   500     ASSERT((event.type == WebInputEvent::RawKeyDown)

   501         || (event.type == WebInputEvent::KeyDown)

   502         || (event.type == WebInputEvent::KeyUp));

   503 

   504     // Please refer to the comments explaining the m_suppressNextKeypressEvent

   505     // member.

   506     // The m_suppressNextKeypressEvent is set if the KeyDown is handled by

   507     // Webkit. A keyDown event is typically associated with a keyPress(char)

   508     // event and a keyUp event. We reset this flag here as this is a new keyDown

   509     // event.

   510     m_suppressNextKeypressEvent = false;

   511 

   512     // Give any select popup a chance at consuming the key event.

   513     if (selectPopupHandleKeyEvent(event))

   514         return true;

   515 

   516     // Give Autocomplete a chance to consume the key events it is interested in.

   517     if (autocompleteHandleKeyEvent(event))

   518         return true;

   519 

   520     Frame* frame = focusedWebCoreFrame();

   521     if (!frame)

   522         return false;

   523 

   524     EventHandler* handler = frame->eventHandler();

   525     if (!handler)

   526         return keyEventDefault(event);

   527 

   528 #if OS(WINDOWS) || OS(LINUX)

   529     const WebInputEvent::Type contextMenuTriggeringEventType =

   530 #if OS(WINDOWS)

   531         WebInputEvent::KeyUp;

   532 #elif OS(LINUX)

   533         WebInputEvent::RawKeyDown;

   534 #endif

   535 

   536     if (((!event.modifiers && (event.windowsKeyCode == VKEY_APPS))

   537         || ((event.modifiers == WebInputEvent::ShiftKey) && (event.windowsKeyCode == VKEY_F10)))

   538         && event.type == contextMenuTriggeringEventType) {

   539         sendContextMenuEvent(event);

   540         return true;

   541     }

   542 #endif

   543 

   544     // It's not clear if we should continue after detecting a capslock keypress.

   545     // I'll err on the side of continuing, which is the pre-existing behaviour.

   546     if (event.windowsKeyCode == VKEY_CAPITAL)

   547         handler->capsLockStateMayHaveChanged();

   548 

   549     PlatformKeyboardEventBuilder evt(event);

   550 

   551     if (handler->keyEvent(evt)) {

   552         if (WebInputEvent::RawKeyDown == event.type) {

   553             // Suppress the next keypress event unless the focused node is a plug-in node.

   554             // (Flash needs these keypress events to handle non-US keyboards.)

   555             Node* node = frame->document()->focusedNode();

   556             if (!node || !node->renderer() || !node->renderer()->isEmbeddedObject())

   557                 m_suppressNextKeypressEvent = true;

   558         }

   559         return true;

   560     }

   561 

   562     return keyEventDefault(event);

   563 }

   564 

   565 bool WebViewImpl::selectPopupHandleKeyEvent(const WebKeyboardEvent& event)

   566 {

   567     if (!m_selectPopup)

   568         return false;

   569 

   570     return m_selectPopup->handleKeyEvent(PlatformKeyboardEventBuilder(event));

   571 }

   572 

   573 bool WebViewImpl::autocompleteHandleKeyEvent(const WebKeyboardEvent& event)

   574 {

   575     if (!m_autoFillPopupShowing

   576         // Home and End should be left to the text field to process.

   577         || event.windowsKeyCode == VKEY_HOME

   578         || event.windowsKeyCode == VKEY_END)

   579       return false;

   580 

   581     // Pressing delete triggers the removal of the selected suggestion from the DB.

   582     if (event.windowsKeyCode == VKEY_DELETE

   583         && m_autoFillPopup->selectedIndex() != -1) {

   584         Node* node = focusedWebCoreNode();

   585         if (!node || (node->nodeType() != Node::ELEMENT_NODE)) {

   586             ASSERT_NOT_REACHED();

   587             return false;

   588         }

   589         Element* element = static_cast<Element*>(node);

   590         if (!element->hasLocalName(HTMLNames::inputTag)) {

   591             ASSERT_NOT_REACHED();

   592             return false;

   593         }

   594 

   595         int selectedIndex = m_autoFillPopup->selectedIndex();

   596 

   597         if (!m_autoFillPopupClient->canRemoveSuggestionAtIndex(selectedIndex))

   598             return false;

   599 

   600         WebString name = WebInputElement(static_cast<HTMLInputElement*>(element)).nameForAutofill();

   601         WebString value = m_autoFillPopupClient->itemText(selectedIndex);

   602         m_client->removeAutofillSuggestions(name, value);

   603         // Update the entries in the currently showing popup to reflect the

   604         // deletion.

   605         m_autoFillPopupClient->removeSuggestionAtIndex(selectedIndex);

   606         refreshAutoFillPopup();

   607         return false;

   608     }

   609 

   610     if (!m_autoFillPopup->isInterestedInEventForKey(event.windowsKeyCode))

   611         return false;

   612 

   613     if (m_autoFillPopup->handleKeyEvent(PlatformKeyboardEventBuilder(event))) {

   614         // We need to ignore the next Char event after this otherwise pressing

   615         // enter when selecting an item in the menu will go to the page.

   616         if (WebInputEvent::RawKeyDown == event.type)

   617             m_suppressNextKeypressEvent = true;

   618         return true;

   619     }

   620 

   621     return false;

   622 }

   623 

   624 bool WebViewImpl::charEvent(const WebKeyboardEvent& event)

   625 {

   626     ASSERT(event.type == WebInputEvent::Char);

   627 

   628     // Please refer to the comments explaining the m_suppressNextKeypressEvent

   629     // member.  The m_suppressNextKeypressEvent is set if the KeyDown is

   630     // handled by Webkit. A keyDown event is typically associated with a

   631     // keyPress(char) event and a keyUp event. We reset this flag here as it

   632     // only applies to the current keyPress event.

   633     bool suppress = m_suppressNextKeypressEvent;

   634     m_suppressNextKeypressEvent = false;

   635 

   636     Frame* frame = focusedWebCoreFrame();

   637     if (!frame)

   638         return suppress;

   639 

   640     EventHandler* handler = frame->eventHandler();

   641     if (!handler)

   642         return suppress || keyEventDefault(event);

   643 

   644     PlatformKeyboardEventBuilder evt(event);

   645     if (!evt.isCharacterKey())

   646         return true;

   647 

   648     // Accesskeys are triggered by char events and can't be suppressed.

   649     if (handler->handleAccessKey(evt))

   650         return true;

   651 

   652     // Safari 3.1 does not pass off windows system key messages (WM_SYSCHAR) to

   653     // the eventHandler::keyEvent. We mimic this behavior on all platforms since

   654     // for now we are converting other platform's key events to windows key

   655     // events.

   656     if (evt.isSystemKey())

   657         return false;

   658 

   659     if (!suppress && !handler->keyEvent(evt))

   660         return keyEventDefault(event);

   661 

   662     return true;

   663 }

   664 

   665 #if ENABLE(TOUCH_EVENTS)

   666 bool WebViewImpl::touchEvent(const WebTouchEvent& event)

   667 {

   668     if (!mainFrameImpl() || !mainFrameImpl()->frameView())

   669         return false;

   670 

   671     PlatformTouchEventBuilder touchEventBuilder(mainFrameImpl()->frameView(), event);

   672     return mainFrameImpl()->frame()->eventHandler()->handleTouchEvent(touchEventBuilder);

   673 }

   674 #endif

   675 

   676 #if OS(WINDOWS) || OS(LINUX)

   677 // Mac has no way to open a context menu based on a keyboard event.

   678 bool WebViewImpl::sendContextMenuEvent(const WebKeyboardEvent& event)

   679 {

   680     // The contextMenuController() holds onto the last context menu that was

   681     // popped up on the page until a new one is created. We need to clear

   682     // this menu before propagating the event through the DOM so that we can

   683     // detect if we create a new menu for this event, since we won't create

   684     // a new menu if the DOM swallows the event and the defaultEventHandler does

   685     // not run.

   686     page()->contextMenuController()->clearContextMenu();

   687 

   688     m_contextMenuAllowed = true;

   689     Frame* focusedFrame = page()->focusController()->focusedOrMainFrame();

   690     bool handled = focusedFrame->eventHandler()->sendContextMenuEventForKey();

   691     m_contextMenuAllowed = false;

   692     return handled;

   693 }

   694 #endif

   695 

   696 bool WebViewImpl::keyEventDefault(const WebKeyboardEvent& event)

   697 {

   698     Frame* frame = focusedWebCoreFrame();

   699     if (!frame)

   700         return false;

   701 

   702     switch (event.type) {

   703     case WebInputEvent::Char:

   704         if (event.windowsKeyCode == VKEY_SPACE) {

   705             int keyCode = ((event.modifiers & WebInputEvent::ShiftKey) ? VKEY_PRIOR : VKEY_NEXT);

   706             return scrollViewWithKeyboard(keyCode, event.modifiers);

   707         }

   708         break;

   709     case WebInputEvent::RawKeyDown:

   710         if (event.modifiers == WebInputEvent::ControlKey) {

   711             switch (event.windowsKeyCode) {

   712 #if !OS(DARWIN)

   713             case 'A':

   714                 focusedFrame()->executeCommand(WebString::fromUTF8("SelectAll"));

   715                 return true;

   716             case VKEY_INSERT:

   717             case 'C':

   718                 focusedFrame()->executeCommand(WebString::fromUTF8("Copy"));

   719                 return true;

   720 #endif

   721             // Match FF behavior in the sense that Ctrl+home/end are the only Ctrl

   722             // key combinations which affect scrolling. Safari is buggy in the

   723             // sense that it scrolls the page for all Ctrl+scrolling key

   724             // combinations. For e.g. Ctrl+pgup/pgdn/up/down, etc.

   725             case VKEY_HOME:

   726             case VKEY_END:

   727                 break;

   728             default:

   729                 return false;

   730             }

   731         }

   732         if (!event.isSystemKey && !(event.modifiers & WebInputEvent::ShiftKey))

   733             return scrollViewWithKeyboard(event.windowsKeyCode, event.modifiers);

   734         break;

   735     default:

   736         break;

   737     }

   738     return false;

   739 }

   740 

   741 bool WebViewImpl::scrollViewWithKeyboard(int keyCode, int modifiers)

   742 {

   743     ScrollDirection scrollDirection;

   744     ScrollGranularity scrollGranularity;

   745     if (!mapKeyCodeForScroll(keyCode, &scrollDirection, &scrollGranularity))

   746         return false;

   747     return propagateScroll(scrollDirection, scrollGranularity);

   748 }

   749 

   750 bool WebViewImpl::mapKeyCodeForScroll(int keyCode,

   751                                       WebCore::ScrollDirection* scrollDirection,

   752                                       WebCore::ScrollGranularity* scrollGranularity)

   753 {

   754     switch (keyCode) {

   755     case VKEY_LEFT:

   756         *scrollDirection = ScrollLeft;

   757         *scrollGranularity = ScrollByLine;

   758         break;

   759     case VKEY_RIGHT:

   760         *scrollDirection = ScrollRight;

   761         *scrollGranularity = ScrollByLine;

   762         break;

   763     case VKEY_UP:

   764         *scrollDirection = ScrollUp;

   765         *scrollGranularity = ScrollByLine;

   766         break;

   767     case VKEY_DOWN:

   768         *scrollDirection = ScrollDown;

   769         *scrollGranularity = ScrollByLine;

   770         break;

   771     case VKEY_HOME:

   772         *scrollDirection = ScrollUp;

   773         *scrollGranularity = ScrollByDocument;

   774         break;

   775     case VKEY_END:

   776         *scrollDirection = ScrollDown;

   777         *scrollGranularity = ScrollByDocument;

   778         break;

   779     case VKEY_PRIOR:  // page up

   780         *scrollDirection = ScrollUp;

   781         *scrollGranularity = ScrollByPage;

   782         break;

   783     case VKEY_NEXT:  // page down

   784         *scrollDirection = ScrollDown;

   785         *scrollGranularity = ScrollByPage;

   786         break;

   787     default:

   788         return false;

   789     }

   790 

   791     return true;

   792 }

   793 

   794 void WebViewImpl::hideSelectPopup()

   795 {

   796     if (m_selectPopup.get())

   797         m_selectPopup->hidePopup();

   798 }

   799 

   800 bool WebViewImpl::propagateScroll(ScrollDirection scrollDirection,

   801                                   ScrollGranularity scrollGranularity)

   802 {

   803     Frame* frame = focusedWebCoreFrame();

   804     if (!frame)

   805         return false;

   806 

   807     bool scrollHandled =

   808         frame->eventHandler()->scrollOverflow(scrollDirection,

   809                                               scrollGranularity);

   810     Frame* currentFrame = frame;

   811     while (!scrollHandled && currentFrame) {

   812         scrollHandled = currentFrame->view()->scroll(scrollDirection,

   813                                                      scrollGranularity);

   814         currentFrame = currentFrame->tree()->parent();

   815     }

   816     return scrollHandled;

   817 }

   818 

   819 void  WebViewImpl::popupOpened(WebCore::PopupContainer* popupContainer)

   820 {

   821     if (popupContainer->popupType() == WebCore::PopupContainer::Select) {

   822         ASSERT(!m_selectPopup);

   823         m_selectPopup = popupContainer;

   824     }

   825 }

   826 

   827 void  WebViewImpl::popupClosed(WebCore::PopupContainer* popupContainer)

   828 {

   829     if (popupContainer->popupType() == WebCore::PopupContainer::Select) {

   830         ASSERT(m_selectPopup.get());

   831         m_selectPopup = 0;

   832     }

   833 }

   834 

   835 void WebViewImpl::hideAutoFillPopup()

   836 {

   837     if (m_autoFillPopupShowing) {

   838         m_autoFillPopup->hidePopup();

   839         m_autoFillPopupShowing = false;

   840     }

   841 }

   842 

   843 Frame* WebViewImpl::focusedWebCoreFrame()

   844 {

   845     return m_page.get() ? m_page->focusController()->focusedOrMainFrame() : 0;

   846 }

   847 

   848 WebViewImpl* WebViewImpl::fromPage(Page* page)

   849 {

   850     if (!page)

   851         return 0;

   852 

   853     return static_cast<ChromeClientImpl*>(page->chrome()->client())->webView();

   854 }

   855 

   856 // WebWidget ------------------------------------------------------------------

   857 

   858 void WebViewImpl::close()

   859 {

   860     RefPtr<WebFrameImpl> mainFrameImpl;

   861 

   862     if (m_page.get()) {

   863         // Initiate shutdown for the entire frameset.  This will cause a lot of

   864         // notifications to be sent.

   865         if (m_page->mainFrame()) {

   866             mainFrameImpl = WebFrameImpl::fromFrame(m_page->mainFrame());

   867             m_page->mainFrame()->loader()->frameDetached();

   868         }

   869         m_page.clear();

   870     }

   871 

   872     // Should happen after m_page.clear().

   873     if (m_devToolsAgent.get())

   874         m_devToolsAgent.clear();

   875 

   876     // Reset the delegate to prevent notifications being sent as we're being

   877     // deleted.

   878     m_client = 0;

   879 

   880     deref();  // Balances ref() acquired in WebView::create

   881 }

   882 

   883 void WebViewImpl::resize(const WebSize& newSize)

   884 {

   885     if (m_size == newSize)

   886         return;

   887     m_size = newSize;

   888 

   889     if (mainFrameImpl()->frameView()) {

   890         mainFrameImpl()->frameView()->resize(m_size.width, m_size.height);

   891         mainFrameImpl()->frame()->eventHandler()->sendResizeEvent();

   892     }

   893 

   894     if (m_client) {

   895         WebRect damagedRect(0, 0, m_size.width, m_size.height);

   896         m_client->didInvalidateRect(damagedRect);

   897     }

   898 }

   899 

   900 void WebViewImpl::layout()

   901 {

   902     WebFrameImpl* webframe = mainFrameImpl();

   903     if (webframe) {

   904         // In order for our child HWNDs (NativeWindowWidgets) to update properly,

   905         // they need to be told that we are updating the screen.  The problem is

   906         // that the native widgets need to recalculate their clip region and not

   907         // overlap any of our non-native widgets.  To force the resizing, call

   908         // setFrameRect().  This will be a quick operation for most frames, but

   909         // the NativeWindowWidgets will update a proper clipping region.

   910         FrameView* view = webframe->frameView();

   911         if (view)

   912             view->setFrameRect(view->frameRect());

   913 

   914         // setFrameRect may have the side-effect of causing existing page

   915         // layout to be invalidated, so layout needs to be called last.

   916 

   917         webframe->layout();

   918     }

   919 }

   920 

   921 void WebViewImpl::paint(WebCanvas* canvas, const WebRect& rect)

   922 {

   923 

   924 #if USE(ACCELERATED_COMPOSITING)

   925     if (!isAcceleratedCompositingActive()) {

   926 #endif

   927         WebFrameImpl* webframe = mainFrameImpl();

   928         if (webframe)

   929             webframe->paint(canvas, rect);

   930 #if USE(ACCELERATED_COMPOSITING)

   931     } else {

   932         // Draw the contents of the root layer.

   933         updateRootLayerContents(rect);

   934 

   935         WebFrameImpl* webframe = mainFrameImpl();

   936         if (!webframe)

   937             return;

   938         FrameView* view = webframe->frameView();

   939         if (!view)

   940             return;

   941 

   942         // The visibleRect includes scrollbars whereas the contentRect doesn't.

   943         IntRect visibleRect = view->visibleContentRect(true);

   944         IntRect contentRect = view->visibleContentRect(false);

   945 

   946         // Ask the layer compositor to redraw all the layers.

   947         m_layerRenderer->drawLayers(rect, visibleRect, contentRect, IntPoint(view->scrollX(), view->scrollY()));

   948     }

   949 #endif

   950 }

   951 

   952 // FIXME: m_currentInputEvent should be removed once ChromeClient::show() can

   953 // get the current-event information from WebCore.

   954 const WebInputEvent* WebViewImpl::m_currentInputEvent = 0;

   955 

   956 bool WebViewImpl::handleInputEvent(const WebInputEvent& inputEvent)

   957 {

   958     // If we've started a drag and drop operation, ignore input events until

   959     // we're done.

   960     if (m_doingDragAndDrop)

   961         return true;

   962 

   963     if (m_ignoreInputEvents)

   964         return true;

   965 

   966     if (m_mouseCaptureNode.get() && WebInputEvent::isMouseEventType(inputEvent.type)) {

   967         // Save m_mouseCaptureNode since mouseCaptureLost() will clear it.

   968         RefPtr<Node> node = m_mouseCaptureNode;

   969 

   970         // Not all platforms call mouseCaptureLost() directly.

   971         if (inputEvent.type == WebInputEvent::MouseUp)

   972             mouseCaptureLost();

   973 

   974         AtomicString eventType;

   975         switch (inputEvent.type) {

   976         case WebInputEvent::MouseMove:

   977             eventType = eventNames().mousemoveEvent;

   978             break;

   979         case WebInputEvent::MouseLeave:

   980             eventType = eventNames().mouseoutEvent;

   981             break;

   982         case WebInputEvent::MouseDown:

   983             eventType = eventNames().mousedownEvent;

   984             break;

   985         case WebInputEvent::MouseUp:

   986             eventType = eventNames().mouseupEvent;

   987             break;

   988         default:

   989             ASSERT_NOT_REACHED();

   990         }

   991 

   992         node->dispatchMouseEvent(

   993               PlatformMouseEventBuilder(mainFrameImpl()->frameView(), *static_cast<const WebMouseEvent*>(&inputEvent)),

   994               eventType);

   995         return true;

   996     }

   997 

   998     // FIXME: Remove m_currentInputEvent.

   999     // This only exists to allow ChromeClient::show() to know which mouse button

  1000     // triggered a window.open event.

  1001     // Safari must perform a similar hack, ours is in our WebKit glue layer

  1002     // theirs is in the application.  This should go when WebCore can be fixed

  1003     // to pass more event information to ChromeClient::show()

  1004     m_currentInputEvent = &inputEvent;

  1005 

  1006     bool handled = true;

  1007 

  1008     // FIXME: WebKit seems to always return false on mouse events processing

  1009     // methods. For now we'll assume it has processed them (as we are only

  1010     // interested in whether keyboard events are processed).

  1011     switch (inputEvent.type) {

  1012     case WebInputEvent::MouseMove:

  1013         mouseMove(*static_cast<const WebMouseEvent*>(&inputEvent));

  1014         break;

  1015 

  1016     case WebInputEvent::MouseLeave:

  1017         mouseLeave(*static_cast<const WebMouseEvent*>(&inputEvent));

  1018         break;

  1019 

  1020     case WebInputEvent::MouseWheel:

  1021         mouseWheel(*static_cast<const WebMouseWheelEvent*>(&inputEvent));

  1022         break;

  1023 

  1024     case WebInputEvent::MouseDown:

  1025         mouseDown(*static_cast<const WebMouseEvent*>(&inputEvent));

  1026         break;

  1027 

  1028     case WebInputEvent::MouseUp:

  1029         mouseUp(*static_cast<const WebMouseEvent*>(&inputEvent));

  1030         break;

  1031 

  1032     case WebInputEvent::RawKeyDown:

  1033     case WebInputEvent::KeyDown:

  1034     case WebInputEvent::KeyUp:

  1035         handled = keyEvent(*static_cast<const WebKeyboardEvent*>(&inputEvent));

  1036         break;

  1037 

  1038     case WebInputEvent::Char:

  1039         handled = charEvent(*static_cast<const WebKeyboardEvent*>(&inputEvent));

  1040         break;

  1041 

  1042 #if ENABLE(TOUCH_EVENTS)

  1043     case WebInputEvent::TouchStart:

  1044     case WebInputEvent::TouchMove:

  1045     case WebInputEvent::TouchEnd:

  1046     case WebInputEvent::TouchCancel:

  1047         handled = touchEvent(*static_cast<const WebTouchEvent*>(&inputEvent));

  1048         break;

  1049 #endif

  1050 

  1051     default:

  1052         handled = false;

  1053     }

  1054 

  1055     m_currentInputEvent = 0;

  1056 

  1057     return handled;

  1058 }

  1059 

  1060 void WebViewImpl::mouseCaptureLost()

  1061 {

  1062     m_mouseCaptureNode = 0;

  1063 }

  1064 

  1065 void WebViewImpl::setFocus(bool enable)

  1066 {

  1067     m_page->focusController()->setFocused(enable);

  1068     if (enable) {

  1069         // Note that we don't call setActive() when disabled as this cause extra

  1070         // focus/blur events to be dispatched.

  1071         m_page->focusController()->setActive(true);

  1072         RefPtr<Frame> focusedFrame = m_page->focusController()->focusedFrame();

  1073         if (focusedFrame) {

  1074             Node* focusedNode = focusedFrame->document()->focusedNode();

  1075             if (focusedNode && focusedNode->isElementNode()

  1076                 && focusedFrame->selection()->selection().isNone()) {

  1077                 // If the selection was cleared while the WebView was not

  1078                 // focused, then the focus element shows with a focus ring but

  1079                 // no caret and does respond to keyboard inputs.

  1080                 Element* element = static_cast<Element*>(focusedNode);

  1081                 if (element->isTextFormControl())

  1082                     element->updateFocusAppearance(true);

  1083                 else if (focusedNode->isContentEditable()) {

  1084                     // updateFocusAppearance() selects all the text of

  1085                     // contentseditable DIVs. So we set the selection explicitly

  1086                     // instead. Note that this has the side effect of moving the

  1087                     // caret back to the beginning of the text.

  1088                     Position position(focusedNode, 0,

  1089                                       Position::PositionIsOffsetInAnchor);

  1090                     focusedFrame->selection()->setSelection(

  1091                         VisibleSelection(position, SEL_DEFAULT_AFFINITY));

  1092                 }

  1093             }

  1094         }

  1095         m_imeAcceptEvents = true;

  1096     } else {

  1097         hideAutoFillPopup();

  1098         hideSelectPopup();

  1099 

  1100         // Clear focus on the currently focused frame if any.

  1101         if (!m_page.get())

  1102             return;

  1103 

  1104         Frame* frame = m_page->mainFrame();

  1105         if (!frame)

  1106             return;

  1107 

  1108         RefPtr<Frame> focusedFrame = m_page->focusController()->focusedFrame();

  1109         if (focusedFrame.get()) {

  1110             // Finish an ongoing composition to delete the composition node.

  1111             Editor* editor = focusedFrame->editor();

  1112             if (editor && editor->hasComposition())

  1113                 editor->confirmComposition();

  1114             m_imeAcceptEvents = false;

  1115         }

  1116     }

  1117 }

  1118 

  1119 bool WebViewImpl::setComposition(

  1120     const WebString& text,

  1121     const WebVector<WebCompositionUnderline>& underlines,

  1122     int selectionStart,

  1123     int selectionEnd)

  1124 {

  1125     Frame* focused = focusedWebCoreFrame();

  1126     if (!focused || !m_imeAcceptEvents)

  1127         return false;

  1128     Editor* editor = focused->editor();

  1129     if (!editor)

  1130         return false;

  1131 

  1132     // The input focus has been moved to another WebWidget object.

  1133     // We should use this |editor| object only to complete the ongoing

  1134     // composition.

  1135     if (!editor->canEdit() && !editor->hasComposition())