Change focus ring rect update logic

[framework/web/webkit-efl.git] / Source / WebKit2 / WebProcess / WebPage / efl / WebPageEfl.cpp

/*
 * Copyright (C) 2010 Apple Inc. All rights reserved.
 * Portions Copyright (c) 2010 Motorola Mobility, Inc.  All rights reserved.
 * Copyright (C) 2011 Igalia S.L.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. 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.
 *
 * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS 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 APPLE INC. OR ITS 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 "WebPage.h"

#include "EditorState.h"
#include "NamedNodeMap.h"
#include "NotImplemented.h"
#include "WebEvent.h"
#include "WindowsKeyboardCodes.h"
#include <WebCore/EflKeyboardUtilities.h>
#include <WebCore/FocusController.h>
#include <WebCore/Frame.h>
#include <WebCore/FrameView.h>
#include <WebCore/KeyboardEvent.h>
#include <WebCore/Page.h>
#include <WebCore/PlatformKeyboardEvent.h>
#include <WebCore/RenderThemeEfl.h>
#include <WebCore/Settings.h>

#if OS(TIZEN)
#include "Arguments.h"
#include "GraphicsContext.h"
#include "WebCoreArgumentCoders.h"
#include "WebFrame.h"
#include "WebImage.h"
#include "WebPageProxyMessages.h"
#include <WebCore/FrameView.h>

#if ENABLE(TIZEN_INPUT_TAG_EXTENSION)
#include <WebCore/HTMLInputElement.h>
#include <WebCore/HTMLNames.h>
#endif

#if ENABLE(TIZEN_MULTIPLE_SELECT)
#include "WebPopupMenu.h"
#include <WebCore/PopupMenuClient.h>
#endif

#if ENABLE(TIZEN_MOBILE_WEB_PRINT)
#include <WebCore/PlatformContextCairo.h>
#endif

#if ENABLE(TIZEN_CLIPBOARD) || ENABLE(TIZEN_PASTEBOARD)
#include <WebCore/ClipboardTizen.h>
#endif

#if ENABLE(TIZEN_PASTEBOARD)
#include <WebCore/Pasteboard.h>
#endif

#if ENABLE(TIZEN_REMOTE_WEB_INSPECTOR)
#include "WebInspectorServerTizen.h"
#endif

#if ENABLE(TIZEN_WEB_STORAGE)
#include <WebCore/GroupSettings.h>
#include <WebCore/PageGroup.h>
#endif

#if ENABLE(TIZEN_PLUGIN_SUSPEND_RESUME)
#include "PluginView.h"
#endif

#if ENABLE(TIZEN_PREFERENCE)
#include "WebPreferencesStore.h"
#include <WebCore/Settings.h>
#endif

#if ENABLE(TIZEN_WEBKIT2_FOCUS_RING)
#include <WebCore/HTMLFrameOwnerElement.h>
#include <WebCore/HTMLImageElement.h>
#endif

#if ENABLE(TIZEN_DEVICE_ORIENTATION)
#include "DeviceMotionClientTizen.h"
#include "DeviceOrientationClientTizen.h"
#endif

#if ENABLE(TIZEN_CSS_OVERFLOW_SCROLL_ACCELERATION_ON_UI_SIDE)
#include "RenderLayer.h"
#include "WebGraphicsLayer.h"
#include <WebCore/RenderView.h>
#endif

#if ENABLE(TIZEN_ISF_PORT)
#include <WebCore/Text.h>
#include <WebCore/EditorClient.h>
#endif

#if ENABLE(TIZEN_INPUT_TAG_EXTENSION) || ENABLE(TIZEN_WEBKIT2_FORM_DATABASE)
#include "EditorClient.h"
#endif

#if ENABLE(TIZEN_DATALIST_ELEMENT)
#include "HTMLCollection.h"
#include "HTMLDataListElement.h"
#include "HTMLOptionElement.h"
#endif

#if ENABLE(TIZEN_STYLE_SCOPED)
#include <WebCore/RuntimeEnabledFeatures.h>
#endif

#if ENABLE(TIZEN_WEBKIT2_TEXT_SELECTION)
#include "htmlediting.h"
#endif

#if ENABLE(TIZEN_LINK_MAGNIFIER)
#include "LinkMagnifier.h"
#endif

#if ENABLE(TIZEN_SCREEN_READER)
#include "WebEventConversion.h"
#endif

#if ENABLE(TIZEN_SCREEN_READER) || ENABLE(TIZEN_FOCUS_UI) || ENABLE(TIZEN_WEBKIT2_TEXT_SELECTION)
#include <WebCore/HTMLAreaElement.h>
#endif

#if ENABLE(TIZEN_CSP)
#include <WebCore/ContentSecurityPolicy.h>
#endif

#if ENABLE(TIZEN_OFFLINE_PAGE_SAVE)
#include "WebPageSerializerTizen.h"
#endif

#if ENABLE(TIZEN_USE_SETTINGS_FONT)
#include "fontconfig/fontconfig.h"
#include <WebCore/FontCache.h>
#endif

#if ENABLE(TIZEN_WEBKIT2_TEXT_SELECTION)
#include "visible_units.h"
#endif
#endif // #if OS(TIZEN)

using namespace WebCore;

namespace WebKit {

void WebPage::platformInitialize()
{
#if ENABLE(TIZEN_DEVICE_ORIENTATION)
    WebCore::provideDeviceMotionTo(m_page.get(), new DeviceMotionClientTizen);
    WebCore::provideDeviceOrientationTo(m_page.get(), new DeviceOrientationClientTizen);
#endif
}

#if ENABLE(TIZEN_PREFERENCE)
void WebPage::platformPreferencesDidChange(const WebPreferencesStore& store)
{
    Settings* settings = m_page->settings();
    settings->setInteractiveFormValidationEnabled(store.getBoolValueForKey(WebPreferencesKey::interactiveFormValidationEnabledKey()));
    settings->setUsesEncodingDetector(store.getBoolValueForKey(WebPreferencesKey::usesEncodingDetectorKey()));
#if ENABLE(TIZEN_LOAD_REMOTE_IMAGES)
    settings->setLoadRemoteImages(store.getBoolValueForKey(WebPreferencesKey::loadRemoteImagesKey()));
#endif
#if ENABLE(TIZEN_LINK_EFFECT)
    settings->setLinkEffectEnabled(store.getBoolValueForKey(WebPreferencesKey::linkEffectEnabledKey()));
#endif
#if ENABLE(TIZEN_ISF_PORT)
    settings->setEnableDefaultKeypad(store.getBoolValueForKey(WebPreferencesKey::defaultKeypadEnabledKey()));
#endif
#if ENABLE(TIZEN_STYLE_SCOPED)
    WebCore::RuntimeEnabledFeatures::setStyleScopedEnabled(store.getBoolValueForKey(WebPreferencesKey::styleScopedEnabledKey()));
#endif
#if ENABLE(TIZEN_WEB_AUDIO)
    settings->setWebAudioEnabled(true);
#endif
}
#else
void WebPage::platformPreferencesDidChange(const WebPreferencesStore&)
{
    notImplemented();
}
#endif // #if ENABLE(TIZEN_PREFERENCE)

static inline void scroll(Page* page, ScrollDirection direction, ScrollGranularity granularity)
{
    page->focusController()->focusedOrMainFrame()->eventHandler()->scrollRecursively(direction, granularity);
}

bool WebPage::performDefaultBehaviorForKeyEvent(const WebKeyboardEvent& keyboardEvent)
{
    notImplemented();
    return false;
}

bool WebPage::platformHasLocalDataForURL(const KURL&)
{
    notImplemented();
    return false;
}

String WebPage::cachedResponseMIMETypeForURL(const KURL&)
{
    notImplemented();
    return String();
}

bool WebPage::platformCanHandleRequest(const ResourceRequest&)
{
    notImplemented();
    return true;
}

String WebPage::cachedSuggestedFilenameForURL(const KURL&)
{
    notImplemented();
    return String();
}

PassRefPtr<SharedBuffer> WebPage::cachedResponseDataForURL(const KURL&)
{
    notImplemented();
    return 0;
}

const char* WebPage::interpretKeyEvent(const KeyboardEvent* event)
{
    ASSERT(event->type() == eventNames().keydownEvent || event->type() == eventNames().keypressEvent);

    if (event->type() == eventNames().keydownEvent)
        return getKeyDownCommandName(event);

    return getKeyPressCommandName(event);
}

void WebPage::setThemePath(const String& themePath)
{
    WebCore::RenderThemeEfl* theme = static_cast<WebCore::RenderThemeEfl*>(m_page->theme());
    theme->setThemePath(themePath);
}

static Frame* targetFrameForEditing(WebPage* page)
{
    Frame* frame = page->corePage()->focusController()->focusedOrMainFrame();
    if (!frame)
        return 0;

    Editor* editor = frame->editor();
    if (!editor->canEdit())
        return 0;

    if (editor->hasComposition()) {
        // We should verify the parent node of this IME composition node are
        // editable because JavaScript may delete a parent node of the composition
        // node. In this case, WebKit crashes while deleting texts from the parent
        // node, which doesn't exist any longer.
        if (PassRefPtr<Range> range = editor->compositionRange()) {
            Node* node = range->startContainer();
            if (!node || !node->isContentEditable())
                return 0;
        }
    }

    return frame;
}

void WebPage::confirmComposition(const String& compositionString)
{
    Frame* targetFrame = targetFrameForEditing(this);
    if (!targetFrame)
        return;

#if ENABLE(TIZEN_ISF_PORT)
    if (m_prepareKeyDownEvent) {
        m_keyPressCommands.append(adoptPtr(new ConfirmCompositionKeyPressCommand(compositionString)));
        return;
    }
#endif

    targetFrame->editor()->confirmComposition(compositionString);

#if ENABLE(TIZEN_ISF_PORT)
    m_page->editorClient()->respondToChangedSelection(targetFrame);
#endif
}

void WebPage::setComposition(const String& compositionString, const Vector<WebCore::CompositionUnderline>& underlines, uint64_t cursorPosition)
{
    Frame* targetFrame = targetFrameForEditing(this);
    if (!targetFrame)
        return;

#if ENABLE(TIZEN_ISF_PORT)
    if (!targetFrame->editor()->hasComposition() && compositionString.isEmpty())
        return;

    if (m_prepareKeyDownEvent) {
        m_keyPressCommands.append(adoptPtr(new SetCompositionKeyPressCommand(compositionString, underlines, cursorPosition)));
        return;
    }

    if (targetFrame->selection()->rootEditableElement()) {
        HTMLTextFormControlElement* textFormControl = toTextFormControl(targetFrame->selection()->rootEditableElement()->shadowAncestorNode());
        if (textFormControl && textFormControl->maxLength() >= 0) {
            unsigned availableLength = textFormControl->maxLength() - textFormControl->value().length();
            if (targetFrame->editor()->hasComposition())
                availableLength += (targetFrame->editor()->compositionEnd() - targetFrame->editor()->compositionStart());
            if (!availableLength)
                return;

            if (availableLength < compositionString.length()) {
                String newCompositionString = compositionString.substring(0, availableLength);
                Vector<CompositionUnderline> newUnderlines;
                size_t numUnderlines = underlines.size();
                for (size_t index = 0; index < numUnderlines; ++index) {
                    if (underlines[index].startOffset < availableLength) {
                        newUnderlines.append(underlines[index]);
                        if (newUnderlines.last().endOffset > availableLength)
                            newUnderlines.last().endOffset = availableLength;
                    }
                }
                targetFrame->editor()->setComposition(newCompositionString, newUnderlines, cursorPosition, 0);
                return;
            }
        }
    }
#endif

    targetFrame->editor()->setComposition(compositionString, underlines, cursorPosition, 0);

#if ENABLE(TIZEN_ISF_PORT)
    m_page->editorClient()->respondToChangedSelection(targetFrame);
#endif
}

void WebPage::cancelComposition()
{
    Frame* frame = m_page->focusController()->focusedOrMainFrame();
    if (!frame)
        return;

    frame->editor()->cancelComposition();
}

#if OS(TIZEN)

#if ENABLE(TIZEN_WEBKIT2_TILED_BACKING_STORE)
IntSize WebPage::contentsSize() const
{
    FrameView* frameView = m_page->mainFrame()->view();
    if (!frameView)
        return IntSize(0, 0);

    return frameView->contentsSize();
}
#endif

void WebPage::scrollMainFrameBy(const IntSize& scrollOffset)
{
    m_page->mainFrame()->view()->scrollBy(scrollOffset);
}

void WebPage::scrollMainFrameTo(const IntPoint& scrollPosition)
{
    m_page->mainFrame()->view()->setScrollPosition(scrollPosition);
}

void WebPage::createSnapshot(const IntRect rect, float scaleFactor, ShareableBitmap::Handle& snapshotHandle)
{
    FrameView* frameView = m_mainFrame->coreFrame()->view();
    if (!frameView)
        return;

    RefPtr<WebImage> snapshotImage = scaledSnapshotInViewCoordinates(rect, scaleFactor, ImageOptionsShareable);
    if (!snapshotImage || !snapshotImage->bitmap())
        return;

    snapshotImage->bitmap()->createHandle(snapshotHandle);
}

void WebPage::requestUpdateFormNavigation()
{
    Frame* frame = m_page->focusController()->focusedOrMainFrame();
    if (!frame)
        return;

    Document* document = frame->document();
    if (!document)
        return;

    Node* focusedNode = document->focusedNode();

    Vector<RefPtr<Node> > focusableNodes;
    document->getFocusableNodes(focusableNodes);

    int formElementCount = 0;
    int currentNodeIndex = -1;
    const Vector<RefPtr<Node> >::iterator end = focusableNodes.end();
    for (Vector<RefPtr<Node> >::iterator it = focusableNodes.begin(); it != end; ++it) {
        AtomicString nodeName = (*it).get()->nodeName();
        if (equalIgnoringCase(nodeName, "SELECT")
            || (equalIgnoringCase(nodeName, "INPUT")
                && !equalIgnoringCase((*it).get()->toInputElement()->type(), "CHECKBOX")
                && !equalIgnoringCase((*it).get()->toInputElement()->type(), "RADIO")
                && !equalIgnoringCase((*it).get()->toInputElement()->type(), "SUBMIT")
                )
            ) {
            if ((*it).get() == focusedNode)
                currentNodeIndex = formElementCount;
            formElementCount++;
        }
    }

    if (currentNodeIndex == -1)
        return;

    send(Messages::WebPageProxy::UpdateFormNavigation(formElementCount, currentNodeIndex));
}

void WebPage::moveFocus(int newIndex)
{
    Frame* frame = m_page->focusController()->focusedOrMainFrame();
    if (!frame)
        return;

    Document* document = frame->document();
    if (!document)
        return;

    Vector<RefPtr<Node> > focusableNodes;
    document->getFocusableNodes(focusableNodes);

    int index = 0;
    const Vector<RefPtr<Node> >::iterator end = focusableNodes.end();
    for (Vector<RefPtr<Node> >::iterator it = focusableNodes.begin(); it != end; ++it) {
        AtomicString nodeName = (*it).get()->nodeName();
        if (equalIgnoringCase(nodeName, "SELECT")) {
            if (index == newIndex) {
                (*it).get()->setFocus();
                LayoutPoint position = LayoutPoint(0, 0);
                PlatformMouseEvent event(flooredIntPoint(position), flooredIntPoint(position), LeftButton, PlatformEvent::MouseMoved, 1, false, false, false, false, 0);
                (*it).get()->dispatchMouseEvent(event, "mousedown", 0, 0);
            }
            index++;
        } else if (equalIgnoringCase(nodeName, "INPUT")
            && !equalIgnoringCase((*it).get()->toInputElement()->type(), "CHECKBOX")
            && !equalIgnoringCase((*it).get()->toInputElement()->type(), "RADIO")
            ) {
            if (index == newIndex) {
                HTMLInputElement* elem = (*it).get()->toInputElement();
                elem->focus();
            }
            index++;
        }
    }
}

#if ENABLE(TIZEN_MOBILE_WEB_PRINT)
#define INCH_TO_MM 25.4
#define INCH_TO_POINTS 72.0

void WebPage::createPagesToPDF(const IntSize& surfaceSize, const IntSize& contentsSize, const String& fileName)
{
    FrameView* frameView = m_mainFrame->coreFrame()->view();
    if (!frameView)
        return;

    RefPtr<WebImage> pageshotImage = WebImage::create(contentsSize, ImageOptionsShareable);
    if (!pageshotImage->bitmap())
        return;

    double pdfWidth = (double)surfaceSize.width() / INCH_TO_MM * INCH_TO_POINTS;
    double pdfHeight = (double)surfaceSize.height() / INCH_TO_MM * INCH_TO_POINTS;
    double scaleFactorPdf = 1.0;
    if (contentsSize.width() > pdfWidth)
        scaleFactorPdf = pdfWidth / (double)contentsSize.width();

    OwnPtr<WebCore::GraphicsContext> graphicsContext = pageshotImage->bitmap()->createGraphicsContextForPdfSurface(fileName, pdfWidth, pdfHeight);
    graphicsContext->scale(FloatSize(scaleFactorPdf, scaleFactorPdf));

    frameView->updateLayoutAndStyleIfNeededRecursive();

    int pageNumber = ((contentsSize.height() * scaleFactorPdf) / pdfHeight) + 1;
    float paintY = 0.0;

    PaintBehavior oldBehavior = frameView->paintBehavior();
    frameView->setPaintBehavior(oldBehavior | PaintBehaviorFlattenCompositingLayers);
    for (int i = 0; i < pageNumber; i++) {
        IntRect paintRect(0, (int)paintY, contentsSize.width(), (int)(pdfHeight / scaleFactorPdf));

        frameView->paint(graphicsContext.get(), paintRect);
        cairo_show_page(graphicsContext->platformContext()->cr());
        graphicsContext->translate(0, -ceil(pdfHeight / scaleFactorPdf));
        paintY += (pdfHeight / scaleFactorPdf);
    }
    frameView->setPaintBehavior(oldBehavior);

    pageshotImage.release();
}
#endif

#if ENABLE(TIZEN_TEXT_CARET_HANDLING_WK2)
bool WebPage::setCaretPosition(const IntPoint& pos)
{
    Frame* frame = m_page->focusController()->focusedOrMainFrame();
    if (!frame)
        return false;

    FrameSelection* controller = frame->selection();
    if (!controller)
        return false;

    FrameView* frameView = frame->view();
    if (!frameView)
        return false;

    IntPoint point = m_page->mainFrame()->view()->windowToContents(pos);
    HitTestResult result = m_page->mainFrame()->eventHandler()->hitTestResultAtPoint(point, /*allowShadowContent*/ true, /*ignoreClipping*/ true);
    if (result.scrollbar())
        return false;

    Node* innerNode = result.innerNode();

    if (!innerNode || !innerNode->renderer())
        return false;

    VisiblePosition visiblePos;

    // we check if content is richly editable - because those input field behave other than plain text ones
    // sometimes they may consists a node structure and they need special approach
    if (innerNode->rendererIsRichlyEditable()) {
        // point gets inner node local coordinates
        point = flooredIntPoint(result.localPoint());
        IntRect rect = innerNode->renderer()->absoluteBoundingBoxRect(true);

        // it is not the best way to do this, but it is not as slow and it works - so maybe in the future someone
        // will have a better idea how to solve it
        // here we are getting innerNode from HitTestResult - unfortunately this is a kind of high level node
        // in the code below I am trying to obtain low level node - #text - to get its coordinates and size

        // all those getting nodes rects are needed to bypass WebCore's methods of positioning caret when user
        // is clicking outside a node - and cheat WebCore telling it that actually we clicked into input field
        // node, not outside of it
        Node* deepInnerNode = innerNode->renderer()->positionForPoint(point).deepEquivalent().deprecatedNode();

        if (!deepInnerNode || !deepInnerNode->renderer())
            return false;

        // so we get a base node rectange
        IntRect deepNodeRect = deepInnerNode->renderer()->absoluteBoundingBoxRect(true);

        // we modify our local point to adjust it to base node local coordinates
        point.move(rect.x() - deepNodeRect.x(), rect.y() - deepNodeRect.y());

        // if we are outside the rect we cheat, that we are just inside of it
        if (point.y() < 0)
            point.setY(0);
        else if (point.y() >= deepNodeRect.height())
            point.setY(deepNodeRect.height() - 1);

        // visible position created - caret ready to set
        visiblePos = deepInnerNode->renderer()->positionForPoint(point);
        if (visiblePos.isNull())
            return false;
    } else {
        // for plain text input fields we can get only a caret bounding box
        if (!controller->isCaret() || !controller->caretRenderer())
            return false;

        const Node* node = controller->start().deprecatedNode();
        if (!node || !node->renderer())
            return false;

        Element* currentRootEditableElement = node->rootEditableElement();
        Element* newRootEditableElement = innerNode->rootEditableElement();
        if (currentRootEditableElement != newRootEditableElement)
            return false;

        IntRect rect = controller->caretRenderer()->absoluteBoundingBoxRect(true);

        // The below wirtten code is not correct way to implement. Presntly the is no
        // other working way. To be replaced by better logic
        // here we also cheat input field that we actually are just inside of if
        IntPoint focusedFramePoint = frame->view()->windowToContents(pos);
        IntPoint oldFocusedFramePoint = focusedFramePoint;

        const int boundariesWidth = 2;
        if (focusedFramePoint.x() < rect.x())
            focusedFramePoint.setX(rect.x());
        else if (focusedFramePoint.x() > rect.maxX())
            focusedFramePoint.setX(rect.maxX());
        if (focusedFramePoint.y() < rect.y() + boundariesWidth)
            focusedFramePoint.setY(rect.y() + boundariesWidth);
        else if (focusedFramePoint.y() >= rect.maxY() - boundariesWidth)
            focusedFramePoint.setY(rect.maxY() - boundariesWidth - 1);

        int diffX = focusedFramePoint.x() - oldFocusedFramePoint.x();
        int diffY = focusedFramePoint.y() - oldFocusedFramePoint.y();
        point.setX((point.x())+diffX);
        point.setY((point.y())+diffY);

        // hit test with fake (adjusted) coordinates
        IntPoint hitTestPoint = m_page->mainFrame()->view()->windowToContents(point);
        HitTestResult newResult = m_page->mainFrame()->eventHandler()->hitTestResultAtPoint(hitTestPoint, /*allowShadowContent*/ true, /*ignoreClipping*/ true);

        if (!newResult.isContentEditable())
            return false;

        Node* newInnerNode = newResult.innerNode();

        if (!newInnerNode || !newInnerNode->renderer())
            return false;

        // visible position created
        visiblePos = newInnerNode->renderer()->positionForPoint(newResult.localPoint());
        if (visiblePos.isNull())
            return false;
    }

    // create visible selection from visible position
    VisibleSelection newSelection = VisibleSelection(visiblePos);
    controller->setSelection(newSelection, CharacterGranularity);
    // after setting selection caret blinking is suspended by default so we are unsuspedning it
    controller->setCaretBlinkingSuspended(false);

    return true;
}
#endif

