/*

 * Copyright (C) 2010 Google Inc. All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions are

 * met:

 *

 *     * Redistributions of source code must retain the above copyright

 * notice, this list of conditions and the following disclaimer.

 *     * Redistributions in binary form must reproduce the above

 * copyright notice, this list of conditions and the following disclaimer

 * in the documentation and/or other materials provided with the

 * distribution.

 *     * Neither the name of Google Inc. nor the names of its

 * contributors may be used to endorse or promote products derived from

 * this software without specific prior written permission.

 *

 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 */

#include "config.h"

#include "WebViewImpl.h"

#include "AutoFillPopupMenuClient.h"

#include "AXObjectCache.h"

#include "Chrome.h"

#include "CompositionUnderlineVectorBuilder.h"

#include "ContextMenu.h"

#include "ContextMenuController.h"

#include "ContextMenuItem.h"

#include "CSSStyleSelector.h"

#include "CSSValueKeywords.h"

#include "Cursor.h"

#include "Document.h"

#include "DocumentLoader.h"

#include "DOMUtilitiesPrivate.h"

#include "DragController.h"

#include "DragScrollTimer.h"

#include "DragData.h"

#include "Editor.h"

#include "EventHandler.h"

#include "FocusController.h"

#include "FontDescription.h"

#include "FrameLoader.h"

#include "FrameTree.h"

#include "FrameView.h"

#include "GLES2Context.h"

#include "GLES2ContextInternal.h"

#include "GraphicsContext.h"

#include "HTMLInputElement.h"

#include "HTMLMediaElement.h"

#include "HitTestResult.h"

#include "HTMLNames.h"

#include "Image.h"

#include "InspectorController.h"

#include "IntRect.h"

#include "KeyboardCodes.h"

#include "KeyboardEvent.h"

#include "MIMETypeRegistry.h"

#include "NodeRenderStyle.h"

#include "Page.h"

#include "PageGroup.h"

#include "PageGroupLoadDeferrer.h"

#include "Pasteboard.h"

#include "PlatformContextSkia.h"

#include "PlatformKeyboardEvent.h"

#include "PlatformMouseEvent.h"

#include "PlatformThemeChromiumGtk.h"

#include "PlatformWheelEvent.h"

#include "PopupMenuChromium.h"

#include "PopupMenuClient.h"

#include "ProgressTracker.h"

#include "RenderView.h"

#include "ResourceHandle.h"

#include "SecurityOrigin.h"

#include "SelectionController.h"

#include "Settings.h"

#include "Timer.h"

#include "TypingCommand.h"

#include "Vector.h"

#include "WebAccessibilityObject.h"

#include "WebDevToolsAgentPrivate.h"

#include "WebDevToolsAgentImpl.h"

#include "WebDragData.h"

#include "WebFrameImpl.h"

#include "WebImage.h"

#include "WebInputElement.h"

#include "WebInputEvent.h"

#include "WebInputEventConversion.h"

#include "WebKit.h"

#include "WebKitClient.h"

#include "WebMediaPlayerAction.h"

#include "WebNode.h"

#include "WebPlugin.h"

#include "WebPluginContainerImpl.h"

#include "WebPoint.h"

#include "WebPopupMenuImpl.h"

#include "WebRect.h"

#include "WebSettingsImpl.h"

#include "WebString.h"

#include "WebVector.h"

#include "WebViewClient.h"

#include "wtf/OwnPtr.h"

#if OS(WINDOWS)

#include "RenderThemeChromiumWin.h"

#else

#if OS(LINUX)

#include "RenderThemeChromiumLinux.h"

#endif

#include "RenderTheme.h"

#endif

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

#undef pow

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

using namespace WebCore;

