Source/WebKit2/WebProcess/WebPage/efl/WebPageEfl.cpp

   1 /*
   2  * Copyright (C) 2010 Apple Inc. All rights reserved.
   3  * Portions Copyright (c) 2010 Motorola Mobility, Inc.  All rights reserved.
   4  * Copyright (C) 2011 Igalia S.L.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
  16  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
  17  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  18  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
  19  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  20  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  21  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  22  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  23  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  24  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
  25  * THE POSSIBILITY OF SUCH DAMAGE.
  26  */
  27
  28 #include "config.h"
  29 #include "WebPage.h"
  30
  31 #include "EditorState.h"
  32 #include "NamedNodeMap.h"
  33 #include "NotImplemented.h"
  34 #include "WebEvent.h"
  35 #include "WindowsKeyboardCodes.h"
  36 #include <WebCore/EflKeyboardUtilities.h>
  37 #include <WebCore/FocusController.h>
  38 #include <WebCore/Frame.h>
  39 #include <WebCore/FrameView.h>
  40 #include <WebCore/KeyboardEvent.h>
  41 #include <WebCore/Page.h>
  42 #include <WebCore/PlatformKeyboardEvent.h>
  43 #include <WebCore/RenderThemeEfl.h>
  44 #include <WebCore/Settings.h>
  45
  46 #if OS(TIZEN)
  47 #include "Arguments.h"
  48 #include "GraphicsContext.h"
  49 #include "WebCoreArgumentCoders.h"
  50 #include "WebFrame.h"
  51 #include "WebImage.h"
  52 #include "WebPageProxyMessages.h"
  53 #include <WebCore/FrameView.h>
  54
  55 #if ENABLE(TIZEN_INPUT_TAG_EXTENSION)
  56 #include <WebCore/HTMLInputElement.h>
  57 #include <WebCore/HTMLNames.h>
  58 #endif
  59
  60 #if ENABLE(TIZEN_MULTIPLE_SELECT)
  61 #include "WebPopupMenu.h"
  62 #include <WebCore/PopupMenuClient.h>
  63 #endif
  64
  65 #if ENABLE(TIZEN_MOBILE_WEB_PRINT)
  66 #include <WebCore/PlatformContextCairo.h>
  67 #endif
  68
  69 #if ENABLE(TIZEN_CLIPBOARD) || ENABLE(TIZEN_PASTEBOARD)
  70 #include <WebCore/ClipboardTizen.h>
  71 #endif
  72
  73 #if ENABLE(TIZEN_PASTEBOARD)
  74 #include <WebCore/Pasteboard.h>
  75 #endif
  76
  77 #if ENABLE(TIZEN_REMOTE_WEB_INSPECTOR)
  78 #include "WebInspectorServerTizen.h"
  79 #endif
  80
  81 #if ENABLE(TIZEN_WEB_STORAGE)
  82 #include <WebCore/GroupSettings.h>
  83 #include <WebCore/PageGroup.h>
  84 #endif
  85
  86 #if ENABLE(TIZEN_PLUGIN_SUSPEND_RESUME)
  87 #include "PluginView.h"
  88 #endif
  89
  90 #if ENABLE(TIZEN_PREFERENCE)
  91 #include "WebPreferencesStore.h"
  92 #include <WebCore/Settings.h>
  93 #endif
  94
  95 #if ENABLE(TIZEN_WEBKIT2_FOCUS_RING)
  96 #include <WebCore/HTMLFrameOwnerElement.h>
  97 #include <WebCore/HTMLImageElement.h>
  98 #endif
  99
 100 #if ENABLE(TIZEN_DEVICE_ORIENTATION)
 101 #include "DeviceMotionClientTizen.h"
 102 #include "DeviceOrientationClientTizen.h"
 103 #endif
 104
 105 #if ENABLE(TIZEN_CSS_OVERFLOW_SCROLL_ACCELERATION_ON_UI_SIDE)
 106 #include "RenderLayer.h"
 107 #include "WebGraphicsLayer.h"
 108 #include <WebCore/RenderView.h>
 109 #endif
 110
 111 #if ENABLE(TIZEN_ISF_PORT)
 112 #include <WebCore/Text.h>
 113 #include <WebCore/EditorClient.h>
 114 #endif
 115
 116 #if ENABLE(TIZEN_INPUT_TAG_EXTENSION) || ENABLE(TIZEN_WEBKIT2_FORM_DATABASE)
 117 #include "EditorClient.h"
 118 #endif
 119
 120 #if ENABLE(TIZEN_DATALIST_ELEMENT)
 121 #include "HTMLCollection.h"
 122 #include "HTMLDataListElement.h"
 123 #include "HTMLOptionElement.h"
 124 #endif
 125
 126 #if ENABLE(TIZEN_STYLE_SCOPED)
 127 #include <WebCore/RuntimeEnabledFeatures.h>
 128 #endif
 129
 130 #if ENABLE(TIZEN_WEBKIT2_TEXT_SELECTION)
 131 #include "htmlediting.h"
 132 #include "RenderIFrame.h"
 133 #endif
 134
 135 #if ENABLE(TIZEN_LINK_MAGNIFIER)
 136 #include "LinkMagnifier.h"
 137 #endif
 138
 139 #if ENABLE(TIZEN_SCREEN_READER)
 140 #include "WebEventConversion.h"
 141 #endif
 142
 143 #if ENABLE(TIZEN_SCREEN_READER) || ENABLE(TIZEN_FOCUS_UI) || ENABLE(TIZEN_WEBKIT2_TEXT_SELECTION)
 144 #include <WebCore/HTMLAreaElement.h>
 145 #endif
 146
 147 #if ENABLE(TIZEN_CSP)
 148 #include <WebCore/ContentSecurityPolicy.h>
 149 #endif
 150
 151 #if ENABLE(TIZEN_OFFLINE_PAGE_SAVE)
 152 #include "WebPageSerializerTizen.h"
 153 #endif
 154
 155 #if ENABLE(TIZEN_USE_SETTINGS_FONT)
 156 #include "fontconfig/fontconfig.h"
 157 #include <WebCore/FontCache.h>
 158 #include <WebCore/PageCache.h>
 159 #endif
 160
 161 #if ENABLE(TIZEN_WEBKIT2_TEXT_SELECTION)
 162 #include "visible_units.h"
 163 #endif
 164 #endif // #if OS(TIZEN)
 165
 166 using namespace WebCore;
 167
 168 namespace WebKit {
 169
 170 void WebPage::platformInitialize()
 171 {
 172 #if ENABLE(TIZEN_DEVICE_ORIENTATION)
 173     WebCore::provideDeviceMotionTo(m_page.get(), new DeviceMotionClientTizen);
 174     WebCore::provideDeviceOrientationTo(m_page.get(), new DeviceOrientationClientTizen);
 175 #endif
 176 }
 177
 178 #if ENABLE(TIZEN_PREFERENCE)
 179 void WebPage::platformPreferencesDidChange(const WebPreferencesStore& store)
 180 {
 181     Settings* settings = m_page->settings();
 182     settings->setInteractiveFormValidationEnabled(store.getBoolValueForKey(WebPreferencesKey::interactiveFormValidationEnabledKey()));
 183     settings->setUsesEncodingDetector(store.getBoolValueForKey(WebPreferencesKey::usesEncodingDetectorKey()));
 184 #if ENABLE(TIZEN_LOAD_REMOTE_IMAGES)
 185     settings->setLoadRemoteImages(store.getBoolValueForKey(WebPreferencesKey::loadRemoteImagesKey()));
 186 #endif
 187 #if ENABLE(TIZEN_LINK_EFFECT)
 188     settings->setLinkEffectEnabled(store.getBoolValueForKey(WebPreferencesKey::linkEffectEnabledKey()));
 189 #endif
 190 #if ENABLE(TIZEN_ISF_PORT)
 191     settings->setEnableDefaultKeypad(store.getBoolValueForKey(WebPreferencesKey::defaultKeypadEnabledKey()));
 192 #endif
 193 #if ENABLE(TIZEN_STYLE_SCOPED)
 194     WebCore::RuntimeEnabledFeatures::setStyleScopedEnabled(store.getBoolValueForKey(WebPreferencesKey::styleScopedEnabledKey()));
 195 #endif
 196 #if ENABLE(TIZEN_WEB_AUDIO)
 197     settings->setWebAudioEnabled(true);
 198 #endif
 199 }
 200 #else
 201 void WebPage::platformPreferencesDidChange(const WebPreferencesStore&)
 202 {
 203     notImplemented();
 204 }
 205 #endif // #if ENABLE(TIZEN_PREFERENCE)
 206
 207 static inline void scroll(Page* page, ScrollDirection direction, ScrollGranularity granularity)
 208 {
 209     page->focusController()->focusedOrMainFrame()->eventHandler()->scrollRecursively(direction, granularity);
 210 }
 211
 212 bool WebPage::performDefaultBehaviorForKeyEvent(const WebKeyboardEvent& keyboardEvent)
 213 {
 214     notImplemented();
 215     return false;
 216 }
 217
 218 bool WebPage::platformHasLocalDataForURL(const KURL&)
 219 {
 220     notImplemented();
 221     return false;
 222 }
 223
 224 String WebPage::cachedResponseMIMETypeForURL(const KURL&)
 225 {
 226     notImplemented();
 227     return String();
 228 }
 229
 230 bool WebPage::platformCanHandleRequest(const ResourceRequest&)
 231 {
 232     notImplemented();
 233     return true;
 234 }
 235
 236 String WebPage::cachedSuggestedFilenameForURL(const KURL&)
 237 {
 238     notImplemented();
 239     return String();
 240 }
 241
 242 PassRefPtr<SharedBuffer> WebPage::cachedResponseDataForURL(const KURL&)
 243 {
 244     notImplemented();
 245     return 0;
 246 }
 247
 248 const char* WebPage::interpretKeyEvent(const KeyboardEvent* event)
 249 {
 250     ASSERT(event->type() == eventNames().keydownEvent || event->type() == eventNames().keypressEvent);
 251
 252     if (event->type() == eventNames().keydownEvent)
 253         return getKeyDownCommandName(event);
 254
 255     return getKeyPressCommandName(event);
 256 }
 257
 258 void WebPage::setThemePath(const String& themePath)
 259 {
 260     WebCore::RenderThemeEfl* theme = static_cast<WebCore::RenderThemeEfl*>(m_page->theme());
 261     theme->setThemePath(themePath);
 262 }
 263
 264 static Frame* targetFrameForEditing(WebPage* page)
 265 {
 266     Frame* frame = page->corePage()->focusController()->focusedOrMainFrame();
 267     if (!frame)
 268         return 0;
 269
 270     Editor* editor = frame->editor();
 271     if (!editor->canEdit())
 272         return 0;
 273
 274     if (editor->hasComposition()) {
 275         // We should verify the parent node of this IME composition node are
 276         // editable because JavaScript may delete a parent node of the composition
 277         // node. In this case, WebKit crashes while deleting texts from the parent
 278         // node, which doesn't exist any longer.
 279         if (PassRefPtr<Range> range = editor->compositionRange()) {
 280             Node* node = range->startContainer();
 281             if (!node || !node->isContentEditable())
 282                 return 0;
 283         }
 284     }
 285
 286     return frame;
 287 }
 288
 289 void WebPage::confirmComposition(const String& compositionString)
 290 {
 291     Frame* targetFrame = targetFrameForEditing(this);
 292     if (!targetFrame)
 293         return;
 294
 295 #if ENABLE(TIZEN_ISF_PORT)
 296     if (m_prepareKeyDownEvent) {
 297         m_keyPressCommands.append(adoptPtr(new ConfirmCompositionKeyPressCommand(compositionString)));
 298         return;
 299     }
 300 #endif
 301
 302     targetFrame->editor()->confirmComposition(compositionString);
 303
 304 #if ENABLE(TIZEN_ISF_PORT)
 305     m_page->editorClient()->respondToChangedSelection(targetFrame);
 306 #endif
 307 }
 308
 309 void WebPage::setComposition(const String& compositionString, const Vector<WebCore::CompositionUnderline>& underlines, uint64_t cursorPosition)
 310 {
 311     Frame* targetFrame = targetFrameForEditing(this);
 312     if (!targetFrame)
 313         return;
 314
 315 #if ENABLE(TIZEN_ISF_PORT)
 316     if (!targetFrame->editor()->hasComposition() && compositionString.isEmpty())
 317         return;
 318
 319     if (m_prepareKeyDownEvent) {
 320         m_keyPressCommands.append(adoptPtr(new SetCompositionKeyPressCommand(compositionString, underlines, cursorPosition)));
 321         return;
 322     }
 323
 324     if (targetFrame->selection()->rootEditableElement()) {
 325         HTMLTextFormControlElement* textFormControl = toTextFormControl(targetFrame->selection()->rootEditableElement()->shadowAncestorNode());
 326         if (textFormControl && textFormControl->maxLength() >= 0) {
 327             unsigned availableLength = textFormControl->maxLength() - textFormControl->value().length();
 328             if (targetFrame->editor()->hasComposition())
 329                 availableLength += (targetFrame->editor()->compositionEnd() - targetFrame->editor()->compositionStart());
 330             if (!availableLength)
 331                 return;
 332
 333             if (availableLength < compositionString.length()) {
 334                 String newCompositionString = compositionString.substring(0, availableLength);
 335                 Vector<CompositionUnderline> newUnderlines;
 336                 size_t numUnderlines = underlines.size();
 337                 for (size_t index = 0; index < numUnderlines; ++index) {
 338                     if (underlines[index].startOffset < availableLength) {
 339                         newUnderlines.append(underlines[index]);
 340                         if (newUnderlines.last().endOffset > availableLength)
 341                             newUnderlines.last().endOffset = availableLength;
 342                     }
 343                 }
 344
 345                 m_page->editorClient()->lockRespondToChangedSelection();
 346                 targetFrame->editor()->setComposition(newCompositionString, newUnderlines, cursorPosition, 0);
 347                 m_page->editorClient()->unlockRespondToChangedSelection();
 348
 349                 return;
 350             }
 351         }
 352     }
 353
 354     m_page->editorClient()->lockRespondToChangedSelection();
 355 #endif
 356
 357     targetFrame->editor()->setComposition(compositionString, underlines, cursorPosition, 0);
 358
 359 #if ENABLE(TIZEN_ISF_PORT)
 360     m_page->editorClient()->unlockRespondToChangedSelection();
 361 #endif
 362 }
 363
 364 void WebPage::cancelComposition()
 365 {
 366     Frame* frame = m_page->focusController()->focusedOrMainFrame();
 367     if (!frame)
 368         return;
 369
 370     frame->editor()->cancelComposition();
 371 }
 372
 373 #if OS(TIZEN)
 374
 375 #if ENABLE(TIZEN_WEBKIT2_TILED_BACKING_STORE)
 376 IntSize WebPage::contentsSize() const
 377 {
 378     FrameView* frameView = m_page->mainFrame()->view();
 379     if (!frameView)
 380         return IntSize(0, 0);
 381
 382     return frameView->contentsSize();
 383 }
 384 #endif
 385
 386 void WebPage::scrollMainFrameBy(const IntSize& scrollOffset)
 387 {
 388     m_page->mainFrame()->view()->scrollBy(scrollOffset);
 389 }
 390
 391 void WebPage::scrollMainFrameTo(const IntPoint& scrollPosition)
 392 {
 393     m_page->mainFrame()->view()->setScrollPosition(scrollPosition);
 394 }
 395
 396 void WebPage::createSnapshot(const IntRect rect, float scaleFactor, ShareableBitmap::Handle& snapshotHandle)
 397 {
 398     FrameView* frameView = m_mainFrame->coreFrame()->view();
 399     if (!frameView)
 400         return;
 401
 402     RefPtr<WebImage> snapshotImage = scaledSnapshotInViewCoordinates(rect, scaleFactor, ImageOptionsShareable);
 403     if (!snapshotImage || !snapshotImage->bitmap())
 404         return;
 405
 406     snapshotImage->bitmap()->createHandle(snapshotHandle);
 407 }
 408
 409 void WebPage::requestUpdateFormNavigation()
 410 {
 411     Frame* frame = m_page->focusController()->focusedOrMainFrame();
 412     if (!frame)
 413         return;
 414
 415     Document* document = frame->document();
 416     if (!document)
 417         return;
 418
 419     Node* focusedNode = document->focusedNode();
 420
 421     Vector<RefPtr<Node> > focusableNodes;
 422     document->getFocusableNodes(focusableNodes);
 423
 424     int formElementCount = 0;
 425     int currentNodeIndex = -1;
 426     const Vector<RefPtr<Node> >::iterator end = focusableNodes.end();
 427     for (Vector<RefPtr<Node> >::iterator it = focusableNodes.begin(); it != end; ++it) {
 428         AtomicString nodeName = (*it).get()->nodeName();
 429         if (equalIgnoringCase(nodeName, "SELECT")
 430             || (equalIgnoringCase(nodeName, "INPUT")
 431                 && !equalIgnoringCase((*it).get()->toInputElement()->type(), "CHECKBOX")
 432                 && !equalIgnoringCase((*it).get()->toInputElement()->type(), "RADIO")
 433                 && !equalIgnoringCase((*it).get()->toInputElement()->type(), "SUBMIT")
 434                 )
 435             ) {
 436             if ((*it).get() == focusedNode)
 437                 currentNodeIndex = formElementCount;
 438             formElementCount++;
 439         }
 440     }
 441
 442     if (currentNodeIndex == -1)
 443         return;
 444
 445     send(Messages::WebPageProxy::UpdateFormNavigation(formElementCount, currentNodeIndex));
 446 }
 447
 448 void WebPage::moveFocus(int newIndex)
 449 {
 450     Frame* frame = m_page->focusController()->focusedOrMainFrame();
 451     if (!frame)
 452         return;
 453
 454     Document* document = frame->document();
 455     if (!document)
 456         return;
 457
 458     Vector<RefPtr<Node> > focusableNodes;
 459     document->getFocusableNodes(focusableNodes);
 460
 461     int index = 0;
 462     const Vector<RefPtr<Node> >::iterator end = focusableNodes.end();
 463     for (Vector<RefPtr<Node> >::iterator it = focusableNodes.begin(); it != end; ++it) {
 464         AtomicString nodeName = (*it).get()->nodeName();
 465         if (equalIgnoringCase(nodeName, "SELECT")) {
 466             if (index == newIndex) {
 467                 (*it).get()->setFocus();
 468                 LayoutPoint position = LayoutPoint(0, 0);
 469                 PlatformMouseEvent event(flooredIntPoint(position), flooredIntPoint(position), LeftButton, PlatformEvent::MouseMoved, 1, false, false, false, false, 0);
 470                 (*it).get()->dispatchMouseEvent(event, "mousedown", 0, 0);
 471             }
 472             index++;
 473         } else if (equalIgnoringCase(nodeName, "INPUT")
 474             && !equalIgnoringCase((*it).get()->toInputElement()->type(), "CHECKBOX")
 475             && !equalIgnoringCase((*it).get()->toInputElement()->type(), "RADIO")
 476             ) {
 477             if (index == newIndex) {
 478                 HTMLInputElement* elem = (*it).get()->toInputElement();
 479                 elem->focus();
 480             }
 481             index++;
 482         }
 483     }
 484 }
 485
 486 #if ENABLE(TIZEN_MOBILE_WEB_PRINT)
 487 #define INCH_TO_MM 25.4
 488 #define INCH_TO_POINTS 72.0
 489
 490 void WebPage::createPagesToPDF(const IntSize& surfaceSize, const IntSize& contentsSize, const String& fileName)
 491 {
 492     FrameView* frameView = m_mainFrame->coreFrame()->view();
 493     if (!frameView)
 494         return;
 495
 496     RefPtr<WebImage> pageshotImage = WebImage::create(contentsSize, ImageOptionsShareable);
 497     if (!pageshotImage->bitmap())
 498         return;
 499
 500     double pdfWidth = (double)surfaceSize.width() / INCH_TO_MM * INCH_TO_POINTS;
 501     double pdfHeight = (double)surfaceSize.height() / INCH_TO_MM * INCH_TO_POINTS;
 502     double scaleFactorPdf = 1.0;
 503     if (contentsSize.width() > pdfWidth)
 504         scaleFactorPdf = pdfWidth / (double)contentsSize.width();
 505
 506     OwnPtr<WebCore::GraphicsContext> graphicsContext = pageshotImage->bitmap()->createGraphicsContextForPdfSurface(fileName, pdfWidth, pdfHeight);
 507     graphicsContext->scale(FloatSize(scaleFactorPdf, scaleFactorPdf));
 508
 509     frameView->updateLayoutAndStyleIfNeededRecursive();
 510
 511     int pageNumber = ((contentsSize.height() * scaleFactorPdf) / pdfHeight) + 1;
 512     float paintY = 0.0;
 513
 514     PaintBehavior oldBehavior = frameView->paintBehavior();
 515     frameView->setPaintBehavior(oldBehavior | PaintBehaviorFlattenCompositingLayers);
 516     for (int i = 0; i < pageNumber; i++) {
 517         IntRect paintRect(0, (int)paintY, contentsSize.width(), (int)(pdfHeight / scaleFactorPdf));
 518
 519         frameView->paint(graphicsContext.get(), paintRect);
 520         cairo_show_page(graphicsContext->platformContext()->cr());
 521         graphicsContext->translate(0, -ceil(pdfHeight / scaleFactorPdf));
 522         paintY += (pdfHeight / scaleFactorPdf);
 523     }
 524     frameView->setPaintBehavior(oldBehavior);
 525
 526     pageshotImage.release();
 527 }
 528 #endif
 529
 530 #if ENABLE(TIZEN_TEXT_CARET_HANDLING_WK2)
 531 bool WebPage::setCaretPosition(const IntPoint& pos)
 532 {
 533     Frame* frame = m_page->focusController()->focusedOrMainFrame();
 534     if (!frame)
 535         return false;
 536
 537     FrameSelection* controller = frame->selection();
 538     if (!controller)
 539         return false;
 540
 541     FrameView* frameView = frame->view();
 542     if (!frameView)
 543         return false;
 544
 545     IntPoint point = m_page->mainFrame()->view()->windowToContents(pos);
 546     HitTestResult result = m_page->mainFrame()->eventHandler()->hitTestResultAtPoint(point, /*allowShadowContent*/ true, /*ignoreClipping*/ true);
 547     if (result.scrollbar())
 548         return false;
 549
 550     Node* innerNode = result.innerNode();
 551
 552     if (!innerNode || !innerNode->renderer())
 553         return false;
 554
 555     VisiblePosition visiblePos;
 556
 557     // we check if content is richly editable - because those input field behave other than plain text ones
 558     // sometimes they may consists a node structure and they need special approach
 559     if (innerNode->rendererIsRichlyEditable()) {
 560         // point gets inner node local coordinates
 561         point = flooredIntPoint(result.localPoint());
 562         IntRect rect = innerNode->renderer()->absoluteBoundingBoxRect(true);
 563
 564         // it is not the best way to do this, but it is not as slow and it works - so maybe in the future someone
 565         // will have a better idea how to solve it
 566         // here we are getting innerNode from HitTestResult - unfortunately this is a kind of high level node
 567         // in the code below I am trying to obtain low level node - #text - to get its coordinates and size
 568
 569         // all those getting nodes rects are needed to bypass WebCore's methods of positioning caret when user
 570         // is clicking outside a node - and cheat WebCore telling it that actually we clicked into input field
 571         // node, not outside of it
 572         Node* deepInnerNode = innerNode->renderer()->positionForPoint(point).deepEquivalent().deprecatedNode();
 573
 574         if (!deepInnerNode || !deepInnerNode->renderer())
 575             return false;
 576
 577         // so we get a base node rectange
 578         IntRect deepNodeRect = deepInnerNode->renderer()->absoluteBoundingBoxRect(true);
 579
 580         // we modify our local point to adjust it to base node local coordinates
 581         point.move(rect.x() - deepNodeRect.x(), rect.y() - deepNodeRect.y());
 582
 583         // if we are outside the rect we cheat, that we are just inside of it
 584         if (point.y() < 0)
 585             point.setY(0);
 586         else if (point.y() >= deepNodeRect.height())
 587             point.setY(deepNodeRect.height() - 1);
 588
 589         // visible position created - caret ready to set
 590         visiblePos = deepInnerNode->renderer()->positionForPoint(point);
 591         if (visiblePos.isNull())
 592             return false;
 593     } else {
 594         // for plain text input fields we can get only a caret bounding box
 595         if (!controller->isCaret() || !controller->caretRenderer())
 596             return false;
 597
 598         const Node* node = controller->start().deprecatedNode();
 599         if (!node || !node->renderer())
 600             return false;
 601
 602         Element* currentRootEditableElement = node->rootEditableElement();
 603         Element* newRootEditableElement = innerNode->rootEditableElement();
 604         if (currentRootEditableElement != newRootEditableElement)
 605             return false;
 606
 607         IntRect rect = controller->caretRenderer()->absoluteBoundingBoxRect(true);
 608
 609         // The below wirtten code is not correct way to implement. Presntly the is no
 610         // other working way. To be replaced by better logic
 611         // here we also cheat input field that we actually are just inside of if
 612         IntPoint focusedFramePoint = frame->view()->windowToContents(pos);
 613         IntPoint oldFocusedFramePoint = focusedFramePoint;
 614
 615         const int boundariesWidth = 2;
 616         if (focusedFramePoint.x() < rect.x())
 617             focusedFramePoint.setX(rect.x());
 618         else if (focusedFramePoint.x() > rect.maxX())
 619             focusedFramePoint.setX(rect.maxX());
 620         if (focusedFramePoint.y() < rect.y() + boundariesWidth)
 621             focusedFramePoint.setY(rect.y() + boundariesWidth);
 622         else if (focusedFramePoint.y() >= rect.maxY() - boundariesWidth)
 623             focusedFramePoint.setY(rect.maxY() - boundariesWidth - 1);
 624
 625         int diffX = focusedFramePoint.x() - oldFocusedFramePoint.x();
 626         int diffY = focusedFramePoint.y() - oldFocusedFramePoint.y();
 627         point.setX((point.x())+diffX);
 628         point.setY((point.y())+diffY);
 629
 630         // hit test with fake (adjusted) coordinates
 631         IntPoint hitTestPoint = m_page->mainFrame()->view()->windowToContents(point);
 632         HitTestResult newResult = m_page->mainFrame()->eventHandler()->hitTestResultAtPoint(hitTestPoint, /*allowShadowContent*/ true, /*ignoreClipping*/ true);
 633
 634         if (!newResult.isContentEditable())
 635             return false;
 636
 637         Node* newInnerNode = newResult.innerNode();
 638
 639         if (!newInnerNode || !newInnerNode->renderer())
 640             return false;
 641
 642         // visible position created
 643         visiblePos = newInnerNode->renderer()->positionForPoint(newResult.localPoint());
 644         if (visiblePos.isNull())
 645             return false;
 646     }
 647
 648     // create visible selection from visible position
 649     VisibleSelection newSelection = VisibleSelection(visiblePos);
 650     controller->setSelection(newSelection, CharacterGranularity);
 651     // after setting selection caret blinking is suspended by default so we are unsuspedning it
 652     controller->setCaretBlinkingSuspended(false);
 653
 654     return true;
 655 }
 656 #endif
 657
 658 #if ENABLE(TIZEN_ISF_PORT)
 659 void WebPage::didCancelComposition(Node* valueChangedNode)
 660 {
 661     Frame* frame = m_page->focusController()->focusedOrMainFrame();
 662     if (!frame || frame->editor()->ignoreCompositionSelectionChange() || !valueChangedNode->containsIncludingShadowDOM(frame->editor()->compositionNode()))
 663         return;
 664
 665     frame->editor()->cancelComposition();
 666     send(Messages::WebPageProxy::DidCancelComposition());
 667 }
 668
 669 void WebPage::prepareKeyDownEvent()
 670 {
 671     m_prepareKeyDownEvent = true;
 672 }
 673
 674 void WebPage::swapKeyPressCommands(Vector<OwnPtr<KeyPressCommand> >& commands)
 675 {
 676     m_keyPressCommands.swap(commands);
 677 }
 678
 679 void WebPage::deleteSurroundingText(int offset, int count)
 680 {
 681     Frame* frame = m_page->focusController()->focusedOrMainFrame();
 682     if (!frame || !frame->editor()->canEdit())
 683         return;
 684
 685     if (m_prepareKeyDownEvent) {
 686         m_keyPressCommands.append(adoptPtr(new DeleteTextKeyPressCommand(offset, count)));
 687         return;
 688     }
 689
 690     Position base(frame->selection()->base());
 691     offset += base.offsetInContainerNode();
 692     base.moveToOffset(offset);
 693     Position extent(base);
 694     extent.moveToOffset(offset + count);
 695     VisibleSelection selection(base, extent);
 696     if (!selection.isRange())
 697         return;
 698
 699     frame->selection()->setSelection(selection);
 700     frame->editor()->deleteWithDirection(DirectionBackward, CharacterGranularity, false, true);
 701 }
 702
 703 bool WebPage::updateEditorStateRect(const Frame* frame, EditorState& state) const
 704 {
 705     ASSERT(frame->selection()->rootEditableElement());
 706
 707 #if ENABLE(TIZEN_WEBKIT2_TEXT_SELECTION)
 708     Vector<IntRect> rects;
 709     calcFocusedRects(frame->selection()->rootEditableElement(), rects);
 710     IntRect rect = unionRect(rects);
 711     if (state.editorRect == rect)
 712         return false;
 713
 714     state.editorRect = rect;
 715 #endif
 716
 717     if (frame->selection()->isCaret())
 718         state.selectionRect = frame->view()->contentsToWindow(frame->selection()->absoluteCaretBounds());
 719     else if (frame->selection()->isRange())
 720         state.selectionRect = frame->view()->contentsToWindow(enclosingIntRect(frame->selection()->bounds(false)));
 721
 722     return true;
 723 }
 724 #endif
 725
 726 #if ENABLE(TIZEN_INPUT_TAG_EXTENSION) || ENABLE(TIZEN_WEBKIT2_FORM_DATABASE)
 727 void WebPage::setFocusedInputElementValue(const String& inputValue)
 728 {
 729     Frame* frame = m_page->focusController()->focusedOrMainFrame();
 730     if (!frame || !frame->document() || !frame->document()->focusedNode())
 731         return;
 732
 733     HTMLInputElement* inputElement = frame->document()->focusedNode()->toInputElement();
 734     if (!inputElement)
 735         return;
 736
 737     inputElement->toNode()->dispatchFocusEvent(0);
 738     inputElement->setValue(inputValue, DispatchChangeEvent);
 739 }
 740
 741 void  WebPage::getFocusedInputElementValue(String& inputValue)
 742 {
 743     inputValue = String();
 744
 745     Frame* frame = m_page->focusController()->focusedOrMainFrame();
 746     if (!frame || !frame->document() || !frame->document()->focusedNode())
 747         return;
 748
 749     HTMLInputElement* inputElement = frame->document()->focusedNode()->toInputElement();
 750     if (!inputElement)
 751         return;
 752
 753     inputValue = inputElement->value();
 754 }
 755 #endif
 756
 757 #if ENABLE(TIZEN_DATALIST_ELEMENT)
 758 void WebPage::getFocusedInputElementDataList(Vector<String>& optionList)
 759 {
 760     Frame* frame = m_page->focusController()->focusedOrMainFrame();
 761     if (!frame || !frame->document())
 762         return;
 763
 764     Node* node = frame->document()->focusedNode();
 765     if (!node)
 766         return;
 767
 768     HTMLInputElement* input = node->toInputElement();
 769     if (!input)
 770         return;
 771
 772     HTMLDataListElement* dataList = static_cast<HTMLDataListElement*>(input->list());
 773     if (!dataList)
 774         return;
 775
 776     RefPtr<HTMLCollection> options = static_cast<HTMLDataListElement*>(dataList)->options();
 777     for (unsigned i = 0; Node* node = options->item(i); i++) {
 778         HTMLOptionElement* optionElement = static_cast<HTMLOptionElement*>(node);
 779         String value = optionElement->value();
 780         optionList.append(value);
 781     }
 782 }
 783 #endif
 784
 785 #if ENABLE(TIZEN_WEBKIT2_FOCUS_RING)
 786 static IntRect getNodeRect(Node* node, Node* focusableNode, bool isImage)
 787 {
 788     IntRect rect;
 789
 790     if (isImage) {
 791         bool isReplaced;
 792         IntRect imageNodeRect = pixelSnappedIntRect(node->getRect());
 793         if (!focusableNode->renderRect(&isReplaced).isEmpty() && imageNodeRect.contains(pixelSnappedIntRect(focusableNode->getRect()))) {
 794             // If render rect of focusableNode is empty and rect of imageNode include rect of focusableNode,
 795             // we have to get rect of focusableNode.
 796             // for example - The rect of google logo image in www.google.com pc site's search result page is bigger than rect of focusableNode.
 797             // for example - The rect of category menu image in www.gmarket.co.kr pc site is bigger than rect of focusableNode.
 798             rect = pixelSnappedIntRect(focusableNode->getRect());
 799         }
 800         else {
 801             // otherwise we have to get rect of imageNode.
 802             // for example - The render rect of images in www.pudelek.pl is empty.
 803             // 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.
 804             rect = imageNodeRect;
 805             focusableNode = node;
 806         }
 807     } else {
 808         // If focusedNode have multiple child nodes, we have to unite rect of child nodes.
 809         // for example - links in www.google.com's search result page.
 810         IntRect tempRect;
 811         for (Node* childNode = focusableNode->firstChild(); childNode; childNode = childNode->traverseNextNode(focusableNode)) {
 812             bool isReplaced;
 813             if (focusableNode->renderRect(&isReplaced).contains(childNode->getRect()))
 814                 tempRect.unite(pixelSnappedIntRect(childNode->getRect()));
 815         }
 816
 817         // If tempRect is empty or rect of focusableNode include tempRect,
 818         // we have to get rect of focusableNode.
 819         // for example - list menu item in m.naver.com.
 820         // otherwise we have to get rect of tempRect.
 821         // getRect API do not return correct rect if the node is a container node,
 822         // hence using absoluteBoundingBoxRect to get the correct bounding rect.
 823         LayoutRect renderRect = focusableNode->renderer() ? focusableNode->renderer()->absoluteBoundingBoxRect() : focusableNode->getRect();
 824         if (tempRect.isEmpty() || renderRect.contains(tempRect))
 825             rect = pixelSnappedIntRect(renderRect);
 826         else
 827             rect = tempRect;
 828     }
 829
 830     // We have to get render rect from ancestor node if current rect is empty.
 831     // for example - The rect of naver logo image in www.naver.com pc site is empty.
 832     bool isReplaced;
 833     for (Node* loopNode = focusableNode; loopNode && rect.isEmpty(); loopNode = loopNode->parentNode()) {
 834         RenderObject* renderer = loopNode->renderer();
 835         if (renderer && renderer->isRoot())
 836             break;
 837
 838         rect = pixelSnappedIntRect(loopNode->renderRect(&isReplaced));
 839     }
 840
 841     Frame* nodeFrame = focusableNode->document()->frame();
 842     Node* owner;
 843     while (nodeFrame && (owner = nodeFrame->ownerElement())) {
 844         rect.moveBy(owner->getRect().pixelSnappedLocation());
 845         nodeFrame = owner->document()->frame();
 846     }
 847
 848     // The y position of tab menu item in www.google.com is negative value,
 849     // so we do not want to draw focus ring in that case.
 850     if ((rect.maxX() < 0) || (rect.maxY() < 0))
 851         rect = IntRect();
 852
 853     return rect;
 854 }
 855 #endif
 856
 857 #if ENABLE(TIZEN_WEBKIT2_HIT_TEST)
 858 #if ENABLE(TIZEN_WEBKIT2_FOCUS_RING)
 859 static bool isClickableOrFocusable(Node* focusableNode)
 860 {
 861
 862    if (!focusableNode)
 863        return false;
 864    if (focusableNode->disabled())
 865         return false;
 866    if (!focusableNode->inDocument())
 867         return false;
 868    if (!focusableNode->renderer() || focusableNode->renderer()->style()->visibility() != VISIBLE)
 869         return false;
 870    if (focusableNode->isFocusable()) {
 871        if (focusableNode->isLink()
 872            || focusableNode->hasTagName(HTMLNames::inputTag)
 873            || focusableNode->hasTagName(HTMLNames::selectTag)
 874            || focusableNode->hasTagName(HTMLNames::buttonTag))
 875            return true;
 876    }
 877    if (focusableNode->supportsFocus()
 878        || focusableNode->hasEventListeners(eventNames().clickEvent)
 879        || focusableNode->hasEventListeners(eventNames().mousedownEvent)
 880        || focusableNode->hasEventListeners(eventNames().mouseupEvent)) {
 881        return true;
 882    }
 883    return false;
 884 }
 885
 886 #if ENABLE(TOUCH_ADJUSTMENT)
 887 void WebPage::getFocusedRect(HitTestResult hitTestResult, Page* page, bool setFocus, Vector<IntRect>& rects, const IntPoint& point, const IntSize& area)
 888 #else
 889 void WebPage::getFocusedRect(HitTestResult hitTestResult, Page* page, bool setFocus, Vector<IntRect>& rects)
 890 #endif
 891 {
 892     Node* node = hitTestResult.innerNode();
 893 #if ENABLE(TOUCH_ADJUSTMENT)
 894     IntPoint adustedPoint;
 895     Frame* mainFrame = page->mainFrame();
 896     Node* adjustedNode = 0;
 897     mainFrame->eventHandler()->bestClickableNodeForTouchPoint(point, IntSize(area.width() / 2, area.height() / 2), adustedPoint, adjustedNode);
 898     if (!isClickableOrFocusable(node))
 899         mainFrame->eventHandler()->bestClickableNodeForTouchPoint(point, IntSize(area.width() / 2, area.height() / 2), adustedPoint, adjustedNode);
 900
 901     if (adjustedNode)
 902         node = adjustedNode;
 903 #endif
 904     if (!node)
 905         return;
 906
 907     bool isFocusRingDrawable = false;
 908     Node* focusableNode = node;
 909     while (focusableNode) {
 910         RenderObject* renderer = focusableNode->renderer();
 911         if (renderer && (renderer->isBody() || renderer->isRenderView() || renderer->isRoot()))
 912             break;
 913
 914         if (isClickableOrFocusable(focusableNode)) {
 915             isFocusRingDrawable = true;
 916             break;
 917         }
 918
 919         focusableNode = focusableNode->parentNode();
 920     }
 921
 922     // Don't draw focus ring if child is focusable or has trigger
 923     if (focusableNode && focusableNode->isContainerNode() && !focusableNode->isLink()) {
 924         WebCore::Node *child = static_cast<const ContainerNode*>(focusableNode)->firstChild();
 925         while(child) {
 926             if( child->supportsFocus()
 927                 || child->hasEventListeners(eventNames().clickEvent)
 928                 || child->hasEventListeners(eventNames().mousedownEvent)
 929                 || child->hasEventListeners(eventNames().mouseupEvent)) {
 930                 return;
 931             }
 932             child = child->traverseNextNode(focusableNode);
 933         }
 934     }
 935
 936     if (!isFocusRingDrawable) {
 937         if (!node->hasTagName(HTMLNames::imgTag))
 938             return;
 939         focusableNode = node;
 940     }
 941
 942     if (setFocus)
 943         setFocusedNode(focusableNode);
 944
 945     calcFocusedRects(focusableNode, rects);
 946 }
 947 #endif
 948
 949 #if ENABLE(TOUCH_ADJUSTMENT)
 950 void WebPage::hitTestResultAtPoint(const IntPoint& point, int hitTestMode, const IntSize& area, WebHitTestResult::Data& hitTestResultData)
 951 #else
 952 void WebPage::hitTestResultAtPoint(const IntPoint& point, int hitTestMode, WebHitTestResult::Data& hitTestResultData)
 953 #endif
 954 {
 955     Frame* frame = m_page->mainFrame();
 956     FrameView* frameView = frame->view();
 957     if (!frameView)
 958         return;
 959
 960     HitTestResult hitTestResult = frame->eventHandler()->hitTestResultAtPoint(frameView->windowToContents(point), false);
 961     hitTestResultData.absoluteImageURL = hitTestResult.absoluteImageURL().string();
 962     hitTestResultData.absoluteLinkURL = hitTestResult.absoluteLinkURL().string();
 963     hitTestResultData.absoluteMediaURL = hitTestResult.absoluteMediaURL().string();
 964     hitTestResultData.linkLabel = hitTestResult.textContent();
 965     hitTestResultData.linkTitle = hitTestResult.titleDisplayString();
 966     hitTestResultData.isContentEditable = hitTestResult.isContentEditable();
 967 #if ENABLE(TIZEN_DRAG_SUPPORT)
 968     hitTestResultData.isDragSupport = hitTestResult.isDragSupport();
 969 #endif
 970
 971     int context = WebHitTestResult::HitTestResultContextDocument;
 972
 973     if (!hitTestResult.absoluteLinkURL().isEmpty())
 974         context |= WebHitTestResult::HitTestResultContextLink;
 975     if (!hitTestResult.absoluteImageURL().isEmpty())
 976         context |= WebHitTestResult::HitTestResultContextImage;
 977     if (!hitTestResult.absoluteMediaURL().isEmpty())
 978         context |= WebHitTestResult::HitTestResultContextMedia;
 979     if (hitTestResult.isSelected())
 980         context |= WebHitTestResult::HitTestResultContextSelection;
 981     if (hitTestResult.isContentEditable())
 982         context |= WebHitTestResult::HitTestResultContextEditable;
 983     if (hitTestResult.innerNonSharedNode() && hitTestResult.innerNonSharedNode()->isTextNode())
 984         context |= WebHitTestResult::HitTestResultContextText;
 985
 986     hitTestResultData.context = context;
 987     hitTestResultData.hitTestMode = hitTestMode;
 988
 989 #if ENABLE(TIZEN_WEBKIT2_FOCUS_RING)
 990     bool setFocus = hitTestResultData.hitTestMode & WebHitTestResult::HitTestModeSetFocus;
 991 #if ENABLE(TOUCH_ADJUSTMENT)
 992     getFocusedRect(hitTestResult, m_page.get(), setFocus, hitTestResultData.focusedRects, point, area);
 993 #else
 994     getFocusedRect(hitTestResult, m_page.get(), setFocus, hitTestResultData.focusedRects);
 995 #endif
 996
 997     // Don't display FocusRect if the size is too big..
 998     IntRect framerect = frameView->visibleContentRect(true);
 999     for (size_t i = 0; i < hitTestResultData.focusedRects.size(); ++i) {
1000         if (hitTestResultData.focusedRects[i].width() > (0.8 * framerect.width())
1001             && hitTestResultData.focusedRects[i].height() > (0.8 * framerect.height()))
1002             hitTestResultData.focusedRects.clear();
1003     }
1004
1005     if (hitTestResult.innerNode() && hitTestResult.innerNode()->renderer() && hitTestResult.innerNode()->renderer()->style()) {
1006         hitTestResultData.focusedColor = hitTestResult.innerNode()->renderer()->style()->tapHighlightColor();
1007         if (!hitTestResultData.focusedColor.hasAlpha())
1008             hitTestResultData.focusedColor = Color(hitTestResultData.focusedColor.red(), hitTestResultData.focusedColor.green(), hitTestResultData.focusedColor.blue(), RenderStyle::initialTapHighlightColor().alpha());
1009     }
1010 #endif
1011
1012     if (hitTestResultData.hitTestMode & WebHitTestResult::HitTestModeNodeData) {
1013         WebCore::Node* hitNode = hitTestResult.innerNonSharedNode();
1014         if (hitNode) {
1015             hitTestResultData.nodeData.nodeValue = hitNode->nodeValue();
1016
1017             if ((hitTestResultData.context & WebHitTestResult::HitTestResultContextText) && hitNode->parentNode())
1018                 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.
1019
1020             if (hitNode->isElementNode()) {
1021                 WebCore::Element* hitElement = static_cast<WebCore::Element*>(hitNode);
1022                 if (hitElement) {
1023                     hitTestResultData.nodeData.tagName = hitElement->tagName();
1024                 }
1025             }
1026
1027             WebCore::NamedNodeMap* namedNodeMap = hitNode->attributes();
1028             if (namedNodeMap) {
1029                 for (size_t i = 0; i < namedNodeMap->length(); i++) {
1030                     const WebCore::Attribute* attribute = namedNodeMap->element()->attributeItem(i);
1031                     String key = attribute->name().toString();
1032                     String value = attribute->value();
1033                     hitTestResultData.nodeData.attributeMap.add(key, value);
1034                 }
1035             }
1036 #if ENABLE(TIZEN_WEBKIT2_TEXT_SELECTION)
1037             hitTestResultData.nodeData.zIndex = 0;
1038             for (Node* node = hitNode; node; node = node->parentNode()) {
1039                 RenderStyle* computedStyle = node->computedStyle();
1040                 if (computedStyle && !(computedStyle->hasAutoZIndex()) && hitTestResultData.nodeData.zIndex < computedStyle->zIndex())
1041                     hitTestResultData.nodeData.zIndex = computedStyle->zIndex();
1042             }
1043 #endif
1044         }
1045     }
1046
1047     if ((hitTestResultData.hitTestMode & WebHitTestResult::HitTestModeImageData) && (hitTestResultData.context & WebHitTestResult::HitTestResultContextImage)) {
1048         WebCore::Image* hitImage = hitTestResult.image();
1049         if (hitImage && hitImage->data() && hitImage->data()->data()) {
1050             hitTestResultData.imageData.data.append(hitImage->data()->data(), hitImage->data()->size());
1051             hitTestResultData.imageData.fileNameExtension = hitImage->filenameExtension();
1052         }
1053     }
1054 }
1055 #endif
1056
1057 #if ENABLE(TIZEN_WEB_STORAGE)
1058 void WebPage::getStorageQuotaBytes(uint64_t callbackID)
1059 {
1060     uint32_t quota = m_page->group().groupSettings()->localStorageQuotaBytes();
1061     send(Messages::WebPageProxy::DidGetWebStorageQuotaBytes(quota, callbackID));
1062 }
1063
1064 void WebPage::setStorageQuotaBytes(uint32_t quota)
1065 {
1066     m_page->group().groupSettings()->setLocalStorageQuotaBytes(quota);
1067 }
1068 #endif
1069
1070 #if ENABLE(TIZEN_CLIPBOARD) || ENABLE(TIZEN_PASTEBOARD)
1071 void WebPage::setClipboardDataForPaste(const String& data, const String& type)
1072 {
1073 #if ENABLE(TIZEN_PASTEBOARD)
1074     // FIXME: Should move to EditorClient like Clipboard
1075     Pasteboard::generalPasteboard()->setDataWithType(data, type);
1076 #else
1077     Frame* mainFrame = m_page->mainFrame();
1078     if (!mainFrame)
1079         return;
1080
1081     mainFrame->editor()->client()->setClipboardDataForPaste(data, type);
1082 #endif
1083 }
1084 #endif
1085
1086 void WebPage::suspendJavaScriptAndResources()
1087 {
1088     Frame* mainFrame = m_page->mainFrame();
1089     if (!mainFrame)
1090         return;
1091
1092     for (Frame* frame = mainFrame; frame; frame = frame->tree()->traverseNext())
1093         frame->document()->suspendScheduledTasks(WebCore::ActiveDOMObject::PageWillBeSuspended);
1094     mainFrame->loader()->suspendAllLoaders();
1095 }
1096
1097 void WebPage::resumeJavaScriptAndResources()
1098 {
1099     Frame* mainFrame = m_page->mainFrame();
1100     if (!mainFrame)
1101         return;
1102
1103     for (Frame* frame = mainFrame; frame; frame = frame->tree()->traverseNext())
1104         frame->document()->resumeScheduledTasks();
1105     mainFrame->loader()->resumeAllLoaders();
1106 }
1107
1108 void WebPage::suspendAnimations()
1109 {
1110     Frame* mainFrame = m_page->mainFrame();
1111     if (!mainFrame)
1112         return;
1113
1114     for (Frame* frame = mainFrame; frame; frame = frame->tree()->traverseNext())
1115         frame->animation()->suspendAnimationsForDocument(frame->document());
1116 }
1117
1118 void WebPage::resumeAnimations()
1119 {
1120     Frame* mainFrame = m_page->mainFrame();
1121     if (!mainFrame)
1122         return;
1123
1124     for (Frame* frame = mainFrame; frame; frame = frame->tree()->traverseNext())
1125         frame->animation()->resumeAnimationsForDocument(frame->document());
1126 }
1127
1128 #if ENABLE(TIZEN_SYNC_REQUEST_ANIMATION_FRAME)
1129 void WebPage::suspendAnimationController()
1130 {
1131     if (!m_suspendedAnimationController) {
1132         Frame* mainFrame = m_page->mainFrame();
1133         if (!mainFrame)
1134             return;
1135
1136         for (Frame* frame = mainFrame; frame; frame = frame->tree()->traverseNext())
1137             frame->document()->suspendScriptedAnimationControllerCallbacks();
1138
1139         m_suspendedAnimationController = true;
1140     }
1141 }
1142
1143 void WebPage::resumeAnimationController()
1144 {
1145     if (m_suspendedAnimationController) {
1146         Frame* mainFrame = m_page->mainFrame();
1147         if (!mainFrame)
1148             return;
1149
1150         for (Frame* frame = mainFrame; frame; frame = frame->tree()->traverseNext())
1151             frame->document()->resumeScriptedAnimationControllerCallbacks();
1152
1153         m_suspendedAnimationController = false;
1154     }
1155 }
1156 #endif
1157
1158 #if ENABLE(TIZEN_REMOTE_WEB_INSPECTOR)
1159 void WebPage::startInspectorServer(uint32_t port,  uint32_t& allocatedPort)
1160 {
1161     bool ret = WebInspectorServerTizen::server()->startServer(port);
1162     if (ret)
1163         allocatedPort = WebInspectorServerTizen::server()->getServerPort();
1164     else
1165         allocatedPort = 0;
1166 }
1167
1168 void WebPage::stopInspectorServer(bool& result)
1169 {
1170     result = WebInspectorServerTizen::server()->stopServer();
1171 }
1172 #endif
1173
1174 #if ENABLE(TIZEN_CSS_OVERFLOW_SCROLL_ACCELERATION_ON_UI_SIDE)
1175 void WebPage::scrollOverflowWithTrajectoryVector(const WebCore::FloatPoint& trajectoryVector)
1176 {
1177     Frame* frame = m_page->focusController()->focusedOrMainFrame();
1178     if (!frame)
1179         return;
1180     frame->eventHandler()->scrollOverflow(trajectoryVector);
1181 }
1182 #endif
1183
1184 #if ENABLE(TIZEN_CSS_OVERFLOW_SCROLL_ACCELERATION)
1185 void WebPage::scrollOverflow(const WebCore::FloatPoint& delta, bool& scrolled)
1186 {
1187     scrolled = m_page->focusController()->focusedOrMainFrame()->eventHandler()->scrollOverflow(delta);
1188 }
1189
1190 void WebPage::setPressedNodeAtPoint(const IntPoint& point, bool checkOverflowLayer, bool& pressed, uint32_t& id)
1191 {
1192     RenderObject* renderer = 0;
1193     id = 0;
1194     pressed = m_page->mainFrame()->eventHandler()->setMousePressNodeAtPoint(point, checkOverflowLayer, renderer);
1195 #if ENABLE(TIZEN_CSS_OVERFLOW_SCROLL_ACCELERATION_ON_UI_SIDE)
1196     if (pressed && renderer)
1197         id = toWebGraphicsLayer(renderer->enclosingLayer()->layerForScrollingContents())->id();
1198 #endif
1199 }
1200 #endif
1201
1202 void WebPage::executeEditCommandWithArgument(const String& commandName, const String& argument)
1203 {
1204     executeEditingCommand(commandName, argument);
1205 }
1206
1207 #if ENABLE(TIZEN_PLUGIN_SUSPEND_RESUME)
1208 void WebPage::suspendPlugin()
1209 {
1210     for (Frame* frame = m_page->mainFrame(); frame; frame = frame->tree()->traverseNext()) {
1211         FrameView* view = frame->view();
1212         if (!view)
1213             continue;
1214
1215         const HashSet<RefPtr<Widget> >* children = view->children();
1216         ASSERT(children);
1217
1218         HashSet<RefPtr<Widget> >::const_iterator end = children->end();
1219         for (HashSet<RefPtr<Widget> >::const_iterator it = children->begin(); it != end; ++it) {
1220             Widget* widget = (*it).get();
1221             if (widget->isPluginViewBase()) {
1222                 PluginView* pluginView = static_cast<PluginView*>(widget);
1223                 if (pluginView)
1224                     pluginView->suspendPlugin();
1225             }
1226         }
1227     }
1228 }
1229
1230 void WebPage::resumePlugin()
1231 {
1232     for (Frame* frame = m_page->mainFrame(); frame; frame = frame->tree()->traverseNext()) {
1233         FrameView* view = frame->view();
1234         if (!view)
1235             continue;
1236
1237         const HashSet<RefPtr<Widget> >* children = view->children();
1238         ASSERT(children);
1239
1240         HashSet<RefPtr<Widget> >::const_iterator end = children->end();
1241         for (HashSet<RefPtr<Widget> >::const_iterator it = children->begin(); it != end; ++it) {
1242             Widget* widget = (*it).get();
1243             if (widget->isPluginViewBase()) {
1244                 PluginView* pluginView = static_cast<PluginView*>(widget);
1245                 if (pluginView)
1246                     pluginView->resumePlugin();
1247             }
1248         }
1249     }
1250 }
1251 #endif
1252
1253 #if ENABLE(TIZEN_MULTIPLE_SELECT)
1254 void WebPage::didChangeSelectedIndexForActivePopupMenuMultiple(Vector<int32_t> newIndex)
1255 {
1256     if (!m_activePopupMenu)
1257         return;
1258
1259     m_activePopupMenu->client()->popupDidHide();
1260
1261     size_t indexSize = newIndex.size();
1262     for (size_t i = 0; i < indexSize; i++)
1263         m_activePopupMenu->didChangeSelectedIndex(newIndex.at(i));
1264
1265 }
1266 #endif
1267
1268 #if ENABLE(TIZEN_OFFLINE_PAGE_SAVE)
1269 void WebPage::startOfflinePageSave(String subresourceFolderName)
1270 {
1271     WebPageSerializerTizen::getSerializedPageContent(this, subresourceFolderName);
1272 }
1273 #endif
1274
1275 #if ENABLE(TIZEN_WEBKIT2_TEXT_SELECTION)
1276 void WebPage::selectClosestWord(const IntPoint& point, bool isAutoWordSelection, bool& result)
1277 {
1278     result = false;
1279
1280     Frame* mainFrame = m_page->mainFrame();
1281     Frame* focusedFrame = m_page->focusController()->focusedOrMainFrame();
1282
1283     HitTestResult hitTestResult = mainFrame->eventHandler()->hitTestResultAtPoint(m_page->mainFrame()->view()->windowToContents(point), false);
1284
1285     Node* node = hitTestResult.innerNonSharedNode();
1286     if (!node)
1287         return;
1288
1289     if (node->renderer() && node->renderer()->style() && (node->renderer()->style()->userSelect() == SELECT_NONE))
1290         return;
1291
1292      Frame* newFocusFrame = node->document()->frame();
1293      if (focusedFrame != newFocusFrame) {
1294          m_page->focusController()->setFocusedFrame(newFocusFrame);
1295          focusedFrame = newFocusFrame;
1296      }
1297
1298     HTMLInputElement* inputElement = node->toInputElement();
1299
1300     if (hitTestResult.isContentEditable()) {
1301 #if ENABLE(TIZEN_INPUT_TAG_EXTENSION)
1302         if (!inputElement || (inputElement
1303             && !inputElement->isDateField() && !inputElement->isDateTimeField() && !inputElement->isDateTimeLocalField()
1304             && !inputElement->isMonthField() && !inputElement->isTimeField() && !inputElement->isWeekField())) {
1305             result = setCaretPosition(point);
1306             if (!isAutoWordSelection)
1307                 return;
1308         }
1309 #else
1310         result = setCaretPosition(point);
1311         if (!isAutoWordSelection)
1312             return;
1313 #endif
1314     }
1315
1316 #if ENABLE(TIZEN_INPUT_TAG_EXTENSION)
1317     if (!node->isTextNode() && !inputElement)
1318 #else
1319     if (!node->isTextNode())
1320 #endif
1321         return;
1322
1323 #if ENABLE(TIZEN_INPUT_TAG_EXTENSION)
1324     if (inputElement
1325         && (inputElement->isDateField() || inputElement->isDateTimeField() || inputElement->isDateTimeLocalField()
1326         || inputElement->isMonthField() || inputElement->isTimeField() || inputElement->isWeekField())) {
1327         if (inputElement->value().isEmpty())
1328             return;
1329     }
1330 #endif
1331
1332     for (Node* node = hitTestResult.innerNonSharedNode(); node; node = node->parentNode()) {
1333         if (node->isFocusable()) {
1334             // Text selection shoud not be started when text of <button> tag is selected.
1335             if (node->hasTagName(HTMLNames::buttonTag))
1336                 return;
1337
1338             if (inputElement && (inputElement->isTextButton() || inputElement->isCheckbox()))
1339                 return;
1340
1341             break;
1342         }
1343     }
1344
1345     FrameSelection* frameSelection = focusedFrame->selection();
1346
1347     VisiblePosition position = mainFrame->visiblePositionForPoint(point);
1348     VisibleSelection selection(position);
1349
1350     // This changes just the 'start' and 'end' positions of the VisibleSelection
1351     selection.expandUsingGranularity(WordGranularity);
1352
1353     FrameSelection::SetSelectionOptions options = FrameSelection::CloseTyping | FrameSelection::ClearTypingStyle | FrameSelection::DoNotSetFocus;
1354     frameSelection->setSelection(VisibleSelection(selection.start(), selection.end()), options);
1355
1356     if (!frameSelection->isRange())
1357         return;
1358
1359     // This changes just the 'start' and 'end' positions of the VisibleSelection
1360     // Find handlers positions
1361     IntRect leftRect, rightRect, updatedEditorRect;
1362     int selectionDirection = 0;
1363     getSelectionHandlers(leftRect, rightRect, selectionDirection, updatedEditorRect);
1364     if (leftRect.size().isZero() && rightRect.size().isZero()) {
1365         // Sometimes there is no selected text, but isNone() returns TRUE
1366         // in this case ewk_frame_selection_handlers_get() returns FALSE and handlers are invalid
1367         // Workaround - clear the selection.
1368         // Better solution would be to modify the ewk_frame_select_closest_word()
1369         // to not select anything in the first place (for example - don't call setSelection()
1370         // if there is nothing under the cursor).
1371         selectionClearAllSelection(m_page->mainFrame());
1372         return;
1373     }
1374
1375     result = true;
1376 }
1377
1378 void WebPage::setLeftSelection(const IntPoint& point, const int direction, int& result)
1379 {
1380     result = HandleMovingDirectionNone;
1381
1382     Frame* focusedFrame = m_page->focusController()->focusedOrMainFrame();
1383     FrameSelection* frameSelection = focusedFrame->selection();
1384     if (!frameSelection->isRange())
1385         return;
1386
1387     Node* selectionEndNode = frameSelection->end().deprecatedNode();
1388     if (!selectionEndNode || !selectionEndNode->renderer())
1389         return;
1390
1391     FrameView* frameView = focusedFrame->view();
1392     if (!frameView)
1393         return;
1394
1395     IntPoint pos = frameView->windowToContents(point);
1396     IntRect leftRect, rightRect, updatedEditorRect;
1397     int selectionDirection = 0;
1398     getSelectionHandlers(leftRect, rightRect, selectionDirection, updatedEditorRect);
1399
1400     if (selectionEndNode->rendererIsEditable() && !selectionEndNode->rendererIsRichlyEditable()) {
1401         const int boundariesWidth = 2;
1402
1403         IntRect rect = frameSelection->caretRenderer()->absoluteBoundingBoxRect(true);
1404         // here we cheat input field that we actually are just inside of if
1405         if (pos.y() < rect.y() + boundariesWidth)
1406             pos.setY(rect.y() + boundariesWidth);
1407         else if (pos.y() >= rect.maxY() - boundariesWidth)
1408             pos.setY(rect.maxY() - boundariesWidth - 1);
1409     }
1410
1411     OwnPtr<VisiblePosition> position = adoptPtr(new VisiblePosition(focusedFrame->visiblePositionForPoint(pos)));
1412     Position base = frameSelection->base();
1413     Position extent = frameSelection->extent();
1414
1415     Node* newSelectionStartNode = position->deepEquivalent().deprecatedNode();
1416
1417     // both start and end nodes should be in the same area type: both should be editable or both should be not editable
1418     // Check if the new position is before the extent's position
1419     if (newSelectionStartNode
1420         && selectionEndNode->isContentEditable() == newSelectionStartNode->isContentEditable()) {
1421         // Change the 'base' and 'extent' positions to 'start' and 'end' positions.
1422         // We do it, because without this, the other modification of the selection
1423         // would destroy the 'start' and/or 'end' positions and set them to
1424         // the 'base'/'extent' positions accordingly
1425         VisibleSelection sel(frameSelection->start(), frameSelection->end());
1426         frameSelection->setSelection(sel);
1427
1428         bool oldProhibitsScrolling = focusedFrame->view()->prohibitsScrolling();
1429         focusedFrame->view()->setProhibitsScrolling(true);
1430
1431         if (direction == HandleMovingDirectionNormal) {
1432             if (comparePositions(position->deepEquivalent(), extent) < 0) {
1433                 frameSelection->setBase(*position);
1434                 result = HandleMovingDirectionNormal;
1435             } else if (comparePositions(position->deepEquivalent(), extent) > 0) {
1436                 frameSelection->setExtent(*position);
1437                 frameSelection->setBase(extent);
1438                 result = HandleMovingDirectionReverse;
1439             }
1440         } else if (direction == HandleMovingDirectionReverse) {
1441             if (comparePositions(position->deepEquivalent(), base) > 0) {
1442                 frameSelection->setExtent(*position);
1443                 result = HandleMovingDirectionReverse;
1444             } else if (comparePositions(position->deepEquivalent(), base) < 0) {
1445                 frameSelection->setBase(*position);
1446                 frameSelection->setExtent(base);
1447                 result = HandleMovingDirectionNormal;
1448             }
1449         }
1450
1451         focusedFrame->view()->setProhibitsScrolling(oldProhibitsScrolling);
1452         // This forces webkit to show selection
1453         // m_coreFrame->invalidateSelection();
1454     }
1455 }
1456
1457 void WebPage::setRightSelection(const IntPoint& point, const int direction, int& result)
1458 {
1459     result = HandleMovingDirectionNone;
1460
1461     Frame* focusedFrame = m_page->focusController()->focusedOrMainFrame();
1462     FrameSelection* frameSelection = focusedFrame->selection();
1463
1464     if (!frameSelection->isRange())
1465         return;
1466
1467     Node* selectionStartNode = frameSelection->start().deprecatedNode();
1468     if (!selectionStartNode || !selectionStartNode->renderer())
1469         return;
1470
1471     FrameView* frameView = focusedFrame->view();
1472     if (!frameView)
1473         return;
1474
1475     IntPoint pos = frameView->windowToContents(point);
1476     if (selectionStartNode->rendererIsEditable() && !selectionStartNode->rendererIsRichlyEditable()) {
1477         const int boundariesWidth = 2;
1478
1479         IntRect rect = frameSelection->caretRenderer()->absoluteBoundingBoxRect(true);
1480         // here we cheat input field that we actually are just inside of if
1481         if (pos.y() < rect.y() + boundariesWidth)
1482             pos.setY(rect.y() + boundariesWidth);
1483         else if (pos.y() >= rect.maxY() - boundariesWidth)
1484             pos.setY(rect.maxY() - boundariesWidth - 1);
1485     }
1486
1487     OwnPtr<VisiblePosition> position = adoptPtr(new VisiblePosition(focusedFrame->visiblePositionForPoint(pos)));
1488     Position base = frameSelection->base();
1489     Position extent = frameSelection->extent();
1490
1491     Node* newSelectionEndNode = position->deepEquivalent().deprecatedNode();
1492
1493     // both start and end nodes should be in the same area type: both should be editable or both should be not editable
1494     // Check if the new position is after the base's position
1495     if (newSelectionEndNode
1496         && selectionStartNode->isContentEditable() == newSelectionEndNode->isContentEditable()) {
1497         // Change the 'base' and 'extent' positions to 'start' and 'end' positions.
1498         // We do it, because without this, the other modifications of the selection
1499         // would destroy the 'start' and/or 'end' positions and set them to
1500         // the 'base'/'extent' positions accordingly
1501
1502         VisibleSelection sel(frameSelection->start(), frameSelection->end());
1503         frameSelection->setSelection(sel);
1504
1505         bool oldProhibitsScrolling = focusedFrame->view()->prohibitsScrolling();
1506         focusedFrame->view()->setProhibitsScrolling(true);
1507
1508         if (direction == HandleMovingDirectionNormal) {
1509             if (comparePositions(position->deepEquivalent(), base) > 0) {
1510                 frameSelection->setExtent(*position);
1511                 result = HandleMovingDirectionNormal;
1512             } else if (comparePositions(position->deepEquivalent(), base) < 0) {
1513                 frameSelection->setBase(*position);
1514                 frameSelection->setExtent(base);
1515                 result = HandleMovingDirectionReverse;
1516             }
1517         } else if (direction == HandleMovingDirectionReverse) {
1518             if (comparePositions(position->deepEquivalent(), extent) < 0) {
1519                 frameSelection->setBase(*position);
1520                 result = HandleMovingDirectionReverse;
1521             } else if (comparePositions(position->deepEquivalent(), extent) > 0) {
1522                 frameSelection->setExtent(*position);
1523                 frameSelection->setBase(extent);
1524                 result = HandleMovingDirectionNormal;
1525             }
1526         }
1527
1528         focusedFrame->view()->setProhibitsScrolling(oldProhibitsScrolling);
1529     }
1530 }
1531
1532 bool WebPage::isSelectionOnlyImage() const
1533 {
1534     bool isImage = false;
1535     Frame* focusedFrame = m_page->focusController()->focusedOrMainFrame();
1536     if (!focusedFrame->selection()->isRange())
1537         return  isImage;
1538
1539     RefPtr<Range> selectedRange = focusedFrame->selection()->toNormalizedRange();
1540     Vector<IntRect> rects;
1541     selectedRange->boundingBoxEx(rects, true);
1542     unsigned size = rects.size();
1543     if(size == 1) {
1544         Node* startNode = selectedRange->startContainer();
1545         Node* endNode = selectedRange->endContainer();
1546         if(startNode == endNode) {
1547             if(endNode && endNode->isContainerNode() && !(endNode->hasTagName(HTMLNames::imgTag))) {
1548                 WebCore::Node *child = static_cast<const ContainerNode*>(endNode)->firstChild();
1549                 while(child) {
1550                     if(child->hasTagName(HTMLNames::imgTag)) {
1551                         isImage = true;
1552                         break;
1553                     }
1554                     child = child->traverseNextNode(endNode);
1555                 }
1556             }
1557             else {
1558                 if(endNode->hasTagName(HTMLNames::imgTag))
1559                     isImage = true;
1560             }
1561         }
1562     }
1563     return isImage;
1564 }
1565
1566 void WebPage::getSelectionHandlers(IntRect& leftRect, IntRect& rightRect, int& selectionDirection, WebCore::IntRect& updatedEditorRect)
1567 {
1568     Frame* focusedFrame = m_page->focusController()->focusedOrMainFrame();
1569     updatedEditorRect = m_editorState.editorRect;
1570     if (!focusedFrame->selection()->isRange())
1571         return;
1572
1573     // Is this check necessary? Leaving it for safety.
1574     RenderView* root = focusedFrame->contentRenderer();
1575     if (!root)
1576         return;
1577
1578     RefPtr<Range> selectedRange = focusedFrame->selection()->toNormalizedRange();
1579
1580     Vector<IntRect> rects;
1581     selectedRange->boundingBoxEx(rects, true);
1582
1583     unsigned size = rects.size();
1584     if (size > 0) {
1585         leftRect = rects[0];
1586         rightRect = rects[size-1];
1587
1588         // If selection rect size is greater than editor rect size because of round operation,
1589         // selection rect size should be changed to editor rect size.
1590         if (size == 1) {
1591             Element* rootEditableElement = focusedFrame->selection()->rootEditableElement();
1592             if (rootEditableElement) {
1593                 Vector<IntRect> rects;
1594                 calcFocusedRects(rootEditableElement, rects);
1595                 IntRect editorRect = unionRect(rects);
1596
1597                 if (m_editorState.editorRect != editorRect)
1598                     updatedEditorRect = editorRect;
1599                 if (leftRect.maxY() > editorRect.maxY()) {
1600                     leftRect.setY(editorRect.y());
1601                     leftRect.setHeight(editorRect.height());
1602                 }
1603
1604                 if (rightRect.maxY() > editorRect.maxY()) {
1605                     rightRect.setY(editorRect.y());
1606                     rightRect.setHeight(editorRect.height());
1607                 }
1608             }
1609         }
1610         // prevent from selecting zero-length selection
1611         if (leftRect.x() == rightRect.x() + rightRect.width()
1612             && leftRect.y() == rightRect.y())
1613             return;
1614
1615         FrameView* frameView = focusedFrame->view();
1616         if (!frameView)
1617             return;
1618
1619         leftRect = frameView->contentsToWindow(leftRect);
1620         rightRect = frameView->contentsToWindow(rightRect);
1621         selectionDirection = focusedFrame->selection()->getSelectionTextDirection();
1622      }
1623 }
1624
1625 void WebPage::getSelectionText(String& result)
1626 {
1627     Frame* focusedFrame = m_page->focusController()->focusedOrMainFrame();
1628     result = focusedFrame->editor()->selectedText();
1629 }
1630
1631 void WebPage::selectionRangeClear(bool& result)
1632 {
1633     result = false;
1634
1635     Frame* focusedFrame = m_page->focusController()->focusedOrMainFrame();
1636     FrameSelection* frameSelection = focusedFrame->selection();
1637     if (frameSelection && frameSelection->isRange() && frameSelection->isContentEditable()) {
1638         VisiblePosition visiblePos(frameSelection->extent());
1639         if (visiblePos.isNull())
1640             return;
1641
1642         focusedFrame->editor()->setIgnoreCompositionSelectionChange(true);
1643         frameSelection->setSelection(VisibleSelection(visiblePos), CharacterGranularity);
1644         focusedFrame->editor()->setIgnoreCompositionSelectionChange(false);
1645
1646         frameSelection->setCaretBlinkingSuspended(false);
1647     } else
1648         selectionClearAllSelection(m_page->mainFrame());
1649
1650     result = true;
1651 }
1652
1653 void WebPage::selectionClearAllSelection(Frame* frame)
1654 {
1655     if (!frame)
1656         return;
1657
1658     FrameSelection* frameSelection = frame->selection();
1659     if (frameSelection)
1660         frameSelection->clear();
1661
1662     if (!frame->tree())
1663         return;
1664
1665     if (frame->tree()->childCount() > 0) {
1666         if (frame->tree()->firstChild())
1667             selectionClearAllSelection(frame->tree()->firstChild());
1668     } else if (frame->tree()->nextSibling())
1669         selectionClearAllSelection(frame->tree()->nextSibling());
1670 }
1671
1672 void WebPage::scrollContentByCharacter(const IntPoint&, int direction, bool& result)
1673 {
1674     result = false;
1675
1676     Frame* focusedFrame = m_page->focusController()->focusedOrMainFrame();
1677     if (!focusedFrame)
1678         return;
1679
1680     FrameSelection* frameSelection = focusedFrame->selection();
1681     if (!frameSelection)
1682         return;
1683
1684     VisiblePosition currentPosition = frameSelection->selection().visibleStart();
1685     if (direction) {
1686         if (isStartOfLine(currentPosition))
1687             return;
1688
1689         focusedFrame->selection()->modify(FrameSelection::AlterationMove, DirectionBackward, CharacterGranularity, UserTriggered);
1690     } else {
1691         if (isEndOfLine(currentPosition))
1692             return;
1693
1694         focusedFrame->selection()->modify(FrameSelection::AlterationMove, DirectionForward, CharacterGranularity, UserTriggered);
1695     }
1696 }
1697
1698 void WebPage::scrollContentByLine(const IntPoint&, int direction, bool& result)
1699 {
1700     result = false;
1701
1702     Frame* focusedFrame = m_page->focusController()->focusedOrMainFrame();
1703     if (!focusedFrame)
1704         return;
1705
1706     FrameSelection* frameSelection = focusedFrame->selection();
1707     if (!frameSelection)
1708         return;
1709
1710     VisiblePosition currentPosition = frameSelection->selection().visibleStart();
1711     if (direction) {
1712         if (inSameLine(currentPosition, previousLinePosition(currentPosition, 0)))
1713             return;
1714
1715         focusedFrame->selection()->modify(FrameSelection::AlterationMove, DirectionBackward, LineGranularity, UserTriggered);
1716     } else {
1717         if (inSameLine(currentPosition, nextLinePosition(currentPosition, 0)))
1718             return;
1719
1720         focusedFrame->selection()->modify(FrameSelection::AlterationMove, DirectionForward, LineGranularity, UserTriggered);
1721     }
1722 }
1723
1724 void WebPage::getFocusedSubFrameRect(IntRect& focusedFrameRect, bool& isFocusedSubFrame)
1725 {
1726     isFocusedSubFrame = false;
1727
1728     Frame* focusedFrame = m_page->focusController()->focusedOrMainFrame();
1729     if (!focusedFrame)
1730         return;
1731
1732     if (focusedFrame != m_page->mainFrame()) {
1733         FrameView* frameView = focusedFrame->view();
1734         HTMLFrameOwnerElement* ownerElement = focusedFrame->ownerElement();
1735
1736         if (!frameView)
1737             return;
1738
1739         if (ownerElement && ownerElement->hasTagName(HTMLNames::iframeTag)){
1740             RenderIFrame* renderIframe = static_cast<RenderIFrame*>(ownerElement->renderer());
1741             if (renderIframe) {
1742                 focusedFrameRect = renderIframe->windowClipRect();
1743                 isFocusedSubFrame = true;
1744             }
1745         }
1746     }
1747 }
1748 #endif
1749
1750 #if ENABLE(TIZEN_LINK_MAGNIFIER)
1751 void WebPage::getLinkMagnifierRect(const IntPoint& position, const IntSize& size)
1752 {
1753     send(Messages::WebPageProxy::DidGetLinkMagnifierRect(position, LinkMagnifier::rect(this, position, size)));
1754 }
1755 #endif
1756
1757 #if ENABLE(TIZEN_SCREEN_READER)
1758 void WebPage::moveScreenReaderFocus(bool forward, bool& result)
1759 {
1760     if (!m_screenReader)
1761         m_screenReader = ScreenReader::create(this);
1762
1763     result = m_screenReader->moveFocus(forward);
1764 }
1765
1766 void WebPage::moveScreenReaderFocusByPoint(const IntPoint& point)
1767 {
1768     if (!m_screenReader)
1769         m_screenReader = ScreenReader::create(this);
1770
1771     if (!m_screenReader->moveFocus(point))
1772         return;
1773 }
1774
1775 void WebPage::clearScreenReaderFocus()
1776 {
1777     if (!m_screenReader)
1778         return;
1779
1780     m_screenReader->clearFocus();
1781 }
1782
1783 void WebPage::raiseTapEvent(const IntPoint& position, const IntPoint& globalPosition, bool& result)
1784 {
1785     result = false;
1786
1787 #if ENABLE(GESTURE_EVENTS)
1788     Frame* frame = m_page->mainFrame();
1789     if (!frame->view())
1790         return;
1791
1792     Vector<WebPlatformTouchPoint> touchPoints;
1793     touchPoints.append(WebPlatformTouchPoint(0, WebPlatformTouchPoint::TouchPressed, globalPosition, position));
1794
1795     WebTouchEvent touchStartEvent(WebEvent::TouchStart, touchPoints, WebEvent::Modifiers(0), ecore_time_get());
1796     bool handled = frame->eventHandler()->handleTouchEvent(platform(touchStartEvent));
1797
1798     touchPoints.at(0).setState(WebPlatformTouchPoint::TouchReleased);
1799
1800     WebTouchEvent touchEndEvent(WebEvent::TouchEnd, touchPoints, WebEvent::Modifiers(0), ecore_time_get());
1801     handled |= frame->eventHandler()->handleTouchEvent(platform(touchEndEvent));
1802
1803     if (!handled) {
1804         WebGestureEvent gestureEvent(WebEvent::GestureSingleTap, position, globalPosition, WebEvent::Modifiers(0), ecore_time_get());
1805         frame->eventHandler()->handleGestureEvent(platform(gestureEvent));
1806         result = true;
1807     }
1808 #endif
1809 }
1810
1811 void WebPage::adjustScreenReaderFocusedObjectValue(bool up)
1812 {
1813     if (!m_screenReader || !m_focusedNode || !m_focusedNode->toInputElement())
1814         return;
1815
1816     ExceptionCode ec;
1817     if (up)
1818         m_focusedNode->toInputElement()->stepUp(ec);
1819     else
1820         m_focusedNode->toInputElement()->stepDown(ec);
1821 }
1822
1823 void WebPage::updateScreenReaderFocus(RenderObject* object)
1824 {
1825     if (!m_screenReader)
1826         return;
1827
1828     if (!object)
1829         m_screenReader->clearFocus();
1830     else if (!m_screenReader->rendererWillBeDestroyed(object))
1831         return;
1832 }
1833
1834 void WebPage::clearScreenReader()
1835 {
1836     m_screenReader.clear();
1837 }
1838 #endif
1839
1840 #if ENABLE(TIZEN_WEBKIT2_FOCUS_RING) || ENABLE(TIZEN_WEBKIT2_TEXT_SELECTION)
1841 static LayoutRect rectToAbsoluteCoordinates(Frame* initialFrame, const LayoutRect& initialRect)
1842 {
1843     LayoutRect rect = initialRect;
1844     for (Frame* frame = initialFrame; frame; frame = frame->tree()->parent()) {
1845         RenderBoxModelObject* renderer;
1846         if (frame->ownerElement() && (renderer = frame->ownerElement()->renderBoxModelObject())) {
1847             do {
1848                 rect.move(renderer->offsetLeft(), renderer->offsetTop());
1849             } while ((renderer = renderer->offsetParent()));
1850             rect.move(-frame->view()->scrollOffset());
1851         }
1852     }
1853     return rect;
1854 }
1855
1856 void WebPage::calcFocusedRects(Node* node, Vector<IntRect>& rects) const
1857 {
1858     if (!node || !node->renderer())
1859         return;
1860
1861     RenderObject* renderer = node->renderer();
1862     FrameView* view = node->document()->frame()->view();
1863     LayoutRect rect;
1864
1865     if (node->hasTagName(HTMLNames::areaTag)) {
1866         HTMLAreaElement* area = static_cast<HTMLAreaElement*>(node);
1867         HTMLImageElement* image = area->imageElement();
1868         if (image && image->renderer())
1869             rect = rectToAbsoluteCoordinates(area->document()->frame(), area->computeRect(area->imageElement()->renderer()));
1870     } else if (node->renderer()) {
1871         if (node->isDocumentNode())
1872             rect = rectToAbsoluteCoordinates(static_cast<Document*>(node)->frame(), static_cast<Document*>(node)->frame()->view()->visibleContentRect());
1873         else
1874             rect = rectToAbsoluteCoordinates(node->document()->frame(), node->renderer()->absoluteClippedOverflowRect());
1875     }
1876
1877     if (rect.pixelSnappedX() < 0)
1878         rect.shiftXEdgeTo(0);
1879     if (rect.pixelSnappedY() < 0)
1880         rect.shiftYEdgeTo(0);
1881
1882     if (rect.isEmpty())
1883         return;
1884
1885     IntRect focusedNodeRect(pixelSnappedIntRect(rect));
1886     IntPoint absolutePoint;
1887     absolutePoint = view->convertToContainingWindow(view->convertFromRenderer(renderer, absolutePoint));
1888     Vector<IntRect> candidateRects;
1889     renderer->addFocusRingRects(candidateRects, absolutePoint);
1890
1891     for (size_t i = 0; i < candidateRects.size(); ++i) {
1892         IntRect candidate(candidateRects[i]);
1893         candidate.intersect(focusedNodeRect);
1894         if (!candidate.isEmpty())
1895             rects.append(candidate);
1896     }
1897
1898     if (rects.isEmpty())
1899         rects.append(focusedNodeRect);
1900 }
1901 #endif
1902
1903 #if ENABLE(TIZEN_WEBKIT2_FOCUS_RING)
1904 void WebPage::setFocusedNode(Node* node)
1905 {
1906     m_focusedNode = node;
1907     didChangeFocusedRects();
1908 }
1909
1910 void WebPage::didChangeFocusedRects()
1911 {
1912     Vector<IntRect> rects;
1913     calcFocusedRects(m_focusedNode.get(), rects);
1914     m_focusedRects = rects;
1915     send(Messages::WebPageProxy::DidChangeFocusedRects(m_focusedRects));
1916 }
1917
1918 void WebPage::recalcFocusedRects()
1919 {
1920     if (!m_focusedNode)
1921         return;
1922
1923     didChangeFocusedRects();
1924 }
1925 #endif
1926
1927 #if ENABLE(TIZEN_WEBKIT2_POPUP_INTERNAL)
1928 // FIXME: Currently with cached pages, hiding Popup list menu is not working correctly.
1929 // This patch is a fix allowing any popup list menu to get close for any page navigation.
1930 void WebPage::notifyTransitionToCommitted(bool forNewPage)
1931 {
1932     if (m_activePopupMenu) {
1933         TIZEN_LOGI("");
1934         m_activePopupMenu->hide();
1935         m_activePopupMenu = 0;
1936     }
1937 }
1938 #endif
1939
1940 #if ENABLE(TIZEN_CSP)
1941 void WebPage::setContentSecurityPolicy(const String& policy, uint32_t headerType)
1942 {
1943     Frame* frame = m_page->focusController()->focusedOrMainFrame();
1944     if (!frame)
1945         return;
1946
1947     Document* document = frame->document();
1948     if (!document)
1949         return;
1950
1951     document->contentSecurityPolicy()->didReceiveHeader(policy, static_cast<WebCore::ContentSecurityPolicy::HeaderType>(headerType));
1952 }
1953 #endif
1954
1955 #if ENABLE(TIZEN_INDEXED_DATABASE)
1956 void WebPage::setIndexedDatabaseDirectory(const String& path)
1957 {
1958     m_page->group().groupSettings()->setIndexedDBDatabasePath(path);
1959 }
1960 #endif
1961
1962 #if ENABLE(TIZEN_WEB_STORAGE)
1963 void WebPage::setLocalStorageDirectory(const String& path)
1964 {
1965     m_page->settings()->setLocalStorageDatabasePath(path);
1966 }
1967 #endif
1968
1969 #if ENABLE(TIZEN_USE_SETTINGS_FONT)
1970 void WebPage::useSettingsFont()
1971 {
1972     if (!WebCore::fontCache()->isFontFamliyTizen())
1973         return;
1974
1975     FcInitReinitialize();
1976     WebCore::fontCache()->invalidate();
1977
1978     int pageCapacity = WebCore::pageCache()->capacity();
1979     // Setting size to 0, makes all pages be released.
1980     WebCore::pageCache()->setCapacity(0);
1981     WebCore::pageCache()->releaseAutoreleasedPagesNow();
1982     WebCore::pageCache()->setCapacity(pageCapacity);
1983
1984     Frame* frame = m_mainFrame->coreFrame();
1985     if (!frame)
1986         return;
1987
1988     if (frame->document())
1989         frame->document()->dispatchWindowEvent(Event::create(eventNames().resizeEvent, false, false));
1990
1991     FrameView* frameView = frame->view();
1992     if (!frameView)
1993         return;
1994
1995     frameView->forceLayout();
1996 }
1997 #endif
1998
1999 void WebPage::didChangeContents()
2000 {
2001     if (!m_page)
2002         return;
2003
2004     Frame* frame = m_page->focusController()->focusedOrMainFrame();
2005     if (!frame || !frame->view() || frame->view()->needsLayout())
2006         return;
2007
2008 #if ENABLE(TIZEN_ISF_PORT) || ENABLE(TIZEN_WEBKIT2_TEXT_SELECTION)
2009     if (m_editorState.isContentEditable && frame->selection()->rootEditableElement() && updateEditorStateRect(frame, m_editorState)) {
2010         m_editorState.updateEditorRectOnly = true;
2011         send(Messages::WebPageProxy::EditorStateChanged(m_editorState));
2012     }
2013 #endif
2014
2015 #if ENABLE(TIZEN_WEBKIT2_FOCUS_RING)
2016     didChangeFocusedRects();
2017 #endif
2018 }
2019
2020 #if ENABLE(TIZEN_FOCUS_UI)
2021 void WebPage::setFocusUIEnabled(bool enabled)
2022 {
2023     m_page->settings()->setSpatialNavigationEnabled(enabled);
2024
2025     if (m_focusedNode && m_focusedNode->renderer())
2026         m_focusedNode->renderer()->repaint();
2027
2028     if (enabled) {
2029         Frame* frame = m_page->focusController()->focusedOrMainFrame();
2030         if (frame) {
2031             PlatformMouseEvent fakeMouseMove(IntPoint(-1, -1), IntPoint(-1, -1), NoButton, PlatformEvent::MouseMoved, 0, false, false, false, false, currentTime());
2032             frame->eventHandler()->mouseMoved(fakeMouseMove);
2033         }
2034         setFocusedNode(frame && frame->document() ? frame->document()->focusedNode() : 0);
2035     } else
2036         setFocusedNode(0);
2037 }
2038 #endif
2039 #endif // #if OS(TIZEN)
2040
2041 } // namespace WebKit