#if ENABLE(TIZEN_ISF_PORT)
void WebPage::didCancelComposition(Node* valueChangedNode)
{
    Frame* frame = m_page->focusController()->focusedOrMainFrame();
    if (!frame || frame->editor()->ignoreCompositionSelectionChange() || !valueChangedNode->containsIncludingShadowDOM(frame->editor()->compositionNode()))
        return;

    frame->editor()->cancelComposition();
    send(Messages::WebPageProxy::DidCancelComposition());
}

void WebPage::prepareKeyDownEvent()
{
    m_prepareKeyDownEvent = true;
}

void WebPage::swapKeyPressCommands(Vector<OwnPtr<KeyPressCommand> >& commands)
{
    m_keyPressCommands.swap(commands);
}

void WebPage::deleteSurroundingText(int offset, int count)
{
    Frame* frame = m_page->focusController()->focusedOrMainFrame();
    if (!frame || !frame->editor()->canEdit())
        return;

    if (m_prepareKeyDownEvent) {
        m_keyPressCommands.append(adoptPtr(new DeleteTextKeyPressCommand(offset, count)));
        return;
    }

    Position base(frame->selection()->base());
    offset += base.offsetInContainerNode();
    base.moveToOffset(offset);
    Position extent(base);
    extent.moveToOffset(offset + count);
    VisibleSelection selection(base, extent);
    if (!selection.isRange())
        return;

    frame->selection()->setSelection(selection);
    frame->editor()->deleteWithDirection(DirectionBackward, CharacterGranularity, false, true);
}