namespace WebKit {

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

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

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

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

static const double textSizeMultiplierRatio = 1.2;

static const double minTextSizeMultiplier = 0.5;

static const double maxTextSizeMultiplier = 3.0;

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

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

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

// one page group.

const char* pageGroupName = "default";

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

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

static Vector<PageGroupLoadDeferrer*> pageGroupLoadDeferrerStack;

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

// DragOperation constants.

#define COMPILE_ASSERT_MATCHING_ENUM(coreName) \

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

COMPILE_ASSERT_MATCHING_ENUM(DragOperationNone);

COMPILE_ASSERT_MATCHING_ENUM(DragOperationCopy);

COMPILE_ASSERT_MATCHING_ENUM(DragOperationLink);

COMPILE_ASSERT_MATCHING_ENUM(DragOperationGeneric);

COMPILE_ASSERT_MATCHING_ENUM(DragOperationPrivate);

COMPILE_ASSERT_MATCHING_ENUM(DragOperationMove);

COMPILE_ASSERT_MATCHING_ENUM(DragOperationDelete);

COMPILE_ASSERT_MATCHING_ENUM(DragOperationEvery);

static const PopupContainerSettings autoFillPopupSettings = {

    false, // setTextOnIndexChange

    false, // acceptOnAbandon

    true,  // loopSelectionNavigation

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

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

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

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

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

    PopupContainerSettings::DOMElementDirection,

};

// WebView ----------------------------------------------------------------

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

{

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

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

}

void WebView::updateVisitedLinkState(unsigned long long linkHash)

{

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

}

void WebView::resetVisitedLinkState()

{

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

}

void WebView::willEnterModalLoop()

{

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

    ASSERT(pageGroup);

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

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

    else {

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

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

    }

}

void WebView::didExitModalLoop()

{

    ASSERT(pageGroupLoadDeferrerStack.size());

    delete pageGroupLoadDeferrerStack.last();

    pageGroupLoadDeferrerStack.removeLast();

}

void WebViewImpl::initializeMainFrame(WebFrameClient* frameClient)

{

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

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

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

    frame->initializeAsMainFrame(this);

    // Restrict the access to the local file system

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

    SecurityOrigin::setLocalLoadPolicy(SecurityOrigin::AllowLocalLoadsForLocalOnly);

}

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

    : m_client(client)

    , m_backForwardListClientImpl(this)

    , m_chromeClientImpl(this)

    , m_contextMenuClientImpl(this)

    , m_dragClientImpl(this)

    , m_editorClientImpl(this)

    , m_inspectorClientImpl(this)

    , m_observedNewNavigation(false)

#ifndef NDEBUG

    , m_newNavigationLoader(0)

#endif

    , m_zoomLevel(0)

    , m_contextMenuAllowed(false)

    , m_doingDragAndDrop(false)

    , m_ignoreInputEvents(false)

    , m_suppressNextKeypressEvent(false)

    , m_initialNavigationPolicy(WebNavigationPolicyIgnore)

    , m_imeAcceptEvents(true)

    , m_dragTargetDispatch(false)

    , m_dragIdentity(0)

    , m_dropEffect(DropEffectDefault)

    , m_operationsAllowed(WebDragOperationNone)

    , m_dragOperation(WebDragOperationNone)

    , m_autoFillPopupShowing(false)

    , m_autoFillPopupClient(0)

    , m_autoFillPopup(0)

    , m_isTransparent(false)

    , m_tabsToLinks(false)

    , m_dragScrollTimer(new DragScrollTimer())

#if USE(ACCELERATED_COMPOSITING)

    , m_layerRenderer(0)

    , m_isAcceleratedCompositingActive(false)

#endif

