Source/WebKit2/WebProcess/WebPage/WebPage.cpp

   1 /*
   2  * Copyright (C) 2010, 2011 Apple Inc. All rights reserved.
   3  * Copyright (C) 2012 Intel Corporation. All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
  15  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
  16  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  17  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
  18  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  19  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  20  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  21  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  22  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  23  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
  24  * THE POSSIBILITY OF SUCH DAMAGE.
  25  */
  26
  27 #include "config.h"
  28 #include "WebPage.h"
  29
  30 #include "Arguments.h"
  31 #include "DataReference.h"
  32 #include "DecoderAdapter.h"
  33 #include "DrawingArea.h"
  34 #include "InjectedBundle.h"
  35 #include "InjectedBundleBackForwardList.h"
  36 #include "LayerTreeHost.h"
  37 #include "MessageID.h"
  38 #include "NetscapePlugin.h"
  39 #include "NotificationPermissionRequestManager.h"
  40 #include "PageOverlay.h"
  41 #include "PluginProxy.h"
  42 #include "PluginView.h"
  43 #include "PrintInfo.h"
  44 #include "SessionState.h"
  45 #include "ShareableBitmap.h"
  46 #include "WebAlternativeTextClient.h"
  47 #include "WebBackForwardList.h"
  48 #include "WebBackForwardListItem.h"
  49 #include "WebBackForwardListProxy.h"
  50 #include "WebChromeClient.h"
  51 #include "WebColorChooser.h"
  52 #include "WebContextMenu.h"
  53 #include "WebContextMenuClient.h"
  54 #include "WebContextMessages.h"
  55 #include "WebCoreArgumentCoders.h"
  56 #include "WebDragClient.h"
  57 #include "WebEditorClient.h"
  58 #include "WebEvent.h"
  59 #include "WebEventConversion.h"
  60 #include "WebFrame.h"
  61 #include "WebFullScreenManager.h"
  62 #include "WebGeolocationClient.h"
  63 #include "WebGeometry.h"
  64 #include "WebImage.h"
  65 #include "WebInspector.h"
  66 #include "WebInspectorClient.h"
  67 #include "WebNotificationClient.h"
  68 #include "WebOpenPanelResultListener.h"
  69 #include "WebPageCreationParameters.h"
  70 #include "WebPageGroupProxy.h"
  71 #include "WebPageProxyMessages.h"
  72 #include "WebPopupMenu.h"
  73 #include "WebPreferencesStore.h"
  74 #include "WebProcess.h"
  75 #include "WebProcessProxyMessages.h"
  76 #include <JavaScriptCore/APICast.h>
  77 #include <WebCore/AbstractDatabase.h>
  78 #include <WebCore/ArchiveResource.h>
  79 #include <WebCore/Chrome.h>
  80 #include <WebCore/ContextMenuController.h>
  81 #include <WebCore/DocumentFragment.h>
  82 #include <WebCore/DocumentLoader.h>
  83 #include <WebCore/DocumentMarkerController.h>
  84 #include <WebCore/DragController.h>
  85 #include <WebCore/DragData.h>
  86 #include <WebCore/DragSession.h>
  87 #include <WebCore/EventHandler.h>
  88 #include <WebCore/FocusController.h>
  89 #include <WebCore/FormState.h>
  90 #include <WebCore/Frame.h>
  91 #include <WebCore/FrameLoadRequest.h>
  92 #include <WebCore/FrameLoaderTypes.h>
  93 #include <WebCore/FrameView.h>
  94 #include <WebCore/HTMLFormElement.h>
  95 #include <WebCore/HTMLInputElement.h>
  96 #include <WebCore/HTMLPlugInElement.h>
  97 #include <WebCore/HistoryItem.h>
  98 #include <WebCore/KeyboardEvent.h>
  99 #include <WebCore/MouseEvent.h>
 100 #include <WebCore/Page.h>
 101 #include <WebCore/PlatformKeyboardEvent.h>
 102 #include <WebCore/PluginDocument.h>
 103 #include <WebCore/PrintContext.h>
 104 #include <WebCore/RenderLayer.h>
 105 #include <WebCore/RenderTreeAsText.h>
 106 #include <WebCore/RenderView.h>
 107 #include <WebCore/ResourceRequest.h>
 108 #include <WebCore/RunLoop.h>
 109 #include <WebCore/SchemeRegistry.h>
 110 #include <WebCore/ScriptValue.h>
 111 #include <WebCore/SerializedScriptValue.h>
 112 #include <WebCore/Settings.h>
 113 #include <WebCore/SharedBuffer.h>
 114 #include <WebCore/SubstituteData.h>
 115 #include <WebCore/TextIterator.h>
 116 #include <WebCore/markup.h>
 117 #include <runtime/JSLock.h>
 118 #include <runtime/JSValue.h>
 119
 120 #include <WebCore/Range.h>
 121 #include <WebCore/VisiblePosition.h>
 122
 123 #if ENABLE(MHTML)
 124 #include <WebCore/MHTMLArchive.h>
 125 #endif
 126
 127 #if ENABLE(PLUGIN_PROCESS)
 128 #if PLATFORM(MAC)
 129 #include "MachPort.h"
 130 #endif
 131 #endif
 132
 133 #if ENABLE(BATTERY_STATUS)
 134 #include "WebBatteryClient.h"
 135 #endif
 136
 137 #if ENABLE(NETWORK_INFO)
 138 #include "WebNetworkInfoClient.h"
 139 #endif
 140
 141 #if ENABLE(WEB_INTENTS)
 142 #include "IntentData.h"
 143 #endif
 144
 145 #if ENABLE(VIBRATION)
 146 #include "WebVibrationClient.h"
 147 #endif
 148
 149 #if ENABLE(TIZEN_REGISTER_PROTOCOL_HANDLER) || ENABLE(TIZEN_CUSTOM_SCHEME_HANDLER)
 150 #include "WebRegisterProtocolHandlerClient.h"
 151 #endif
 152
 153 #if ENABLE(TIZEN_REGISTER_CONTENT_HANDLER)
 154 #include "WebRegisterContentHandlerClient.h"
 155 #endif
 156
 157 #if PLATFORM(MAC)
 158 #include "BuiltInPDFView.h"
 159 #endif
 160
 161 #if PLATFORM(QT)
 162 #if ENABLE(DEVICE_ORIENTATION)
 163 #include "DeviceMotionClientQt.h"
 164 #include "DeviceOrientationClientQt.h"
 165 #endif
 166 #include "HitTestResult.h"
 167 #include <QMimeData>
 168 #endif
 169
 170 #if PLATFORM(GTK)
 171 #include <gtk/gtk.h>
 172 #include "DataObjectGtk.h"
 173 #include "WebPrintOperationGtk.h"
 174 #endif
 175
 176 #if ENABLE(TIZEN_MEDIA_STREAM)
 177 #include "WebUserMediaClient.h"
 178 #include "UserMediaPermissionRequestManager.h"
 179 #endif
 180
 181 #if ENABLE(TIZEN_SUPPORT_WEBAPP_META_TAG)
 182 #include <WebCore/NodeList.h>
 183 #include "HTMLLinkElement.h"
 184 #include "HTMLMetaElement.h"
 185 #endif
 186
 187 #if ENABLE(TIZEN_GEOLOCATION)
 188 #include <WebCore/GeolocationClientMock.h>
 189 #include <WebCore/GeolocationController.h>
 190 #endif
 191
 192 #ifndef NDEBUG
 193 #include <wtf/RefCountedLeakCounter.h>
 194 #endif
 195
 196 #if ENABLE(TIZEN_INDEXED_DATABASE)
 197 #include <WebCore/PageGroup.h>
 198 #include <WebCore/GroupSettings.h>
 199 #endif
 200
 201 #if ENABLE(TIZEN_ISF_PORT)
 202 #include "NativeWebKeyboardEvent.h"
 203 #endif
 204
 205 #if ENABLE(TIZEN_NATIVE_MEMORY_SNAPSHOT)
 206 #include "AboutDataTizen.h"
 207 #endif
 208
 209 #if ENABLE(TIZEN_DRAG_SUPPORT)
 210 #include "DataObjectTizen.h"
 211 #endif
 212
 213 #if ENABLE(TIZEN_WEBKIT2_CONTEXT_MENU_TEXT_SELECTION_MODE)
 214 #include "HTMLImageElement.h"
 215 #endif
 216
 217 using namespace JSC;
 218 using namespace WebCore;
 219 using namespace std;
 220
 221 namespace WebKit {
 222
 223 class SendStopResponsivenessTimer {
 224 public:
 225     SendStopResponsivenessTimer(WebPage* page)
 226         : m_page(page)
 227     {
 228     }
 229
 230     ~SendStopResponsivenessTimer()
 231     {
 232         m_page->send(Messages::WebPageProxy::StopResponsivenessTimer());
 233     }
 234
 235 private:
 236     WebPage* m_page;
 237 };
 238
 239 DEFINE_DEBUG_ONLY_GLOBAL(WTF::RefCountedLeakCounter, webPageCounter, ("WebPage"));
 240
 241 PassRefPtr<WebPage> WebPage::create(uint64_t pageID, const WebPageCreationParameters& parameters)
 242 {
 243     RefPtr<WebPage> page = adoptRef(new WebPage(pageID, parameters));
 244
 245     if (page->pageGroup()->isVisibleToInjectedBundle() && WebProcess::shared().injectedBundle())
 246         WebProcess::shared().injectedBundle()->didCreatePage(page.get());
 247
 248     return page.release();
 249 }
 250
 251 WebPage::WebPage(uint64_t pageID, const WebPageCreationParameters& parameters)
 252     : m_viewSize(parameters.viewSize)
 253     , m_useFixedLayout(false)
 254     , m_drawsBackground(true)
 255     , m_drawsTransparentBackground(false)
 256     , m_isInRedo(false)
 257     , m_isClosed(false)
 258     , m_tabToLinks(false)
 259 #if PLATFORM(MAC)
 260     , m_windowIsVisible(false)
 261     , m_isSmartInsertDeleteEnabled(parameters.isSmartInsertDeleteEnabled)
 262     , m_layerHostingMode(parameters.layerHostingMode)
 263     , m_keyboardEventBeingInterpreted(0)
 264 #elif PLATFORM(WIN)
 265     , m_nativeWindow(parameters.nativeWindow)
 266 #elif PLATFORM(GTK)
 267     , m_accessibilityObject(0)
 268 #endif
 269     , m_setCanStartMediaTimer(WebProcess::shared().runLoop(), this, &WebPage::setCanStartMediaTimerFired)
 270     , m_findController(this)
 271 #if ENABLE(TOUCH_EVENTS)
 272 #if PLATFORM(QT)
 273     , m_tapHighlightController(this)
 274 #endif
 275 #endif
 276 #if ENABLE(INPUT_TYPE_COLOR)
 277     , m_activeColorChooser(0)
 278 #endif
 279 #if ENABLE(GEOLOCATION)
 280     , m_geolocationPermissionRequestManager(this)
 281 #endif
 282     , m_pageID(pageID)
 283     , m_canRunBeforeUnloadConfirmPanel(parameters.canRunBeforeUnloadConfirmPanel)
 284     , m_canRunModal(parameters.canRunModal)
 285     , m_isRunningModal(false)
 286     , m_cachedMainFrameIsPinnedToLeftSide(false)
 287     , m_cachedMainFrameIsPinnedToRightSide(false)
 288     , m_canShortCircuitHorizontalWheelEvents(false)
 289     , m_numWheelEventHandlers(0)
 290     , m_cachedPageCount(0)
 291 #if ENABLE(CONTEXT_MENUS)
 292     , m_isShowingContextMenu(false)
 293 #endif
 294     , m_willGoToBackForwardItemCallbackEnabled(true)
 295 #if PLATFORM(WIN)
 296     , m_gestureReachedScrollingLimit(false)
 297 #endif
 298 #if ENABLE(PAGE_VISIBILITY_API)
 299     , m_visibilityState(WebCore::PageVisibilityStateVisible)
 300 #endif
 301 #if ENABLE(TIZEN_SYNC_REQUEST_ANIMATION_FRAME)
 302     , m_suspendedAnimationController(false)
 303 #endif
 304     , m_inspectorClient(0)
 305 {
 306     ASSERT(m_pageID);
 307     // FIXME: This is a non-ideal location for this Setting and
 308     // 4ms should be adopted project-wide now, https://bugs.webkit.org/show_bug.cgi?id=61214
 309 #if ENABLE(TIZEN_DOM_TIMER_MIN_INTERVAL_SET)
 310     Settings::setDefaultMinDOMTimerInterval(0.001);
 311 #else
 312     Settings::setDefaultMinDOMTimerInterval(0.004);
 313 #endif
 314
 315     Page::PageClients pageClients;
 316     pageClients.chromeClient = new WebChromeClient(this);
 317 #if ENABLE(CONTEXT_MENUS)
 318     pageClients.contextMenuClient = new WebContextMenuClient(this);
 319 #endif
 320     pageClients.editorClient = new WebEditorClient(this);
 321 #if ENABLE(DRAG_SUPPORT)
 322     pageClients.dragClient = new WebDragClient(this);
 323 #endif
 324     pageClients.backForwardClient = WebBackForwardListProxy::create(this);
 325 #if ENABLE(INSPECTOR)
 326     m_inspectorClient = new WebInspectorClient(this);
 327     pageClients.inspectorClient = m_inspectorClient;
 328 #endif
 329 #if USE(AUTOCORRECTION_PANEL)
 330     pageClients.alternativeTextClient = new WebAlternativeTextClient(this);
 331 #endif
 332
 333     m_page = adoptPtr(new Page(pageClients));
 334
 335 #if ENABLE(BATTERY_STATUS)
 336     WebCore::provideBatteryTo(m_page.get(), new WebBatteryClient(this));
 337 #endif
 338 #if ENABLE(GEOLOCATION)
 339 #if ENABLE(TIZEN_GEOLOCATION) && ENABLE(TIZEN_WEBKIT2_EFL_WTR)
 340     if (WebProcess::shared().injectedBundle() && WebProcess::shared().injectedBundle()->testRunnerModeEnabled()) {
 341         GeolocationClientMock* mock = new GeolocationClientMock();
 342         WebCore::provideGeolocationTo(m_page.get(), mock);
 343         mock->setController(WebCore::GeolocationController::from(m_page.get()));
 344     } else
 345 #endif // ENABLE(TIZEN_GEOLOCATION) && ENABLE(TIZEN_WEBKIT2_EFL_WTR)
 346     WebCore::provideGeolocationTo(m_page.get(), new WebGeolocationClient(this));
 347 #endif
 348 #if ENABLE(DEVICE_ORIENTATION) && PLATFORM(QT)
 349     WebCore::provideDeviceMotionTo(m_page.get(), new DeviceMotionClientQt);
 350     WebCore::provideDeviceOrientationTo(m_page.get(), new DeviceOrientationClientQt);
 351 #endif
 352 #if ENABLE(NETWORK_INFO)
 353     WebCore::provideNetworkInfoTo(m_page.get(), new WebNetworkInfoClient(this));
 354 #endif
 355 #if ENABLE(NOTIFICATIONS) || ENABLE(LEGACY_NOTIFICATIONS)
 356     WebCore::provideNotification(m_page.get(), new WebNotificationClient(this));
 357 #endif
 358 #if ENABLE(VIBRATION)
 359     WebCore::provideVibrationTo(m_page.get(), new WebVibrationClient(this));
 360 #endif
 361
 362 #if ENABLE(VIBRATION)
 363     WebCore::provideVibrationTo(m_page.get(), new WebVibrationClient(this));
 364 #endif
 365
 366 #if ENABLE(TIZEN_MEDIA_STREAM)
 367     WebCore::provideUserMediaTo(m_page.get(), new WebUserMediaClient(this));
 368 #endif
 369
 370 #if ENABLE(TIZEN_REGISTER_PROTOCOL_HANDLER) || ENABLE(TIZEN_CUSTOM_SCHEME_HANDLER)
 371     WebCore::provideRegisterProtocolHandlerTo(m_page.get(), new WebRegisterProtocolHandlerClient(this));
 372 #endif
 373
 374 #if ENABLE(TIZEN_REGISTER_CONTENT_HANDLER)
 375     WebCore::provideRegisterContentHandlerTo(m_page.get(), new WebRegisterContentHandlerClient(this));
 376 #endif
 377
 378     // Qt does not yet call setIsInWindow. Until it does, just leave
 379     // this line out so plug-ins and video will work. Eventually all platforms
 380     // should call setIsInWindow and this comment and #if should be removed,
 381     // leaving behind the setCanStartMedia call.
 382 #if !PLATFORM(QT)
 383     m_page->setCanStartMedia(false);
 384 #endif
 385
 386     updatePreferences(parameters.store);
 387
 388     m_pageGroup = WebProcess::shared().webPageGroup(parameters.pageGroupData);
 389     m_page->setGroupName(m_pageGroup->identifier());
 390     m_page->setDeviceScaleFactor(parameters.deviceScaleFactor);
 391
 392     platformInitialize();
 393
 394     m_drawingArea = DrawingArea::create(this, parameters);
 395     m_drawingArea->setPaintingEnabled(false);
 396
 397     m_mainFrame = WebFrame::createMainFrame(this);
 398
 399     setUseFixedLayout(parameters.useFixedLayout);
 400
 401     setDrawsBackground(parameters.drawsBackground);
 402     setDrawsTransparentBackground(parameters.drawsTransparentBackground);
 403
 404     setPaginationMode(parameters.paginationMode);
 405     setPaginationBehavesLikeColumns(parameters.paginationBehavesLikeColumns);
 406     setPageLength(parameters.pageLength);
 407     setGapBetweenPages(parameters.gapBetweenPages);
 408
 409     setMemoryCacheMessagesEnabled(parameters.areMemoryCacheClientCallsEnabled);
 410
 411     setActive(parameters.isActive);
 412     setFocused(parameters.isFocused);
 413     setIsInWindow(parameters.isInWindow);
 414
 415     m_userAgent = parameters.userAgent;
 416
 417     WebBackForwardListProxy::setHighestItemIDFromUIProcess(parameters.highestUsedBackForwardItemID);
 418
 419     if (!parameters.sessionState.isEmpty())
 420         restoreSession(parameters.sessionState);
 421
 422     m_drawingArea->setPaintingEnabled(true);
 423
 424     setMediaVolume(parameters.mediaVolume);
 425
 426 #ifndef NDEBUG
 427     webPageCounter.increment();
 428 #endif
 429 }
 430
 431 WebPage::~WebPage()
 432 {
 433     if (m_backForwardList)
 434         m_backForwardList->detach();
 435
 436     ASSERT(!m_page);
 437
 438     m_sandboxExtensionTracker.invalidate();
 439
 440     for (HashSet<PluginView*>::const_iterator it = m_pluginViews.begin(), end = m_pluginViews.end(); it != end; ++it)
 441         (*it)->webPageDestroyed();
 442
 443 #ifndef NDEBUG
 444     webPageCounter.decrement();
 445 #endif
 446 }
 447
 448 void WebPage::dummy(bool&)
 449 {
 450 }
 451
 452 CoreIPC::Connection* WebPage::connection() const
 453 {
 454     return WebProcess::shared().connection();
 455 }
 456
 457 #if ENABLE(CONTEXT_MENUS)
 458 void WebPage::initializeInjectedBundleContextMenuClient(WKBundlePageContextMenuClient* client)
 459 {
 460     m_contextMenuClient.initialize(client);
 461 }
 462 #endif
 463
 464 void WebPage::initializeInjectedBundleEditorClient(WKBundlePageEditorClient* client)
 465 {
 466     m_editorClient.initialize(client);
 467 }
 468
 469 void WebPage::initializeInjectedBundleFormClient(WKBundlePageFormClient* client)
 470 {
 471     m_formClient.initialize(client);
 472 }
 473
 474 void WebPage::initializeInjectedBundleLoaderClient(WKBundlePageLoaderClient* client)
 475 {
 476     m_loaderClient.initialize(client);
 477 }
 478
 479 void WebPage::initializeInjectedBundlePolicyClient(WKBundlePagePolicyClient* client)
 480 {
 481     m_policyClient.initialize(client);
 482 }
 483
 484 void WebPage::initializeInjectedBundleResourceLoadClient(WKBundlePageResourceLoadClient* client)
 485 {
 486     m_resourceLoadClient.initialize(client);
 487 }
 488
 489 void WebPage::initializeInjectedBundleUIClient(WKBundlePageUIClient* client)
 490 {
 491     m_uiClient.initialize(client);
 492 }
 493
 494 #if ENABLE(FULLSCREEN_API)
 495 void WebPage::initializeInjectedBundleFullScreenClient(WKBundlePageFullScreenClient* client)
 496 {
 497     m_fullScreenClient.initialize(client);
 498 }
 499 #endif
 500
 501 void WebPage::initializeInjectedBundleDiagnosticLoggingClient(WKBundlePageDiagnosticLoggingClient* client)
 502 {
 503     m_logDiagnosticMessageClient.initialize(client);
 504 }
 505
 506 PassRefPtr<Plugin> WebPage::createPlugin(WebFrame* frame, HTMLPlugInElement* pluginElement, const Plugin::Parameters& parameters)
 507 {
 508     String pluginPath;
 509     bool blocked = false;
 510
 511     if (!WebProcess::shared().connection()->sendSync(
 512             Messages::WebContext::GetPluginPath(parameters.mimeType, parameters.url.string()),
 513             Messages::WebContext::GetPluginPath::Reply(pluginPath, blocked), 0)) {
 514         return 0;
 515     }
 516
 517     if (blocked) {
 518         if (pluginElement->renderer()->isEmbeddedObject())
 519             toRenderEmbeddedObject(pluginElement->renderer())->setPluginUnavailabilityReason(RenderEmbeddedObject::InsecurePluginVersion);
 520
 521         send(Messages::WebPageProxy::DidBlockInsecurePluginVersion(parameters.mimeType, parameters.url.string()));
 522         return 0;
 523     }
 524
 525     if (pluginPath.isNull()) {
 526 #if PLATFORM(MAC)
 527         if (parameters.mimeType == "application/pdf"
 528             || (parameters.mimeType.isEmpty() && parameters.url.path().lower().endsWith(".pdf")))
 529             return BuiltInPDFView::create(frame);
 530 #else
 531         UNUSED_PARAM(frame);
 532 #endif
 533         return 0;
 534     }
 535
 536 #if ENABLE(PLUGIN_PROCESS)
 537     return PluginProxy::create(pluginPath);
 538 #elif ENABLE(NETSCAPE_PLUGIN_API)
 539     NetscapePlugin::setSetExceptionFunction(NPRuntimeObjectMap::setGlobalException);
 540     return NetscapePlugin::create(NetscapePluginModule::getOrCreate(pluginPath));
 541 #else
 542     return 0;
 543 #endif
 544 }
 545
 546 EditorState WebPage::editorState() const
 547 {
 548     Frame* frame = m_page->focusController()->focusedOrMainFrame();
 549     ASSERT(frame);
 550
 551     EditorState result;
 552     result.selectionIsNone = frame->selection()->isNone();
 553     result.selectionIsRange = frame->selection()->isRange();
 554     result.isContentEditable = frame->selection()->isContentEditable();
 555     result.isContentRichlyEditable = frame->selection()->isContentRichlyEditable();
 556     result.isInPasswordField = frame->selection()->isInPasswordField();
 557     result.hasComposition = frame->editor()->hasComposition();
 558     result.shouldIgnoreCompositionSelectionChange = frame->editor()->ignoreCompositionSelectionChange();
 559
 560 #if ENABLE(TIZEN_WEBKIT2_TEXT_SELECTION) || ENABLE(TIZEN_ISF_PORT)
 561     Element* selectionRoot = frame->selection()->rootEditableElementOrDocumentElement();
 562     if (!selectionRoot)
 563         return result;
 564
 565     result.editorRect = frame->view()->contentsToWindow(selectionRoot->getPixelSnappedRect());
 566     if (result.editorRect.maxX() <= 0 || result.editorRect.maxY() <= 0)
 567         result.isContentEditable = false;
 568
 569 #if ENABLE(TIZEN_WEBKIT2_GET_TEXT_STYLE_FOR_SELECTION)
 570     result.bgColor = frame->editor()->selectionStartCSSPropertyValue(CSSPropertyBackgroundColor);
 571     result.color = frame->editor()->selectionStartCSSPropertyValue(CSSPropertyColor);
 572 #endif
 573 #endif
 574
 575 #if ENABLE(TIZEN_ISF_PORT)
 576     Node* hostNode = selectionRoot->shadowAncestorNode();
 577     if (result.isContentEditable) {
 578         HTMLTextFormControlElement* formControl = toTextFormControl(hostNode);
 579         if (formControl) {
 580             result.inputMethodHints = formControl->type();
 581             result.surroundingText = formControl->value();
 582         }
 583
 584         Position base = frame->selection()->base();
 585         Node* baseNode = base.containerNode();
 586         if (baseNode)
 587             result.cursorPosition = baseNode->isTextNode() ? base.offsetInContainerNode() : 0;
 588     }
 589 #endif
 590
 591 #if PLATFORM(QT)
 592     size_t location = 0;
 593     size_t length = 0;
 594
 595     Element* selectionRoot = frame->selection()->rootEditableElement();
 596     Element* scope = selectionRoot ? selectionRoot : frame->document()->documentElement();
 597
 598     if (!scope)
 599         return result;
 600
 601     if (scope->hasTagName(HTMLNames::inputTag)) {
 602         HTMLInputElement* input = static_cast<HTMLInputElement*>(scope);
 603         if (input->isTelephoneField())
 604             result.inputMethodHints |= Qt::ImhDialableCharactersOnly;
 605         else if (input->isNumberField())
 606             result.inputMethodHints |= Qt::ImhDigitsOnly;
 607         else if (input->isEmailField()) {
 608             result.inputMethodHints |= Qt::ImhEmailCharactersOnly;
 609             result.inputMethodHints |= Qt::ImhNoAutoUppercase;
 610         } else if (input->isURLField()) {
 611             result.inputMethodHints |= Qt::ImhUrlCharactersOnly;
 612             result.inputMethodHints |= Qt::ImhNoAutoUppercase;
 613         } else if (input->isPasswordField()) {
 614             // Set ImhHiddenText flag for password fields. The Qt platform
 615             // is responsible for determining which widget will receive input
 616             // method events for password fields.
 617             result.inputMethodHints |= Qt::ImhHiddenText;
 618             result.inputMethodHints |= Qt::ImhNoAutoUppercase;
 619             result.inputMethodHints |= Qt::ImhNoPredictiveText;
 620             result.inputMethodHints |= Qt::ImhSensitiveData;
 621         }
 622     }
 623
 624     if (selectionRoot)
 625         result.editorRect = frame->view()->contentsToWindow(selectionRoot->getPixelSnappedRect());
 626
 627     RefPtr<Range> range;
 628     if (result.hasComposition && (range = frame->editor()->compositionRange())) {
 629         frame->editor()->getCompositionSelection(result.anchorPosition, result.cursorPosition);
 630
 631         result.compositionRect = frame->view()->contentsToWindow(range->boundingBox());
 632     }
 633
 634     if (!result.hasComposition && !result.selectionIsNone && (range = frame->selection()->selection().firstRange())) {
 635         TextIterator::getLocationAndLengthFromRange(scope, range.get(), location, length);
 636         bool baseIsFirst = frame->selection()->selection().isBaseFirst();
 637
 638         result.cursorPosition = (baseIsFirst) ? location + length : location;
 639         result.anchorPosition = (baseIsFirst) ? location : location + length;
 640         result.selectedText = range->text();
 641     }
 642
 643     if (range)
 644         result.cursorRect = frame->view()->contentsToWindow(frame->editor()->firstRectForRange(range.get()));
 645
 646     // FIXME: We should only transfer innerText when it changes and do this on the UI side.
 647     if (result.isContentEditable && !result.isInPasswordField) {
 648         result.surroundingText = scope->innerText();
 649         if (result.hasComposition) {
 650             // The anchor is always the left position when they represent a composition.
 651             result.surroundingText.remove(result.anchorPosition, result.cursorPosition - result.anchorPosition);
 652         }
 653     }
 654 #endif
 655
 656     return result;
 657 }
 658
 659 String WebPage::renderTreeExternalRepresentation() const
 660 {
 661     return externalRepresentation(m_mainFrame->coreFrame(), RenderAsTextBehaviorNormal);
 662 }
 663
 664 uint64_t WebPage::renderTreeSize() const
 665 {
 666     if (!m_page)
 667         return 0;
 668     return m_page->renderTreeSize().treeSize;
 669 }
 670
 671 void WebPage::setPaintedObjectsCounterThreshold(uint64_t threshold)
 672 {
 673     if (!m_page)
 674         return;
 675     m_page->setRelevantRepaintedObjectsCounterThreshold(threshold);
 676 }
 677
 678 void WebPage::setTracksRepaints(bool trackRepaints)
 679 {
 680     if (FrameView* view = mainFrameView())
 681         view->setTracksRepaints(trackRepaints);
 682 }
 683
 684 bool WebPage::isTrackingRepaints() const
 685 {
 686     if (FrameView* view = mainFrameView())
 687         return view->isTrackingRepaints();
 688
 689     return false;
 690 }
 691
 692 void WebPage::resetTrackedRepaints()
 693 {
 694     if (FrameView* view = mainFrameView())
 695         view->resetTrackedRepaints();
 696 }
 697
 698 PassRefPtr<ImmutableArray> WebPage::trackedRepaintRects()
 699 {
 700     FrameView* view = mainFrameView();
 701     if (!view)
 702         return ImmutableArray::create();
 703
 704     const Vector<IntRect>& rects = view->trackedRepaintRects();
 705     size_t size = rects.size();
 706     if (!size)
 707         return ImmutableArray::create();
 708
 709     Vector<RefPtr<APIObject> > vector;
 710     vector.reserveInitialCapacity(size);
 711
 712     for (size_t i = 0; i < size; ++i)
 713         vector.uncheckedAppend(WebRect::create(toAPI(rects[i])));
 714
 715     return ImmutableArray::adopt(vector);
 716 }
 717
 718 void WebPage::executeEditingCommand(const String& commandName, const String& argument)
 719 {
 720     Frame* frame = m_page->focusController()->focusedOrMainFrame();
 721     if (!frame)
 722         return;
 723     frame->editor()->command(commandName).execute(argument);
 724 }
 725
 726 bool WebPage::isEditingCommandEnabled(const String& commandName)
 727 {
 728     Frame* frame = m_page->focusController()->focusedOrMainFrame();
 729     if (!frame)
 730         return false;
 731
 732     Editor::Command command = frame->editor()->command(commandName);
 733     return command.isSupported() && command.isEnabled();
 734 }
 735
 736 void WebPage::clearMainFrameName()
 737 {
 738     if (Frame* frame = mainFrame())
 739         frame->tree()->clearName();
 740 }
 741
 742 #if USE(ACCELERATED_COMPOSITING)
 743 void WebPage::enterAcceleratedCompositingMode(GraphicsLayer* layer)
 744 {
 745     m_drawingArea->setRootCompositingLayer(layer);
 746 }
 747
 748 void WebPage::exitAcceleratedCompositingMode()
 749 {
 750     m_drawingArea->setRootCompositingLayer(0);
 751 }
 752 #endif
 753
 754 void WebPage::close()
 755 {
 756     if (m_isClosed)
 757         return;
 758
 759     m_isClosed = true;
 760
 761     if (pageGroup()->isVisibleToInjectedBundle() && WebProcess::shared().injectedBundle())
 762         WebProcess::shared().injectedBundle()->willDestroyPage(this);
 763
 764 #if ENABLE(INSPECTOR)
 765     m_inspector = 0;
 766 #endif
 767 #if ENABLE(FULLSCREEN_API)
 768     m_fullScreenManager = 0;
 769 #endif
 770
 771     if (m_activePopupMenu) {
 772         m_activePopupMenu->disconnectFromPage();
 773         m_activePopupMenu = 0;
 774     }
 775
 776     if (m_activeOpenPanelResultListener) {
 777         m_activeOpenPanelResultListener->disconnectFromPage();
 778         m_activeOpenPanelResultListener = 0;
 779     }
 780
 781 #if ENABLE(INPUT_TYPE_COLOR)
 782     if (m_activeColorChooser) {
 783         m_activeColorChooser->disconnectFromPage();
 784         m_activeColorChooser = 0;
 785     }
 786 #endif
 787
 788     m_sandboxExtensionTracker.invalidate();
 789
 790     m_underlayPage = nullptr;
 791     m_printContext = nullptr;
 792     m_mainFrame->coreFrame()->loader()->detachFromParent();
 793     m_page = nullptr;
 794     m_drawingArea = nullptr;
 795
 796     bool isRunningModal = m_isRunningModal;
 797     m_isRunningModal = false;
 798
 799     // The WebPage can be destroyed by this call.
 800     WebProcess::shared().removeWebPage(m_pageID);
 801
 802     if (isRunningModal)
 803         WebProcess::shared().runLoop()->stop();
 804 }
 805
 806 void WebPage::tryClose()
 807 {
 808     SendStopResponsivenessTimer stopper(this);
 809
 810     if (!m_mainFrame->coreFrame()->loader()->shouldClose()) {
 811         send(Messages::WebPageProxy::StopResponsivenessTimer());
 812         return;
 813     }
 814
 815     send(Messages::WebPageProxy::ClosePage(true));
 816 }
 817
 818 void WebPage::sendClose()
 819 {
 820     send(Messages::WebPageProxy::ClosePage(false));
 821 }
 822
 823 void WebPage::loadURL(const String& url, const SandboxExtension::Handle& sandboxExtensionHandle)
 824 {
 825     loadURLRequest(ResourceRequest(KURL(KURL(), url)), sandboxExtensionHandle);
 826 }
 827
 828 void WebPage::loadURLRequest(const ResourceRequest& request, const SandboxExtension::Handle& sandboxExtensionHandle)
 829 {
 830     SendStopResponsivenessTimer stopper(this);
 831
 832     m_sandboxExtensionTracker.beginLoad(m_mainFrame.get(), sandboxExtensionHandle);
 833     m_mainFrame->coreFrame()->loader()->load(request, false);
 834 }
 835
 836 void WebPage::loadData(PassRefPtr<SharedBuffer> sharedBuffer, const String& MIMEType, const String& encodingName, const KURL& baseURL, const KURL& unreachableURL)
 837 {
 838     SendStopResponsivenessTimer stopper(this);
 839
 840     ResourceRequest request(baseURL);
 841     SubstituteData substituteData(sharedBuffer, MIMEType, encodingName, unreachableURL);
 842     m_mainFrame->coreFrame()->loader()->load(request, substituteData, false);
 843 }
 844
 845 void WebPage::loadHTMLString(const String& htmlString, const String& baseURLString)
 846 {
 847 #if ENABLE(TIZEN_LOAD_HTML_STRING_AS_UTF8)
 848     CString html = htmlString.utf8();
 849     RefPtr<SharedBuffer> sharedBuffer = SharedBuffer::create(reinterpret_cast<const char*>(html.data()), html.length());
 850     KURL baseURL = baseURLString.isEmpty() ? blankURL() : KURL(KURL(), baseURLString);
 851     loadData(sharedBuffer, "text/html", "utf-8", baseURL, KURL());
 852 #else
 853     RefPtr<SharedBuffer> sharedBuffer = SharedBuffer::create(reinterpret_cast<const char*>(htmlString.characters()), htmlString.length() * sizeof(UChar));
 854     KURL baseURL = baseURLString.isEmpty() ? blankURL() : KURL(KURL(), baseURLString);
 855     loadData(sharedBuffer, "text/html", "utf-16", baseURL, KURL());
 856 #endif
 857 }
 858
 859 void WebPage::loadAlternateHTMLString(const String& htmlString, const String& baseURLString, const String& unreachableURLString)
 860 {
 861     RefPtr<SharedBuffer> sharedBuffer = SharedBuffer::create(reinterpret_cast<const char*>(htmlString.characters()), htmlString.length() * sizeof(UChar));
 862     KURL baseURL = baseURLString.isEmpty() ? blankURL() : KURL(KURL(), baseURLString);
 863     KURL unreachableURL = unreachableURLString.isEmpty() ? KURL() : KURL(KURL(), unreachableURLString);
 864     loadData(sharedBuffer, "text/html", "utf-16", baseURL, unreachableURL);
 865 }
 866
 867 void WebPage::loadPlainTextString(const String& string)
 868 {
 869     RefPtr<SharedBuffer> sharedBuffer = SharedBuffer::create(reinterpret_cast<const char*>(string.characters()), string.length() * sizeof(UChar));
 870     loadData(sharedBuffer, "text/plain", "utf-16", blankURL(), KURL());
 871 }
 872
 873 void WebPage::loadWebArchiveData(const CoreIPC::DataReference& webArchiveData)
 874 {
 875     RefPtr<SharedBuffer> sharedBuffer = SharedBuffer::create(reinterpret_cast<const char*>(webArchiveData.data()), webArchiveData.size() * sizeof(uint8_t));
 876     loadData(sharedBuffer, "application/x-webarchive", "utf-16", blankURL(), KURL());
 877 }
 878
 879 #if OS(TIZEN)
 880 void WebPage::loadContentsbyMimeType(const CoreIPC::DataReference& contents, const String& mimeType, const String& encoding, const String& baseURL)
 881 {
 882     RefPtr<SharedBuffer> sharedBuffer = SharedBuffer::create(reinterpret_cast<const char*>(contents.data()), contents.size() * sizeof(uint8_t));
 883     KURL baseKURL(WebCore::KURL(), baseURL);
 884     loadData(sharedBuffer, mimeType, encoding, baseKURL, KURL());
 885 }
 886 #endif
 887
 888 void WebPage::linkClicked(const String& url, const WebMouseEvent& event)
 889 {
 890     Frame* frame = m_page->mainFrame();
 891     if (!frame)
 892         return;
 893
 894     RefPtr<Event> coreEvent;
 895     if (event.type() != WebEvent::NoType)
 896         coreEvent = MouseEvent::create(eventNames().clickEvent, frame->document()->defaultView(), platform(event), 0, 0);
 897
 898     frame->loader()->loadFrameRequest(FrameLoadRequest(frame->document()->securityOrigin(), ResourceRequest(url)),
 899         false, false, coreEvent.get(), 0, MaybeSendReferrer);
 900 }
 901
 902 void WebPage::stopLoadingFrame(uint64_t frameID)
 903 {
 904     WebFrame* frame = WebProcess::shared().webFrame(frameID);
 905     if (!frame)
 906         return;
 907
 908     frame->coreFrame()->loader()->stopForUserCancel();
 909 }
 910
 911 void WebPage::stopLoading()
 912 {
 913     SendStopResponsivenessTimer stopper(this);
 914
 915     m_mainFrame->coreFrame()->loader()->stopForUserCancel();
 916 }
 917
 918 void WebPage::setDefersLoading(bool defersLoading)
 919 {
 920     m_page->setDefersLoading(defersLoading);
 921 }
 922
 923 void WebPage::reload(bool reloadFromOrigin, const SandboxExtension::Handle& sandboxExtensionHandle)
 924 {
 925     SendStopResponsivenessTimer stopper(this);
 926
 927     m_sandboxExtensionTracker.beginLoad(m_mainFrame.get(), sandboxExtensionHandle);
 928     m_mainFrame->coreFrame()->loader()->reload(reloadFromOrigin);
 929 }
 930
 931 void WebPage::goForward(uint64_t backForwardItemID)
 932 {
 933     SendStopResponsivenessTimer stopper(this);
 934
 935     HistoryItem* item = WebBackForwardListProxy::itemForID(backForwardItemID);
 936     ASSERT(item);
 937     if (!item)
 938         return;
 939
 940     m_page->goToItem(item, FrameLoadTypeForward);
 941 }
 942
 943 void WebPage::goBack(uint64_t backForwardItemID)
 944 {
 945     SendStopResponsivenessTimer stopper(this);
 946
 947     HistoryItem* item = WebBackForwardListProxy::itemForID(backForwardItemID);
 948     ASSERT(item);
 949     if (!item)
 950         return;
 951
 952     m_page->goToItem(item, FrameLoadTypeBack);
 953 }
 954
 955 void WebPage::goToBackForwardItem(uint64_t backForwardItemID)
 956 {
 957     SendStopResponsivenessTimer stopper(this);
 958
 959     HistoryItem* item = WebBackForwardListProxy::itemForID(backForwardItemID);
 960     ASSERT(item);
 961     if (!item)
 962         return;
 963
 964     m_page->goToItem(item, FrameLoadTypeIndexedBackForward);
 965 }
 966
 967 void WebPage::tryRestoreScrollPosition()
 968 {
 969     m_page->mainFrame()->loader()->history()->restoreScrollPositionAndViewState();
 970 }
 971
 972 void WebPage::layoutIfNeeded()
 973 {
 974     if (m_mainFrame->coreFrame()->view())
 975         m_mainFrame->coreFrame()->view()->updateLayoutAndStyleIfNeededRecursive();
 976
 977     if (m_underlayPage) {
 978         if (FrameView *frameView = m_underlayPage->mainFrameView())
 979             frameView->updateLayoutAndStyleIfNeededRecursive();
 980     }
 981 }
 982
 983 void WebPage::setSize(const WebCore::IntSize& viewSize)
 984 {
 985     FrameView* view = m_page->mainFrame()->view();
 986
 987 #if USE(TILED_BACKING_STORE)
 988     // If we are resizing to content ignore external attempts.
 989     if (view->useFixedLayout())
 990         return;
 991 #endif
 992
 993     if (m_viewSize == viewSize)
 994         return;
 995
 996     view->resize(viewSize);
 997     view->setNeedsLayout();
 998     m_drawingArea->setNeedsDisplay(IntRect(IntPoint(0, 0), viewSize));
 999
1000     m_viewSize = viewSize;
1001 }
1002
1003 #if USE(TILED_BACKING_STORE)
1004 void WebPage::setFixedVisibleContentRect(const IntRect& rect)
1005 {
1006     ASSERT(m_useFixedLayout);
1007
1008     m_page->mainFrame()->view()->setFixedVisibleContentRect(rect);
1009 }
1010
1011 void WebPage::setResizesToContentsUsingLayoutSize(const IntSize& targetLayoutSize)
1012 {
1013     ASSERT(m_useFixedLayout);
1014     ASSERT(!targetLayoutSize.isEmpty());
1015
1016     FrameView* view = m_page->mainFrame()->view();
1017
1018     view->setDelegatesScrolling(true);
1019     view->setUseFixedLayout(true);
1020     view->setPaintsEntireContents(true);
1021
1022     if (view->fixedLayoutSize() == targetLayoutSize)
1023         return;
1024
1025     m_page->settings()->setAcceleratedCompositingForFixedPositionEnabled(true);
1026     m_page->settings()->setFixedElementsLayoutRelativeToFrame(true);
1027     m_page->settings()->setFixedPositionCreatesStackingContext(true);
1028
1029     // Always reset even when empty. This also takes care of the relayout.
1030     setFixedLayoutSize(targetLayoutSize);
1031 }
1032
1033 void WebPage::resizeToContentsIfNeeded()
1034 {
1035     ASSERT(m_useFixedLayout);
1036
1037     FrameView* view = m_page->mainFrame()->view();
1038
1039     if (!view->useFixedLayout())
1040         return;
1041
1042     IntSize newSize = view->contentsSize().expandedTo(view->fixedLayoutSize());
1043
1044     if (newSize == m_viewSize)
1045         return;
1046
1047     m_viewSize = newSize;
1048     view->resize(newSize);
1049     view->setNeedsLayout();
1050 }
1051
1052 void WebPage::sendViewportAttributesChanged()
1053 {
1054     ASSERT(m_useFixedLayout);
1055
1056     // Viewport properties have no impact on zero sized fixed viewports.
1057     if (m_viewportSize.isEmpty())
1058         return;
1059
1060     // Recalculate the recommended layout size, when the available size (device pixel) changes.
1061     Settings* settings = m_page->settings();
1062
1063 #if OS(TIZEN)
1064     // As android and iphone does, we set layout width to 980 for desktop content
1065     int minimumLayoutFallbackWidth = settings->layoutFallbackWidth();
1066 #else
1067     int minimumLayoutFallbackWidth = std::max(settings->layoutFallbackWidth(), m_viewportSize.width());
1068 #endif
1069
1070     // If unset  we use the viewport dimensions. This fits with the behavior of desktop browsers.
1071     int deviceWidth = (settings->deviceWidth() > 0) ? settings->deviceWidth() : m_viewportSize.width();
1072     int deviceHeight = (settings->deviceHeight() > 0) ? settings->deviceHeight() : m_viewportSize.height();
1073
1074     ViewportAttributes attr = computeViewportAttributes(m_page->viewportArguments(), minimumLayoutFallbackWidth, deviceWidth, deviceHeight, m_page->deviceScaleFactor(), m_viewportSize);
1075     WebCore::restrictMinimumScaleFactorToViewportSize(attr, m_viewportSize);
1076     WebCore::restrictScaleFactorToInitialScaleIfNotUserScalable(attr);
1077
1078 #if ENABLE(TIZEN_VIEWPORT_META_TAG)
1079     // On WebProcess, JS runs before visible content rect is updated by UIProcess
1080     // In this case, JS returns incorrect inner size value because scale factor is not updated yet
1081     // So, we update fixed visible content rect at here.
1082     // FIXME: scale factor needs to be calculated and set fixed visible content rect
1083
1084     // if constrainsScrollingToContentEdge is true, scroll position will be adjusted with contents size.
1085     // disable this to avoid adjust scroll position on setFixedVisibleContentRect() because contents size is not fixed yet.
1086     bool constrainsScrollingToContentEdge = mainFrameView()->constrainsScrollingToContentEdge();
1087     mainFrameView()->setConstrainsScrollingToContentEdge(false);
1088
1089     FloatSize contentFixedSize = m_viewportSize;
1090     contentFixedSize.scale(1 / (attr.initialScale * attr.devicePixelRatio));
1091     mainFrameView()->setFixedVisibleContentRect(IntRect(mainFrameView()->scrollPosition(), roundedIntSize(contentFixedSize)));
1092
1093     // If viewport meta tag is not defined or initial scale factor is not defined,
1094     // initial scale factor can be defined by "Default View" setting of UIProcess.
1095     // Therefore we set initialScale as ValueAuto as WebKit opensource does, to handle it with setting on UIProcess.
1096     // You can find this implementation on WebKit bug.
1097     // https://bugs.webkit.org/show_bug.cgi?id=102392
1098     if (m_page->viewportArguments().type == ViewportArguments::Implicit
1099         || m_page->viewportArguments().initialScale == ViewportArguments::ValueAuto)
1100         attr.initialScale = ViewportArguments::ValueAuto;
1101 #endif
1102
1103     setResizesToContentsUsingLayoutSize(IntSize(static_cast<int>(attr.layoutSize.width()), static_cast<int>(attr.layoutSize.height())));
1104
1105 #if ENABLE(TIZEN_VIEWPORT_META_TAG)
1106     // recover constrainsScrollingToContentEdge
1107     mainFrameView()->setConstrainsScrollingToContentEdge(constrainsScrollingToContentEdge);
1108 #endif
1109
1110     send(Messages::WebPageProxy::DidChangeViewportProperties(attr));
1111 }
1112
1113 void WebPage::setViewportSize(const IntSize& size)
1114 {
1115     ASSERT(m_useFixedLayout);
1116
1117     if (m_viewportSize == size)
1118         return;
1119
1120      m_viewportSize = size;
1121
1122     sendViewportAttributesChanged();
1123 }
1124
1125 #endif
1126
1127 void WebPage::scrollMainFrameIfNotAtMaxScrollPosition(const IntSize& scrollOffset)
1128 {
1129     Frame* frame = m_page->mainFrame();
1130
1131     IntPoint scrollPosition = frame->view()->scrollPosition();
1132     IntPoint maximumScrollPosition = frame->view()->maximumScrollPosition();
1133
1134     // If the current scroll position in a direction is the max scroll position
1135     // we don't want to scroll at all.
1136     IntSize newScrollOffset;
1137     if (scrollPosition.x() < maximumScrollPosition.x())
1138         newScrollOffset.setWidth(scrollOffset.width());
1139     if (scrollPosition.y() < maximumScrollPosition.y())
1140         newScrollOffset.setHeight(scrollOffset.height());
1141
1142     if (newScrollOffset.isZero())
1143         return;
1144
1145     frame->view()->setScrollPosition(frame->view()->scrollPosition() + newScrollOffset);
1146 }
1147
1148 void WebPage::drawRect(GraphicsContext& graphicsContext, const IntRect& rect)
1149 {
1150     GraphicsContextStateSaver stateSaver(graphicsContext);
1151     graphicsContext.clip(rect);
1152
1153     if (m_underlayPage) {
1154         m_underlayPage->drawRect(graphicsContext, rect);
1155
1156         graphicsContext.beginTransparencyLayer(1);
1157         m_mainFrame->coreFrame()->view()->paint(&graphicsContext, rect);
1158         graphicsContext.endTransparencyLayer();
1159         return;
1160     }
1161
1162     m_mainFrame->coreFrame()->view()->paint(&graphicsContext, rect);
1163 }
1164
1165 #if ENABLE(TIZEN_WEBKIT2_CONTEXT_MENU_TEXT_SELECTION_MODE)
1166 void WebPage::selectLink(WebCore::IntPoint positionForSelection, bool& result)
1167 {
1168     result = false;
1169     Frame* frame = m_page->focusController()->focusedOrMainFrame();
1170     if (!frame)
1171         return;
1172
1173     FrameView* frameView = frame->view();
1174     if (!frameView)
1175         return;
1176
1177     HitTestResult hitTestResult = frame->eventHandler()->hitTestResultAtPoint(frameView->windowToContents(positionForSelection), false);
1178
1179     RefPtr<Range> range;
1180     Element* URLElement = hitTestResult.URLElement();
1181     if (URLElement) {
1182         for (Node* childNode = URLElement->firstChild(); childNode; childNode = childNode->traverseNextNode(URLElement)) {
1183             RenderObject* r = childNode->renderer();
1184             if (r && (r->isText() || r->isImage())) {
1185                 if (!range)
1186                     range = VisibleSelection::selectionFromContentsOfNode(childNode).toNormalizedRange();
1187                 else if (!hitTestResult.image()) {
1188                     RefPtr<Range> extendedRange = VisibleSelection::selectionFromContentsOfNode(childNode).toNormalizedRange();
1189                     range->setEnd(childNode, extendedRange->endOffset());
1190                 }
1191             }
1192         }
1193         if(!range)
1194             range = VisibleSelection::selectionFromContentsOfNode(URLElement).toNormalizedRange();
1195     } else
1196         range = VisibleSelection::selectionFromContentsOfNode(hitTestResult.innerNonSharedNode()).toNormalizedRange();
1197
1198     WebCore::FrameSelection* frameSelection = frame->selection();
1199     if (!frameSelection)
1200         return;
1201
1202     EAffinity affinity = frameSelection->affinity();
1203     frameSelection->setSelectedRange(range.get(), affinity, true);
1204
1205     if (frameSelection->isRange())
1206         result = true;
1207
1208     return;
1209 }
1210 #endif
1211
1212 #if ENABLE(TIZEN_ORIENTATION_EVENTS)
1213 void WebPage::sendOrientationChangeEvent(int newOrientation)
1214 {
1215     Frame* frame = m_mainFrame->coreFrame();
1216     if (!frame || frame->orientation() == newOrientation)
1217         return;
1218
1219     frame->sendOrientationChangeEvent(newOrientation);
1220     for (WebCore::Frame* child = frame->tree()->firstChild(); child; child = child->tree()->nextSibling())
1221         child->sendOrientationChangeEvent(newOrientation);
1222 }
1223 #endif
1224
1225 void WebPage::drawPageOverlay(GraphicsContext& graphicsContext, const IntRect& rect)
1226 {
1227     ASSERT(m_pageOverlay);
1228
1229     GraphicsContextStateSaver stateSaver(graphicsContext);
1230     graphicsContext.clip(rect);
1231     m_pageOverlay->drawRect(graphicsContext, rect);
1232 }
1233
1234 double WebPage::textZoomFactor() const
1235 {
1236     Frame* frame = m_mainFrame->coreFrame();
1237     if (!frame)
1238         return 1;
1239     return frame->textZoomFactor();
1240 }
1241
1242 void WebPage::setTextZoomFactor(double zoomFactor)
1243 {
1244     Frame* frame = m_mainFrame->coreFrame();
1245     if (!frame)
1246         return;
1247     frame->setTextZoomFactor(static_cast<float>(zoomFactor));
1248 }
1249
1250 double WebPage::pageZoomFactor() const
1251 {
1252     Frame* frame = m_mainFrame->coreFrame();
1253     if (!frame)
1254         return 1;
1255     return frame->pageZoomFactor();
1256 }
1257
1258 void WebPage::setPageZoomFactor(double zoomFactor)
1259 {
1260     Frame* frame = m_mainFrame->coreFrame();
1261     if (!frame)
1262         return;
1263     frame->setPageZoomFactor(static_cast<float>(zoomFactor));
1264 }
1265
1266 void WebPage::setPageAndTextZoomFactors(double pageZoomFactor, double textZoomFactor)
1267 {
1268     Frame* frame = m_mainFrame->coreFrame();
1269     if (!frame)
1270         return;
1271     return frame->setPageAndTextZoomFactors(static_cast<float>(pageZoomFactor), static_cast<float>(textZoomFactor));
1272 }
1273
1274 void WebPage::windowScreenDidChange(uint64_t displayID)
1275 {
1276     m_page->windowScreenDidChange(static_cast<PlatformDisplayID>(displayID));
1277 }
1278
1279 void WebPage::setViewMode(Page::ViewMode mode)
1280 {
1281     m_page->setViewMode(mode);
1282 }
1283
1284 void WebPage::scalePage(double scale, const IntPoint& origin)
1285 {
1286     m_page->setPageScaleFactor(scale, origin);
1287
1288     for (HashSet<PluginView*>::const_iterator it = m_pluginViews.begin(), end = m_pluginViews.end(); it != end; ++it)
1289         (*it)->pageScaleFactorDidChange();
1290
1291     send(Messages::WebPageProxy::PageScaleFactorDidChange(scale));
1292 }
1293
1294 double WebPage::pageScaleFactor() const
1295 {
1296     return m_page->pageScaleFactor();
1297 }
1298
1299 void WebPage::setDeviceScaleFactor(float scaleFactor)
1300 {
1301     if (scaleFactor == m_page->deviceScaleFactor())
1302         return;
1303
1304     m_page->setDeviceScaleFactor(scaleFactor);
1305
1306     // Tell all our plug-in views that the device scale factor changed.
1307 #if PLATFORM(MAC)
1308     for (HashSet<PluginView*>::const_iterator it = m_pluginViews.begin(), end = m_pluginViews.end(); it != end; ++it)
1309         (*it)->setDeviceScaleFactor(scaleFactor);
1310 #endif
1311
1312     if (m_findController.isShowingOverlay()) {
1313         // We must have updated layout to get the selection rects right.
1314         layoutIfNeeded();
1315         m_findController.deviceScaleFactorDidChange();
1316     }
1317 }
1318
1319 float WebPage::deviceScaleFactor() const
1320 {
1321     return m_page->deviceScaleFactor();
1322 }
1323
1324 void WebPage::setUseFixedLayout(bool fixed)
1325 {
1326     m_useFixedLayout = fixed;
1327
1328     FrameView* view = mainFrameView();
1329     if (!view)
1330         return;
1331
1332     view->setUseFixedLayout(fixed);
1333     if (!fixed)
1334         setFixedLayoutSize(IntSize());
1335 }
1336
1337 void WebPage::setFixedLayoutSize(const IntSize& size)
1338 {
1339     FrameView* view = mainFrameView();
1340     if (!view || view->fixedLayoutSize() == size)
1341         return;
1342
1343     view->setFixedLayoutSize(size);
1344     // Do not force it until the first layout, this would then become our first layout prematurely.
1345     if (view->didFirstLayout())
1346         view->forceLayout();
1347 }
1348
1349 void WebPage::setPaginationMode(uint32_t mode)
1350 {
1351     Page::Pagination pagination = m_page->pagination();
1352     pagination.mode = static_cast<Page::Pagination::Mode>(mode);
1353     m_page->setPagination(pagination);
1354 }
1355
1356 void WebPage::setPaginationBehavesLikeColumns(bool behavesLikeColumns)
1357 {
1358     Page::Pagination pagination = m_page->pagination();
1359     pagination.behavesLikeColumns = behavesLikeColumns;
1360     m_page->setPagination(pagination);
1361 }
1362
1363 void WebPage::setPageLength(double pageLength)
1364 {
1365     Page::Pagination pagination = m_page->pagination();
1366     pagination.pageLength = pageLength;
1367     m_page->setPagination(pagination);
1368 }
1369
1370 void WebPage::setGapBetweenPages(double gap)
1371 {
1372     Page::Pagination pagination = m_page->pagination();
1373     pagination.gap = gap;
1374     m_page->setPagination(pagination);
1375 }
1376
1377 void WebPage::installPageOverlay(PassRefPtr<PageOverlay> pageOverlay)
1378 {
1379     bool shouldFadeIn = true;
1380
1381     if (m_pageOverlay) {
1382         m_pageOverlay->setPage(0);
1383
1384         if (pageOverlay) {
1385             // We're installing a page overlay when a page overlay is already active.
1386             // In this case we don't want to fade in the new overlay.
1387             shouldFadeIn = false;
1388         }
1389     }
1390
1391     m_pageOverlay = pageOverlay;
1392     m_pageOverlay->setPage(this);
1393
1394     if (shouldFadeIn)
1395         m_pageOverlay->startFadeInAnimation();
1396
1397     m_drawingArea->didInstallPageOverlay();
1398 #if PLATFORM(WIN)
1399     send(Messages::WebPageProxy::DidInstallOrUninstallPageOverlay(true));
1400 #endif
1401
1402     m_pageOverlay->setNeedsDisplay();
1403 }
1404
1405 void WebPage::uninstallPageOverlay(PageOverlay* pageOverlay, bool fadeOut)
1406 {
1407     if (pageOverlay != m_pageOverlay)
1408         return;
1409
1410     if (fadeOut) {
1411         m_pageOverlay->startFadeOutAnimation();
1412         return;
1413     }
1414
1415     m_pageOverlay->setPage(0);
1416     m_pageOverlay = nullptr;
1417
1418     m_drawingArea->didUninstallPageOverlay();
1419 #if PLATFORM(WIN)
1420     send(Messages::WebPageProxy::DidInstallOrUninstallPageOverlay(false));
1421 #endif
1422 }
1423
1424 #if PLATFORM(EFL) && OS(TIZEN)
1425 PassRefPtr<WebImage> WebPage::scaledSnapshotInViewCoordinates(const IntRect& rect, double scaleFactor, ImageOptions options)
1426 {
1427     FrameView* frameView = m_mainFrame->coreFrame()->view();
1428     if (!frameView)
1429         return 0;
1430
1431     IntSize size(ceil(rect.width() * scaleFactor), ceil(rect.height() * scaleFactor));
1432     RefPtr<WebImage> snapshot = WebImage::create(size, options);
1433     if (!snapshot->bitmap())
1434         return 0;
1435
1436     OwnPtr<WebCore::GraphicsContext> graphicsContext = snapshot->bitmap()->createGraphicsContext();
1437     graphicsContext->scale(FloatSize(scaleFactor, scaleFactor));
1438     graphicsContext->translate(-rect.x(), -rect.y());
1439
1440     frameView->updateLayoutAndStyleIfNeededRecursive();
1441
1442     PaintBehavior oldBehavior = frameView->paintBehavior();
1443     frameView->setPaintBehavior(oldBehavior | PaintBehaviorFlattenCompositingLayers);
1444     frameView->paint(graphicsContext.get(), rect);
1445     frameView->setPaintBehavior(oldBehavior);
1446
1447     return snapshot.release();
1448 }
1449
1450 PassRefPtr<WebImage> WebPage::snapshotInViewCoordinates(const IntRect& rect, ImageOptions options)
1451 {
1452     return scaledSnapshotInViewCoordinates(rect, 1, options);
1453 }
1454 #else
1455 PassRefPtr<WebImage> WebPage::snapshotInViewCoordinates(const IntRect& rect, ImageOptions options)
1456 {
1457     FrameView* frameView = m_mainFrame->coreFrame()->view();
1458     if (!frameView)
1459         return 0;
1460
1461     IntSize bitmapSize = rect.size();
1462     float deviceScaleFactor = corePage()->deviceScaleFactor();
1463     bitmapSize.scale(deviceScaleFactor);
1464
1465     RefPtr<WebImage> snapshot = WebImage::create(bitmapSize, options);
1466     if (!snapshot->bitmap())
1467         return 0;
1468
1469     OwnPtr<WebCore::GraphicsContext> graphicsContext = snapshot->bitmap()->createGraphicsContext();
1470     graphicsContext->applyDeviceScaleFactor(deviceScaleFactor);
1471     graphicsContext->translate(-rect.x(), -rect.y());
1472
1473     frameView->updateLayoutAndStyleIfNeededRecursive();
1474
1475     PaintBehavior oldBehavior = frameView->paintBehavior();
1476     frameView->setPaintBehavior(oldBehavior | PaintBehaviorFlattenCompositingLayers);
1477     frameView->paint(graphicsContext.get(), rect);
1478     frameView->setPaintBehavior(oldBehavior);
1479
1480     return snapshot.release();
1481 }
1482 #endif
1483
1484 PassRefPtr<WebImage> WebPage::scaledSnapshotInDocumentCoordinates(const IntRect& rect, double scaleFactor, ImageOptions options)
1485 {
1486     FrameView* frameView = m_mainFrame->coreFrame()->view();
1487     if (!frameView)
1488         return 0;
1489
1490     float combinedScaleFactor = scaleFactor * corePage()->deviceScaleFactor();
1491     IntSize size(ceil(rect.width() * combinedScaleFactor), ceil(rect.height() * combinedScaleFactor));
1492     RefPtr<WebImage> snapshot = WebImage::create(size, options);
1493     if (!snapshot->bitmap())
1494         return 0;
1495
1496     OwnPtr<WebCore::GraphicsContext> graphicsContext = snapshot->bitmap()->createGraphicsContext();
1497     graphicsContext->applyDeviceScaleFactor(combinedScaleFactor);
1498     graphicsContext->translate(-rect.x(), -rect.y());
1499
1500     frameView->updateLayoutAndStyleIfNeededRecursive();
1501
1502     PaintBehavior oldBehavior = frameView->paintBehavior();
1503     frameView->setPaintBehavior(oldBehavior | PaintBehaviorFlattenCompositingLayers);
1504     frameView->paintContents(graphicsContext.get(), rect);
1505     frameView->setPaintBehavior(oldBehavior);
1506
1507     return snapshot.release();
1508 }
1509
1510 PassRefPtr<WebImage> WebPage::snapshotInDocumentCoordinates(const IntRect& rect, ImageOptions options)
1511 {
1512     return scaledSnapshotInDocumentCoordinates(rect, 1, options);
1513 }
1514
1515 void WebPage::pageDidScroll()
1516 {
1517     m_uiClient.pageDidScroll(this);
1518
1519     send(Messages::WebPageProxy::PageDidScroll());
1520 }
1521
1522 #if USE(TILED_BACKING_STORE)
1523 void WebPage::pageDidRequestScroll(const IntPoint& point)
1524 {
1525     send(Messages::WebPageProxy::PageDidRequestScroll(point));
1526 }
1527 #endif
1528
1529 #if ENABLE(TIZEN_WEBKIT2_HISTORICAL_RESTORE_VISIBLE_CONTENT_RECT)
1530 void WebPage::pageDidRequestRestoreVisibleContentRect(const IntPoint& point, float scale)
1531 {
1532     send(Messages::WebPageProxy::pageDidRequestRestoreVisibleContentRect(point, scale));
1533 }
1534 #endif
1535
1536 #if ENABLE(CONTEXT_MENUS)
1537 WebContextMenu* WebPage::contextMenu()
1538 {
1539     if (!m_contextMenu)
1540         m_contextMenu = WebContextMenu::create(this);
1541     return m_contextMenu.get();
1542 }
1543 #endif
1544
1545 // Events
1546
1547 static const WebEvent* g_currentEvent = 0;
1548
1549 // FIXME: WebPage::currentEvent is used by the plug-in code to avoid having to convert from DOM events back to
1550 // WebEvents. When we get the event handling sorted out, this should go away and the Widgets should get the correct
1551 // platform events passed to the event handler code.
1552 const WebEvent* WebPage::currentEvent()
1553 {
1554     return g_currentEvent;
1555 }
1556
1557 class CurrentEvent {
1558 public:
1559     explicit CurrentEvent(const WebEvent& event)
1560         : m_previousCurrentEvent(g_currentEvent)
1561     {
1562         g_currentEvent = &event;
1563     }
1564
1565     ~CurrentEvent()
1566     {
1567         g_currentEvent = m_previousCurrentEvent;
1568     }
1569
1570 private:
1571     const WebEvent* m_previousCurrentEvent;
1572 };
1573
1574 #if ENABLE(CONTEXT_MENUS)
1575 static bool isContextClick(const PlatformMouseEvent& event)
1576 {
1577     if (event.button() == WebCore::RightButton)
1578         return true;
1579
1580 #if PLATFORM(MAC)
1581     // FIXME: this really should be about OSX-style UI, not about the Mac port
1582     if (event.button() == WebCore::LeftButton && event.ctrlKey())
1583         return true;
1584 #endif
1585
1586     return false;
1587 }
1588
1589 static bool handleContextMenuEvent(const PlatformMouseEvent& platformMouseEvent, WebPage* page)
1590 {
1591     IntPoint point = page->corePage()->mainFrame()->view()->windowToContents(platformMouseEvent.position());
1592     HitTestResult result = page->corePage()->mainFrame()->eventHandler()->hitTestResultAtPoint(point, false);
1593
1594     Frame* frame = page->corePage()->mainFrame();
1595 #if !ENABLE(TIZEN_CONTEXT_MENU_WEBKIT_2)
1596     if (result.innerNonSharedNode())
1597         frame = result.innerNonSharedNode()->document()->frame();
1598 #endif
1599
1600     bool handled = frame->eventHandler()->sendContextMenuEvent(platformMouseEvent);
1601     if (handled)
1602         page->contextMenu()->show();
1603
1604 #if ENABLE(TIZEN_DRAG_SUPPORT)
1605     if(result.isDragSupport()) {
1606         if (result.innerNonSharedNode())
1607             frame = result.innerNonSharedNode()->document()->frame();
1608
1609         PlatformMouseEvent event(frame->view()->windowToContents(platformMouseEvent.position()), platformMouseEvent.globalPosition(), LeftButton, PlatformEvent::MousePressed, 1, false, false, false, false, currentTime());
1610         frame->page()->dragController()->setPosition(event);
1611     }
1612 #endif
1613
1614     return handled;
1615 }
1616 #endif
1617
1618 static bool handleMouseEvent(const WebMouseEvent& mouseEvent, WebPage* page, bool onlyUpdateScrollbars)
1619 {
1620     Frame* frame = page->corePage()->mainFrame();
1621     if (!frame->view())
1622         return false;
1623
1624     PlatformMouseEvent platformMouseEvent = platform(mouseEvent);
1625
1626     switch (platformMouseEvent.type()) {
1627         case PlatformEvent::MousePressed: {
1628 #if ENABLE(CONTEXT_MENUS)
1629             if (isContextClick(platformMouseEvent))
1630                 page->corePage()->contextMenuController()->clearContextMenu();
1631 #endif
1632
1633 #if ENABLE(TIZEN_CONTEXT_MENU_WEBKIT_2)
1634             bool handled;
1635             if (!isContextClick(platformMouseEvent))
1636                 handled = frame->eventHandler()->handleMousePressEvent(platformMouseEvent);
1637 #else
1638             bool handled = frame->eventHandler()->handleMousePressEvent(platformMouseEvent);
1639 #endif
1640 #if ENABLE(CONTEXT_MENUS)
1641             if (isContextClick(platformMouseEvent))
1642                 handled = handleContextMenuEvent(platformMouseEvent, page);
1643 #endif
1644 #if PLATFORM(GTK)
1645             bool gtkMouseButtonPressHandled = page->handleMousePressedEvent(platformMouseEvent);
1646             handled = handled || gtkMouseButtonPressHandled;
1647 #endif
1648
1649             return handled;
1650         }
1651         case PlatformEvent::MouseReleased:
1652             return frame->eventHandler()->handleMouseReleaseEvent(platformMouseEvent);
1653         case PlatformEvent::MouseMoved:
1654             if (onlyUpdateScrollbars)
1655                 return frame->eventHandler()->passMouseMovedEventToScrollbars(platformMouseEvent);
1656             return frame->eventHandler()->mouseMoved(platformMouseEvent);
1657         default:
1658             ASSERT_NOT_REACHED();
1659             return false;
1660     }
1661 }
1662
1663 void WebPage::mouseEvent(const WebMouseEvent& mouseEvent)
1664 {
1665 #if ENABLE(CONTEXT_MENUS)
1666     // Don't try to handle any pending mouse events if a context menu is showing.
1667     if (m_isShowingContextMenu) {
1668         send(Messages::WebPageProxy::DidReceiveEvent(static_cast<uint32_t>(mouseEvent.type()), false));
1669         return;
1670     }
1671 #endif
1672
1673     bool handled = false;
1674
1675     if (m_pageOverlay) {
1676         // Let the page overlay handle the event.
1677         handled = m_pageOverlay->mouseEvent(mouseEvent);
1678     }
1679
1680     if (!handled) {
1681         CurrentEvent currentEvent(mouseEvent);
1682
1683         // We need to do a full, normal hit test during this mouse event if the page is active or if a mouse
1684         // button is currently pressed. It is possible that neither of those things will be true since on
1685         // Lion when legacy scrollbars are enabled, WebKit receives mouse events all the time. If it is one
1686         // of those cases where the page is not active and the mouse is not pressed, then we can fire a more
1687         // efficient scrollbars-only version of the event.
1688         bool onlyUpdateScrollbars = !(m_page->focusController()->isActive() || (mouseEvent.button() != WebMouseEvent::NoButton));
1689         handled = handleMouseEvent(mouseEvent, this, onlyUpdateScrollbars);
1690     }
1691
1692     send(Messages::WebPageProxy::DidReceiveEvent(static_cast<uint32_t>(mouseEvent.type()), handled));
1693 }
1694
1695 void WebPage::mouseEventSyncForTesting(const WebMouseEvent& mouseEvent, bool& handled)
1696 {
1697     handled = m_pageOverlay && m_pageOverlay->mouseEvent(mouseEvent);
1698
1699     if (!handled) {
1700         CurrentEvent currentEvent(mouseEvent);
1701
1702         // We need to do a full, normal hit test during this mouse event if the page is active or if a mouse
1703         // button is currently pressed. It is possible that neither of those things will be true since on
1704         // Lion when legacy scrollbars are enabled, WebKit receives mouse events all the time. If it is one
1705         // of those cases where the page is not active and the mouse is not pressed, then we can fire a more
1706         // efficient scrollbars-only version of the event.
1707         bool onlyUpdateScrollbars = !(m_page->focusController()->isActive() || (mouseEvent.button() != WebMouseEvent::NoButton));
1708         handled = handleMouseEvent(mouseEvent, this, onlyUpdateScrollbars);
1709     }
1710 }
1711
1712 static bool handleWheelEvent(const WebWheelEvent& wheelEvent, Page* page)
1713 {
1714     Frame* frame = page->mainFrame();
1715     if (!frame->view())
1716         return false;
1717
1718     PlatformWheelEvent platformWheelEvent = platform(wheelEvent);
1719     return frame->eventHandler()->handleWheelEvent(platformWheelEvent);
1720 }
1721
1722 void WebPage::wheelEvent(const WebWheelEvent& wheelEvent)
1723 {
1724     CurrentEvent currentEvent(wheelEvent);
1725
1726     bool handled = handleWheelEvent(wheelEvent, m_page.get());
1727     send(Messages::WebPageProxy::DidReceiveEvent(static_cast<uint32_t>(wheelEvent.type()), handled));
1728 }
1729
1730 void WebPage::wheelEventSyncForTesting(const WebWheelEvent& wheelEvent, bool& handled)
1731 {
1732     CurrentEvent currentEvent(wheelEvent);
1733
1734     handled = handleWheelEvent(wheelEvent, m_page.get());
1735 }
1736
1737 static bool handleKeyEvent(const WebKeyboardEvent& keyboardEvent, Page* page)
1738 {
1739     if (!page->mainFrame()->view())
1740         return false;
1741
1742     if (keyboardEvent.type() == WebEvent::Char && keyboardEvent.isSystemKey())
1743         return page->focusController()->focusedOrMainFrame()->eventHandler()->handleAccessKey(platform(keyboardEvent));
1744     return page->focusController()->focusedOrMainFrame()->eventHandler()->keyEvent(platform(keyboardEvent));
1745 }
1746
1747 #if ENABLE(TIZEN_ISF_PORT)
1748 void WebPage::keyEvent(const NativeWebKeyboardEvent& keyboardEvent)
1749 #else
1750 void WebPage::keyEvent(const WebKeyboardEvent& keyboardEvent)
1751 #endif
1752 {
1753     CurrentEvent currentEvent(keyboardEvent);
1754
1755     bool handled = handleKeyEvent(keyboardEvent, m_page.get());
1756     // FIXME: Platform default behaviors should be performed during normal DOM event dispatch (in most cases, in default keydown event handler).
1757     if (!handled)
1758         handled = performDefaultBehaviorForKeyEvent(keyboardEvent);
1759
1760     send(Messages::WebPageProxy::DidReceiveEvent(static_cast<uint32_t>(keyboardEvent.type()), handled));
1761 }
1762
1763 void WebPage::keyEventSyncForTesting(const WebKeyboardEvent& keyboardEvent, bool& handled)
1764 {
1765     CurrentEvent currentEvent(keyboardEvent);
1766
1767     handled = handleKeyEvent(keyboardEvent, m_page.get());
1768     if (!handled)
1769         handled = performDefaultBehaviorForKeyEvent(keyboardEvent);
1770 }
1771
1772 #if ENABLE(GESTURE_EVENTS)
1773 static bool handleGestureEvent(const WebGestureEvent& gestureEvent, Page* page)
1774 {
1775     Frame* frame = page->mainFrame();
1776     if (!frame->view())
1777         return false;
1778
1779     PlatformGestureEvent platformGestureEvent = platform(gestureEvent);
1780     return frame->eventHandler()->handleGestureEvent(platformGestureEvent);
1781 }
1782
1783 void WebPage::gestureEvent(const WebGestureEvent& gestureEvent)
1784 {
1785     CurrentEvent currentEvent(gestureEvent);
1786
1787     bool handled = handleGestureEvent(gestureEvent, m_page.get());
1788     send(Messages::WebPageProxy::DidReceiveEvent(static_cast<uint32_t>(gestureEvent.type()), handled));
1789 }
1790 #endif
1791
1792 void WebPage::validateCommand(const String& commandName, uint64_t callbackID)
1793 {
1794     bool isEnabled = false;
1795     int32_t state = 0;
1796     Frame* frame = m_page->focusController()->focusedOrMainFrame();
1797     if (frame) {
1798         Editor::Command command = frame->editor()->command(commandName);
1799         state = command.state();
1800         isEnabled = command.isSupported() && command.isEnabled();
1801     }
1802
1803     send(Messages::WebPageProxy::ValidateCommandCallback(commandName, isEnabled, state, callbackID));
1804 }
1805
1806 void WebPage::executeEditCommand(const String& commandName)
1807 {
1808     executeEditingCommand(commandName, String());
1809 }
1810
1811 uint64_t WebPage::restoreSession(const SessionState& sessionState)
1812 {
1813     const BackForwardListItemVector& list = sessionState.list();
1814     size_t size = list.size();
1815     uint64_t currentItemID = 0;
1816     for (size_t i = 0; i < size; ++i) {
1817         WebBackForwardListItem* webItem = list[i].get();
1818         DecoderAdapter decoder(webItem->backForwardData().data(), webItem->backForwardData().size());
1819
1820         RefPtr<HistoryItem> item = HistoryItem::decodeBackForwardTree(webItem->url(), webItem->title(), webItem->originalURL(), decoder);
1821         if (!item) {
1822             LOG_ERROR("Failed to decode a HistoryItem from session state data.");
1823             return 0;
1824         }
1825
1826         if (i == sessionState.currentIndex())
1827             currentItemID = webItem->itemID();
1828
1829         WebBackForwardListProxy::addItemFromUIProcess(list[i]->itemID(), item.release());
1830     }
1831     ASSERT(currentItemID);
1832     return currentItemID;
1833 }
1834
1835 void WebPage::restoreSessionAndNavigateToCurrentItem(const SessionState& sessionState)
1836 {
1837     if (uint64_t currentItemID = restoreSession(sessionState))
1838         goToBackForwardItem(currentItemID);
1839 }
1840
1841 #if ENABLE(TOUCH_EVENTS)
1842 #if PLATFORM(QT)
1843 void WebPage::highlightPotentialActivation(const IntPoint& point, const IntSize& area)
1844 {
1845     if (point == IntPoint::zero()) {
1846         // An empty point deactivates the highlighting.
1847         tapHighlightController().hideHighlight();
1848     } else {
1849         Frame* mainframe = m_page->mainFrame();
1850         Node* activationNode = 0;
1851         Node* adjustedNode = 0;
1852         IntPoint adjustedPoint;
1853
1854 #if ENABLE(TOUCH_ADJUSTMENT)
1855         if (!mainframe->eventHandler()->bestClickableNodeForTouchPoint(point, IntSize(area.width() / 2, area.height() / 2), adjustedPoint, adjustedNode))
1856             return;
1857
1858 #else
1859         HitTestResult result = mainframe->eventHandler()->hitTestResultAtPoint(mainframe->view()->windowToContents(point), /*allowShadowContent*/ false, /*ignoreClipping*/ true);
1860         adjustedNode = result.innerNode();
1861 #endif
1862         // Find the node to highlight. This is not the same as the node responding the tap gesture, because many
1863         // pages has a global click handler and we do not want to highlight the body.
1864         // Instead find the enclosing link or focusable element, or the last enclosing inline element.
1865         for (Node* node = adjustedNode; node; node = node->parentOrHostNode()) {
1866             if (node->isMouseFocusable() || node->isLink()) {
1867                 activationNode = node;
1868                 break;
1869             }
1870             if (node->renderer() && node->renderer()->isInline())
1871                 activationNode = node;
1872             else if (activationNode)
1873                 break;
1874         }
1875
1876         if (activationNode)
1877             tapHighlightController().highlight(activationNode);
1878     }
1879 }
1880 #endif
1881
1882 static bool handleTouchEvent(const WebTouchEvent& touchEvent, Page* page)
1883 {
1884     Frame* frame = page->mainFrame();
1885     if (!frame->view())
1886         return false;
1887
1888     return frame->eventHandler()->handleTouchEvent(platform(touchEvent));
1889 }
1890
1891 void WebPage::touchEvent(const WebTouchEvent& touchEvent)
1892 {
1893     CurrentEvent currentEvent(touchEvent);
1894
1895     bool handled = handleTouchEvent(touchEvent, m_page.get());
1896
1897 #if ENABLE(TIZEN_CSS_OVERFLOW_SCROLL_ACCELERATION)
1898     static bool checkOverflow = false;
1899     if (touchEvent.type() == WebEvent::TouchStart && touchEvent.touchPoints().size() == 1) {
1900         checkOverflow = true;
1901     } else if (checkOverflow && touchEvent.type() == WebEvent::TouchMove && touchEvent.touchPoints().size() == 1) {
1902         bool pressed = false;
1903         uint32_t id = 0;
1904 #if ENABLE(TIZEN_CSS_OVERFLOW_SCROLL_ACCELERATION_ON_UI_SIDE)
1905         setPressedNodeAtPoint(touchEvent.touchPoints()[0].position(), true, pressed, id);
1906 #else
1907         setPressedNodeAtPoint(touchEvent.touchPoints()[0].position(), false, pressed, id);
1908 #endif
1909         send(Messages::WebPageProxy::SetOverflowResult(pressed, id));
1910         checkOverflow = false;
1911     }
1912 #endif
1913     send(Messages::WebPageProxy::DidReceiveEvent(static_cast<uint32_t>(touchEvent.type()), handled));
1914 }
1915
1916 void WebPage::touchEventSyncForTesting(const WebTouchEvent& touchEvent, bool& handled)
1917 {
1918     CurrentEvent currentEvent(touchEvent);
1919     handled = handleTouchEvent(touchEvent, m_page.get());
1920 }
1921 #endif
1922
1923 void WebPage::scroll(Page* page, ScrollDirection direction, ScrollGranularity granularity)
1924 {
1925     page->focusController()->focusedOrMainFrame()->eventHandler()->scrollRecursively(direction, granularity);
1926 }
1927
1928 void WebPage::logicalScroll(Page* page, ScrollLogicalDirection direction, ScrollGranularity granularity)
1929 {
1930     page->focusController()->focusedOrMainFrame()->eventHandler()->logicalScrollRecursively(direction, granularity);
1931 }
1932
1933 void WebPage::scrollBy(uint32_t scrollDirection, uint32_t scrollGranularity)
1934 {
1935     scroll(m_page.get(), static_cast<ScrollDirection>(scrollDirection), static_cast<ScrollGranularity>(scrollGranularity));
1936 }
1937
1938 void WebPage::centerSelectionInVisibleArea()
1939 {
1940     Frame* frame = m_page->focusController()->focusedOrMainFrame();
1941     if (!frame)
1942         return;
1943
1944     frame->selection()->revealSelection(ScrollAlignment::alignCenterAlways);
1945     m_findController.showFindIndicatorInSelection();
1946 }
1947
1948 void WebPage::setActive(bool isActive)
1949 {
1950     m_page->focusController()->setActive(isActive);
1951
1952 #if PLATFORM(MAC)
1953     // Tell all our plug-in views that the window focus changed.
1954     for (HashSet<PluginView*>::const_iterator it = m_pluginViews.begin(), end = m_pluginViews.end(); it != end; ++it)
1955         (*it)->setWindowIsFocused(isActive);
1956 #endif
1957 }
1958
1959 void WebPage::setDrawsBackground(bool drawsBackground)
1960 {
1961     if (m_drawsBackground == drawsBackground)
1962         return;
1963
1964     m_drawsBackground = drawsBackground;
1965
1966     for (Frame* coreFrame = m_mainFrame->coreFrame(); coreFrame; coreFrame = coreFrame->tree()->traverseNext()) {
1967         if (FrameView* view = coreFrame->view())
1968             view->setTransparent(!drawsBackground);
1969     }
1970
1971     m_drawingArea->pageBackgroundTransparencyChanged();
1972     m_drawingArea->setNeedsDisplay(IntRect(IntPoint(0, 0), m_viewSize));
1973 }
1974
1975 void WebPage::setDrawsTransparentBackground(bool drawsTransparentBackground)
1976 {
1977     if (m_drawsTransparentBackground == drawsTransparentBackground)
1978         return;
1979
1980     m_drawsTransparentBackground = drawsTransparentBackground;
1981
1982     Color backgroundColor = drawsTransparentBackground ? Color::transparent : Color::white;
1983     for (Frame* coreFrame = m_mainFrame->coreFrame(); coreFrame; coreFrame = coreFrame->tree()->traverseNext()) {
1984         if (FrameView* view = coreFrame->view())
1985             view->setBaseBackgroundColor(backgroundColor);
1986     }
1987
1988     m_drawingArea->pageBackgroundTransparencyChanged();
1989     m_drawingArea->setNeedsDisplay(IntRect(IntPoint(0, 0), m_viewSize));
1990 }
1991
1992 void WebPage::viewWillStartLiveResize()
1993 {
1994     if (!m_page)
1995         return;
1996
1997     // FIXME: This should propagate to all ScrollableAreas.
1998     if (Frame* frame = m_page->focusController()->focusedOrMainFrame()) {
1999         if (FrameView* view = frame->view())
2000             view->willStartLiveResize();
2001     }
2002 }
2003
2004 void WebPage::viewWillEndLiveResize()
2005 {
2006     if (!m_page)
2007         return;
2008
2009     // FIXME: This should propagate to all ScrollableAreas.
2010     if (Frame* frame = m_page->focusController()->focusedOrMainFrame()) {
2011         if (FrameView* view = frame->view())
2012             view->willEndLiveResize();
2013     }
2014 }
2015
2016 void WebPage::setFocused(bool isFocused)
2017 {
2018     m_page->focusController()->setFocused(isFocused);
2019 }
2020
2021 void WebPage::setInitialFocus(bool forward, bool isKeyboardEventValid, const WebKeyboardEvent& event)
2022 {
2023     if (!m_page || !m_page->focusController())
2024         return;
2025
2026     Frame* frame = m_page->focusController()->focusedOrMainFrame();
2027     frame->document()->setFocusedNode(0);
2028
2029     if (isKeyboardEventValid && event.type() == WebEvent::KeyDown) {
2030         PlatformKeyboardEvent platformEvent(platform(event));
2031         platformEvent.disambiguateKeyDownEvent(PlatformEvent::RawKeyDown);
2032         m_page->focusController()->setInitialFocus(forward ? FocusDirectionForward : FocusDirectionBackward, KeyboardEvent::create(platformEvent, frame->document()->defaultView()).get());
2033         return;
2034     }
2035
2036     m_page->focusController()->setInitialFocus(forward ? FocusDirectionForward : FocusDirectionBackward, 0);
2037 }
2038
2039 void WebPage::setWindowResizerSize(const IntSize& windowResizerSize)
2040 {
2041     if (m_windowResizerSize == windowResizerSize)
2042         return;
2043
2044     m_windowResizerSize = windowResizerSize;
2045
2046     for (Frame* coreFrame = m_mainFrame->coreFrame(); coreFrame; coreFrame = coreFrame->tree()->traverseNext()) {
2047         FrameView* view = coreFrame->view();
2048         if (view)
2049             view->windowResizerRectChanged();
2050     }
2051 }
2052
2053 void WebPage::setCanStartMediaTimerFired()
2054 {
2055     if (m_page)
2056         m_page->setCanStartMedia(true);
2057 }
2058
2059 void WebPage::setIsInWindow(bool isInWindow)
2060 {
2061     if (!isInWindow) {
2062         m_setCanStartMediaTimer.stop();
2063         m_page->setCanStartMedia(false);
2064         m_page->willMoveOffscreen();
2065     } else {
2066         // Defer the call to Page::setCanStartMedia() since it ends up sending a syncrhonous messages to the UI process
2067         // in order to get plug-in connections, and the UI process will be waiting for the Web process to update the backing
2068         // store after moving the view into a window, until it times out and paints white. See <rdar://problem/9242771>.
2069         m_setCanStartMediaTimer.startOneShot(0);
2070         m_page->didMoveOnscreen();
2071     }
2072 }
2073
2074 void WebPage::didReceivePolicyDecision(uint64_t frameID, uint64_t listenerID, uint32_t policyAction, uint64_t downloadID)
2075 {
2076     WebFrame* frame = WebProcess::shared().webFrame(frameID);
2077     if (!frame)
2078         return;
2079     frame->didReceivePolicyDecision(listenerID, static_cast<PolicyAction>(policyAction), downloadID);
2080 }
2081
2082 void WebPage::show()
2083 {
2084     send(Messages::WebPageProxy::ShowPage());
2085 }
2086
2087 void WebPage::setUserAgent(const String& userAgent)
2088 {
2089     m_userAgent = userAgent;
2090 }
2091 #if ENABLE(TIZEN_CUSTOM_HEADERS)
2092 void WebPage::addCustomHeader(const String& name, const String& value)
2093 {
2094     m_customHeaders.add(name, value);
2095 }
2096
2097 void WebPage::removeCustomHeader(const String& name)
2098 {
2099     m_customHeaders.remove(name);
2100 }
2101
2102 void WebPage::clearCustomHeaders()
2103 {
2104     m_customHeaders.clear();
2105 }
2106
2107 WebCore::HTTPHeaderMap WebPage::customHeaders()
2108 {
2109     return m_customHeaders;
2110 }
2111 #endif
2112
2113 void WebPage::suspendActiveDOMObjectsAndAnimations()
2114 {
2115     m_page->suspendActiveDOMObjectsAndAnimations();
2116 }
2117
2118 void WebPage::resumeActiveDOMObjectsAndAnimations()
2119 {
2120     m_page->resumeActiveDOMObjectsAndAnimations();
2121
2122     // We need to repaint on resume to kickstart animated painting again.
2123     m_drawingArea->setNeedsDisplay(IntRect(IntPoint(0, 0), m_viewSize));
2124 }
2125
2126 IntPoint WebPage::screenToWindow(const IntPoint& point)
2127 {
2128     IntPoint windowPoint;
2129     sendSync(Messages::WebPageProxy::ScreenToWindow(point), Messages::WebPageProxy::ScreenToWindow::Reply(windowPoint));
2130     return windowPoint;
2131 }
2132
2133 IntRect WebPage::windowToScreen(const IntRect& rect)
2134 {
2135     IntRect screenRect;
2136     sendSync(Messages::WebPageProxy::WindowToScreen(rect), Messages::WebPageProxy::WindowToScreen::Reply(screenRect));
2137     return screenRect;
2138 }
2139
2140 IntRect WebPage::windowResizerRect() const
2141 {
2142     if (m_windowResizerSize.isEmpty())
2143         return IntRect();
2144
2145     IntSize frameViewSize;
2146     if (Frame* coreFrame = m_mainFrame->coreFrame()) {
2147         if (FrameView* view = coreFrame->view())
2148             frameViewSize = view->size();
2149     }
2150
2151     return IntRect(frameViewSize.width() - m_windowResizerSize.width(), frameViewSize.height() - m_windowResizerSize.height(),
2152                    m_windowResizerSize.width(), m_windowResizerSize.height());
2153 }
2154
2155 KeyboardUIMode WebPage::keyboardUIMode()
2156 {
2157     bool fullKeyboardAccessEnabled = WebProcess::shared().fullKeyboardAccessEnabled();
2158     return static_cast<KeyboardUIMode>((fullKeyboardAccessEnabled ? KeyboardAccessFull : KeyboardAccessDefault) | (m_tabToLinks ? KeyboardAccessTabsToLinks : 0));
2159 }
2160
2161 void WebPage::runJavaScriptInMainFrame(const String& script, uint64_t callbackID)
2162 {
2163     // NOTE: We need to be careful when running scripts that the objects we depend on don't
2164     // disappear during script execution.
2165
2166     // Retain the SerializedScriptValue at this level so it (and the internal data) lives
2167     // long enough for the DataReference to be encoded by the sent message.
2168     RefPtr<SerializedScriptValue> serializedResultValue;
2169     CoreIPC::DataReference dataReference;
2170
2171     JSLockHolder lock(JSDOMWindow::commonJSGlobalData());
2172     if (JSValue resultValue = m_mainFrame->coreFrame()->script()->executeScript(script, true).jsValue()) {
2173         if ((serializedResultValue = SerializedScriptValue::create(m_mainFrame->jsContext(), toRef(m_mainFrame->coreFrame()->script()->globalObject(mainThreadNormalWorld())->globalExec(), resultValue), 0)))
2174             dataReference = serializedResultValue->data();
2175     }
2176
2177     send(Messages::WebPageProxy::ScriptValueCallback(dataReference, callbackID));
2178 }
2179
2180 void WebPage::getContentsAsString(uint64_t callbackID)
2181 {
2182     String resultString = m_mainFrame->contentsAsString();
2183     send(Messages::WebPageProxy::StringCallback(resultString, callbackID));
2184 }
2185
2186 #if ENABLE(MHTML)
2187 void WebPage::getContentsAsMHTMLData(uint64_t callbackID, bool useBinaryEncoding)
2188 {
2189     CoreIPC::DataReference dataReference;
2190
2191     RefPtr<SharedBuffer> buffer = useBinaryEncoding
2192         ? MHTMLArchive::generateMHTMLDataUsingBinaryEncoding(m_page.get())
2193         : MHTMLArchive::generateMHTMLData(m_page.get());
2194
2195     if (buffer)
2196         dataReference = CoreIPC::DataReference(reinterpret_cast<const uint8_t*>(buffer->data()), buffer->size());
2197
2198     send(Messages::WebPageProxy::DataCallback(dataReference, callbackID));
2199 }
2200 #endif
2201
2202 void WebPage::getRenderTreeExternalRepresentation(uint64_t callbackID)
2203 {
2204     String resultString = renderTreeExternalRepresentation();
2205     send(Messages::WebPageProxy::StringCallback(resultString, callbackID));
2206 }
2207
2208 void WebPage::getSelectionOrContentsAsString(uint64_t callbackID)
2209 {
2210     String resultString = m_mainFrame->selectionAsString();
2211     if (resultString.isEmpty())
2212         resultString = m_mainFrame->contentsAsString();
2213     send(Messages::WebPageProxy::StringCallback(resultString, callbackID));
2214 }
2215
2216 void WebPage::getSourceForFrame(uint64_t frameID, uint64_t callbackID)
2217 {
2218     String resultString;
2219     if (WebFrame* frame = WebProcess::shared().webFrame(frameID))
2220        resultString = frame->source();
2221
2222     send(Messages::WebPageProxy::StringCallback(resultString, callbackID));
2223 }
2224
2225 void WebPage::getMainResourceDataOfFrame(uint64_t frameID, uint64_t callbackID)
2226 {
2227     CoreIPC::DataReference dataReference;
2228
2229     RefPtr<SharedBuffer> buffer;
2230     if (WebFrame* frame = WebProcess::shared().webFrame(frameID)) {
2231         if (DocumentLoader* loader = frame->coreFrame()->loader()->documentLoader()) {
2232             if ((buffer = loader->mainResourceData()))
2233                 dataReference = CoreIPC::DataReference(reinterpret_cast<const uint8_t*>(buffer->data()), buffer->size());
2234         }
2235     }
2236
2237     send(Messages::WebPageProxy::DataCallback(dataReference, callbackID));
2238 }
2239
2240 static PassRefPtr<SharedBuffer> resourceDataForFrame(Frame* frame, const KURL& resourceURL)
2241 {
2242     DocumentLoader* loader = frame->loader()->documentLoader();
2243     if (!loader)
2244         return 0;
2245
2246     RefPtr<ArchiveResource> subresource = loader->subresource(resourceURL);
2247     if (!subresource)
2248         return 0;
2249
2250     return subresource->data();
2251 }
2252
2253 void WebPage::getResourceDataFromFrame(uint64_t frameID, const String& resourceURLString, uint64_t callbackID)
2254 {
2255     CoreIPC::DataReference dataReference;
2256     KURL resourceURL(KURL(), resourceURLString);
2257
2258     RefPtr<SharedBuffer> buffer;
2259     if (WebFrame* frame = WebProcess::shared().webFrame(frameID)) {
2260         buffer = resourceDataForFrame(frame->coreFrame(), resourceURL);
2261         if (!buffer) {
2262             // Try to get the resource data from the cache.
2263             buffer = cachedResponseDataForURL(resourceURL);
2264         }
2265
2266         if (buffer)
2267             dataReference = CoreIPC::DataReference(reinterpret_cast<const uint8_t*>(buffer->data()), buffer->size());
2268     }
2269
2270     send(Messages::WebPageProxy::DataCallback(dataReference, callbackID));
2271 }
2272
2273 void WebPage::getWebArchiveOfFrame(uint64_t frameID, uint64_t callbackID)
2274 {
2275     CoreIPC::DataReference dataReference;
2276
2277 #if PLATFORM(MAC) || PLATFORM(WIN)
2278     RetainPtr<CFDataRef> data;
2279     if (WebFrame* frame = WebProcess::shared().webFrame(frameID)) {
2280         if ((data = frame->webArchiveData(0, 0)))
2281             dataReference = CoreIPC::DataReference(CFDataGetBytePtr(data.get()), CFDataGetLength(data.get()));
2282     }
2283 #endif
2284
2285     send(Messages::WebPageProxy::DataCallback(dataReference, callbackID));
2286 }
2287
2288 void WebPage::forceRepaintWithoutCallback()
2289 {
2290     m_drawingArea->forceRepaint();
2291 }
2292
2293 void WebPage::forceRepaint(uint64_t callbackID)
2294 {
2295     if (m_drawingArea->forceRepaintAsync(callbackID))
2296         return;
2297
2298     forceRepaintWithoutCallback();
2299     send(Messages::WebPageProxy::VoidCallback(callbackID));
2300 }
2301
2302 #if ENABLE(WEB_INTENTS)
2303 void WebPage::deliverIntentToFrame(uint64_t frameID, const IntentData& intentData)
2304 {
2305     WebFrame* frame = WebProcess::shared().webFrame(frameID);
2306     if (!frame)
2307         return;
2308
2309     frame->deliverIntent(intentData);
2310 }
2311 #endif
2312
2313 void WebPage::preferencesDidChange(const WebPreferencesStore& store)
2314 {
2315     WebPreferencesStore::removeTestRunnerOverrides();
2316     updatePreferences(store);
2317 }
2318
2319 void WebPage::updatePreferences(const WebPreferencesStore& store)
2320 {
2321     Settings* settings = m_page->settings();
2322
2323     m_tabToLinks = store.getBoolValueForKey(WebPreferencesKey::tabsToLinksKey());
2324
2325     // FIXME: This should be generated from macro expansion for all preferences,
2326     // but we currently don't match the naming of WebCore exactly so we are
2327     // handrolling the boolean and integer preferences until that is fixed.
2328
2329 #define INITIALIZE_SETTINGS(KeyUpper, KeyLower, TypeName, Type, DefaultValue) settings->set##KeyUpper(store.get##TypeName##ValueForKey(WebPreferencesKey::KeyLower##Key()));
2330
2331     FOR_EACH_WEBKIT_STRING_PREFERENCE(INITIALIZE_SETTINGS)
2332
2333 #undef INITIALIZE_SETTINGS
2334
2335     settings->setScriptEnabled(store.getBoolValueForKey(WebPreferencesKey::javaScriptEnabledKey()));
2336     settings->setLoadsImagesAutomatically(store.getBoolValueForKey(WebPreferencesKey::loadsImagesAutomaticallyKey()));
2337     settings->setLoadsSiteIconsIgnoringImageLoadingSetting(store.getBoolValueForKey(WebPreferencesKey::loadsSiteIconsIgnoringImageLoadingPreferenceKey()));
2338     settings->setPluginsEnabled(store.getBoolValueForKey(WebPreferencesKey::pluginsEnabledKey()));
2339     settings->setJavaEnabled(store.getBoolValueForKey(WebPreferencesKey::javaEnabledKey()));
2340     settings->setJavaEnabledForLocalFiles(store.getBoolValueForKey(WebPreferencesKey::javaEnabledForLocalFilesKey()));
2341     settings->setOfflineWebApplicationCacheEnabled(store.getBoolValueForKey(WebPreferencesKey::offlineWebApplicationCacheEnabledKey()));
2342     settings->setLocalStorageEnabled(store.getBoolValueForKey(WebPreferencesKey::localStorageEnabledKey()));
2343     settings->setXSSAuditorEnabled(store.getBoolValueForKey(WebPreferencesKey::xssAuditorEnabledKey()));
2344     settings->setFrameFlatteningEnabled(store.getBoolValueForKey(WebPreferencesKey::frameFlatteningEnabledKey()));
2345     settings->setPrivateBrowsingEnabled(store.getBoolValueForKey(WebPreferencesKey::privateBrowsingEnabledKey()));
2346     settings->setDeveloperExtrasEnabled(store.getBoolValueForKey(WebPreferencesKey::developerExtrasEnabledKey()));
2347     settings->setJavaScriptExperimentsEnabled(store.getBoolValueForKey(WebPreferencesKey::javaScriptExperimentsEnabledKey()));
2348     settings->setTextAreasAreResizable(store.getBoolValueForKey(WebPreferencesKey::textAreasAreResizableKey()));
2349     settings->setNeedsSiteSpecificQuirks(store.getBoolValueForKey(WebPreferencesKey::needsSiteSpecificQuirksKey()));
2350     settings->setJavaScriptCanOpenWindowsAutomatically(store.getBoolValueForKey(WebPreferencesKey::javaScriptCanOpenWindowsAutomaticallyKey()));
2351     settings->setForceFTPDirectoryListings(store.getBoolValueForKey(WebPreferencesKey::forceFTPDirectoryListingsKey()));
2352     settings->setDNSPrefetchingEnabled(store.getBoolValueForKey(WebPreferencesKey::dnsPrefetchingEnabledKey()));
2353 #if ENABLE(WEB_ARCHIVE)
2354     settings->setWebArchiveDebugModeEnabled(store.getBoolValueForKey(WebPreferencesKey::webArchiveDebugModeEnabledKey()));
2355 #endif
2356     settings->setLocalFileContentSniffingEnabled(store.getBoolValueForKey(WebPreferencesKey::localFileContentSniffingEnabledKey()));
2357     settings->setUsesPageCache(store.getBoolValueForKey(WebPreferencesKey::usesPageCacheKey()));
2358     settings->setPageCacheSupportsPlugins(store.getBoolValueForKey(WebPreferencesKey::pageCacheSupportsPluginsKey()));
2359     settings->setAuthorAndUserStylesEnabled(store.getBoolValueForKey(WebPreferencesKey::authorAndUserStylesEnabledKey()));
2360     settings->setPaginateDuringLayoutEnabled(store.getBoolValueForKey(WebPreferencesKey::paginateDuringLayoutEnabledKey()));
2361     settings->setDOMPasteAllowed(store.getBoolValueForKey(WebPreferencesKey::domPasteAllowedKey()));
2362     settings->setJavaScriptCanAccessClipboard(store.getBoolValueForKey(WebPreferencesKey::javaScriptCanAccessClipboardKey()));
2363     settings->setShouldPrintBackgrounds(store.getBoolValueForKey(WebPreferencesKey::shouldPrintBackgroundsKey()));
2364     settings->setWebSecurityEnabled(store.getBoolValueForKey(WebPreferencesKey::webSecurityEnabledKey()));
2365     settings->setAllowUniversalAccessFromFileURLs(store.getBoolValueForKey(WebPreferencesKey::allowUniversalAccessFromFileURLsKey()));
2366     settings->setAllowFileAccessFromFileURLs(store.getBoolValueForKey(WebPreferencesKey::allowFileAccessFromFileURLsKey()));
2367
2368     settings->setMinimumFontSize(store.getUInt32ValueForKey(WebPreferencesKey::minimumFontSizeKey()));
2369     settings->setMinimumLogicalFontSize(store.getUInt32ValueForKey(WebPreferencesKey::minimumLogicalFontSizeKey()));
2370     settings->setDefaultFontSize(store.getUInt32ValueForKey(WebPreferencesKey::defaultFontSizeKey()));
2371     settings->setDefaultFixedFontSize(store.getUInt32ValueForKey(WebPreferencesKey::defaultFixedFontSizeKey()));
2372     settings->setLayoutFallbackWidth(store.getUInt32ValueForKey(WebPreferencesKey::layoutFallbackWidthKey()));
2373     settings->setDeviceWidth(store.getUInt32ValueForKey(WebPreferencesKey::deviceWidthKey()));
2374     settings->setDeviceHeight(store.getUInt32ValueForKey(WebPreferencesKey::deviceHeightKey()));
2375     settings->setEditableLinkBehavior(static_cast<WebCore::EditableLinkBehavior>(store.getUInt32ValueForKey(WebPreferencesKey::editableLinkBehaviorKey())));
2376     settings->setShowsToolTipOverTruncatedText(store.getBoolValueForKey(WebPreferencesKey::showsToolTipOverTruncatedTextKey()));
2377
2378     settings->setAcceleratedCompositingEnabled(store.getBoolValueForKey(WebPreferencesKey::acceleratedCompositingEnabledKey()) && LayerTreeHost::supportsAcceleratedCompositing());
2379     settings->setAcceleratedDrawingEnabled(store.getBoolValueForKey(WebPreferencesKey::acceleratedDrawingEnabledKey()) && LayerTreeHost::supportsAcceleratedCompositing());
2380     settings->setCanvasUsesAcceleratedDrawing(store.getBoolValueForKey(WebPreferencesKey::canvasUsesAcceleratedDrawingKey()) && LayerTreeHost::supportsAcceleratedCompositing());
2381     settings->setShowDebugBorders(store.getBoolValueForKey(WebPreferencesKey::compositingBordersVisibleKey()));
2382     settings->setShowRepaintCounter(store.getBoolValueForKey(WebPreferencesKey::compositingRepaintCountersVisibleKey()));
2383     settings->setCSSCustomFilterEnabled(store.getBoolValueForKey(WebPreferencesKey::cssCustomFilterEnabledKey()));
2384     settings->setCSSRegionsEnabled(store.getBoolValueForKey(WebPreferencesKey::cssRegionsEnabledKey()));
2385     settings->setCSSGridLayoutEnabled(store.getBoolValueForKey(WebPreferencesKey::cssGridLayoutEnabledKey()));
2386     settings->setRegionBasedColumnsEnabled(store.getBoolValueForKey(WebPreferencesKey::regionBasedColumnsEnabledKey()));
2387     settings->setWebGLEnabled(store.getBoolValueForKey(WebPreferencesKey::webGLEnabledKey()));
2388     settings->setMediaPlaybackRequiresUserGesture(store.getBoolValueForKey(WebPreferencesKey::mediaPlaybackRequiresUserGestureKey()));
2389     settings->setMediaPlaybackAllowsInline(store.getBoolValueForKey(WebPreferencesKey::mediaPlaybackAllowsInlineKey()));
2390     settings->setMockScrollbarsEnabled(store.getBoolValueForKey(WebPreferencesKey::mockScrollbarsEnabledKey()));
2391     settings->setHyperlinkAuditingEnabled(store.getBoolValueForKey(WebPreferencesKey::hyperlinkAuditingEnabledKey()));
2392     settings->setRequestAnimationFrameEnabled(store.getBoolValueForKey(WebPreferencesKey::requestAnimationFrameEnabledKey()));
2393
2394     // <rdar://problem/10697417>: It is necessary to force compositing when accelerate drawing
2395     // is enabled on Mac so that scrollbars are always in their own layers.
2396 #if PLATFORM(MAC)
2397     if (settings->acceleratedDrawingEnabled())
2398         settings->setForceCompositingMode(LayerTreeHost::supportsAcceleratedCompositing());
2399     else
2400 #endif
2401         settings->setForceCompositingMode(store.getBoolValueForKey(WebPreferencesKey::forceCompositingModeKey()) && LayerTreeHost::supportsAcceleratedCompositing());
2402
2403 #if ENABLE(TIZEN_RUNTIME_BACKEND_SELECTION)
2404     if (!settings->acceleratedCompositingEnabled()) {
2405         settings->setAcceleratedCompositingFor3DTransformsEnabled(false);
2406         settings->setAcceleratedCompositingForVideoEnabled(false);
2407         settings->setAcceleratedCompositingForPluginsEnabled(false);
2408         settings->setAcceleratedCompositingForCanvasEnabled(false);
2409         settings->setAcceleratedCompositingForAnimationEnabled(false);
2410     }
2411 #endif
2412 #if ENABLE(TIZEN_WEBKIT2_MEMORY_SAVING_MODE)
2413     settings->setMemorySavingMode(WebProcess::shared().memorySavingModeEnabled());
2414 #endif
2415
2416 #if ENABLE(SQL_DATABASE)
2417     AbstractDatabase::setIsAvailable(store.getBoolValueForKey(WebPreferencesKey::databasesEnabledKey()));
2418 #endif
2419
2420 #if ENABLE(FULLSCREEN_API)
2421     settings->setFullScreenEnabled(store.getBoolValueForKey(WebPreferencesKey::fullScreenEnabledKey()));
2422 #endif
2423
2424 #if ENABLE(TIZEN_WEBKIT2_ASYNCHRONOUS_SPELLCHECKING)
2425     settings->setAsynchronousSpellCheckingEnabled(store.getBoolValueForKey(WebPreferencesKey::asynchronousSpellCheckingEnabledKey()));
2426 #endif
2427     settings->setLocalStorageDatabasePath(WebProcess::shared().localStorageDirectory());
2428
2429 #if USE(AVFOUNDATION)
2430     settings->setAVFoundationEnabled(store.getBoolValueForKey(WebPreferencesKey::isAVFoundationEnabledKey()));
2431 #endif
2432
2433 #if ENABLE(WEB_AUDIO)
2434     settings->setWebAudioEnabled(store.getBoolValueForKey(WebPreferencesKey::webAudioEnabledKey()));
2435 #endif
2436
2437     settings->setApplicationChromeMode(store.getBoolValueForKey(WebPreferencesKey::applicationChromeModeKey()));
2438     settings->setSuppressesIncrementalRendering(store.getBoolValueForKey(WebPreferencesKey::suppressesIncrementalRenderingKey()));
2439     settings->setBackspaceKeyNavigationEnabled(store.getBoolValueForKey(WebPreferencesKey::backspaceKeyNavigationEnabledKey()));
2440     settings->setWantsBalancedSetDefersLoadingBehavior(store.getBoolValueForKey(WebPreferencesKey::wantsBalancedSetDefersLoadingBehaviorKey()));
2441     settings->setCaretBrowsingEnabled(store.getBoolValueForKey(WebPreferencesKey::caretBrowsingEnabledKey()));
2442
2443 #if ENABLE(VIDEO_TRACK)
2444     settings->setShouldDisplaySubtitles(store.getBoolValueForKey(WebPreferencesKey::shouldDisplaySubtitlesKey()));
2445     settings->setShouldDisplayCaptions(store.getBoolValueForKey(WebPreferencesKey::shouldDisplayCaptionsKey()));
2446     settings->setShouldDisplayTextDescriptions(store.getBoolValueForKey(WebPreferencesKey::shouldDisplayTextDescriptionsKey()));
2447 #endif
2448
2449 #if ENABLE(NOTIFICATIONS) || ENABLE(LEGACY_NOTIFICATIONS)
2450     settings->setNotificationsEnabled(store.getBoolValueForKey(WebPreferencesKey::notificationsEnabledKey()));
2451 #endif
2452
2453     settings->setShouldRespectImageOrientation(store.getBoolValueForKey(WebPreferencesKey::shouldRespectImageOrientationKey()));
2454
2455 #if ENABLE(TIZEN_INDEXED_DATABASE)
2456     m_page->group().groupSettings()->setIndexedDBDatabasePath(WebProcess::shared().indexedDatabaseDirectory());
2457     m_page->group().groupSettings()->setIndexedDBQuotaBytes(0x6400000); //100M
2458 #endif
2459
2460     settings->setDiagnosticLoggingEnabled(store.getBoolValueForKey(WebPreferencesKey::diagnosticLoggingEnabledKey()));
2461
2462 #if ENABLE(TEXT_AUTOSIZING)
2463     settings->setTextAutosizingEnabled(store.getBoolValueForKey(WebPreferencesKey::textAutosizingEnabledKey()));
2464 #endif
2465
2466 #if ENABLE(TIZEN_FILE_SYSTEM)
2467     m_page->group().groupSettings()->setLocalFileSystemQuotaBytes(0x6400000); //100M
2468 #endif
2469
2470 #if ENABLE(TIZEN_WORKERS)
2471     m_page->group().groupSettings()->setAllowUniversalAccessFromFileURLs(settings->allowUniversalAccessFromFileURLs());
2472 #endif
2473
2474     platformPreferencesDidChange(store);
2475
2476     if (m_drawingArea)
2477         m_drawingArea->updatePreferences();
2478 }
2479
2480 #if ENABLE(INSPECTOR)
2481 WebInspector* WebPage::inspector()
2482 {
2483     if (m_isClosed)
2484         return 0;
2485     if (!m_inspector)
2486         m_inspector = WebInspector::create(this, m_inspectorClient);
2487     return m_inspector.get();
2488 }
2489 #endif
2490
2491 #if ENABLE(FULLSCREEN_API)
2492 WebFullScreenManager* WebPage::fullScreenManager()
2493 {
2494     if (!m_fullScreenManager)
2495         m_fullScreenManager = WebFullScreenManager::create(this);
2496     return m_fullScreenManager.get();
2497 }
2498 #endif
2499
2500 NotificationPermissionRequestManager* WebPage::notificationPermissionRequestManager()
2501 {
2502     if (m_notificationPermissionRequestManager)
2503         return m_notificationPermissionRequestManager.get();
2504
2505     m_notificationPermissionRequestManager = NotificationPermissionRequestManager::create(this);
2506     return m_notificationPermissionRequestManager.get();
2507 }
2508
2509 #if ENABLE(TIZEN_MEDIA_STREAM)
2510 UserMediaPermissionRequestManager* WebPage::userMediaPermissionRequestManager()
2511 {
2512     if (m_userMediaPermissionRequestManager)
2513         return m_userMediaPermissionRequestManager.get();
2514
2515     m_userMediaPermissionRequestManager = UserMediaPermissionRequestManager::create(this);
2516     return m_userMediaPermissionRequestManager.get();
2517 }
2518 #endif
2519
2520 #if !PLATFORM(GTK) && !PLATFORM(MAC)
2521 bool WebPage::handleEditingKeyboardEvent(KeyboardEvent* evt)
2522 {
2523     Node* node = evt->target()->toNode();
2524     ASSERT(node);
2525     Frame* frame = node->document()->frame();
2526     ASSERT(frame);
2527
2528     const PlatformKeyboardEvent* keyEvent = evt->keyEvent();
2529     if (!keyEvent)
2530         return false;
2531
2532     Editor::Command command = frame->editor()->command(interpretKeyEvent(evt));
2533
2534     if (keyEvent->type() == PlatformEvent::RawKeyDown) {
2535         // WebKit doesn't have enough information about mode to decide how commands that just insert text if executed via Editor should be treated,
2536         // so we leave it upon WebCore to either handle them immediately (e.g. Tab that changes focus) or let a keypress event be generated
2537         // (e.g. Tab that inserts a Tab character, or Enter).
2538         return !command.isTextInsertion() && command.execute(evt);
2539     }
2540
2541     if (command.execute(evt))
2542         return true;
2543
2544     // Don't allow text insertion for nodes that cannot edit.
2545     if (!frame->editor()->canEdit())
2546         return false;
2547
2548     // Don't insert null or control characters as they can result in unexpected behaviour
2549     if (evt->charCode() < ' ')
2550         return false;
2551
2552     return frame->editor()->insertText(evt->keyEvent()->text(), evt);
2553 }
2554 #endif
2555
2556 #if ENABLE(DRAG_SUPPORT)
2557
2558 #if PLATFORM(WIN)
2559 void WebPage::performDragControllerAction(uint64_t action, WebCore::IntPoint clientPosition, WebCore::IntPoint globalPosition, uint64_t draggingSourceOperationMask, const WebCore::DragDataMap& dataMap, uint32_t flags)
2560 {
2561     if (!m_page) {
2562         send(Messages::WebPageProxy::DidPerformDragControllerAction(WebCore::DragSession()));
2563         return;
2564     }
2565
2566     DragData dragData(dataMap, clientPosition, globalPosition, static_cast<DragOperation>(draggingSourceOperationMask), static_cast<DragApplicationFlags>(flags));
2567     switch (action) {
2568     case DragControllerActionEntered:
2569         send(Messages::WebPageProxy::DidPerformDragControllerAction(m_page->dragController()->dragEntered(&dragData)));
2570         break;
2571
2572     case DragControllerActionUpdated:
2573         send(Messages::WebPageProxy::DidPerformDragControllerAction(m_page->dragController()->dragUpdated(&dragData)));
2574         break;
2575
2576     case DragControllerActionExited:
2577         m_page->dragController()->dragExited(&dragData);
2578         break;
2579
2580     case DragControllerActionPerformDrag:
2581         m_page->dragController()->performDrag(&dragData);
2582         break;
2583
2584     default:
2585         ASSERT_NOT_REACHED();
2586     }
2587 }
2588
2589 #elif PLATFORM(QT) || PLATFORM(GTK) || ENABLE(TIZEN_DRAG_SUPPORT)
2590 void WebPage::performDragControllerAction(uint64_t action, WebCore::DragData dragData)
2591 {
2592     if (!m_page) {
2593         send(Messages::WebPageProxy::DidPerformDragControllerAction(WebCore::DragSession()));
2594 #if PLATFORM(QT)
2595         QMimeData* data = const_cast<QMimeData*>(dragData.platformData());
2596         delete data;
2597 #elif PLATFORM(GTK)
2598         DataObjectGtk* data = const_cast<DataObjectGtk*>(dragData.platformData());
2599         data->deref();
2600 #endif
2601 #if ENABLE(TIZEN_DRAG_SUPPORT)
2602         DataObjectTizen* data = const_cast<DataObjectTizen*>(dragData.platformData());
2603         data->deref();
2604 #endif
2605         return;
2606     }
2607
2608     switch (action) {
2609     case DragControllerActionEntered:
2610         send(Messages::WebPageProxy::DidPerformDragControllerAction(m_page->dragController()->dragEntered(&dragData)));
2611         break;
2612
2613     case DragControllerActionUpdated:
2614         send(Messages::WebPageProxy::DidPerformDragControllerAction(m_page->dragController()->dragUpdated(&dragData)));
2615         break;
2616
2617     case DragControllerActionExited:
2618         m_page->dragController()->dragExited(&dragData);
2619         break;
2620
2621     case DragControllerActionPerformDrag: {
2622         m_page->dragController()->performDrag(&dragData);
2623         break;
2624     }
2625
2626     default:
2627         ASSERT_NOT_REACHED();
2628     }
2629     // DragData does not delete its platformData so we need to do that here.
2630 #if PLATFORM(QT)
2631     QMimeData* data = const_cast<QMimeData*>(dragData.platformData());
2632     delete data;
2633 #elif PLATFORM(GTK)
2634     DataObjectGtk* data = const_cast<DataObjectGtk*>(dragData.platformData());
2635     data->deref();
2636 #endif
2637 #if ENABLE(TIZEN_DRAG_SUPPORT)
2638     DataObjectTizen* data = const_cast<DataObjectTizen*>(dragData.platformData());
2639     data->deref();
2640 #endif
2641 }
2642
2643 #else
2644 void WebPage::performDragControllerAction(uint64_t action, WebCore::IntPoint clientPosition, WebCore::IntPoint globalPosition, uint64_t draggingSourceOperationMask, const String& dragStorageName, uint32_t flags, const SandboxExtension::Handle& sandboxExtensionHandle, const SandboxExtension::HandleArray& sandboxExtensionsHandleArray)
2645 {
2646     if (!m_page) {
2647         send(Messages::WebPageProxy::DidPerformDragControllerAction(WebCore::DragSession()));
2648         return;
2649     }
2650
2651     DragData dragData(dragStorageName, clientPosition, globalPosition, static_cast<DragOperation>(draggingSourceOperationMask), static_cast<DragApplicationFlags>(flags));
2652     switch (action) {
2653     case DragControllerActionEntered:
2654         send(Messages::WebPageProxy::DidPerformDragControllerAction(m_page->dragController()->dragEntered(&dragData)));
2655         break;
2656
2657     case DragControllerActionUpdated:
2658         send(Messages::WebPageProxy::DidPerformDragControllerAction(m_page->dragController()->dragUpdated(&dragData)));
2659         break;
2660
2661     case DragControllerActionExited:
2662         m_page->dragController()->dragExited(&dragData);
2663         break;
2664
2665     case DragControllerActionPerformDrag: {
2666         ASSERT(!m_pendingDropSandboxExtension);
2667
2668         m_pendingDropSandboxExtension = SandboxExtension::create(sandboxExtensionHandle);
2669         for (size_t i = 0; i < sandboxExtensionsHandleArray.size(); i++) {
2670             if (RefPtr<SandboxExtension> extension = SandboxExtension::create(sandboxExtensionsHandleArray[i]))
2671                 m_pendingDropExtensionsForFileUpload.append(extension);
2672         }
2673
2674         m_page->dragController()->performDrag(&dragData);
2675
2676         // If we started loading a local file, the sandbox extension tracker would have adopted this
2677         // pending drop sandbox extension. If not, we'll play it safe and invalidate it.
2678         if (m_pendingDropSandboxExtension) {
2679             m_pendingDropSandboxExtension->invalidate();
2680             m_pendingDropSandboxExtension = nullptr;
2681         }
2682         for (size_t i = 0; i < m_pendingDropExtensionsForFileUpload.size(); i++)
2683             m_pendingDropExtensionsForFileUpload[i]->invalidate();
2684
2685         m_pendingDropExtensionsForFileUpload.clear();
2686         break;
2687     }
2688
2689     default:
2690         ASSERT_NOT_REACHED();
2691     }
2692 }
2693 #endif
2694
2695 void WebPage::dragEnded(WebCore::IntPoint clientPosition, WebCore::IntPoint globalPosition, uint64_t operation)
2696 {
2697     IntPoint adjustedClientPosition(clientPosition.x() + m_page->dragController()->dragOffset().x(), clientPosition.y() + m_page->dragController()->dragOffset().y());
2698     IntPoint adjustedGlobalPosition(globalPosition.x() + m_page->dragController()->dragOffset().x(), globalPosition.y() + m_page->dragController()->dragOffset().y());
2699
2700     m_page->dragController()->dragEnded();
2701     FrameView* view = m_page->mainFrame()->view();
2702     if (!view)
2703         return;
2704     // FIXME: These are fake modifier keys here, but they should be real ones instead.
2705     PlatformMouseEvent event(adjustedClientPosition, adjustedGlobalPosition, LeftButton, PlatformEvent::MouseMoved, 0, false, false, false, false, currentTime());
2706     m_page->mainFrame()->eventHandler()->dragSourceEndedAt(event, (DragOperation)operation);
2707 }
2708
2709 void WebPage::willPerformLoadDragDestinationAction()
2710 {
2711     m_sandboxExtensionTracker.willPerformLoadDragDestinationAction(m_pendingDropSandboxExtension.release());
2712 }
2713
2714 void WebPage::mayPerformUploadDragDestinationAction()
2715 {
2716     for (size_t i = 0; i < m_pendingDropExtensionsForFileUpload.size(); i++)
2717         m_pendingDropExtensionsForFileUpload[i]->consumePermanently();
2718     m_pendingDropExtensionsForFileUpload.clear();
2719 }
2720
2721 #endif // ENABLE(DRAG_SUPPORT)
2722
2723 WebUndoStep* WebPage::webUndoStep(uint64_t stepID)
2724 {
2725     return m_undoStepMap.get(stepID).get();
2726 }
2727
2728 void WebPage::addWebUndoStep(uint64_t stepID, WebUndoStep* entry)
2729 {
2730     m_undoStepMap.set(stepID, entry);
2731 }
2732
2733 void WebPage::removeWebEditCommand(uint64_t stepID)
2734 {
2735     m_undoStepMap.remove(stepID);
2736 }
2737
2738 void WebPage::unapplyEditCommand(uint64_t stepID)
2739 {
2740     WebUndoStep* step = webUndoStep(stepID);
2741     if (!step)
2742         return;
2743
2744     step->step()->unapply();
2745 }
2746
2747 void WebPage::reapplyEditCommand(uint64_t stepID)
2748 {
2749     WebUndoStep* step = webUndoStep(stepID);
2750     if (!step)
2751         return;
2752
2753     m_isInRedo = true;
2754     step->step()->reapply();
2755     m_isInRedo = false;
2756 }
2757
2758 void WebPage::didRemoveEditCommand(uint64_t commandID)
2759 {
2760     removeWebEditCommand(commandID);
2761 }
2762
2763 void WebPage::setActivePopupMenu(WebPopupMenu* menu)
2764 {
2765     m_activePopupMenu = menu;
2766 }
2767
2768 #if ENABLE(INPUT_TYPE_COLOR)
2769 void WebPage::setActiveColorChooser(WebColorChooser* colorChooser)
2770 {
2771     m_activeColorChooser = colorChooser;
2772 }
2773
2774 void WebPage::didEndColorChooser()
2775 {
2776     m_activeColorChooser->didEndChooser();
2777 }
2778
2779 void WebPage::didChooseColor(const WebCore::Color& color)
2780 {
2781     m_activeColorChooser->didChooseColor(color);
2782 }
2783 #endif
2784
2785 void WebPage::setActiveOpenPanelResultListener(PassRefPtr<WebOpenPanelResultListener> openPanelResultListener)
2786 {
2787     m_activeOpenPanelResultListener = openPanelResultListener;
2788 }
2789
2790 bool WebPage::findStringFromInjectedBundle(const String& target, FindOptions options)
2791 {
2792     return m_page->findString(target, options);
2793 }
2794
2795 void WebPage::findString(const String& string, uint32_t options, uint32_t maxMatchCount)
2796 {
2797     m_findController.findString(string, static_cast<FindOptions>(options), maxMatchCount);
2798 }
2799
2800 void WebPage::findStringMatches(const String& string, uint32_t options, uint32_t maxMatchCount)
2801 {
2802     m_findController.findStringMatches(string, static_cast<FindOptions>(options), maxMatchCount);
2803 }
2804
2805 void WebPage::getImageForFindMatch(uint32_t matchIndex)
2806 {
2807     m_findController.getImageForFindMatch(matchIndex);
2808 }
2809
2810 void WebPage::selectFindMatch(uint32_t matchIndex)
2811 {
2812     m_findController.selectFindMatch(matchIndex);
2813 }
2814
2815 void WebPage::hideFindUI()
2816 {
2817     m_findController.hideFindUI();
2818 }
2819
2820 void WebPage::countStringMatches(const String& string, uint32_t options, uint32_t maxMatchCount)
2821 {
2822     m_findController.countStringMatches(string, static_cast<FindOptions>(options), maxMatchCount);
2823 }
2824
2825 void WebPage::didChangeSelectedIndexForActivePopupMenu(int32_t newIndex)
2826 {
2827     changeSelectedIndex(newIndex);
2828
2829     // Since applictions on tizen may provide a way to select item more than one time,
2830     // we need to keep the active popup menu to allow repetitive selection.
2831 #if !OS(TIZEN)
2832     m_activePopupMenu = 0;
2833 #endif
2834 }
2835
2836 void WebPage::changeSelectedIndex(int32_t index)
2837 {
2838     if (!m_activePopupMenu)
2839         return;
2840
2841     m_activePopupMenu->didChangeSelectedIndex(index);
2842 }
2843
2844 void WebPage::didChooseFilesForOpenPanel(const Vector<String>& files)
2845 {
2846     if (!m_activeOpenPanelResultListener)
2847         return;
2848
2849     m_activeOpenPanelResultListener->didChooseFiles(files);
2850     m_activeOpenPanelResultListener = 0;
2851 }
2852
2853 void WebPage::didCancelForOpenPanel()
2854 {
2855     m_activeOpenPanelResultListener = 0;
2856 }
2857
2858 #if OS(TIZEN)
2859 void WebPage::cancelForOpenPanel()
2860 {
2861     if (m_activeOpenPanelResultListener) {
2862         m_activeOpenPanelResultListener->disconnectFromPage();
2863         m_activeOpenPanelResultListener = 0;
2864     }
2865 }
2866 #endif
2867
2868 #if ENABLE(WEB_PROCESS_SANDBOX)
2869 void WebPage::extendSandboxForFileFromOpenPanel(const SandboxExtension::Handle& handle)
2870 {
2871     SandboxExtension::create(handle)->consumePermanently();
2872 }
2873 #endif
2874
2875 #if ENABLE(GEOLOCATION)
2876 void WebPage::didReceiveGeolocationPermissionDecision(uint64_t geolocationID, bool allowed)
2877 {
2878     m_geolocationPermissionRequestManager.didReceiveGeolocationPermissionDecision(geolocationID, allowed);
2879 }
2880 #endif
2881
2882 void WebPage::didReceiveNotificationPermissionDecision(uint64_t notificationID, bool allowed)
2883 {
2884     notificationPermissionRequestManager()->didReceiveNotificationPermissionDecision(notificationID, allowed);
2885 }
2886
2887 #if ENABLE(TIZEN_MEDIA_STREAM)
2888 void WebPage::didReceiveUserMediaPermissionDecision(uint64_t userMediaID, bool allowed)
2889 {
2890     userMediaPermissionRequestManager()->didReceiveUserMediaPermissionDecision(userMediaID, allowed);
2891 }
2892 #endif
2893
2894 void WebPage::advanceToNextMisspelling(bool startBeforeSelection)
2895 {
2896     Frame* frame = m_page->focusController()->focusedOrMainFrame();
2897     frame->editor()->advanceToNextMisspelling(startBeforeSelection);
2898 }
2899
2900 void WebPage::changeSpellingToWord(const String& word)
2901 {
2902     replaceSelectionWithText(m_page->focusController()->focusedOrMainFrame(), word);
2903 }
2904
2905 void WebPage::unmarkAllMisspellings()
2906 {
2907     for (Frame* frame = m_page->mainFrame(); frame; frame = frame->tree()->traverseNext()) {
2908         if (Document* document = frame->document())
2909             document->markers()->removeMarkers(DocumentMarker::Spelling);
2910     }
2911 }
2912
2913 void WebPage::unmarkAllBadGrammar()
2914 {
2915     for (Frame* frame = m_page->mainFrame(); frame; frame = frame->tree()->traverseNext()) {
2916         if (Document* document = frame->document())
2917             document->markers()->removeMarkers(DocumentMarker::Grammar);
2918     }
2919 }
2920
2921 #if USE(APPKIT)
2922 void WebPage::uppercaseWord()
2923 {
2924     m_page->focusController()->focusedOrMainFrame()->editor()->uppercaseWord();
2925 }
2926
2927 void WebPage::lowercaseWord()
2928 {
2929     m_page->focusController()->focusedOrMainFrame()->editor()->lowercaseWord();
2930 }
2931
2932 void WebPage::capitalizeWord()
2933 {
2934     m_page->focusController()->focusedOrMainFrame()->editor()->capitalizeWord();
2935 }
2936 #endif
2937
2938 void WebPage::setTextForActivePopupMenu(int32_t index)
2939 {
2940     if (!m_activePopupMenu)
2941         return;
2942
2943     m_activePopupMenu->setTextForIndex(index);
2944 }
2945
2946 #if PLATFORM(GTK)
2947 void WebPage::failedToShowPopupMenu()
2948 {
2949     if (!m_activePopupMenu)
2950         return;
2951
2952     m_activePopupMenu->client()->popupDidHide();
2953 }
2954 #endif
2955
2956 #if ENABLE(CONTEXT_MENUS)
2957 void WebPage::didSelectItemFromActiveContextMenu(const WebContextMenuItemData& item)
2958 {
2959     if (!m_contextMenu)
2960         return;
2961
2962     m_contextMenu->itemSelected(item);
2963     m_contextMenu = 0;
2964 }
2965 #endif
2966
2967 void WebPage::replaceSelectionWithText(Frame* frame, const String& text)
2968 {
2969     bool selectReplacement = true;
2970     bool smartReplace = false;
2971     return frame->editor()->replaceSelectionWithText(text, selectReplacement, smartReplace);
2972 }
2973
2974 void WebPage::clearSelection()
2975 {
2976     m_page->focusController()->focusedOrMainFrame()->selection()->clear();
2977 }
2978
2979 bool WebPage::mainFrameHasCustomRepresentation() const
2980 {
2981     if (Frame* frame = mainFrame())
2982         return static_cast<WebFrameLoaderClient*>(frame->loader()->client())->frameHasCustomRepresentation();
2983
2984     return false;
2985 }
2986
2987 void WebPage::didChangeScrollOffsetForMainFrame()
2988 {
2989     Frame* frame = m_page->mainFrame();
2990     IntPoint scrollPosition = frame->view()->scrollPosition();
2991     IntPoint maximumScrollPosition = frame->view()->maximumScrollPosition();
2992     IntPoint minimumScrollPosition = frame->view()->minimumScrollPosition();
2993
2994 #if PLATFORM(EFL) && OS(TIZEN)
2995     send(Messages::WebPageProxy::DidChangeScrollPositionForMainFrame(scrollPosition));
2996 #endif
2997
2998     bool isPinnedToLeftSide = (scrollPosition.x() <= minimumScrollPosition.x());
2999     bool isPinnedToRightSide = (scrollPosition.x() >= maximumScrollPosition.x());
3000
3001     if (isPinnedToLeftSide != m_cachedMainFrameIsPinnedToLeftSide || isPinnedToRightSide != m_cachedMainFrameIsPinnedToRightSide) {
3002         send(Messages::WebPageProxy::DidChangeScrollOffsetPinningForMainFrame(isPinnedToLeftSide, isPinnedToRightSide));
3003
3004         m_cachedMainFrameIsPinnedToLeftSide = isPinnedToLeftSide;
3005         m_cachedMainFrameIsPinnedToRightSide = isPinnedToRightSide;
3006     }
3007 }
3008
3009 void WebPage::mainFrameDidLayout()
3010 {
3011     unsigned pageCount = m_page->pageCount();
3012     if (pageCount != m_cachedPageCount) {
3013         send(Messages::WebPageProxy::DidChangePageCount(pageCount));
3014         m_cachedPageCount = pageCount;
3015     }
3016
3017     double red, green, blue, alpha;
3018     m_mainFrame->getDocumentBackgroundColor(&red, &green, &blue, &alpha);
3019     send(Messages::WebPageProxy::SetBackgroundColor(red, green, blue, alpha));
3020 }
3021
3022 void WebPage::addPluginView(PluginView* pluginView)
3023 {
3024     ASSERT(!m_pluginViews.contains(pluginView));
3025
3026     m_pluginViews.add(pluginView);
3027 }
3028
3029 void WebPage::removePluginView(PluginView* pluginView)
3030 {
3031     ASSERT(m_pluginViews.contains(pluginView));
3032
3033     m_pluginViews.remove(pluginView);
3034 }
3035
3036 #if PLATFORM(MAC)
3037 void WebPage::setWindowIsVisible(bool windowIsVisible)
3038 {
3039     m_windowIsVisible = windowIsVisible;
3040
3041     corePage()->focusController()->setContainingWindowIsVisible(windowIsVisible);
3042
3043     // Tell all our plug-in views that the window visibility changed.
3044     for (HashSet<PluginView*>::const_iterator it = m_pluginViews.begin(), end = m_pluginViews.end(); it != end; ++it)
3045         (*it)->setWindowIsVisible(windowIsVisible);
3046 }
3047
3048 void WebPage::windowAndViewFramesChanged(const WebCore::IntRect& windowFrameInScreenCoordinates, const WebCore::IntRect& viewFrameInWindowCoordinates, const WebCore::IntPoint& accessibilityViewCoordinates)
3049 {
3050     m_windowFrameInScreenCoordinates = windowFrameInScreenCoordinates;
3051     m_viewFrameInWindowCoordinates = viewFrameInWindowCoordinates;
3052     m_accessibilityPosition = accessibilityViewCoordinates;
3053
3054     // Tell all our plug-in views that the window and view frames have changed.
3055     for (HashSet<PluginView*>::const_iterator it = m_pluginViews.begin(), end = m_pluginViews.end(); it != end; ++it)
3056         (*it)->windowAndViewFramesChanged(windowFrameInScreenCoordinates, viewFrameInWindowCoordinates);
3057 }
3058 #endif
3059
3060 bool WebPage::windowIsFocused() const
3061 {
3062     return m_page->focusController()->isActive();
3063 }
3064
3065 bool WebPage::windowAndWebPageAreFocused() const
3066 {
3067 #if PLATFORM(MAC)
3068     if (!m_windowIsVisible)
3069         return false;
3070 #endif
3071     return m_page->focusController()->isFocused() && m_page->focusController()->isActive();
3072 }
3073
3074 void WebPage::didReceiveMessage(CoreIPC::Connection* connection, CoreIPC::MessageID messageID, CoreIPC::ArgumentDecoder* arguments)
3075 {
3076     if (messageID.is<CoreIPC::MessageClassDrawingArea>()) {
3077         if (m_drawingArea)
3078             m_drawingArea->didReceiveDrawingAreaMessage(connection, messageID, arguments);
3079         return;
3080     }
3081
3082 #if USE(TILED_BACKING_STORE) && USE(ACCELERATED_COMPOSITING)
3083     if (messageID.is<CoreIPC::MessageClassLayerTreeCoordinator>()) {
3084         if (m_drawingArea)
3085             m_drawingArea->didReceiveLayerTreeCoordinatorMessage(connection, messageID, arguments);
3086         return;
3087     }
3088 #endif
3089
3090 #if ENABLE(INSPECTOR)
3091     if (messageID.is<CoreIPC::MessageClassWebInspector>()) {
3092         if (WebInspector* inspector = this->inspector())
3093             inspector->didReceiveWebInspectorMessage(connection, messageID, arguments);
3094         return;
3095     }
3096 #endif
3097
3098 #if ENABLE(FULLSCREEN_API)
3099     if (messageID.is<CoreIPC::MessageClassWebFullScreenManager>()) {
3100         fullScreenManager()->didReceiveMessage(connection, messageID, arguments);
3101         return;
3102     }
3103 #endif
3104
3105     didReceiveWebPageMessage(connection, messageID, arguments);
3106 }
3107
3108 void WebPage::didReceiveSyncMessage(CoreIPC::Connection* connection, CoreIPC::MessageID messageID, CoreIPC::ArgumentDecoder* arguments, OwnPtr<CoreIPC::ArgumentEncoder>& reply)
3109 {
3110     didReceiveSyncWebPageMessage(connection, messageID, arguments, reply);
3111 }
3112
3113 InjectedBundleBackForwardList* WebPage::backForwardList()
3114 {
3115     if (!m_backForwardList)
3116         m_backForwardList = InjectedBundleBackForwardList::create(this);
3117     return m_backForwardList.get();
3118 }
3119
3120 #if PLATFORM(QT) || OS(TIZEN)
3121 #if ENABLE(TOUCH_ADJUSTMENT)
3122 void WebPage::findZoomableAreaForPoint(const WebCore::IntPoint& point, const WebCore::IntSize& area)
3123 {
3124     Node* node = 0;
3125     IntRect zoomableArea;
3126     bool foundAreaForTouchPoint = m_mainFrame->coreFrame()->eventHandler()->bestZoomableAreaForTouchPoint(point, IntSize(area.width() / 2, area.height() / 2), zoomableArea, node);
3127     ASSERT(node);
3128
3129     if (!foundAreaForTouchPoint)
3130         return;
3131
3132     send(Messages::WebPageProxy::DidFindZoomableArea(point, zoomableArea));
3133 }
3134
3135 #else
3136 void WebPage::findZoomableAreaForPoint(const WebCore::IntPoint& point, const WebCore::IntSize& area)
3137 {
3138     UNUSED_PARAM(area);
3139     Frame* mainframe = m_mainFrame->coreFrame();
3140     HitTestResult result = mainframe->eventHandler()->hitTestResultAtPoint(mainframe->view()->windowToContents(point), /*allowShadowContent*/ false, /*ignoreClipping*/ true);
3141
3142     Node* node = result.innerNode();
3143
3144     if (!node)
3145         return;
3146
3147 #if OS(TIZEN) // FIXME: This is to fix wrong codes of open source.
3148     IntRect zoomableArea = enclosingIntRect(node->getRect());
3149 #else
3150     IntRect zoomableArea = node->getRect();
3151 #endif
3152
3153     while (true) {
3154         bool found = !node->isTextNode() && !node->isShadowRoot();
3155
3156         // No candidate found, bail out.
3157         if (!found && !node->parentNode())
3158             return;
3159
3160         // Candidate found, and it is a better candidate than its parent.
3161         // NB: A parent is considered a better candidate iff the node is
3162         // contained by it and it is the only child.
3163         if (found && (!node->parentNode() || node->parentNode()->childNodeCount() != 1))
3164             break;
3165
3166         node = node->parentNode();
3167 #if OS(TIZEN) // FIXME: This is to fix wrong codes of open source.
3168         zoomableArea.unite(enclosingIntRect(node->getRect()));
3169 #else
3170         zoomableArea.unite(node->getRect());
3171 #endif
3172     }
3173
3174     if (node->document() && node->document()->frame() && node->document()->frame()->view()) {
3175         const ScrollView* view = node->document()->frame()->view();
3176         zoomableArea = view->contentsToWindow(zoomableArea);
3177     }
3178
3179     send(Messages::WebPageProxy::DidFindZoomableArea(point, zoomableArea));
3180 }
3181 #endif
3182 #endif
3183
3184 WebPage::SandboxExtensionTracker::~SandboxExtensionTracker()
3185 {
3186     invalidate();
3187 }
3188
3189 void WebPage::SandboxExtensionTracker::invalidate()
3190 {
3191     if (m_pendingProvisionalSandboxExtension) {
3192         m_pendingProvisionalSandboxExtension->invalidate();
3193         m_pendingProvisionalSandboxExtension = 0;
3194     }
3195
3196     if (m_provisionalSandboxExtension) {
3197         m_provisionalSandboxExtension->invalidate();
3198         m_provisionalSandboxExtension = 0;
3199     }
3200
3201     if (m_committedSandboxExtension) {
3202         m_committedSandboxExtension->invalidate();
3203         m_committedSandboxExtension = 0;
3204     }
3205 }
3206
3207 void WebPage::SandboxExtensionTracker::willPerformLoadDragDestinationAction(PassRefPtr<SandboxExtension> pendingDropSandboxExtension)
3208 {
3209     setPendingProvisionalSandboxExtension(pendingDropSandboxExtension);
3210 }
3211
3212 void WebPage::SandboxExtensionTracker::beginLoad(WebFrame* frame, const SandboxExtension::Handle& handle)
3213 {
3214     ASSERT(frame->isMainFrame());
3215
3216     setPendingProvisionalSandboxExtension(SandboxExtension::create(handle));
3217 }
3218
3219 void WebPage::SandboxExtensionTracker::setPendingProvisionalSandboxExtension(PassRefPtr<SandboxExtension> pendingProvisionalSandboxExtension)
3220 {
3221     // If we get two beginLoad calls in succession, without a provisional load starting, then
3222     // m_pendingProvisionalSandboxExtension will be non-null. Invalidate and null out the extension if that is the case.
3223     if (m_pendingProvisionalSandboxExtension) {
3224         m_pendingProvisionalSandboxExtension->invalidate();
3225         m_pendingProvisionalSandboxExtension = nullptr;
3226     }
3227
3228     m_pendingProvisionalSandboxExtension = pendingProvisionalSandboxExtension;
3229 }
3230
3231 static bool shouldReuseCommittedSandboxExtension(WebFrame* frame)
3232 {
3233     ASSERT(frame->isMainFrame());
3234
3235     FrameLoader* frameLoader = frame->coreFrame()->loader();
3236     FrameLoadType frameLoadType = frameLoader->loadType();
3237
3238     // If the page is being reloaded, it should reuse whatever extension is committed.
3239     if (frameLoadType == FrameLoadTypeReload || frameLoadType == FrameLoadTypeReloadFromOrigin)
3240         return true;
3241
3242     DocumentLoader* documentLoader = frameLoader->documentLoader();
3243     DocumentLoader* provisionalDocumentLoader = frameLoader->provisionalDocumentLoader();
3244     if (!documentLoader || !provisionalDocumentLoader)
3245         return false;
3246
3247     if (documentLoader->url().isLocalFile() && provisionalDocumentLoader->url().isLocalFile())
3248         return true;
3249
3250     return false;
3251 }
3252
3253 void WebPage::SandboxExtensionTracker::didStartProvisionalLoad(WebFrame* frame)
3254 {
3255     if (!frame->isMainFrame())
3256         return;
3257
3258     // We should only reuse the commited sandbox extension if it is not null. It can be
3259     // null if the last load was for an error page.
3260     if (m_committedSandboxExtension && shouldReuseCommittedSandboxExtension(frame)) {
3261         m_pendingProvisionalSandboxExtension = m_committedSandboxExtension.release();
3262         ASSERT(!m_committedSandboxExtension);
3263     }
3264
3265     ASSERT(!m_provisionalSandboxExtension);
3266
3267     m_provisionalSandboxExtension = m_pendingProvisionalSandboxExtension.release();
3268     if (!m_provisionalSandboxExtension)
3269         return;
3270
3271     m_provisionalSandboxExtension->consume();
3272 }
3273
3274 void WebPage::SandboxExtensionTracker::didCommitProvisionalLoad(WebFrame* frame)
3275 {
3276     if (!frame->isMainFrame())
3277         return;
3278
3279     // Generally, there should be no pending extension at this stage, but we can have one if UI process
3280     // has an out of date idea of WebProcess state, and initiates a load or reload without stopping an existing one.
3281     if (m_pendingProvisionalSandboxExtension) {
3282         m_pendingProvisionalSandboxExtension->invalidate();
3283         m_pendingProvisionalSandboxExtension = nullptr;
3284     }
3285
3286     // The provisional load has been committed. Invalidate the currently committed sandbox
3287     // extension and make the provisional sandbox extension the committed sandbox extension.
3288     if (m_committedSandboxExtension)
3289         m_committedSandboxExtension->invalidate();
3290
3291     m_committedSandboxExtension = m_provisionalSandboxExtension.release();
3292 }
3293
3294 void WebPage::SandboxExtensionTracker::didFailProvisionalLoad(WebFrame* frame)
3295 {
3296     if (!frame->isMainFrame())
3297         return;
3298
3299     // Generally, there should be no pending extension at this stage, but we can have one if UI process
3300     // has an out of date idea of WebProcess state, and initiates a load or reload without stopping an existing one.
3301     if (m_pendingProvisionalSandboxExtension) {
3302         m_pendingProvisionalSandboxExtension->invalidate();
3303         m_pendingProvisionalSandboxExtension = nullptr;
3304     }
3305
3306     if (!m_provisionalSandboxExtension)
3307         return;
3308
3309     m_provisionalSandboxExtension->invalidate();
3310     m_provisionalSandboxExtension = nullptr;
3311 }
3312
3313 bool WebPage::hasLocalDataForURL(const KURL& url)
3314 {
3315     if (url.isLocalFile())
3316         return true;
3317
3318     FrameLoader* frameLoader = m_page->mainFrame()->loader();
3319     DocumentLoader* documentLoader = frameLoader ? frameLoader->documentLoader() : 0;
3320     if (documentLoader && documentLoader->subresource(url))
3321         return true;
3322
3323     return platformHasLocalDataForURL(url);
3324 }
3325
3326 void WebPage::setCustomTextEncodingName(const String& encoding)
3327 {
3328     m_page->mainFrame()->loader()->reloadWithOverrideEncoding(encoding);
3329 }
3330
3331 void WebPage::didRemoveBackForwardItem(uint64_t itemID)
3332 {
3333     WebBackForwardListProxy::removeItem(itemID);
3334 }
3335
3336 #if PLATFORM(MAC)
3337
3338 bool WebPage::isSpeaking()
3339 {
3340     bool result;
3341     return sendSync(Messages::WebPageProxy::GetIsSpeaking(), Messages::WebPageProxy::GetIsSpeaking::Reply(result)) && result;
3342 }
3343
3344 void WebPage::speak(const String& string)
3345 {
3346     send(Messages::WebPageProxy::Speak(string));
3347 }
3348
3349 void WebPage::stopSpeaking()
3350 {
3351     send(Messages::WebPageProxy::StopSpeaking());
3352 }
3353
3354 #endif
3355
3356 #if PLATFORM(MAC)
3357 RetainPtr<PDFDocument> WebPage::pdfDocumentForPrintingFrame(Frame* coreFrame)
3358 {
3359     Document* document = coreFrame->document();
3360     if (!document)
3361         return 0;
3362
3363     if (!document->isPluginDocument())
3364         return 0;
3365
3366     PluginView* pluginView = static_cast<PluginView*>(toPluginDocument(document)->pluginWidget());
3367     if (!pluginView)
3368         return 0;
3369
3370     return pluginView->pdfDocumentForPrinting();
3371 }
3372 #endif // PLATFORM(MAC)
3373
3374 void WebPage::beginPrinting(uint64_t frameID, const PrintInfo& printInfo)
3375 {
3376     WebFrame* frame = WebProcess::shared().webFrame(frameID);
3377     if (!frame)
3378         return;
3379
3380     Frame* coreFrame = frame->coreFrame();
3381     if (!coreFrame)
3382         return;
3383
3384 #if PLATFORM(MAC)
3385     if (pdfDocumentForPrintingFrame(coreFrame))
3386         return;
3387 #endif // PLATFORM(MAC)
3388
3389     if (!m_printContext)
3390         m_printContext = adoptPtr(new PrintContext(coreFrame));
3391
3392     drawingArea()->setLayerTreeStateIsFrozen(true);
3393     m_printContext->begin(printInfo.availablePaperWidth, printInfo.availablePaperHeight);
3394
3395     float fullPageHeight;
3396     m_printContext->computePageRects(FloatRect(0, 0, printInfo.availablePaperWidth, printInfo.availablePaperHeight), 0, 0, printInfo.pageSetupScaleFactor, fullPageHeight, true);
3397
3398 #if PLATFORM(GTK)
3399     if (!m_printOperation)
3400         m_printOperation = WebPrintOperationGtk::create(this, printInfo);
3401 #endif
3402 }
3403
3404 void WebPage::endPrinting()
3405 {
3406     drawingArea()->setLayerTreeStateIsFrozen(false);
3407 #if PLATFORM(GTK)
3408     m_printOperation = 0;
3409 #endif
3410     m_printContext = nullptr;
3411 }
3412
3413 void WebPage::computePagesForPrinting(uint64_t frameID, const PrintInfo& printInfo, uint64_t callbackID)
3414 {
3415     Vector<IntRect> resultPageRects;
3416     double resultTotalScaleFactorForPrinting = 1;
3417
3418     beginPrinting(frameID, printInfo);
3419
3420     if (m_printContext) {
3421         resultPageRects = m_printContext->pageRects();
3422         resultTotalScaleFactorForPrinting = m_printContext->computeAutomaticScaleFactor(FloatSize(printInfo.availablePaperWidth, printInfo.availablePaperHeight)) * printInfo.pageSetupScaleFactor;
3423     }
3424 #if PLATFORM(MAC)
3425     else
3426         computePagesForPrintingPDFDocument(frameID, printInfo, resultPageRects);
3427 #endif // PLATFORM(MAC)
3428
3429     // If we're asked to print, we should actually print at least a blank page.
3430     if (resultPageRects.isEmpty())
3431         resultPageRects.append(IntRect(0, 0, 1, 1));
3432
3433     send(Messages::WebPageProxy::ComputedPagesCallback(resultPageRects, resultTotalScaleFactorForPrinting, callbackID));
3434 }
3435
3436 #if PLATFORM(MAC) || PLATFORM(WIN)
3437 void WebPage::drawRectToPDF(uint64_t frameID, const PrintInfo& printInfo, const WebCore::IntRect& rect, uint64_t callbackID)
3438 {
3439     WebFrame* frame = WebProcess::shared().webFrame(frameID);
3440     Frame* coreFrame = frame ? frame->coreFrame() : 0;
3441
3442     RetainPtr<CFMutableDataRef> pdfPageData(AdoptCF, CFDataCreateMutable(0, 0));
3443
3444 #if USE(CG)
3445     if (coreFrame) {
3446 #if PLATFORM(MAC)
3447         ASSERT(coreFrame->document()->printing() || pdfDocumentForPrintingFrame(coreFrame));
3448 #else
3449         ASSERT(coreFrame->document()->printing());
3450 #endif
3451
3452         // FIXME: Use CGDataConsumerCreate with callbacks to avoid copying the data.
3453         RetainPtr<CGDataConsumerRef> pdfDataConsumer(AdoptCF, CGDataConsumerCreateWithCFData(pdfPageData.get()));
3454
3455         CGRect mediaBox = CGRectMake(0, 0, rect.width(), rect.height());
3456         RetainPtr<CGContextRef> context(AdoptCF, CGPDFContextCreate(pdfDataConsumer.get(), &mediaBox, 0));
3457         RetainPtr<CFDictionaryRef> pageInfo(AdoptCF, CFDictionaryCreateMutable(0, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks));
3458         CGPDFContextBeginPage(context.get(), pageInfo.get());
3459
3460 #if PLATFORM(MAC)
3461         if (RetainPtr<PDFDocument> pdfDocument = pdfDocumentForPrintingFrame(coreFrame)) {
3462             ASSERT(!m_printContext);
3463             drawRectToPDFFromPDFDocument(context.get(), pdfDocument.get(), printInfo, rect);
3464         } else
3465 #endif
3466         {
3467             GraphicsContext ctx(context.get());
3468             ctx.scale(FloatSize(1, -1));
3469             ctx.translate(0, -rect.height());
3470             m_printContext->spoolRect(ctx, rect);
3471         }
3472
3473         CGPDFContextEndPage(context.get());
3474         CGPDFContextClose(context.get());
3475     }
3476 #endif
3477
3478     send(Messages::WebPageProxy::DataCallback(CoreIPC::DataReference(CFDataGetBytePtr(pdfPageData.get()), CFDataGetLength(pdfPageData.get())), callbackID));
3479 }
3480
3481 void WebPage::drawPagesToPDF(uint64_t frameID, const PrintInfo& printInfo, uint32_t first, uint32_t count, uint64_t callbackID)
3482 {
3483     WebFrame* frame = WebProcess::shared().webFrame(frameID);
3484     Frame* coreFrame = frame ? frame->coreFrame() : 0;
3485
3486     RetainPtr<CFMutableDataRef> pdfPageData(AdoptCF, CFDataCreateMutable(0, 0));
3487
3488 #if USE(CG)
3489     if (coreFrame) {
3490
3491 #if PLATFORM(MAC)
3492         ASSERT(coreFrame->document()->printing() || pdfDocumentForPrintingFrame(coreFrame));
3493 #else
3494         ASSERT(coreFrame->document()->printing());
3495 #endif
3496
3497         // FIXME: Use CGDataConsumerCreate with callbacks to avoid copying the data.
3498         RetainPtr<CGDataConsumerRef> pdfDataConsumer(AdoptCF, CGDataConsumerCreateWithCFData(pdfPageData.get()));
3499
3500         CGRect mediaBox = (m_printContext && m_printContext->pageCount()) ? m_printContext->pageRect(0) : CGRectMake(0, 0, printInfo.availablePaperWidth, printInfo.availablePaperHeight);
3501         RetainPtr<CGContextRef> context(AdoptCF, CGPDFContextCreate(pdfDataConsumer.get(), &mediaBox, 0));
3502
3503 #if PLATFORM(MAC)
3504         if (RetainPtr<PDFDocument> pdfDocument = pdfDocumentForPrintingFrame(coreFrame)) {
3505             ASSERT(!m_printContext);
3506             drawPagesToPDFFromPDFDocument(context.get(), pdfDocument.get(), printInfo, first, count);
3507         } else
3508 #endif
3509         {
3510             size_t pageCount = m_printContext->pageCount();
3511             for (uint32_t page = first; page < first + count; ++page) {
3512                 if (page >= pageCount)
3513                     break;
3514
3515                 RetainPtr<CFDictionaryRef> pageInfo(AdoptCF, CFDictionaryCreateMutable(0, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks));
3516                 CGPDFContextBeginPage(context.get(), pageInfo.get());
3517
3518                 GraphicsContext ctx(context.get());
3519                 ctx.scale(FloatSize(1, -1));
3520                 ctx.translate(0, -m_printContext->pageRect(page).height());
3521                 m_printContext->spoolPage(ctx, page, m_printContext->pageRect(page).width());
3522
3523                 CGPDFContextEndPage(context.get());
3524             }
3525         }
3526         CGPDFContextClose(context.get());
3527     }
3528 #endif
3529
3530     send(Messages::WebPageProxy::DataCallback(CoreIPC::DataReference(CFDataGetBytePtr(pdfPageData.get()), CFDataGetLength(pdfPageData.get())), callbackID));
3531 }
3532
3533 #elif PLATFORM(GTK)
3534
3535 void WebPage::drawPagesForPrinting(uint64_t frameID, const PrintInfo& printInfo, uint64_t callbackID)
3536 {
3537     beginPrinting(frameID, printInfo);
3538     if (m_printContext && m_printOperation) {
3539         m_printOperation->startPrint(m_printContext.get(), callbackID);
3540         return;
3541     }
3542
3543     send(Messages::WebPageProxy::VoidCallback(callbackID));
3544 }
3545 #endif
3546
3547 #if ENABLE(TIZEN_SUPPORT_WEBAPP_META_TAG)
3548 void WebPage::getWebAppCapable(uint64_t callbackID)
3549 {
3550     RefPtr<WebCore::NodeList> nodeList = mainFrame()->document()->getElementsByTagName("meta");
3551     bool capable = false;
3552
3553     for (unsigned i = 0; i < nodeList->length(); i++) {
3554         WebCore::HTMLMetaElement* metaElement = static_cast<WebCore::HTMLMetaElement*>(nodeList->item(i));
3555         if (metaElement->name() == "apple-mobile-web-app-capable") {
3556             capable = metaElement->content() == "yes" ? true : false;
3557             break;
3558         }
3559     }
3560
3561     send(Messages::WebPageProxy::DidGetWebAppCapable(capable, callbackID));
3562 }
3563
3564 void WebPage::getWebAppIconURL(uint64_t callbackID)
3565 {
3566     RefPtr<WebCore::NodeList> nodeList = mainFrame()->document()->getElementsByTagName("link");
3567     String iconURL;
3568
3569     for (unsigned i = 0; i < nodeList->length(); i++) {
3570         WebCore::HTMLLinkElement* linkElement = static_cast<WebCore::HTMLLinkElement*>(nodeList->item(i));
3571         if (linkElement->rel() == "apple-touch-icon" || linkElement->rel() == "apple-touch-icon-precomposed")
3572             iconURL = linkElement->href().string();
3573     }
3574
3575     send(Messages::WebPageProxy::DidGetWebAppIconURL(iconURL, callbackID));
3576 }
3577
3578 void WebPage::getWebAppIconURLs(uint64_t callbackID)
3579 {
3580     RefPtr<WebCore::NodeList> nodeList = mainFrame()->document()->getElementsByTagName("link");
3581     Vector<std::pair<String, String> > iconURLs;
3582
3583     for (unsigned i = 0; i < nodeList->length(); i++) {
3584         WebCore::HTMLLinkElement* linkElement = static_cast<WebCore::HTMLLinkElement*>(nodeList->item(i));
3585         if (linkElement->rel() == "apple-touch-icon" || linkElement->rel() == "apple-touch-icon-precomposed")
3586             iconURLs.append(pair<String, String>(linkElement->href().string(), linkElement->iconSizes()));
3587     }
3588
3589     send(Messages::WebPageProxy::DidGetWebAppIconURLs(iconURLs, callbackID));
3590 }
3591 #endif
3592
3593 void WebPage::setMediaVolume(float volume)
3594 {
3595     m_page->setMediaVolume(volume);
3596 }
3597
3598 void WebPage::runModal()
3599 {
3600     if (m_isClosed)
3601         return;
3602     if (m_isRunningModal)
3603         return;
3604
3605     m_isRunningModal = true;
3606     send(Messages::WebPageProxy::RunModal());
3607     RunLoop::run();
3608     ASSERT(!m_isRunningModal);
3609 }
3610
3611 void WebPage::setMemoryCacheMessagesEnabled(bool memoryCacheMessagesEnabled)
3612 {
3613     m_page->setMemoryCacheClientCallsEnabled(memoryCacheMessagesEnabled);
3614 }
3615
3616 bool WebPage::canHandleRequest(const WebCore::ResourceRequest& request)
3617 {
3618     if (SchemeRegistry::shouldLoadURLSchemeAsEmptyDocument(request.url().protocol()))
3619         return true;
3620     return platformCanHandleRequest(request);
3621 }
3622
3623 #if PLATFORM(MAC) && __MAC_OS_X_VERSION_MIN_REQUIRED >= 1070
3624 void WebPage::handleAlternativeTextUIResult(const String& result)
3625 {
3626     Frame* frame = m_page->focusController()->focusedOrMainFrame();
3627     if (!frame)
3628         return;
3629     frame->editor()->handleAlternativeTextUIResult(result);
3630 }
3631 #endif
3632
3633 void WebPage::simulateMouseDown(int button, WebCore::IntPoint position, int clickCount, WKEventModifiers modifiers, double time)
3634 {
3635     mouseEvent(WebMouseEvent(WebMouseEvent::MouseDown, static_cast<WebMouseEvent::Button>(button), position, position, 0, 0, 0, clickCount, static_cast<WebMouseEvent::Modifiers>(modifiers), time));
3636 }
3637
3638 void WebPage::simulateMouseUp(int button, WebCore::IntPoint position, int clickCount, WKEventModifiers modifiers, double time)
3639 {
3640     mouseEvent(WebMouseEvent(WebMouseEvent::MouseUp, static_cast<WebMouseEvent::Button>(button), position, position, 0, 0, 0, clickCount, static_cast<WebMouseEvent::Modifiers>(modifiers), time));
3641 }
3642
3643 void WebPage::simulateMouseMotion(WebCore::IntPoint position, double time)
3644 {
3645     mouseEvent(WebMouseEvent(WebMouseEvent::MouseMove, WebMouseEvent::NoButton, position, position, 0, 0, 0, 0, WebMouseEvent::Modifiers(), time));
3646 }
3647
3648 void WebPage::setCompositionForTesting(const String& compositionString, uint64_t from, uint64_t length)
3649 {
3650     Frame* frame = m_page->focusController()->focusedOrMainFrame();
3651     if (!frame || !frame->editor()->canEdit())
3652         return;
3653
3654     Vector<CompositionUnderline> underlines;
3655     underlines.append(CompositionUnderline(0, compositionString.length(), Color(Color::black), false));
3656     frame->editor()->setComposition(compositionString, underlines, from, from + length);
3657 }
3658
3659 bool WebPage::hasCompositionForTesting()
3660 {
3661     Frame* frame = m_page->focusController()->focusedOrMainFrame();
3662     return frame && frame->editor()->hasComposition();
3663 }
3664
3665 void WebPage::confirmCompositionForTesting(const String& compositionString)
3666 {
3667     Frame* frame = m_page->focusController()->focusedOrMainFrame();
3668     if (!frame || !frame->editor()->canEdit())
3669         return;
3670
3671     if (compositionString.isNull())
3672         frame->editor()->confirmComposition();
3673     frame->editor()->confirmComposition(compositionString);
3674 }
3675
3676 void WebPage::numWheelEventHandlersChanged(unsigned numWheelEventHandlers)
3677 {
3678     if (m_numWheelEventHandlers == numWheelEventHandlers)
3679         return;
3680
3681     m_numWheelEventHandlers = numWheelEventHandlers;
3682     recomputeShortCircuitHorizontalWheelEventsState();
3683 }
3684
3685 static bool hasEnabledHorizontalScrollbar(ScrollableArea* scrollableArea)
3686 {
3687     if (Scrollbar* scrollbar = scrollableArea->horizontalScrollbar())
3688         return scrollbar->enabled();
3689
3690     return false;
3691 }
3692
3693 static bool pageContainsAnyHorizontalScrollbars(Frame* mainFrame)
3694 {
3695     if (FrameView* frameView = mainFrame->view()) {
3696         if (hasEnabledHorizontalScrollbar(frameView))
3697             return true;
3698     }
3699
3700     for (Frame* frame = mainFrame; frame; frame = frame->tree()->traverseNext()) {
3701         FrameView* frameView = frame->view();
3702         if (!frameView)
3703             continue;
3704
3705         const HashSet<ScrollableArea*>* scrollableAreas = frameView->scrollableAreas();
3706         if (!scrollableAreas)
3707             continue;
3708
3709         for (HashSet<ScrollableArea*>::const_iterator it = scrollableAreas->begin(), end = scrollableAreas->end(); it != end; ++it) {
3710             ScrollableArea* scrollableArea = *it;
3711             if (!scrollableArea->isOnActivePage())
3712                 continue;
3713
3714             if (hasEnabledHorizontalScrollbar(scrollableArea))
3715                 return true;
3716         }
3717     }
3718
3719     return false;
3720 }
3721
3722 void WebPage::recomputeShortCircuitHorizontalWheelEventsState()
3723 {
3724     bool canShortCircuitHorizontalWheelEvents = !m_numWheelEventHandlers;
3725
3726     if (canShortCircuitHorizontalWheelEvents) {
3727         // Check if we have any horizontal scroll bars on the page.
3728         if (pageContainsAnyHorizontalScrollbars(mainFrame()))
3729             canShortCircuitHorizontalWheelEvents = false;
3730     }
3731
3732     if (m_canShortCircuitHorizontalWheelEvents == canShortCircuitHorizontalWheelEvents)
3733         return;
3734
3735     m_canShortCircuitHorizontalWheelEvents = canShortCircuitHorizontalWheelEvents;
3736     send(Messages::WebPageProxy::SetCanShortCircuitHorizontalWheelEvents(m_canShortCircuitHorizontalWheelEvents));
3737 }
3738
3739 Frame* WebPage::mainFrame() const
3740 {
3741     return m_page ? m_page->mainFrame() : 0;
3742 }
3743
3744 FrameView* WebPage::mainFrameView() const
3745 {
3746     if (Frame* frame = mainFrame())
3747         return frame->view();
3748
3749     return 0;
3750 }
3751
3752 #if ENABLE(PAGE_VISIBILITY_API)
3753 void WebPage::setVisibilityState(int visibilityState, bool isInitialState)
3754 {
3755     if (!m_page)
3756         return;
3757
3758     WebCore::PageVisibilityState state = static_cast<WebCore::PageVisibilityState>(visibilityState);
3759
3760     if (m_visibilityState == state)
3761         return;
3762
3763     FrameView* view = m_page->mainFrame() ? m_page->mainFrame()->view() : 0;
3764
3765     if (state == WebCore::PageVisibilityStateVisible) {
3766         m_page->didMoveOnscreen();
3767         if (view)
3768             view->show();
3769     }
3770
3771     m_page->setVisibilityState(state, isInitialState);
3772     m_visibilityState = state;
3773
3774     if (state == WebCore::PageVisibilityStateHidden) {
3775         m_page->willMoveOffscreen();
3776         if (view)
3777             view->hide();
3778     }
3779 }
3780 #endif
3781
3782 #if ENABLE(TIZEN_NATIVE_MEMORY_SNAPSHOT)
3783 const char* dumpFileName = "/tmp/webkit_memory";
3784 char* lastUrl = 0;
3785
3786 void dumpMemorySnapshotForUrl(char* url)
3787 {
3788     PrintFormat format = PRINT_FORMAT_JSON;
3789     FILE* fp = 0;
3790     fp = fopen(dumpFileName, "a");
3791     if (fp) {
3792         if (format == PRINT_FORMAT_JSON)
3793             fprintf(fp, "{");
3794         else
3795             fprintf(fp, "URL:%s\n", url);
3796         fprintf(fp, "%s", memoryPage(format).utf8().data());
3797         if (format == PRINT_FORMAT_JSON)
3798             fprintf(fp, "\"URL\":\"%s\"}\n", url);
3799         fclose(fp);
3800     }
3801     lastUrl = url;
3802 }
3803
3804 void dumpMemorySnapshot()
3805 {
3806     dumpMemorySnapshotForUrl(lastUrl);
3807 }
3808
3809 void WebPage::dumpMemorySnapshot()
3810 {
3811     char* url = strdup(mainWebFrame()->url().utf8().data());
3812     if (lastUrl)
3813         free(lastUrl);
3814     lastUrl = url;
3815 }
3816 #endif
3817
3818 } // namespace WebKit