void WebPage::updateEditorStateRect(const Frame* frame, EditorState& state) const
{
    ASSERT(frame->selection()->rootEditableElement());

#if ENABLE(TIZEN_WEBKIT2_TEXT_SELECTION)
    Vector<IntRect> rects;
    calcFocusedRects(frame->selection()->rootEditableElement(), rects);
    state.editorRect = unionRect(rects);
#endif

    if (frame->selection()->isCaret())
        state.selectionRect = frame->view()->contentsToWindow(frame->selection()->absoluteCaretBounds());
    else if (frame->selection()->isRange())
        state.selectionRect = frame->view()->contentsToWindow(enclosingIntRect(frame->selection()->bounds(false)));
}
#endif

#if ENABLE(TIZEN_INPUT_TAG_EXTENSION) || ENABLE(TIZEN_WEBKIT2_FORM_DATABASE)
void WebPage::setFocusedInputElementValue(const String& inputValue)
{
    Frame* frame = m_page->focusController()->focusedOrMainFrame();
    if (!frame || !frame->document() || !frame->document()->focusedNode())
        return;

    HTMLInputElement* inputElement = frame->document()->focusedNode()->toInputElement();
    if (!inputElement)
        return;

    inputElement->toNode()->dispatchFocusEvent(0);
    inputElement->setValue(inputValue, DispatchChangeEvent);
}

void  WebPage::getFocusedInputElementValue(String& inputValue)
{
    inputValue = String();

    Frame* frame = m_page->focusController()->focusedOrMainFrame();
    if (!frame || !frame->document() || !frame->document()->focusedNode())
        return;

    HTMLInputElement* inputElement = frame->document()->focusedNode()->toInputElement();
    if (!inputElement)
        return;

    inputValue = inputElement->value();
}
#endif