    , m_gles2Context(0)

{

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

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

    // initialized because CollatorICU requires it.

    WTF::initializeThreading();

    WTF::initializeMainThread();

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

    m_lastMousePosition = WebPoint(-1, -1);

    if (devToolsClient)

        m_devToolsAgent = new WebDevToolsAgentImpl(this, devToolsClient);

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

    // the page will take ownership of the various clients

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

    m_page->setGroupName(pageGroupName);

    m_inspectorSettingsMap.set(new SettingsMap);

}

WebViewImpl::~WebViewImpl()

{

    ASSERT(!m_page);

}

RenderTheme* WebViewImpl::theme() const

{

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

}

WebFrameImpl* WebViewImpl::mainFrameImpl()

{

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

}

bool WebViewImpl::tabKeyCyclesThroughElements() const

{

    ASSERT(m_page.get());

    return m_page->tabKeyCyclesThroughElements();

}

void WebViewImpl::setTabKeyCyclesThroughElements(bool value)

{

    if (m_page)

        m_page->setTabKeyCyclesThroughElements(value);

}

void WebViewImpl::mouseMove(const WebMouseEvent& event)

{

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

        return;

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

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

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

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

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

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

}

void WebViewImpl::mouseLeave(const WebMouseEvent& event)

{

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

    // ignore it.

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

        return;

    m_client->setMouseOverURL(WebURL());

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

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

}

void WebViewImpl::mouseDown(const WebMouseEvent& event)

{

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

        return;

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

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

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

    RefPtr<WebCore::PopupContainer> selectPopup;

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

        selectPopup = m_selectPopup;

        hideSelectPopup();

        ASSERT(!m_selectPopup);

    }

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

    RefPtr<Node> clickedNode;

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

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

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

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

        Node* hitNode = result.innerNonSharedNode();

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

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

            m_mouseCaptureNode = hitNode;

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

        // AutoFill popup.

        RefPtr<Node> focusedNode = focusedWebCoreNode();

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

            if (hitNode == focusedNode) {

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

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

                // trigger the autocomplete.

                clickedNode = focusedNode;

            }

        }

    }

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

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

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

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

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

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

            showFormAutofillForNode(clickedNode.get());

    }

    if (m_selectPopup && m_selectPopup == selectPopup) {

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

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

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

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

        hideSelectPopup();

    }

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

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

#if OS(DARWIN)

    if (event.button == WebMouseEvent::ButtonRight

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

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

        mouseContextMenu(event);

#elif OS(LINUX)

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

        mouseContextMenu(event);

#endif

}

void WebViewImpl::mouseContextMenu(const WebMouseEvent& event)

{

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

        return;

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

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

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

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

    Frame* targetFrame;

    if (result.innerNonSharedNode())

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

    else

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

#if OS(WINDOWS)

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

#endif

    m_contextMenuAllowed = true;

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

    m_contextMenuAllowed = false;

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

    // implementation...

}

void WebViewImpl::mouseUp(const WebMouseEvent& event)

{

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

        return;

#if OS(LINUX)

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

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

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

    //

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

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

    //   xterm: pastes on up.

    //   GTK: pastes on down.

    //   Firefox: pastes on up.

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

    //

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

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

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

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

    // handleMouseReleaseEvent() earlier in this function

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

        Frame* focused = focusedWebCoreFrame();

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

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

        IntPoint contentPoint = view->windowToContents(clickPoint);

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

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

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

        // have to be handled separately.

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

            Editor* editor = focused->editor();

            Pasteboard* pasteboard = Pasteboard::generalPasteboard();

            bool oldSelectionMode = pasteboard->isSelectionMode();

            pasteboard->setSelectionMode(true);

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

            pasteboard->setSelectionMode(oldSelectionMode);

        }

    }

#endif

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

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

#if OS(WINDOWS)

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

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

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

        mouseContextMenu(event);

#endif

}

void WebViewImpl::mouseWheel(const WebMouseWheelEvent& event)

{

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

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

}

bool WebViewImpl::keyEvent(const WebKeyboardEvent& event)

{

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

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

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

    // Please refer to the comments explaining the m_suppressNextKeypressEvent

    // member.

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

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

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

    // event.

    m_suppressNextKeypressEvent = false;

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

    if (selectPopupHandleKeyEvent(event))

        return true;

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

    if (autocompleteHandleKeyEvent(event))

        return true;

    Frame* frame = focusedWebCoreFrame();

    if (!frame)

        return false;

    EventHandler* handler = frame->eventHandler();

    if (!handler)

        return keyEventDefault(event);

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

    const WebInputEvent::Type contextMenuTriggeringEventType =