#if ENABLE(TIZEN_DATALIST_ELEMENT)
void WebPage::getFocusedInputElementDataList(Vector<String>& optionList)
{
    Frame* frame = m_page->focusController()->focusedOrMainFrame();
    if (!frame || !frame->document())
        return;

    Node* node = frame->document()->focusedNode();
    if (!node)
        return;

    HTMLInputElement* input = node->toInputElement();
    if (!input)
        return;

    HTMLDataListElement* dataList = static_cast<HTMLDataListElement*>(input->list());
    if (!dataList)
        return;

    RefPtr<HTMLCollection> options = static_cast<HTMLDataListElement*>(dataList)->options();
    for (unsigned i = 0; Node* node = options->item(i); i++) {
        HTMLOptionElement* optionElement = static_cast<HTMLOptionElement*>(node);
        String value = optionElement->value();
        optionList.append(value);
    }
}
#endif

#if ENABLE(TIZEN_WEBKIT2_FOCUS_RING)
static IntRect getNodeRect(Node* node, Node* focusableNode, bool isImage)
{
    IntRect rect;

    if (isImage) {
        bool isReplaced;
        IntRect imageNodeRect = pixelSnappedIntRect(node->getRect());
        if (!focusableNode->renderRect(&isReplaced).isEmpty() && imageNodeRect.contains(pixelSnappedIntRect(focusableNode->getRect()))) {
            // If render rect of focusableNode is empty and rect of imageNode include rect of focusableNode,
            // we have to get rect of focusableNode.
            // for example - The rect of google logo image in www.google.com pc site's search result page is bigger than rect of focusableNode.
            // for example - The rect of category menu image in www.gmarket.co.kr pc site is bigger than rect of focusableNode.
            rect = pixelSnappedIntRect(focusableNode->getRect());
        }
        else {
            // otherwise we have to get rect of imageNode.
            // for example - The render rect of images in www.pudelek.pl is empty.
            // for example - The rect of focusableNode of 'Test your browser GO' image in peacekeeper.futuremark.com is bigger than rect of 'Test your browser GO' image.
            rect = imageNodeRect;
            focusableNode = node;
        }
    } else {
        // If focusedNode have multiple child nodes, we have to unite rect of child nodes.
        // for example - links in www.google.com's search result page.
        IntRect tempRect;
        for (Node* childNode = focusableNode->firstChild(); childNode; childNode = childNode->traverseNextNode(focusableNode)) {
            bool isReplaced;
            if (focusableNode->renderRect(&isReplaced).contains(childNode->getRect()))
                tempRect.unite(pixelSnappedIntRect(childNode->getRect()));
        }

        // If tempRect is empty or rect of focusableNode include tempRect,
        // we have to get rect of focusableNode.
        // for example - list menu item in m.naver.com.
        // otherwise we have to get rect of tempRect.
        // getRect API do not return correct rect if the node is a container node,
        // hence using absoluteBoundingBoxRect to get the correct bounding rect.
        LayoutRect renderRect = focusableNode->renderer() ? focusableNode->renderer()->absoluteBoundingBoxRect() : focusableNode->getRect();
        if (tempRect.isEmpty() || renderRect.contains(tempRect))
            rect = pixelSnappedIntRect(renderRect);
        else
            rect = tempRect;
    }

    // We have to get render rect from ancestor node if current rect is empty.
    // for example - The rect of naver logo image in www.naver.com pc site is empty.
    bool isReplaced;
    for (Node* loopNode = focusableNode; loopNode && rect.isEmpty(); loopNode = loopNode->parentNode()) {
        RenderObject* renderer = loopNode->renderer();
        if (renderer && renderer->isRoot())
            break;

        rect = pixelSnappedIntRect(loopNode->renderRect(&isReplaced));
    }

    Frame* nodeFrame = focusableNode->document()->frame();
    Node* owner;
    while (nodeFrame && (owner = nodeFrame->ownerElement())) {
        rect.moveBy(owner->getRect().pixelSnappedLocation());
        nodeFrame = owner->document()->frame();
    }

    // The y position of tab menu item in www.google.com is negative value,
    // so we do not want to draw focus ring in that case.
    if ((rect.maxX() < 0) || (rect.maxY() < 0))
        rect = IntRect();

    return rect;
}
#endif

#if ENABLE(TIZEN_WEBKIT2_HIT_TEST)
#if ENABLE(TIZEN_WEBKIT2_FOCUS_RING)
static bool isClickableOrFocusable(Node* focusableNode)
{

   if (!focusableNode)
       return false;
   if (focusableNode->disabled())
        return false;
   if (!focusableNode->inDocument())
        return false;
   if (!focusableNode->renderer() || focusableNode->renderer()->style()->visibility() != VISIBLE)
        return false;
   if (focusableNode->isFocusable()) {
       if (focusableNode->isLink()
           || focusableNode->hasTagName(HTMLNames::inputTag)
           || focusableNode->hasTagName(HTMLNames::selectTag)
           || focusableNode->hasTagName(HTMLNames::buttonTag))
           return true;
   }
   if (focusableNode->supportsFocus()
       || focusableNode->hasEventListeners(eventNames().clickEvent)
       || focusableNode->hasEventListeners(eventNames().mousedownEvent)
       || focusableNode->hasEventListeners(eventNames().mouseupEvent)) {
       return true;
   }
   return false;
}

#if ENABLE(TOUCH_ADJUSTMENT)
void WebPage::getFocusedRect(HitTestResult hitTestResult, Page* page, bool setFocus, Vector<IntRect>& rects, const IntPoint& point, const IntSize& area)
#else
void WebPage::getFocusedRect(HitTestResult hitTestResult, Page* page, bool setFocus, Vector<IntRect>& rects)
#endif
{
    Node* node = hitTestResult.innerNode();
#if ENABLE(TOUCH_ADJUSTMENT)
    IntPoint adustedPoint;
    Frame* mainFrame = page->mainFrame();
    Node* adjustedNode = 0;
    mainFrame->eventHandler()->bestClickableNodeForTouchPoint(point, IntSize(area.width() / 2, area.height() / 2), adustedPoint, adjustedNode);
    if (!isClickableOrFocusable(node))
        mainFrame->eventHandler()->bestClickableNodeForTouchPoint(point, IntSize(area.width() / 2, area.height() / 2), adustedPoint, adjustedNode);

    if (adjustedNode)
        node = adjustedNode;
#endif
    if (!node)
        return;

    bool isFocusRingDrawable = false;
    Node* focusableNode = node;
    while (focusableNode) {
        RenderObject* renderer = focusableNode->renderer();
        if (renderer && (renderer->isBody() || renderer->isRenderView() || renderer->isRoot()))
            break;

        if (isClickableOrFocusable(focusableNode)) {
            isFocusRingDrawable = true;
            break;
        }

        focusableNode = focusableNode->parentNode();
    }

    // Don't draw focus ring if child is focusable or has trigger
    if (focusableNode && focusableNode->isContainerNode() && !focusableNode->isLink()) {
        WebCore::Node *child = static_cast<const ContainerNode*>(focusableNode)->firstChild();
        while(child) {
            if( child->supportsFocus()
                || child->hasEventListeners(eventNames().clickEvent)
                || child->hasEventListeners(eventNames().mousedownEvent)
                || child->hasEventListeners(eventNames().mouseupEvent)) {
                return;
            }
            child = child->traverseNextNode(focusableNode);
        }
    }

    if (!isFocusRingDrawable) {
        if (!node->hasTagName(HTMLNames::imgTag))
            return;
        focusableNode = node;
    }

    if (setFocus)
        setFocusedNode(focusableNode);

    calcFocusedRects(focusableNode, rects);
}
#endif

#if ENABLE(TOUCH_ADJUSTMENT)
void WebPage::hitTestResultAtPoint(const IntPoint& point, int hitTestMode, const IntSize& area, WebHitTestResult::Data& hitTestResultData)
#else
void WebPage::hitTestResultAtPoint(const IntPoint& point, int hitTestMode, WebHitTestResult::Data& hitTestResultData)
#endif
{
    Frame* frame = m_page->mainFrame();
    FrameView* frameView = frame->view();
    if (!frameView)
        return;

    HitTestResult hitTestResult = frame->eventHandler()->hitTestResultAtPoint(frameView->windowToContents(point), false);
    hitTestResultData.absoluteImageURL = hitTestResult.absoluteImageURL().string();
    hitTestResultData.absoluteLinkURL = hitTestResult.absoluteLinkURL().string();
    hitTestResultData.absoluteMediaURL = hitTestResult.absoluteMediaURL().string();
    hitTestResultData.linkLabel = hitTestResult.textContent();
    hitTestResultData.linkTitle = hitTestResult.titleDisplayString();
    hitTestResultData.isContentEditable = hitTestResult.isContentEditable();
#if ENABLE(TIZEN_DRAG_SUPPORT)
    hitTestResultData.isDragSupport = hitTestResult.isDragSupport();
#endif

    int context = WebHitTestResult::HitTestResultContextDocument;

    if (!hitTestResult.absoluteLinkURL().isEmpty())
        context |= WebHitTestResult::HitTestResultContextLink;
    if (!hitTestResult.absoluteImageURL().isEmpty())
        context |= WebHitTestResult::HitTestResultContextImage;
    if (!hitTestResult.absoluteMediaURL().isEmpty())
        context |= WebHitTestResult::HitTestResultContextMedia;
    if (hitTestResult.isSelected())
        context |= WebHitTestResult::HitTestResultContextSelection;
    if (hitTestResult.isContentEditable())
        context |= WebHitTestResult::HitTestResultContextEditable;
    if (hitTestResult.innerNonSharedNode() && hitTestResult.innerNonSharedNode()->isTextNode())
        context |= WebHitTestResult::HitTestResultContextText;

    hitTestResultData.context = context;
    hitTestResultData.hitTestMode = hitTestMode;

#if ENABLE(TIZEN_WEBKIT2_FOCUS_RING)
    bool setFocus = hitTestResultData.hitTestMode & WebHitTestResult::HitTestModeSetFocus;
#if ENABLE(TOUCH_ADJUSTMENT)
    getFocusedRect(hitTestResult, m_page.get(), setFocus, hitTestResultData.focusedRects, point, area);
#else
    getFocusedRect(hitTestResult, m_page.get(), setFocus, hitTestResultData.focusedRects);
#endif

    // Don't display FocusRect if the size is too big..
    IntRect framerect = frameView->visibleContentRect(true);
    for (size_t i = 0; i < hitTestResultData.focusedRects.size(); ++i) {
        if (hitTestResultData.focusedRects[i].width() > (0.8 * framerect.width())
            && hitTestResultData.focusedRects[i].height() > (0.8 * framerect.height()))
            hitTestResultData.focusedRects.clear();
    }

    if (hitTestResult.innerNode() && hitTestResult.innerNode()->renderer() && hitTestResult.innerNode()->renderer()->style()) {
        hitTestResultData.focusedColor = hitTestResult.innerNode()->renderer()->style()->tapHighlightColor();
        if (!hitTestResultData.focusedColor.hasAlpha())
            hitTestResultData.focusedColor = Color(hitTestResultData.focusedColor.red(), hitTestResultData.focusedColor.green(), hitTestResultData.focusedColor.blue(), RenderStyle::initialTapHighlightColor().alpha());
    }
#endif

    if (hitTestResultData.hitTestMode & WebHitTestResult::HitTestModeNodeData) {
        WebCore::Node* hitNode = hitTestResult.innerNonSharedNode();
        if (hitNode) {
            hitTestResultData.nodeData.nodeValue = hitNode->nodeValue();

            if ((hitTestResultData.context & WebHitTestResult::HitTestResultContextText) && hitNode->parentNode())
                hitNode = hitNode->parentNode(); // if hittest inner node is Text node, fill tagName with parent node's info and fill attributeMap with parent node's attributes.

            if (hitNode->isElementNode()) {
                WebCore::Element* hitElement = static_cast<WebCore::Element*>(hitNode);
                if (hitElement) {
                    hitTestResultData.nodeData.tagName = hitElement->tagName();
                }
            }

            WebCore::NamedNodeMap* namedNodeMap = hitNode->attributes();
            if (namedNodeMap) {
                for (size_t i = 0; i < namedNodeMap->length(); i++) {
                    const WebCore::Attribute* attribute = namedNodeMap->element()->attributeItem(i);
                    String key = attribute->name().toString();
                    String value = attribute->value();
                    hitTestResultData.nodeData.attributeMap.add(key, value);
                }
            }
        }
    }

    if ((hitTestResultData.hitTestMode & WebHitTestResult::HitTestModeImageData) && (hitTestResultData.context & WebHitTestResult::HitTestResultContextImage)) {
        WebCore::Image* hitImage = hitTestResult.image();
        if (hitImage && hitImage->data() && hitImage->data()->data()) {
            hitTestResultData.imageData.data.append(hitImage->data()->data(), hitImage->data()->size());
            hitTestResultData.imageData.fileNameExtension = hitImage->filenameExtension();
        }
    }
}
#endif

#if ENABLE(TIZEN_WEB_STORAGE)
void WebPage::getStorageQuotaBytes(uint64_t callbackID)
{
    uint32_t quota = m_page->group().groupSettings()->localStorageQuotaBytes();
    send(Messages::WebPageProxy::DidGetWebStorageQuotaBytes(quota, callbackID));
}

void WebPage::setStorageQuotaBytes(uint32_t quota)
{
    m_page->group().groupSettings()->setLocalStorageQuotaBytes(quota);
}
#endif

#if ENABLE(TIZEN_CLIPBOARD) || ENABLE(TIZEN_PASTEBOARD)
void WebPage::setClipboardDataForPaste(const String& data, const String& type)
{
#if ENABLE(TIZEN_PASTEBOARD)
    // FIXME: Should move to EditorClient like Clipboard
    Pasteboard::generalPasteboard()->setDataWithType(data, type);
#else
    Frame* mainFrame = m_page->mainFrame();
    if (!mainFrame)
        return;

    mainFrame->editor()->client()->setClipboardDataForPaste(data, type);
#endif
}
#endif

void WebPage::suspendJavaScriptAndResources()
{
    Frame* mainFrame = m_page->mainFrame();
    if (!mainFrame)
        return;

    for (Frame* frame = mainFrame; frame; frame = frame->tree()->traverseNext())
        frame->document()->suspendScheduledTasks(WebCore::ActiveDOMObject::PageWillBeSuspended);
    mainFrame->loader()->suspendAllLoaders();
}

void WebPage::resumeJavaScriptAndResources()
{
    Frame* mainFrame = m_page->mainFrame();
    if (!mainFrame)
        return;

    for (Frame* frame = mainFrame; frame; frame = frame->tree()->traverseNext())
        frame->document()->resumeScheduledTasks();
    mainFrame->loader()->resumeAllLoaders();
}

void WebPage::suspendAnimations()
{
    Frame* mainFrame = m_page->mainFrame();
    if (!mainFrame)
        return;

    for (Frame* frame = mainFrame; frame; frame = frame->tree()->traverseNext())
        frame->animation()->suspendAnimationsForDocument(frame->document());
}

void WebPage::resumeAnimations()
{
    Frame* mainFrame = m_page->mainFrame();
    if (!mainFrame)
        return;

    for (Frame* frame = mainFrame; frame; frame = frame->tree()->traverseNext())
        frame->animation()->resumeAnimationsForDocument(frame->document());
}

#if ENABLE(TIZEN_SYNC_REQUEST_ANIMATION_FRAME)
void WebPage::suspendAnimationController()
{
    if (!m_suspendedAnimationController) {
        Frame* mainFrame = m_page->mainFrame();
        if (!mainFrame)
            return;

        for (Frame* frame = mainFrame; frame; frame = frame->tree()->traverseNext())
            frame->document()->suspendScriptedAnimationControllerCallbacks();

        m_suspendedAnimationController = true;
    }
}

void WebPage::resumeAnimationController()
{
    if (m_suspendedAnimationController) {
        Frame* mainFrame = m_page->mainFrame();
        if (!mainFrame)
            return;

        for (Frame* frame = mainFrame; frame; frame = frame->tree()->traverseNext())
            frame->document()->resumeScriptedAnimationControllerCallbacks();

        m_suspendedAnimationController = false;
    }
}
#endif

#if ENABLE(TIZEN_REMOTE_WEB_INSPECTOR)
void WebPage::startInspectorServer(uint32_t port,  uint32_t& allocatedPort)
{
    bool ret = WebInspectorServerTizen::server()->startServer(port);
    if (ret)
        allocatedPort = WebInspectorServerTizen::server()->getServerPort();
    else
        allocatedPort = 0;
}

void WebPage::stopInspectorServer(bool& result)
{
    result = WebInspectorServerTizen::server()->stopServer();
}
#endif

#if ENABLE(TIZEN_CSS_OVERFLOW_SCROLL_ACCELERATION_ON_UI_SIDE)
void WebPage::scrollOverflowWithTrajectoryVector(const WebCore::FloatPoint& trajectoryVector)
{
    Frame* frame = m_page->focusController()->focusedOrMainFrame();
    if (!frame)
        return;
    frame->eventHandler()->scrollOverflow(trajectoryVector);
}
#endif

#if ENABLE(TIZEN_CSS_OVERFLOW_SCROLL_ACCELERATION)
void WebPage::scrollOverflow(const WebCore::FloatPoint& delta, bool& scrolled)
{
    scrolled = m_page->focusController()->focusedOrMainFrame()->eventHandler()->scrollOverflow(delta);
}

void WebPage::setPressedNodeAtPoint(const IntPoint& point, bool checkOverflowLayer, bool& pressed, uint32_t& id)
{
    RenderObject* renderer = 0;
    id = 0;
    pressed = m_page->mainFrame()->eventHandler()->setMousePressNodeAtPoint(point, checkOverflowLayer, renderer);
#if ENABLE(TIZEN_CSS_OVERFLOW_SCROLL_ACCELERATION_ON_UI_SIDE)
    if (pressed && renderer)
        id = toWebGraphicsLayer(renderer->enclosingLayer()->layerForScrollingContents())->id();
#endif
}
#endif

void WebPage::executeEditCommandWithArgument(const String& commandName, const String& argument)
{
    executeEditingCommand(commandName, argument);
}

#if ENABLE(TIZEN_PLUGIN_SUSPEND_RESUME)
void WebPage::suspendPlugin()
{
    for (Frame* frame = m_page->mainFrame(); frame; frame = frame->tree()->traverseNext()) {
        FrameView* view = frame->view();
        if (!view)
            continue;

        const HashSet<RefPtr<Widget> >* children = view->children();
        ASSERT(children);

        HashSet<RefPtr<Widget> >::const_iterator end = children->end();
        for (HashSet<RefPtr<Widget> >::const_iterator it = children->begin(); it != end; ++it) {
            Widget* widget = (*it).get();
            if (widget->isPluginViewBase()) {
                PluginView* pluginView = static_cast<PluginView*>(widget);
                if (pluginView)
                    pluginView->suspendPlugin();
            }
        }
    }
}

void WebPage::resumePlugin()
{
    for (Frame* frame = m_page->mainFrame(); frame; frame = frame->tree()->traverseNext()) {
        FrameView* view = frame->view();
        if (!view)
            continue;

        const HashSet<RefPtr<Widget> >* children = view->children();
        ASSERT(children);

        HashSet<RefPtr<Widget> >::const_iterator end = children->end();
        for (HashSet<RefPtr<Widget> >::const_iterator it = children->begin(); it != end; ++it) {
            Widget* widget = (*it).get();
            if (widget->isPluginViewBase()) {
                PluginView* pluginView = static_cast<PluginView*>(widget);
                if (pluginView)
                    pluginView->resumePlugin();
            }
        }
    }
}
#endif

#if ENABLE(TIZEN_MULTIPLE_SELECT)
void WebPage::didChangeSelectedIndexForActivePopupMenuMultiple(Vector<int32_t> newIndex)
{
    if (!m_activePopupMenu)
        return;

    m_activePopupMenu->client()->popupDidHide();

    size_t indexSize = newIndex.size();
    for (size_t i = 0; i < indexSize; i++)
        m_activePopupMenu->didChangeSelectedIndex(newIndex.at(i));

}
#endif

#if ENABLE(TIZEN_OFFLINE_PAGE_SAVE)
void WebPage::startOfflinePageSave(String subresourceFolderName)
{
    WebPageSerializerTizen::getSerializedPageContent(this, subresourceFolderName);
}
#endif

#if ENABLE(TIZEN_WEBKIT2_TEXT_SELECTION)
void WebPage::selectClosestWord(const IntPoint& point, bool& result)
{
    result = false;

    Frame* mainFrame = m_page->mainFrame();
    Frame* focusedFrame = m_page->focusController()->focusedOrMainFrame();

    HitTestResult hitTestResult = mainFrame->eventHandler()->hitTestResultAtPoint(m_page->mainFrame()->view()->windowToContents(point), false);

    Node* node = hitTestResult.innerNonSharedNode();
    if (!node)
        return;

     Frame* newFocusFrame = node->document()->frame();
     if (focusedFrame != newFocusFrame) {
         m_page->focusController()->setFocusedFrame(newFocusFrame);
         focusedFrame = newFocusFrame;
     }

    HTMLInputElement* inputElement = node->toInputElement();

    if (hitTestResult.isContentEditable()) {
        result = setCaretPosition(point);
        return;
    }

#if ENABLE(TIZEN_INPUT_TAG_EXTENSION)
    if (!node->isTextNode() && !inputElement)
#else
    if (!node->isTextNode())
#endif
        return;

#if ENABLE(TIZEN_INPUT_TAG_EXTENSION)
    if (inputElement
        && (inputElement->isDateField() || inputElement->isDateTimeField() || inputElement->isDateTimeLocalField()
        || inputElement->isMonthField() || inputElement->isTimeField() || inputElement->isWeekField())) {
        if (inputElement->value().isEmpty())
            return;
    }
#endif

    for (Node* node = hitTestResult.innerNonSharedNode(); node; node = node->parentNode()) {
        if (node->isFocusable()) {
            // Text selection shoud not be started when text of <button> tag is selected.
            if (node->hasTagName(HTMLNames::buttonTag))
                return;

            if (inputElement && inputElement->isTextButton())
                return;

            break;
        }
    }

    FrameSelection* frameSelection = focusedFrame->selection();

    VisiblePosition position = mainFrame->visiblePositionForPoint(point);
    VisibleSelection selection(position);

    // This changes just the 'start' and 'end' positions of the VisibleSelection
    selection.expandUsingGranularity(WordGranularity);

    FrameSelection::SetSelectionOptions options = FrameSelection::CloseTyping | FrameSelection::ClearTypingStyle | FrameSelection::DoNotSetFocus;
    frameSelection->setSelection(VisibleSelection(selection.start(), selection.end()), options);

    if (!frameSelection->isRange())
        return;

    // This changes just the 'start' and 'end' positions of the VisibleSelection
    // Find handlers positions
    IntRect leftRect, rightRect;
    getSelectionHandlers(leftRect, rightRect);
    if (leftRect.size().isZero() && rightRect.size().isZero()) {
        // Sometimes there is no selected text, but isNone() returns TRUE
        // in this case ewk_frame_selection_handlers_get() returns FALSE and handlers are invalid
        // Workaround - clear the selection.
        // Better solution would be to modify the ewk_frame_select_closest_word()
        // to not select anything in the first place (for example - don't call setSelection()
        // if there is nothing under the cursor).
        selectionClearAllSelection(m_page->mainFrame());
        return;
    }

    result = true;
}

void WebPage::setLeftSelection(const IntPoint& point, const int direction, int& result)
{
    result = HandleMovingDirectionNone;

    Frame* focusedFrame = m_page->focusController()->focusedOrMainFrame();
    FrameSelection* frameSelection = focusedFrame->selection();
    if (!frameSelection->isRange())
        return;

    Node* selectionEndNode = frameSelection->end().deprecatedNode();
    if (!selectionEndNode || !selectionEndNode->renderer())
        return;

    FrameView* frameView = focusedFrame->view();
    if (!frameView)
        return;

    IntPoint pos = frameView->windowToContents(point);
    IntRect leftRect, rightRect;
    getSelectionHandlers(leftRect, rightRect);

    if (selectionEndNode->rendererIsEditable() && !selectionEndNode->rendererIsRichlyEditable()) {
        const int boundariesWidth = 2;

        IntRect rect = frameSelection->caretRenderer()->absoluteBoundingBoxRect(true);
        // here we cheat input field that we actually are just inside of if
        if (pos.y() < rect.y() + boundariesWidth)
            pos.setY(rect.y() + boundariesWidth);
        else if (pos.y() >= rect.maxY() - boundariesWidth)
            pos.setY(rect.maxY() - boundariesWidth - 1);
    }

    OwnPtr<VisiblePosition> position = adoptPtr(new VisiblePosition(focusedFrame->visiblePositionForPoint(pos)));
    Position base = frameSelection->base();
    Position extent = frameSelection->extent();

    Node* newSelectionStartNode = position->deepEquivalent().deprecatedNode();

    // both start and end nodes should be in the same area type: both should be editable or both should be not editable
    // Check if the new position is before the extent's position
    if (newSelectionStartNode
        && selectionEndNode->isContentEditable() == newSelectionStartNode->isContentEditable()) {
        // Change the 'base' and 'extent' positions to 'start' and 'end' positions.
        // We do it, because without this, the other modification of the selection
        // would destroy the 'start' and/or 'end' positions and set them to
        // the 'base'/'extent' positions accordingly
        VisibleSelection sel(frameSelection->start(), frameSelection->end());
        frameSelection->setSelection(sel);

        bool oldProhibitsScrolling = focusedFrame->view()->prohibitsScrolling();
        focusedFrame->view()->setProhibitsScrolling(true);

        if (direction == HandleMovingDirectionNormal) {
            if (comparePositions(position->deepEquivalent(), extent) < 0) {
                frameSelection->setBase(*position);
                result = HandleMovingDirectionNormal;
            } else if (comparePositions(position->deepEquivalent(), extent) > 0) {
                frameSelection->setExtent(*position);
                frameSelection->setBase(extent);
                result = HandleMovingDirectionReverse;
            }
        } else if (direction == HandleMovingDirectionReverse) {
            if (comparePositions(position->deepEquivalent(), base) > 0) {
                frameSelection->setExtent(*position);
                result = HandleMovingDirectionReverse;
            } else if (comparePositions(position->deepEquivalent(), base) < 0) {
                frameSelection->setBase(*position);
                frameSelection->setExtent(base);
                result = HandleMovingDirectionNormal;
            }
        }

        focusedFrame->view()->setProhibitsScrolling(oldProhibitsScrolling);
        // This forces webkit to show selection
        // m_coreFrame->invalidateSelection();
    }
}

void WebPage::setRightSelection(const IntPoint& point, const int direction, int& result)
{
    result = HandleMovingDirectionNone;

    Frame* focusedFrame = m_page->focusController()->focusedOrMainFrame();
    FrameSelection* frameSelection = focusedFrame->selection();

    if (!frameSelection->isRange())
        return;

    Node* selectionStartNode = frameSelection->start().deprecatedNode();
    if (!selectionStartNode || !selectionStartNode->renderer())
        return;

    FrameView* frameView = focusedFrame->view();
    if (!frameView)
        return;

    IntPoint pos = frameView->windowToContents(point);
    if (selectionStartNode->rendererIsEditable() && !selectionStartNode->rendererIsRichlyEditable()) {
        const int boundariesWidth = 2;

        IntRect rect = frameSelection->caretRenderer()->absoluteBoundingBoxRect(true);
        // here we cheat input field that we actually are just inside of if
        if (pos.y() < rect.y() + boundariesWidth)
            pos.setY(rect.y() + boundariesWidth);
        else if (pos.y() >= rect.maxY() - boundariesWidth)
            pos.setY(rect.maxY() - boundariesWidth - 1);
    }

    OwnPtr<VisiblePosition> position = adoptPtr(new VisiblePosition(focusedFrame->visiblePositionForPoint(pos)));
    Position base = frameSelection->base();
    Position extent = frameSelection->extent();

    Node* newSelectionEndNode = position->deepEquivalent().deprecatedNode();

    // both start and end nodes should be in the same area type: both should be editable or both should be not editable
    // Check if the new position is after the base's position
    if (newSelectionEndNode
        && selectionStartNode->isContentEditable() == newSelectionEndNode->isContentEditable()) {
        // Change the 'base' and 'extent' positions to 'start' and 'end' positions.
        // We do it, because without this, the other modifications of the selection
        // would destroy the 'start' and/or 'end' positions and set them to
        // the 'base'/'extent' positions accordingly

        VisibleSelection sel(frameSelection->start(), frameSelection->end());
        frameSelection->setSelection(sel);

        bool oldProhibitsScrolling = focusedFrame->view()->prohibitsScrolling();
        focusedFrame->view()->setProhibitsScrolling(true);

        if (direction == HandleMovingDirectionNormal) {
            if (comparePositions(position->deepEquivalent(), base) > 0) {
                frameSelection->setExtent(*position);
                result = HandleMovingDirectionNormal;
            } else if (comparePositions(position->deepEquivalent(), base) < 0) {
                frameSelection->setBase(*position);
                frameSelection->setExtent(base);
                result = HandleMovingDirectionReverse;
            }
        } else if (direction == HandleMovingDirectionReverse) {
            if (comparePositions(position->deepEquivalent(), extent) < 0) {
                frameSelection->setBase(*position);
                result = HandleMovingDirectionReverse;
            } else if (comparePositions(position->deepEquivalent(), extent) > 0) {
                frameSelection->setExtent(*position);
                frameSelection->setBase(extent);
                result = HandleMovingDirectionNormal;
            }
        }

        focusedFrame->view()->setProhibitsScrolling(oldProhibitsScrolling);
    }
}

void WebPage::getSelectionHandlers(IntRect& leftRect, IntRect& rightRect)
{
    Frame* focusedFrame = m_page->focusController()->focusedOrMainFrame();
    if (!focusedFrame->selection()->isRange())
        return;

    // Is this check necessary? Leaving it for safety.
    RenderView* root = focusedFrame->contentRenderer();
    if (!root)
        return;

    RefPtr<Range> selectedRange = focusedFrame->selection()->toNormalizedRange();

    Vector<IntRect> rects;
    selectedRange->boundingBoxEx(rects, true);

    unsigned size = rects.size();
    if (size > 0) {
        leftRect = rects[0];
        rightRect = rects[size-1];

        // If selection rect size is greater than editor rect size because of round operation,
        // selection rect size should be changed to editor rect size.
        if (size == 1) {
            Element* rootEditableElement = focusedFrame->selection()->rootEditableElement();
            if (rootEditableElement) {
                Vector<IntRect> rects;
                calcFocusedRects(rootEditableElement, rects);
                IntRect editorRect = unionRect(rects);

#if ENABLE(TIZEN_WEBKIT2_TEXT_SELECTION)
                if (m_editorState.editorRect != editorRect) {
                    EditorState state = editorState();
                    state.updateEditorRectOnly = true;
                    setEditorState(state);
                    send(Messages::WebPageProxy::EditorStateChanged(state));
                }
#endif

                if (leftRect.maxY() > editorRect.maxY()) {
                    leftRect.setY(editorRect.y());
                    leftRect.setHeight(editorRect.height());
                }

                if (rightRect.maxY() > editorRect.maxY()) {
                    rightRect.setY(editorRect.y());
                    rightRect.setHeight(editorRect.height());
                }
            }
        }

        // prevent from selecting zero-length selection
        if (leftRect.x() == rightRect.x() + rightRect.width()
            && leftRect.y() == rightRect.y())
            return;

        FrameView* frameView = focusedFrame->view();
        if (!frameView)
            return;

        leftRect = frameView->contentsToWindow(leftRect);
        rightRect = frameView->contentsToWindow(rightRect);
     }
}

void WebPage::getSelectionText(String& result)
{
    Frame* focusedFrame = m_page->focusController()->focusedOrMainFrame();
    result = focusedFrame->editor()->selectedText();
}

void WebPage::selectionRangeClear(bool& result)
{
    result = false;

    Frame* focusedFrame = m_page->focusController()->focusedOrMainFrame();
    FrameSelection* frameSelection = focusedFrame->selection();
    if (frameSelection && frameSelection->isRange() && frameSelection->isContentEditable()) {
        VisiblePosition visiblePos(frameSelection->extent());
        if (visiblePos.isNull())
            return;

        focusedFrame->editor()->setIgnoreCompositionSelectionChange(true);
        frameSelection->setSelection(VisibleSelection(visiblePos), CharacterGranularity);
        focusedFrame->editor()->setIgnoreCompositionSelectionChange(false);

        frameSelection->setCaretBlinkingSuspended(false);
    } else
        selectionClearAllSelection(m_page->mainFrame());

    result = true;
}

void WebPage::selectionClearAllSelection(Frame* frame)
{
    if (!frame)
        return;

    FrameSelection* frameSelection = frame->selection();
    if (frameSelection)
        frameSelection->clear();

    if (!frame->tree())
        return;

    if (frame->tree()->childCount() > 0) {
        if (frame->tree()->firstChild())
            selectionClearAllSelection(frame->tree()->firstChild());
    } else if (frame->tree()->nextSibling())
        selectionClearAllSelection(frame->tree()->nextSibling());
}

void WebPage::scrollContentByCharacter(const IntPoint&, int direction, bool& result)
{
    result = false;

    Frame* focusedFrame = m_page->focusController()->focusedOrMainFrame();
    if (!focusedFrame)
        return;

    FrameSelection* frameSelection = focusedFrame->selection();
    if (!frameSelection)
        return;

    VisiblePosition currentPosition = frameSelection->selection().visibleStart();
    if (direction) {
        if (isStartOfLine(currentPosition))
            return;

        focusedFrame->selection()->modify(FrameSelection::AlterationMove, DirectionBackward, CharacterGranularity, UserTriggered);
    } else {
        if (isEndOfLine(currentPosition))
            return;

        focusedFrame->selection()->modify(FrameSelection::AlterationMove, DirectionForward, CharacterGranularity, UserTriggered);
    }
}

void WebPage::scrollContentByLine(const IntPoint&, int direction, bool& result)
{
    result = false;

    Frame* focusedFrame = m_page->focusController()->focusedOrMainFrame();
    if (!focusedFrame)
        return;

    FrameSelection* frameSelection = focusedFrame->selection();
    if (!frameSelection)
        return;

    VisiblePosition currentPosition = frameSelection->selection().visibleStart();
    if (direction) {
        if (inSameLine(currentPosition, previousLinePosition(currentPosition, 0)))
            return;

        focusedFrame->selection()->modify(FrameSelection::AlterationMove, DirectionBackward, LineGranularity, UserTriggered);
    } else {
        if (inSameLine(currentPosition, nextLinePosition(currentPosition, 0)))
            return;

        focusedFrame->selection()->modify(FrameSelection::AlterationMove, DirectionForward, LineGranularity, UserTriggered);
    }
}
#endif

#if ENABLE(TIZEN_LINK_MAGNIFIER)
void WebPage::getLinkMagnifierRect(const IntPoint& position, const IntSize& size)
{
    send(Messages::WebPageProxy::DidGetLinkMagnifierRect(position, LinkMagnifier::rect(this, position, size)));
}
#endif

#if ENABLE(TIZEN_SCREEN_READER)
void WebPage::moveScreenReaderFocus(bool forward, bool& result)
{
    if (!m_screenReader)
        m_screenReader = ScreenReader::create(this);

    result = m_screenReader->moveFocus(forward);
}

void WebPage::moveScreenReaderFocusByPoint(const IntPoint& point)
{
    if (!m_screenReader)
        m_screenReader = ScreenReader::create(this);

    if (!m_screenReader->moveFocus(point))
        return;
}

void WebPage::clearScreenReaderFocus()
{
    if (!m_screenReader)
        return;

    m_screenReader->clearFocus();
}

void WebPage::raiseTapEvent(const IntPoint& position, const IntPoint& globalPosition, bool& result)
{
    result = false;

#if ENABLE(GESTURE_EVENTS)
    Frame* frame = m_page->mainFrame();
    if (!frame->view())
        return;

    Vector<WebPlatformTouchPoint> touchPoints;
    touchPoints.append(WebPlatformTouchPoint(0, WebPlatformTouchPoint::TouchPressed, globalPosition, position));

    WebTouchEvent touchStartEvent(WebEvent::TouchStart, touchPoints, WebEvent::Modifiers(0), ecore_time_get());
    bool handled = frame->eventHandler()->handleTouchEvent(platform(touchStartEvent));

    touchPoints.at(0).setState(WebPlatformTouchPoint::TouchReleased);

    WebTouchEvent touchEndEvent(WebEvent::TouchEnd, touchPoints, WebEvent::Modifiers(0), ecore_time_get());
    handled |= frame->eventHandler()->handleTouchEvent(platform(touchEndEvent));

    if (!handled) {
        WebGestureEvent gestureEvent(WebEvent::GestureSingleTap, position, globalPosition, WebEvent::Modifiers(0), ecore_time_get());
        frame->eventHandler()->handleGestureEvent(platform(gestureEvent));
        result = true;
    }
#endif
}

void WebPage::adjustScreenReaderFocusedObjectValue(bool up)
{
    if (!m_screenReader || !m_focusedNode || !m_focusedNode->toInputElement())
        return;

    ExceptionCode ec;
    if (up)
        m_focusedNode->toInputElement()->stepUp(ec);
    else
        m_focusedNode->toInputElement()->stepDown(ec);
}

void WebPage::updateScreenReaderFocus(RenderObject* object)
{
    if (!m_screenReader)
        return;

    if (!object)
        m_screenReader->clearFocus();
    else if (!m_screenReader->rendererWillBeDestroyed(object))
        return;
}

void WebPage::clearScreenReader()
{
    m_screenReader.clear();
}
#endif

#if ENABLE(TIZEN_WEBKIT2_FOCUS_RING) || ENABLE(TIZEN_WEBKIT2_TEXT_SELECTION)
static LayoutRect rectToAbsoluteCoordinates(Frame* initialFrame, const LayoutRect& initialRect)
{
    LayoutRect rect = initialRect;
    for (Frame* frame = initialFrame; frame; frame = frame->tree()->parent()) {
        RenderBoxModelObject* renderer;
        if (frame->ownerElement() && (renderer = frame->ownerElement()->renderBoxModelObject())) {
            do {
                rect.move(renderer->offsetLeft(), renderer->offsetTop());
            } while ((renderer = renderer->offsetParent()));
            rect.move(-frame->view()->scrollOffset());
        }
    }
    return rect;
}

void WebPage::calcFocusedRects(Node* node, Vector<IntRect>& rects) const
{
    if (!node || !node->renderer())
        return;

    RenderObject* renderer = node->renderer();
    FrameView* view = node->document()->frame()->view();

    IntPoint absolutePoint;
    absolutePoint = view->convertToContainingWindow(view->convertFromRenderer(renderer, absolutePoint));
    renderer->addFocusRingRects(rects, absolutePoint);

    if (!rects.isEmpty())
        return;

    LayoutRect rect;
    if (node->hasTagName(HTMLNames::areaTag)) {
        HTMLAreaElement* area = static_cast<HTMLAreaElement*>(node);
        HTMLImageElement* image = area->imageElement();
        if (!image || !image->renderer())
            return;

        rect = rectToAbsoluteCoordinates(area->document()->frame(), area->computeRect(area->imageElement()->renderer()));
    } else if (node->renderer()) {
        if (node->isDocumentNode())
            rect = rectToAbsoluteCoordinates(static_cast<Document*>(node)->frame(), static_cast<Document*>(node)->frame()->view()->visibleContentRect());
        else {
            rect = node->getRect();
            rect.intersect(node->renderer()->absoluteClippedOverflowRect());
            rect = rectToAbsoluteCoordinates(node->document()->frame(), rect);

            rect.move(node->renderer()->style()->borderLeftWidth(), node->renderer()->style()->borderTopWidth());
            rect.setWidth(rect.width() - node->renderer()->style()->borderLeftWidth() - node->renderer()->style()->borderRightWidth());
            rect.setHeight(rect.height() - node->renderer()->style()->borderTopWidth() - node->renderer()->style()->borderBottomWidth());
        }
    }

    rects.append(pixelSnappedIntRect(rect));
}
#endif

#if ENABLE(TIZEN_WEBKIT2_FOCUS_RING)
void WebPage::setFocusedNode(Node* node)
{
    m_focusedNode = node;
    didChangeFocusedRects();
}

void WebPage::didChangeFocusedRects()
{
    Vector<IntRect> rects;
    calcFocusedRects(m_focusedNode.get(), rects);
    if (m_focusedRects == rects)
        return;

    m_focusedRects = rects;
    send(Messages::WebPageProxy::DidChangeFocusedRects(m_focusedRects));
}

void WebPage::recalcFocusedRects()
{
    if (!m_focusedNode)
        return;

    didChangeFocusedRects();
}
#endif

#if ENABLE(TIZEN_WEBKIT2_POPUP_INTERNAL)
// FIXME: Currently with cached pages, hiding Popup list menu is not working correctly.
// This patch is a fix allowing any popup list menu to get close for any page navigation.
void WebPage::notifyTransitionToCommitted(bool forNewPage)
{
    if (m_activePopupMenu) {
        TIZEN_LOGI("");
        m_activePopupMenu->hide();
        m_activePopupMenu = 0;
    }
}
#endif

#if ENABLE(TIZEN_CSP)
void WebPage::setContentSecurityPolicy(const String& policy, uint32_t headerType)
{
    Frame* frame = m_page->focusController()->focusedOrMainFrame();
    if (!frame)
        return;

    Document* document = frame->document();
    if (!document)
        return;

    document->contentSecurityPolicy()->didReceiveHeader(policy, static_cast<WebCore::ContentSecurityPolicy::HeaderType>(headerType));
}
#endif

#if ENABLE(TIZEN_INDEXED_DATABASE)
void WebPage::setIndexedDatabaseDirectory(const String& path)
{
    m_page->group().groupSettings()->setIndexedDBDatabasePath(path);
}
#endif

#if ENABLE(TIZEN_WEB_STORAGE)
void WebPage::setLocalStorageDirectory(const String& path)
{
    m_page->settings()->setLocalStorageDatabasePath(path);
}
#endif

#if ENABLE(TIZEN_USE_SETTINGS_FONT)
void WebPage::useSettingsFont()
{
    if (!WebCore::fontCache()->isFontFamliyTizen())
        return;

    FcInitReinitialize();
    WebCore::fontCache()->invalidate();

    FrameView* frameView = m_mainFrame->coreFrame()->view();
    if (!frameView)
        return;

    frameView->forceLayout();
}
#endif

void WebPage::didChangeContents(const IntRect& rect)
{
    if (!m_page)
        return;

    Frame* frame = m_page->focusController()->focusedOrMainFrame();
    if (!frame || !frame->view() || frame->view()->needsLayout())
        return;

#if ENABLE(TIZEN_ISF_PORT) || ENABLE(TIZEN_WEBKIT2_TEXT_SELECTION)
    if (m_editorState.isContentEditable && rect.intersects(m_editorState.editorRect) && frame->selection()->rootEditableElement()) {
        IntRect previousEditorRect = m_editorState.editorRect;
        updateEditorStateRect(frame, m_editorState);

        if (m_editorState.editorRect != previousEditorRect) {
            m_editorState.updateEditorRectOnly = true;
            send(Messages::WebPageProxy::EditorStateChanged(m_editorState));
        }
    }
#endif

#if ENABLE(TIZEN_WEBKIT2_FOCUS_RING)
    didChangeFocusedRects();
#endif
}

#if ENABLE(TIZEN_FOCUS_UI)
void WebPage::setSpatialNavigationEnabled(bool enabled)
{
    m_page->settings()->setSpatialNavigationEnabled(enabled);
}
#endif
#endif // #if OS(TIZEN)

} // namespace WebKit