Source/WebKit2/UIProcess/WebPageProxy.h

   1 /*
   2  * Copyright (C) 2010, 2011 Apple Inc. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
  14  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
  15  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  16  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
  17  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  18  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  19  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  20  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  21  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  22  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
  23  * THE POSSIBILITY OF SUCH DAMAGE.
  24  */
  25
  26 #ifndef WebPageProxy_h
  27 #define WebPageProxy_h
  28
  29 #include "APIObject.h"
  30 #include "Connection.h"
  31 #include "DragControllerAction.h"
  32 #include "DrawingAreaProxy.h"
  33 #include "EditorState.h"
  34 #include "GeolocationPermissionRequestManagerProxy.h"
  35 #if ENABLE(TOUCH_EVENTS)
  36 #include "NativeWebTouchEvent.h"
  37 #endif
  38 #if ENABLE(TIZEN_WEBKIT2_ROTATION_WHILE_JAVASCRIPT_POPUP)
  39 #include "NativeWebKeyboardEvent.h"
  40 #endif
  41 #if PLATFORM(QT)
  42 #include "QtNetworkRequestData.h"
  43 #endif
  44 #include "LayerTreeContext.h"
  45 #include "NotificationPermissionRequestManagerProxy.h"
  46 #include "PlatformProcessIdentifier.h"
  47 #include "SandboxExtension.h"
  48 #include "ShareableBitmap.h"
  49 #include "WKBase.h"
  50 #include "WKPagePrivate.h"
  51 #include "WebColorChooserProxy.h"
  52 #include "WebContextMenuItemData.h"
  53 #include "WebCoreArgumentCoders.h"
  54 #include "WebFindClient.h"
  55 #include "WebFormClient.h"
  56 #include "WebFrameProxy.h"
  57 #include "WebFullScreenManagerProxy.h"
  58 #include "WebHistoryClient.h"
  59 #include "WebHitTestResult.h"
  60 #include "WebLoaderClient.h"
  61 #include "WebPageContextMenuClient.h"
  62 #include "WebPolicyClient.h"
  63 #include "WebPopupMenuProxy.h"
  64 #include "WebResourceLoadClient.h"
  65 #include "WebUIClient.h"
  66 #include <WebCore/AlternativeTextClient.h>
  67 #include <WebCore/Color.h>
  68 #include <WebCore/DragActions.h>
  69 #include <WebCore/DragSession.h>
  70 #include <WebCore/HitTestResult.h>
  71 #include <WebCore/Page.h>
  72 #include <WebCore/PlatformScreen.h>
  73 #include <WebCore/ScrollTypes.h>
  74 #include <WebCore/TextChecking.h>
  75 #include <wtf/HashMap.h>
  76 #include <wtf/HashSet.h>
  77 #include <wtf/OwnPtr.h>
  78 #include <wtf/PassOwnPtr.h>
  79 #include <wtf/PassRefPtr.h>
  80 #include <wtf/RefPtr.h>
  81 #include <wtf/Vector.h>
  82 #include <wtf/text/WTFString.h>
  83
  84 #if ENABLE(DRAG_SUPPORT)
  85 #include <WebCore/DragActions.h>
  86 #include <WebCore/DragSession.h>
  87 #endif
  88
  89 #if PLATFORM(EFL)
  90 #include <Evas.h>
  91 #include <Ecore_IMF_Evas.h>
  92 #endif
  93
  94 #if OS(TIZEN)
  95 #include "WebPageProxyMessages.h"
  96 #include "WebTizenClient.h"
  97 #include <WebCore/Color.h>
  98 #endif
  99
 100 #if ENABLE(TIZEN_MEDIA_STREAM)
 101 #include "UserMediaPermissionRequestManagerProxy.h"
 102 #endif
 103
 104 #if ENABLE(TIZEN_OFFLINE_PAGE_SAVE)
 105 #include "WebSubresourceTizen.h"
 106 #endif
 107
 108 #if ENABLE(TIZEN_CSS_OVERFLOW_SCROLL_ACCELERATION)
 109 #include "WebLayerTreeInfo.h"
 110 #endif
 111
 112 #if ENABLE(TIZEN_CSP)
 113 #include <WebCore/ContentSecurityPolicy.h>
 114 #endif
 115
 116 #if ENABLE(TIZEN_WEBKIT2_TEXT_SELECTION)
 117 #include <WebCore/VisibleSelection.h>
 118 #endif
 119
 120 namespace CoreIPC {
 121     class ArgumentDecoder;
 122     class Connection;
 123     class MessageID;
 124 }
 125
 126 namespace WebCore {
 127     class AuthenticationChallenge;
 128     class Cursor;
 129     class DragData;
 130     class FloatRect;
 131     class IntSize;
 132     class ProtectionSpace;
 133     struct FileChooserSettings;
 134     struct TextAlternativeWithRange;
 135     struct TextCheckingResult;
 136     struct ViewportAttributes;
 137     struct WindowFeatures;
 138 }
 139
 140 #if PLATFORM(QT)
 141 class QQuickNetworkReply;
 142 #endif
 143
 144 #if USE(APPKIT)
 145 #ifdef __OBJC__
 146 @class WKView;
 147 #else
 148 class WKView;
 149 #endif
 150 #endif
 151
 152 #if ENABLE(WEB_INTENTS)
 153 class WebIntentData;
 154 #endif
 155
 156 namespace WebKit {
 157
 158 #if !ENABLE(TIZEN_WEBKIT2_ROTATION_WHILE_JAVASCRIPT_POPUP)
 159 class NativeWebKeyboardEvent;
 160 #endif
 161 class NativeWebMouseEvent;
 162 class NativeWebWheelEvent;
 163 class PageClient;
 164 class PlatformCertificateInfo;
 165 class StringPairVector;
 166 class WebBackForwardList;
 167 class WebBackForwardListItem;
 168 #if ENABLE(TIZEN_INPUT_COLOR_PICKER) // wait for upstream
 169 class WebColorPickerResultListenerProxy;
 170 #endif
 171 class WebContextMenuProxy;
 172 class WebData;
 173 class WebEditCommandProxy;
 174 class WebKeyboardEvent;
 175 class WebMouseEvent;
 176 class WebOpenPanelResultListenerProxy;
 177 class WebPageGroup;
 178 class WebProcessProxy;
 179 #if ENABLE(TIZEN_OFFLINE_PAGE_SAVE)
 180 class WebSubresourceTizen;
 181 #endif
 182 class WebURLRequest;
 183 class WebWheelEvent;
 184 struct AttributedString;
 185 struct ColorSpaceData;
 186 struct DictionaryPopupInfo;
 187 struct EditorState;
 188 struct PlatformPopupMenuData;
 189 struct PrintInfo;
 190 struct WebPageCreationParameters;
 191 struct WebPopupItem;
 192
 193 #if PLATFORM(WIN)
 194 struct WindowGeometry;
 195 #endif
 196
 197 #if ENABLE(GESTURE_EVENTS)
 198 class WebGestureEvent;
 199 #endif
 200
 201 #if ENABLE(WEB_INTENTS)
 202 struct IntentData;
 203 #endif
 204
 205 #if ENABLE(WEB_INTENTS_TAG)
 206 struct IntentServiceInfo;
 207 #endif
 208
 209 typedef GenericCallback<WKStringRef, StringImpl*> StringCallback;
 210 typedef GenericCallback<WKSerializedScriptValueRef, WebSerializedScriptValue*> ScriptValueCallback;
 211 #if ENABLE(TIZEN_SUPPORT_WEBAPP_META_TAG)
 212 typedef GenericCallback<WKBooleanRef> BooleanCallback;
 213 typedef GenericCallback<WKDictionaryRef> DictionaryCallback;
 214 #endif
 215 #if ENABLE(TIZEN_WEB_STORAGE)
 216 #if ENABLE(TIZEN_WEBKIT2_NUMBER_TYPE_SUPPORT)
 217 typedef GenericCallback<WKUInt32Ref> WebStorageQuotaCallback;
 218 #endif
 219 #endif
 220
 221 #if PLATFORM(GTK)
 222 typedef GenericCallback<WKErrorRef> PrintFinishedCallback;
 223 #endif
 224
 225 #if ENABLE(TIZEN_WEBKIT2_ROTATION_WHILE_JAVASCRIPT_POPUP)
 226 template<typename T>
 227 struct QueuedUIEvents {
 228     QueuedUIEvents(const T& event)
 229         : forwardedEvent(event)
 230     {
 231     }
 232     T forwardedEvent;
 233     Vector<T> deferredEvents;
 234 };
 235 #else
 236 #if ENABLE(TOUCH_EVENTS)
 237 struct QueuedTouchEvents {
 238     QueuedTouchEvents(const NativeWebTouchEvent& event)
 239         : forwardedEvent(event)
 240     {
 241     }
 242     NativeWebTouchEvent forwardedEvent;
 243     Vector<NativeWebTouchEvent> deferredTouchEvents;
 244 };
 245 #endif
 246 #endif
 247
 248 // FIXME: Make a version of CallbackBase with three arguments, and define ValidateCommandCallback as a specialization.
 249 class ValidateCommandCallback : public CallbackBase {
 250 public:
 251     typedef void (*CallbackFunction)(WKStringRef, bool, int32_t, WKErrorRef, void*);
 252
 253     static PassRefPtr<ValidateCommandCallback> create(void* context, CallbackFunction callback)
 254     {
 255         return adoptRef(new ValidateCommandCallback(context, callback));
 256     }
 257
 258     virtual ~ValidateCommandCallback()
 259     {
 260         ASSERT(!m_callback);
 261     }
 262
 263     void performCallbackWithReturnValue(StringImpl* returnValue1, bool returnValue2, int returnValue3)
 264     {
 265         ASSERT(m_callback);
 266
 267         m_callback(toAPI(returnValue1), returnValue2, returnValue3, 0, context());
 268
 269         m_callback = 0;
 270     }
 271
 272     void invalidate()
 273     {
 274         ASSERT(m_callback);
 275
 276         RefPtr<WebError> error = WebError::create();
 277         m_callback(0, 0, 0, toAPI(error.get()), context());
 278
 279         m_callback = 0;
 280     }
 281
 282 private:
 283
 284     ValidateCommandCallback(void* context, CallbackFunction callback)
 285         : CallbackBase(context)
 286         , m_callback(callback)
 287     {
 288     }
 289
 290     CallbackFunction m_callback;
 291 };
 292
 293 class WebPageProxy
 294     : public APIObject
 295 #if ENABLE(INPUT_TYPE_COLOR)
 296     , public WebColorChooserProxy::Client
 297 #endif
 298     , public WebPopupMenuProxy::Client {
 299 public:
 300     static const Type APIType = TypePage;
 301
 302     static PassRefPtr<WebPageProxy> create(PageClient*, PassRefPtr<WebProcessProxy>, WebPageGroup*, uint64_t pageID);
 303     virtual ~WebPageProxy();
 304
 305     uint64_t pageID() const { return m_pageID; }
 306
 307     WebFrameProxy* mainFrame() const { return m_mainFrame.get(); }
 308     WebFrameProxy* focusedFrame() const { return m_focusedFrame.get(); }
 309     WebFrameProxy* frameSetLargestFrame() const { return m_frameSetLargestFrame.get(); }
 310
 311     DrawingAreaProxy* drawingArea() const { return m_drawingArea.get(); }
 312
 313     WebBackForwardList* backForwardList() const { return m_backForwardList.get(); }
 314
 315 #if ENABLE(TIZEN_WEBKIT2_NOTIFY_SUSPEND_BY_REMOTE_WEB_INSPECTOR)
 316     bool isContentSuspendedByInspector() { return m_contentSuspendedByInspector; }
 317 #endif
 318
 319 #if ENABLE(INSPECTOR)
 320     WebInspectorProxy* inspector();
 321 #endif
 322
 323 #if ENABLE(FULLSCREEN_API)
 324     WebFullScreenManagerProxy* fullScreenManager();
 325 #endif
 326
 327 #if ENABLE(CONTEXT_MENUS)
 328     void initializeContextMenuClient(const WKPageContextMenuClient*);
 329 #endif
 330     void initializeFindClient(const WKPageFindClient*);
 331     void initializeFindMatchesClient(const WKPageFindMatchesClient*);
 332     void initializeFormClient(const WKPageFormClient*);
 333     void initializeLoaderClient(const WKPageLoaderClient*);
 334     void initializePolicyClient(const WKPagePolicyClient*);
 335     void initializeResourceLoadClient(const WKPageResourceLoadClient*);
 336     void initializeUIClient(const WKPageUIClient*);
 337 #if OS(TIZEN)
 338     void initializeTizenClient(const WKPageTizenClient*);
 339 #endif
 340
 341     void initializeWebPage();
 342
 343     void close();
 344     bool tryClose();
 345     bool isClosed() const { return m_isClosed; }
 346
 347     void loadURL(const String&);
 348     void loadURLRequest(WebURLRequest*);
 349     void loadHTMLString(const String& htmlString, const String& baseURL);
 350     void loadAlternateHTMLString(const String& htmlString, const String& baseURL, const String& unreachableURL);
 351     void loadPlainTextString(const String& string);
 352     void loadWebArchiveData(const WebData*);
 353 #if OS(TIZEN)
 354     void loadContentsbyMimeType(const WebData*, const String& mimeType, const String& encoding, const String& baseURL);
 355 #endif
 356
 357     void stopLoading();
 358     void reload(bool reloadFromOrigin);
 359
 360     void goForward();
 361     bool canGoForward() const;
 362     void goBack();
 363     bool canGoBack() const;
 364
 365     void goToBackForwardItem(WebBackForwardListItem*);
 366     void tryRestoreScrollPosition();
 367     void didChangeBackForwardList(WebBackForwardListItem* addedItem, Vector<RefPtr<APIObject> >* removedItems);
 368     void shouldGoToBackForwardListItem(uint64_t itemID, bool& shouldGoToBackForwardListItem);
 369     void willGoToBackForwardListItem(uint64_t itemID, CoreIPC::ArgumentDecoder* arguments);
 370
 371     String activeURL() const;
 372     String provisionalURL() const;
 373     String committedURL() const;
 374
 375     bool willHandleHorizontalScrollEvents() const;
 376
 377     bool canShowMIMEType(const String& mimeType) const;
 378
 379     bool drawsBackground() const { return m_drawsBackground; }
 380     void setDrawsBackground(bool);
 381
 382     bool drawsTransparentBackground() const { return m_drawsTransparentBackground; }
 383     void setDrawsTransparentBackground(bool);
 384
 385     void viewWillStartLiveResize();
 386     void viewWillEndLiveResize();
 387
 388     void setInitialFocus(bool forward, bool isKeyboardEventValid, const WebKeyboardEvent&);
 389     void setWindowResizerSize(const WebCore::IntSize&);
 390
 391     void clearSelection();
 392
 393     void setViewNeedsDisplay(const WebCore::IntRect&);
 394     void displayView();
 395     void scrollView(const WebCore::IntRect& scrollRect, const WebCore::IntSize& scrollOffset);
 396
 397     enum {
 398         ViewWindowIsActive = 1 << 0,
 399         ViewIsFocused = 1 << 1,
 400         ViewIsVisible = 1 << 2,
 401         ViewIsInWindow = 1 << 3,
 402     };
 403     typedef unsigned ViewStateFlags;
 404     void viewStateDidChange(ViewStateFlags flags);
 405
 406     WebCore::IntSize viewSize() const;
 407     bool isViewVisible() const { return m_isVisible; }
 408     bool isViewWindowActive() const;
 409
 410     void executeEditCommand(const String& commandName);
 411 #if OS(TIZEN)
 412     void executeEditCommandWithArgument(const String& commandName, const String& argument);
 413 #endif
 414     void validateCommand(const String& commandName, PassRefPtr<ValidateCommandCallback>);
 415
 416     const EditorState& editorState() const { return m_editorState; }
 417     bool canDelete() const { return hasSelectedRange() && isContentEditable(); }
 418     bool hasSelectedRange() const { return m_editorState.selectionIsRange; }
 419     bool isContentEditable() const { return m_editorState.isContentEditable; }
 420
 421     bool maintainsInactiveSelection() const { return m_maintainsInactiveSelection; }
 422     void setMaintainsInactiveSelection(bool);
 423 #if PLATFORM(QT)
 424     void registerApplicationScheme(const String& scheme);
 425     void resolveApplicationSchemeRequest(QtNetworkRequestData);
 426     void sendApplicationSchemeReply(const QQuickNetworkReply*);
 427     void authenticationRequiredRequest(const String& hostname, const String& realm, const String& prefilledUsername, String& username, String& password);
 428     void certificateVerificationRequest(const String& hostname, bool& ignoreErrors);
 429     void proxyAuthenticationRequiredRequest(const String& hostname, uint16_t port, const String& prefilledUsername, String& username, String& password);
 430     void setUserScripts(const Vector<String>&);
 431 #endif // PLATFORM(QT).
 432 #if PLATFORM(EFL)
 433     void setThemePath(const String&);
 434 #endif
 435
 436 #if PLATFORM(QT)
 437     void setComposition(const String& text, Vector<WebCore::CompositionUnderline> underlines, uint64_t selectionStart, uint64_t selectionEnd, uint64_t replacementRangeStart, uint64_t replacementRangeEnd);
 438     void confirmComposition(const String& compositionString, int64_t selectionStart, int64_t selectionLength);
 439     void cancelComposition();
 440 #endif
 441 #if PLATFORM(MAC)
 442     void updateWindowIsVisible(bool windowIsVisible);
 443     void windowAndViewFramesChanged(const WebCore::IntRect& windowFrameInScreenCoordinates, const WebCore::IntRect& viewFrameInWindowCoordinates, const WebCore::IntPoint& accessibilityViewCoordinates);
 444
 445     void setComposition(const String& text, Vector<WebCore::CompositionUnderline> underlines, uint64_t selectionStart, uint64_t selectionEnd, uint64_t replacementRangeStart, uint64_t replacementRangeEnd);
 446     void confirmComposition();
 447     void cancelComposition();
 448     bool insertText(const String& text, uint64_t replacementRangeStart, uint64_t replacementRangeEnd);
 449     bool insertDictatedText(const String& text, uint64_t replacementRangeStart, uint64_t replacementRangeEnd, const Vector<WebCore::TextAlternativeWithRange>& dictationAlternatives);
 450     void getMarkedRange(uint64_t& location, uint64_t& length);
 451     void getSelectedRange(uint64_t& location, uint64_t& length);
 452     void getAttributedSubstringFromRange(uint64_t location, uint64_t length, AttributedString&);
 453     uint64_t characterIndexForPoint(const WebCore::IntPoint);
 454     WebCore::IntRect firstRectForCharacterRange(uint64_t, uint64_t);
 455     bool executeKeypressCommands(const Vector<WebCore::KeypressCommand>&);
 456
 457     void sendComplexTextInputToPlugin(uint64_t pluginComplexTextInputIdentifier, const String& textInput);
 458     CGContextRef containingWindowGraphicsContext();
 459     bool shouldDelayWindowOrderingForEvent(const WebMouseEvent&);
 460     bool acceptsFirstMouse(int eventNumber, const WebMouseEvent&);
 461
 462 #if USE(APPKIT)
 463     WKView* wkView() const;
 464 #endif
 465 #endif
 466 #if PLATFORM(WIN)
 467     void didChangeCompositionSelection(bool);
 468     void confirmComposition(const String&);
 469     void setComposition(const String&, Vector<WebCore::CompositionUnderline>&, int);
 470     WebCore::IntRect firstRectForCharacterInSelectedRange(int);
 471     String getSelectedText();
 472
 473     bool gestureWillBegin(const WebCore::IntPoint&);
 474     void gestureDidScroll(const WebCore::IntSize&);
 475     void gestureDidEnd();
 476
 477     void setGestureReachedScrollingLimit(bool);
 478
 479     HWND nativeWindow() const;
 480 #endif
 481 #if PLATFORM(EFL)
 482     void handleInputMethodKeydown(bool& handled);
 483     void confirmComposition(const String&);
 484     void setComposition(const String&, Vector<WebCore::CompositionUnderline>&, int);
 485     void cancelComposition();
 486 #endif
 487 #if PLATFORM(GTK)
 488     GtkWidget* viewWidget();
 489 #endif
 490 #if PLATFORM(EFL)
 491     Evas_Object* viewWidget();
 492 #endif
 493
 494 #if OS(TIZEN)
 495 #if ENABLE(TIZEN_REDUCE_KEY_LAGGING)
 496     static Eina_Bool pageContentResumeTimerFired(void* data);
 497 #endif
 498 #if ENABLE(TIZEN_TEXT_CARET_HANDLING_WK2)
 499     void setCaretPosition(const WebCore::IntPoint&);
 500 #endif
 501     bool scrollMainFrameBy(const WebCore::IntSize&);
 502     void scrollMainFrameTo(const WebCore::IntPoint&);
 503     WebCore::IntPoint& scrollPosition() { return m_scrollPosition; }
 504     WebCore::IntSize& contentsSize() { return m_contentsSize; }
 505     PassRefPtr<WebImage> createSnapshot(const WebCore::IntRect&, float);
 506
 507     void requestUpdateFormNavigation();
 508     void moveFocus(int);
 509     void updateFormNavigation(int length, int offset);
 510     void focusedNodeChanged(const WebCore::IntRect&);
 511
 512 #if ENABLE(TIZEN_WEB_STORAGE)
 513 #if ENABLE(TIZEN_WEBKIT2_NUMBER_TYPE_SUPPORT)
 514     void getWebStorageQuotaBytes(PassRefPtr<WebStorageQuotaCallback>);
 515     void didGetWebStorageQuotaBytes(const uint32_t quota, uint64_t callbackID);
 516 #endif
 517     void setWebStorageQuotaBytes(uint32_t quota);
 518 #endif
 519
 520 #if ENABLE(TIZEN_WEBKIT2_HIT_TEST)
 521 #if ENABLE(TOUCH_ADJUSTMENT)
 522     WebHitTestResult::Data hitTestResultAtPoint(const WebCore::IntPoint&, int hitTestMode = WebHitTestResult::HitTestModeDefault, const WebCore::IntSize& area = WebCore::IntSize());
 523 #else
 524     WebHitTestResult::Data hitTestResultAtPoint(const WebCore::IntPoint&, int hitTestMode = WebHitTestResult::HitTestModeDefault);
 525 #endif
 526 #endif
 527 #if ENABLE(TIZEN_CONTEXT_MENU_WEBKIT_2)
 528     void hideContextMenu();
 529     String contextMenuAbsoluteLinkURLString();
 530     String contextMenuAbsoluteImageURLString();
 531 #endif
 532 #if ENABLE(TIZEN_CLIPBOARD) || ENABLE(TIZEN_PASTEBOARD)
 533     void setClipboardData(const String& data, const String& type);
 534     void clearClipboardData();
 535 #endif
 536 #if ENABLE(TIZEN_WEBKIT2_CLIPBOARD_HELPER)
 537     void didSelectPasteMenuFromContextMenu(const String& data, const String& type);
 538     void pasteContextMenuSelected();
 539 #endif
 540 #if ENABLE(TIZEN_WEBKIT2_CONTEXT_MENU_CLIPBOARD)
 541     void clipboardContextMenuSelected();
 542     void executePasteFromClipboardItem(const String& data, const String& type);
 543 #endif
 544 #if ENABLE(TIZEN_REMOTE_WEB_INSPECTOR)
 545     uint32_t startInspectorServer(uint32_t port);
 546     bool stopInspectorServer();
 547 #endif
 548 #if ENABLE(TIZEN_MOBILE_WEB_PRINT)
 549     void createPagesToPDF(const WebCore::IntSize&, const WebCore::IntSize&, const String&);
 550 #endif
 551
 552     void scale(double, const WebCore::IntPoint&);
 553     void scaleImage(double, const WebCore::IntPoint&);
 554     double scaleFactor();
 555
 556 #if ENABLE(TIZEN_ORIENTATION_EVENTS)
 557     void sendOrientationChangeEvent(int orientation);
 558 #endif
 559
 560     void suspendPainting();
 561     void resumePainting();
 562
 563     void suspendJavaScriptAndResource();
 564     void resumeJavaScriptAndResource();
 565
 566     void suspendAnimations();
 567     void resumeAnimations();
 568
 569 #if ENABLE(TIZEN_PLUGIN_SUSPEND_RESUME)
 570     void suspendPlugin();
 571     void resumePlugin();
 572 #endif
 573
 574 #if ENABLE(TIZEN_WEBKIT2_TILED_AC)
 575     void purgeBackingStoresOfInactiveView();
 576 #endif
 577
 578 #endif // #if OS(TIZEN)
 579
 580 #if USE(TILED_BACKING_STORE)
 581     void setViewportSize(const WebCore::IntSize&);
 582 #endif
 583
 584     void handleMouseEvent(const NativeWebMouseEvent&);
 585     void handleWheelEvent(const NativeWebWheelEvent&);
 586     void handleKeyboardEvent(const NativeWebKeyboardEvent&);
 587 #if ENABLE(GESTURE_EVENTS)
 588     void handleGestureEvent(const WebGestureEvent&);
 589 #endif
 590 #if ENABLE(TOUCH_EVENTS)
 591     void handleTouchEvent(const NativeWebTouchEvent&);
 592 #if PLATFORM(QT)
 593     void handlePotentialActivation(const WebCore::IntPoint& touchPoint, const WebCore::IntSize& touchArea);
 594 #endif
 595 #endif
 596
 597     void scrollBy(WebCore::ScrollDirection, WebCore::ScrollGranularity);
 598     void centerSelectionInVisibleArea();
 599
 600     String pageTitle() const;
 601     const String& toolTip() const { return m_toolTip; }
 602
 603     void setUserAgent(const String&);
 604     const String& userAgent() const { return m_userAgent; }
 605     void setApplicationNameForUserAgent(const String&);
 606     const String& applicationNameForUserAgent() const { return m_applicationNameForUserAgent; }
 607     void setCustomUserAgent(const String&);
 608     const String& customUserAgent() const { return m_customUserAgent; }
 609     static String standardUserAgent(const String& applicationName = String());
 610 #if ENABLE(TIZEN_CUSTOM_HEADERS)
 611     void addCustomHeader(const String&, const String&);
 612     void removeCustomHeader(const String&);
 613     void clearCustomHeaders();
 614 #endif
 615
 616     bool supportsTextEncoding() const;
 617     void setCustomTextEncodingName(const String&);
 618     String customTextEncodingName() const { return m_customTextEncodingName; }
 619
 620     void resumeActiveDOMObjectsAndAnimations();
 621     void suspendActiveDOMObjectsAndAnimations();
 622
 623     double estimatedProgress() const;
 624
 625     void terminateProcess();
 626
 627     typedef bool (*WebPageProxySessionStateFilterCallback)(WKPageRef, WKStringRef type, WKTypeRef object, void* context);
 628     PassRefPtr<WebData> sessionStateData(WebPageProxySessionStateFilterCallback, void* context) const;
 629     void restoreFromSessionStateData(WebData*);
 630
 631     bool supportsTextZoom() const;
 632     double textZoomFactor() const { return m_mainFrameHasCustomRepresentation ? 1 : m_textZoomFactor; }
 633     void setTextZoomFactor(double);
 634     double pageZoomFactor() const;
 635     void setPageZoomFactor(double);
 636     void setPageAndTextZoomFactors(double pageZoomFactor, double textZoomFactor);
 637
 638     void scalePage(double scale, const WebCore::IntPoint& origin);
 639     double pageScaleFactor() const { return m_pageScaleFactor; }
 640
 641     float deviceScaleFactor() const;
 642     void setIntrinsicDeviceScaleFactor(float);
 643     void setCustomDeviceScaleFactor(float);
 644     void windowScreenDidChange(PlatformDisplayID);
 645
 646     LayerHostingMode layerHostingMode() const { return m_layerHostingMode; }
 647
 648     void setUseFixedLayout(bool);
 649     void setFixedLayoutSize(const WebCore::IntSize&);
 650     bool useFixedLayout() const { return m_useFixedLayout; };
 651     const WebCore::IntSize& fixedLayoutSize() const { return m_fixedLayoutSize; };
 652
 653     bool hasHorizontalScrollbar() const { return m_mainFrameHasHorizontalScrollbar; }
 654     bool hasVerticalScrollbar() const { return m_mainFrameHasVerticalScrollbar; }
 655
 656     bool isPinnedToLeftSide() const { return m_mainFrameIsPinnedToLeftSide; }
 657     bool isPinnedToRightSide() const { return m_mainFrameIsPinnedToRightSide; }
 658
 659     void setPaginationMode(WebCore::Page::Pagination::Mode);
 660     WebCore::Page::Pagination::Mode paginationMode() const { return m_paginationMode; }
 661     void setPaginationBehavesLikeColumns(bool);
 662     bool paginationBehavesLikeColumns() const { return m_paginationBehavesLikeColumns; }
 663     void setPageLength(double);
 664     double pageLength() const { return m_pageLength; }
 665     void setGapBetweenPages(double);
 666     double gapBetweenPages() const { return m_gapBetweenPages; }
 667     unsigned pageCount() const { return m_pageCount; }
 668
 669 #if PLATFORM(MAC)
 670     // Called by the web process through a message.
 671     void registerWebProcessAccessibilityToken(const CoreIPC::DataReference&);
 672     // Called by the UI process when it is ready to send its tokens to the web process.
 673     void registerUIProcessAccessibilityTokens(const CoreIPC::DataReference& elemenToken, const CoreIPC::DataReference& windowToken);
 674     bool readSelectionFromPasteboard(const String& pasteboardName);
 675     String stringSelectionForPasteboard();
 676     PassRefPtr<WebCore::SharedBuffer> dataSelectionForPasteboard(const String& pasteboardType);
 677     void makeFirstResponder();
 678
 679     ColorSpaceData colorSpace();
 680 #endif
 681
 682     void pageScaleFactorDidChange(double);
 683
 684     void setMemoryCacheClientCallsEnabled(bool);
 685
 686     // Find.
 687     void findString(const String&, FindOptions, unsigned maxMatchCount);
 688     void findStringMatches(const String&, FindOptions, unsigned maxMatchCount);
 689     void getImageForFindMatch(int32_t matchIndex);
 690     void selectFindMatch(int32_t matchIndex);
 691     void didGetImageForFindMatch(const ShareableBitmap::Handle& contentImageHandle, uint32_t matchIndex);
 692     void hideFindUI();
 693     void countStringMatches(const String&, FindOptions, unsigned maxMatchCount);
 694     void didCountStringMatches(const String&, uint32_t matchCount);
 695     void setFindIndicator(const WebCore::FloatRect& selectionRectInWindowCoordinates, const Vector<WebCore::FloatRect>& textRectsInSelectionRectCoordinates, float contentImageScaleFactor, const ShareableBitmap::Handle& contentImageHandle, bool fadeOut, bool animate);
 696     void didFindString(const String&, uint32_t matchCount);
 697     void didFailToFindString(const String&);
 698     void didFindStringMatches(const String&, Vector<Vector<WebCore::IntRect> > matchRects, int32_t firstIndexAfterSelection);
 699 #if PLATFORM(WIN)
 700     void didInstallOrUninstallPageOverlay(bool);
 701 #endif
 702
 703     void getContentsAsString(PassRefPtr<StringCallback>);
 704 #if ENABLE(MHTML)
 705     void getContentsAsMHTMLData(PassRefPtr<DataCallback>, bool useBinaryEncoding);
 706 #endif
 707     void getMainResourceDataOfFrame(WebFrameProxy*, PassRefPtr<DataCallback>);
 708     void getResourceDataFromFrame(WebFrameProxy*, WebURL*, PassRefPtr<DataCallback>);
 709     void getRenderTreeExternalRepresentation(PassRefPtr<StringCallback>);
 710     void getSelectionOrContentsAsString(PassRefPtr<StringCallback>);
 711     void getSourceForFrame(WebFrameProxy*, PassRefPtr<StringCallback>);
 712     void getWebArchiveOfFrame(WebFrameProxy*, PassRefPtr<DataCallback>);
 713     void runJavaScriptInMainFrame(const String&, PassRefPtr<ScriptValueCallback>);
 714     void forceRepaint(PassRefPtr<VoidCallback>);
 715
 716 #if ENABLE(WEB_INTENTS)
 717     void deliverIntentToFrame(WebFrameProxy*, WebIntentData*);
 718 #endif
 719
 720     float headerHeight(WebFrameProxy*);
 721     float footerHeight(WebFrameProxy*);
 722     void drawHeader(WebFrameProxy*, const WebCore::FloatRect&);
 723     void drawFooter(WebFrameProxy*, const WebCore::FloatRect&);
 724
 725 #if ENABLE(SCREEN_ORIENTATION_SUPPORT) && ENABLE(TIZEN_SCREEN_ORIENTATION_SUPPORT)
 726     void lockOrientation(int orientation, bool& result);
 727     void unlockOrientation();
 728 #endif
 729
 730 #if PLATFORM(MAC)
 731     // Dictionary.
 732     void performDictionaryLookupAtLocation(const WebCore::FloatPoint&);
 733 #endif
 734
 735     void receivedPolicyDecision(WebCore::PolicyAction, WebFrameProxy*, uint64_t listenerID);
 736
 737     void backForwardRemovedItem(uint64_t itemID);
 738
 739 #if ENABLE(DRAG_SUPPORT)
 740     // Drag and drop support.
 741     void dragEntered(WebCore::DragData*, const String& dragStorageName = String());
 742     void dragUpdated(WebCore::DragData*, const String& dragStorageName = String());
 743     void dragExited(WebCore::DragData*, const String& dragStorageName = String());
 744 #if ENABLE(TIZEN_DRAG_SUPPORT)
 745     void performDrag(WebCore::DragData*, const String& dragStorageName = String());
 746 #else
 747     void performDrag(WebCore::DragData*, const String& dragStorageName, const SandboxExtension::Handle&, const SandboxExtension::HandleArray&);
 748 #endif
 749
 750     void didPerformDragControllerAction(WebCore::DragSession);
 751     void dragEnded(const WebCore::IntPoint& clientPosition, const WebCore::IntPoint& globalPosition, uint64_t operation);
 752 #if PLATFORM(MAC)
 753     void setDragImage(const WebCore::IntPoint& clientPosition, const ShareableBitmap::Handle& dragImageHandle, bool isLinkDrag);
 754     void setPromisedData(const String& pasteboardName, const SharedMemory::Handle& imageHandle, uint64_t imageSize, const String& filename, const String& extension,
 755                          const String& title, const String& url, const String& visibleURL, const SharedMemory::Handle& archiveHandle, uint64_t archiveSize);
 756 #endif
 757 #if PLATFORM(WIN)
 758     void startDragDrop(const WebCore::IntPoint& imagePoint, const WebCore::IntPoint& dragPoint, uint64_t okEffect, const HashMap<UINT, Vector<String> >& dataMap, uint64_t fileSize, const String& pathname, const SharedMemory::Handle& fileContentHandle, const WebCore::IntSize& dragImageSize, const SharedMemory::Handle& dragImageHandle, bool isLinkDrag);
 759 #endif
 760 #if PLATFORM(QT) || PLATFORM(GTK) || ENABLE(TIZEN_DRAG_SUPPORT)
 761     void startDrag(const WebCore::DragData&, const ShareableBitmap::Handle& dragImage);
 762 #endif
 763 #endif
 764
 765     void didReceiveMessage(CoreIPC::Connection*, CoreIPC::MessageID, CoreIPC::ArgumentDecoder*);
 766     void didReceiveSyncMessage(CoreIPC::Connection*, CoreIPC::MessageID, CoreIPC::ArgumentDecoder*, OwnPtr<CoreIPC::ArgumentEncoder>&);
 767
 768     void processDidBecomeUnresponsive();
 769     void interactionOccurredWhileProcessUnresponsive();
 770     void processDidBecomeResponsive();
 771     void processDidCrash();
 772
 773 #if USE(ACCELERATED_COMPOSITING)
 774     virtual void enterAcceleratedCompositingMode(const LayerTreeContext&);
 775     virtual void exitAcceleratedCompositingMode();
 776     virtual void updateAcceleratedCompositingMode(const LayerTreeContext&);
 777 #endif
 778
 779     void didDraw();
 780
 781     enum UndoOrRedo { Undo, Redo };
 782     void addEditCommand(WebEditCommandProxy*);
 783     void removeEditCommand(WebEditCommandProxy*);
 784     bool isValidEditCommand(WebEditCommandProxy*);
 785     void registerEditCommand(PassRefPtr<WebEditCommandProxy>, UndoOrRedo);
 786
 787 #if PLATFORM(MAC)
 788     void registerKeypressCommandName(const String& name) { m_knownKeypressCommandNames.add(name); }
 789     bool isValidKeypressCommandName(const String& name) const { return m_knownKeypressCommandNames.contains(name); }
 790 #endif
 791
 792     WebProcessProxy* process() const;
 793     PlatformProcessIdentifier processIdentifier() const;
 794
 795     WebPageGroup* pageGroup() const { return m_pageGroup.get(); }
 796
 797     bool isValid();
 798
 799     const String& urlAtProcessExit() const { return m_urlAtProcessExit; }
 800     WebFrameProxy::LoadState loadStateAtProcessExit() const { return m_loadStateAtProcessExit; }
 801
 802 #if ENABLE(DRAG_SUPPORT)
 803     WebCore::DragSession dragSession() const { return m_currentDragSession; }
 804     void resetDragOperation() { m_currentDragSession = WebCore::DragSession(); }
 805 #endif
 806
 807     void preferencesDidChange();
 808
 809 #if ENABLE(CONTEXT_MENUS)
 810     // Called by the WebContextMenuProxy.
 811     void contextMenuItemSelected(const WebContextMenuItemData&);
 812 #endif
 813
 814     // Called by the WebOpenPanelResultListenerProxy.
 815     void didChooseFilesForOpenPanel(const Vector<String>&);
 816     void didCancelForOpenPanel();
 817
 818     WebPageCreationParameters creationParameters() const;
 819
 820 #if PLATFORM(QT)
 821     void findZoomableAreaForPoint(const WebCore::IntPoint&, const WebCore::IntSize&);
 822     void didReceiveMessageFromNavigatorQtObject(const String&);
 823 #endif
 824
 825 #if PLATFORM(QT) || PLATFORM(EFL)
 826     void handleDownloadRequest(DownloadProxy*);
 827 #endif
 828 #if OS(TIZEN)
 829     void findZoomableAreaForPoint(const WebCore::IntPoint&, const WebCore::IntSize&);
 830 #endif // #if OS(TIZEN)
 831
 832     void advanceToNextMisspelling(bool startBeforeSelection) const;
 833     void changeSpellingToWord(const String& word) const;
 834 #if USE(APPKIT)
 835     void uppercaseWord();
 836     void lowercaseWord();
 837     void capitalizeWord();
 838 #endif
 839
 840 #if PLATFORM(MAC)
 841     bool isSmartInsertDeleteEnabled() const { return m_isSmartInsertDeleteEnabled; }
 842     void setSmartInsertDeleteEnabled(bool);
 843 #endif
 844
 845 #if PLATFORM(GTK)
 846     String accessibilityPlugID() const { return m_accessibilityPlugID; }
 847 #endif
 848
 849     void setCanRunModal(bool);
 850     bool canRunModal();
 851
 852     void beginPrinting(WebFrameProxy*, const PrintInfo&);
 853     void endPrinting();
 854     void computePagesForPrinting(WebFrameProxy*, const PrintInfo&, PassRefPtr<ComputedPagesCallback>);
 855 #if PLATFORM(MAC) || PLATFORM(WIN)
 856     void drawRectToPDF(WebFrameProxy*, const PrintInfo&, const WebCore::IntRect&, PassRefPtr<DataCallback>);
 857     void drawPagesToPDF(WebFrameProxy*, const PrintInfo&, uint32_t first, uint32_t count, PassRefPtr<DataCallback>);
 858 #elif PLATFORM(GTK)
 859     void drawPagesForPrinting(WebFrameProxy*, const PrintInfo&, PassRefPtr<PrintFinishedCallback>);
 860 #endif
 861
 862     const String& pendingAPIRequestURL() const { return m_pendingAPIRequestURL; }
 863
 864     void flashBackingStoreUpdates(const Vector<WebCore::IntRect>& updateRects);
 865
 866 #if PLATFORM(MAC)
 867     void handleAlternativeTextUIResult(const String& result);
 868 #endif
 869
 870     static void setDebugPaintFlags(WKPageDebugPaintFlags flags) { s_debugPaintFlags = flags; }
 871     static WKPageDebugPaintFlags debugPaintFlags() { return s_debugPaintFlags; }
 872
 873     // Color to be used with kWKDebugFlashViewUpdates.
 874     static WebCore::Color viewUpdatesFlashColor();
 875
 876     // Color to be used with kWKDebugFlashBackingStoreUpdates.
 877     static WebCore::Color backingStoreUpdatesFlashColor();
 878
 879     void saveDataToFileInDownloadsFolder(const String& suggestedFilename, const String& mimeType, const String& originatingURLString, WebData*);
 880
 881     void linkClicked(const String&, const WebMouseEvent&);
 882
 883     WebCore::IntRect visibleScrollerThumbRect() const { return m_visibleScrollerThumbRect; }
 884
 885     uint64_t renderTreeSize() const { return m_renderTreeSize; }
 886
 887     void setShouldSendEventsSynchronously(bool sync) { m_shouldSendEventsSynchronously = sync; };
 888 #if ENABLE(TIZEN_INPUT_TAG_EXTENSION) || ENABLE(TIZEN_WEBKIT2_FORM_DATABASE)
 889     void setCurrentTargetInputElementValue(const String& inputValue);
 890     void setFocusedInputElementValue(const String& inputValue);
 891     String getFocusedInputElementValue();
 892 #endif
 893
 894 #if ENABLE(TIZEN_DATALIST_ELEMENT)
 895     Vector<String> getFocusedInputElementDataList();
 896 #endif
 897
 898     void printMainFrame();
 899
 900 #if ENABLE(TIZEN_REGISTER_PROTOCOL_HANDLER)
 901     void registerProtocolHandler(const String& scheme, const String& baseURL, const String& url, const String& title);
 902 #endif
 903 #if ENABLE(TIZEN_CUSTOM_SCHEME_HANDLER)
 904     void isProtocolHandlerRegistered(const String& scheme, const String& baseURL, const String& url, unsigned int& result);
 905     void unregisterProtocolHandler(const String& scheme, const String& baseURL, const String& url);
 906 #endif
 907 #if ENABLE(TIZEN_REGISTER_CONTENT_HANDLER)
 908     void registerContentHandler(const String& mimeType, const String& baseURL, const String& url, const String& title);
 909     void isContentHandlerRegistered(const String& mimeType, const String& baseURL, const String& url, unsigned int& result);
 910     void unregisterContentHandler(const String& mimeType, const String& baseURL, const String& url);
 911 #endif
 912
 913 #if ENABLE(TIZEN_SEARCH_PROVIDER)
 914     void addSearchProvider(const String& baseURL, const String& engineURL);
 915     void isSearchProviderInstalled(const String& baseURL, const String& engineURL, uint64_t& result);
 916 #endif
 917
 918 #if ENABLE(TIZEN_SUPPORT_WEBAPP_META_TAG)
 919     void getStandaloneStatus(bool& standalone);
 920     void getWebAppCapable(PassRefPtr<BooleanCallback>);
 921     void getWebAppIconURL(PassRefPtr<StringCallback>);
 922     void getWebAppIconURLs(PassRefPtr<DictionaryCallback>);
 923 #endif
 924
 925     void setMediaVolume(float);
 926
 927 #if OS(TIZEN)
 928     void replyJavaScriptAlert();
 929     void replyJavaScriptConfirm(bool result);
 930     void replyJavaScriptPrompt(const String& result);
 931 #if ENABLE(TIZEN_SUPPORT_BEFORE_UNLOAD_CONFIRM_PANEL)
 932     void replyBeforeUnloadConfirmPanel(bool result);
 933 #endif
 934 #endif
 935
 936 #if ENABLE(TIZEN_ON_AUTHENTICATION_REQUESTED)
 937     void replyReceiveAuthenticationChallengeInFrame(bool result);
 938 #endif
 939
 940 #if ENABLE(TIZEN_CERTIFICATE_HANDLING)
 941     void replyPolicyForCertificateError(bool result);
 942 #endif
 943
 944     // WebPopupMenuProxy::Client
 945     virtual NativeWebMouseEvent* currentlyProcessedMouseDownEvent();
 946
 947 #if ENABLE(TIZEN_PAGE_VISIBILITY_API)
 948     void setPageVisibility(WebCore::PageVisibilityState, bool isInitialState);
 949 #endif
 950
 951 #if ENABLE(TIZEN_CSS_OVERFLOW_SCROLL_ACCELERATION)
 952     bool scrollOverflow(const WebCore::FloatPoint&);
 953     bool setPressedNodeAtPoint(const WebCore::IntPoint&, bool checkOverflowLayer, WebLayerID&);
 954     void setLoadingFinished(const bool isLoadingFinished) { m_isLoadingFinished = isLoadingFinished; }
 955     bool isLoadingFinished() const { return m_isLoadingFinished; }
 956     bool askOverflow() const { return m_askOverflow; }
 957     void setOverflowResult(bool pressed, WebLayerID webLayerID);
 958 #endif
 959
 960 #if ENABLE(TIZEN_ISF_PORT)
 961     void prepareKeyDownEvent();
 962     void deleteSurroundingText(int, int);
 963
 964     void didCancelComposition();
 965     void removeInputMethodContext(uintptr_t);
 966     void recalcFilterEvent(const EditorState&, bool, bool&);
 967 #endif
 968
 969     void setBackgroundColor(double red, double green, double blue, double alpha);
 970 #if ENABLE(TIZEN_WEBKIT2_TILED_AC)
 971     bool makeContextCurrent();
 972 #endif
 973
 974 #if OS(TIZEN)
 975     void didRenderFrame();
 976 #endif
 977
 978 #if PLATFORM(GTK) && USE(TEXTURE_MAPPER_GL)
 979     void widgetMapped(uint64_t nativeWindowId);
 980 #endif
 981
 982     void setSuppressVisibilityUpdates(bool flag) { m_suppressVisibilityUpdates = flag; }
 983     bool suppressVisibilityUpdates() { return m_suppressVisibilityUpdates; }
 984
 985 #if ENABLE(TIZEN_INPUT_COLOR_PICKER) // wait for upstream
 986 #if ENABLE(INPUT_TYPE_COLOR)
 987     void setColorChooserColor(const WebCore::Color&);
 988     void endColorChooser();
 989 #endif
 990 #endif
 991
 992 #if ENABLE(TIZEN_MULTIPLE_SELECT)
 993     void valueChangedForPopupMenuMultiple(WebPopupMenuProxy*, Vector<int32_t> newSelectedIndex);
 994 #endif
 995
 996 #if ENABLE(TIZEN_NATIVE_MEMORY_SNAPSHOT)
 997     void dumpMemorySnapshot();
 998 #endif
 999
1000 #if ENABLE(TIZEN_OFFLINE_PAGE_SAVE)
1001     void saveSerializedHTMLDataForMainPage(const String& serializedData, const String& fileName);
1002     void saveSubresourcesData(Vector<WebSubresourceTizen> subresourceData);
1003     void startOfflinePageSave(String subresourceFolderName);
1004 #endif
1005
1006 #if ENABLE(TIZEN_WEBKIT2_TEXT_SELECTION)
1007     bool selectClosestWord(const WebCore::IntPoint&, bool isAutoWordSelection);
1008     int setLeftSelection(const WebCore::IntPoint&, const int direction);
1009     int setRightSelection(const WebCore::IntPoint&, const int direction);
1010     bool getSelectionHandlers(WebCore::IntRect& leftRect, WebCore::IntRect& rightRect, int& selectionDirection);
1011     String getSelectionText();
1012     bool selectionRangeClear();
1013     bool scrollContentByCharacter(const WebCore::IntPoint&, WebCore::SelectionDirection direction);
1014     bool scrollContentByLine(const WebCore::IntPoint&, WebCore::SelectionDirection direction);
1015     bool getFocusedSubFrameRect(WebCore::IntRect&);
1016 #endif
1017
1018 #if ENABLE(TIZEN_LINK_MAGNIFIER)
1019     void getLinkMagnifierRect(const WebCore::IntPoint&, const WebCore::IntSize&);
1020     void openLink(const WebCore::IntPoint&);
1021 #endif
1022
1023 #if ENABLE(TIZEN_SCREEN_READER)
1024     bool moveScreenReaderFocus(bool);
1025     void moveScreenReaderFocusByPoint(const WebCore::IntPoint&);
1026     void clearScreenReaderFocus();
1027     bool raiseTapEvent(const WebCore::IntPoint&);
1028     void adjustScreenReaderFocusedObjectValue(bool);
1029     void clearScreenReader();
1030
1031     void didScreenReaderTextChanged(const String&);
1032 #endif
1033
1034 #if ENABLE(TIZEN_WEBKIT2_FOCUS_RING)
1035     void didChangeFocusedRects(const Vector<WebCore::IntRect>&);
1036     void recalcFocusedRects();
1037 #endif
1038
1039 #if ENABLE(TIZEN_CSP)
1040     void setContentSecurityPolicy(const String& policy, WebCore::ContentSecurityPolicy::HeaderType type);
1041 #endif
1042
1043 #if ENABLE(TIZEN_APPLICATION_CACHE)
1044     void replyApplicationCachePermission(bool allow);
1045 #endif
1046
1047 #if ENABLE(TIZEN_INDEXED_DATABASE)
1048     void replyExceededIndexedDatabaseQuota(bool allow);
1049 #endif
1050
1051 #if ENABLE(TIZEN_SQL_DATABASE)
1052     void replyExceededDatabaseQuota(bool allow);
1053 #endif
1054
1055 #if ENABLE(TIZEN_FILE_SYSTEM)
1056     void replyExceededLocalFileSystemQuota(bool allow);
1057 #endif
1058
1059 #if ENABLE(TIZEN_USE_SETTINGS_FONT)
1060     void useSettingsFont();
1061 #endif
1062
1063 #if ENABLE(TIZEN_FOCUS_UI)
1064     void setFocusUIEnabled(bool);
1065 #endif
1066
1067 private:
1068     WebPageProxy(PageClient*, PassRefPtr<WebProcessProxy>, WebPageGroup*, uint64_t pageID);
1069
1070     virtual Type type() const { return APIType; }
1071
1072     // WebPopupMenuProxy::Client
1073     virtual void valueChangedForPopupMenu(WebPopupMenuProxy*, int32_t newSelectedIndex);
1074     virtual void setTextFromItemForPopupMenu(WebPopupMenuProxy*, int32_t index);
1075 #if PLATFORM(GTK)
1076     virtual void failedToShowPopupMenu();
1077 #endif
1078 #if PLATFORM(QT)
1079     virtual void changeSelectedIndex(int32_t newSelectedIndex);
1080     virtual void closePopupMenu();
1081 #endif
1082
1083     // Implemented in generated WebPageProxyMessageReceiver.cpp
1084     void didReceiveWebPageProxyMessage(CoreIPC::Connection*, CoreIPC::MessageID, CoreIPC::ArgumentDecoder*);
1085     void didReceiveSyncWebPageProxyMessage(CoreIPC::Connection*, CoreIPC::MessageID, CoreIPC::ArgumentDecoder*, OwnPtr<CoreIPC::ArgumentEncoder>&);
1086
1087     void didCreateMainFrame(uint64_t frameID);
1088     void didCreateSubframe(uint64_t frameID, uint64_t parentFrameID);
1089     void didSaveFrameToPageCache(uint64_t frameID);
1090     void didRestoreFrameFromPageCache(uint64_t frameID, uint64_t parentFrameID);
1091
1092     void didStartProvisionalLoadForFrame(uint64_t frameID, const String& url, const String& unreachableURL, CoreIPC::ArgumentDecoder*);
1093     void didReceiveServerRedirectForProvisionalLoadForFrame(uint64_t frameID, const String&, CoreIPC::ArgumentDecoder*);
1094     void didFailProvisionalLoadForFrame(uint64_t frameID, const WebCore::ResourceError&, CoreIPC::ArgumentDecoder*);
1095     void didCommitLoadForFrame(uint64_t frameID, const String& mimeType, bool frameHasCustomRepresentation, const PlatformCertificateInfo&, CoreIPC::ArgumentDecoder*);
1096     void didFinishDocumentLoadForFrame(uint64_t frameID, CoreIPC::ArgumentDecoder*);
1097     void didFinishLoadForFrame(uint64_t frameID, CoreIPC::ArgumentDecoder*);
1098     void didFailLoadForFrame(uint64_t frameID, const WebCore::ResourceError&, CoreIPC::ArgumentDecoder*);
1099     void didSameDocumentNavigationForFrame(uint64_t frameID, uint32_t sameDocumentNavigationType, const String&, CoreIPC::ArgumentDecoder*);
1100     void didReceiveTitleForFrame(uint64_t frameID, const String&, CoreIPC::ArgumentDecoder*);
1101     void didFirstLayoutForFrame(uint64_t frameID, CoreIPC::ArgumentDecoder*);
1102     void didFirstVisuallyNonEmptyLayoutForFrame(uint64_t frameID, CoreIPC::ArgumentDecoder*);
1103     void didNewFirstVisuallyNonEmptyLayout(CoreIPC::ArgumentDecoder*);
1104     void didRemoveFrameFromHierarchy(uint64_t frameID, CoreIPC::ArgumentDecoder*);
1105     void didDisplayInsecureContentForFrame(uint64_t frameID, CoreIPC::ArgumentDecoder*);
1106     void didRunInsecureContentForFrame(uint64_t frameID, CoreIPC::ArgumentDecoder*);
1107     void didDetectXSSForFrame(uint64_t frameID, CoreIPC::ArgumentDecoder*);
1108     void frameDidBecomeFrameSet(uint64_t frameID, bool);
1109     void didStartProgress();
1110     void didChangeProgress(double);
1111     void didFinishProgress();
1112
1113 #if ENABLE(TIZEN_PLUGIN_CUSTOM_REQUEST)
1114     void processPluginCustomRequest(const String& request, const String& msg);
1115 #endif
1116
1117 #if ENABLE(WEB_INTENTS)
1118     void didReceiveIntentForFrame(uint64_t frameID, const IntentData&, CoreIPC::ArgumentDecoder*);
1119 #endif
1120 #if ENABLE(WEB_INTENTS_TAG)
1121     void registerIntentServiceForFrame(uint64_t frameID, const IntentServiceInfo&, CoreIPC::ArgumentDecoder*);
1122 #endif
1123
1124 #if ENABLE(TIZEN_DOWNLOAD_ATTRIBUTE)
1125     // Called by the web process through a message when the download need to be initiated from the web process.
1126     void startDownload(const WebCore::ResourceRequest&, const String& suggestedName = String());
1127 #endif
1128
1129      void decidePolicyForNavigationAction(uint64_t frameID, uint32_t navigationType, uint32_t modifiers, int32_t mouseButton, const WebCore::ResourceRequest&, uint64_t listenerID, CoreIPC::ArgumentDecoder*, bool& receivedPolicyAction, uint64_t& policyAction, uint64_t& downloadID);
1130     void decidePolicyForNewWindowAction(uint64_t frameID, uint32_t navigationType, uint32_t modifiers, int32_t mouseButton, const WebCore::ResourceRequest&, const String& frameName, uint64_t listenerID, CoreIPC::ArgumentDecoder*);
1131     void decidePolicyForResponse(uint64_t frameID, const WebCore::ResourceResponse&, const WebCore::ResourceRequest&, uint64_t listenerID, CoreIPC::ArgumentDecoder* arguments, bool& receivedPolicyAction, uint64_t& policyAction, uint64_t& downloadID);
1132     void unableToImplementPolicy(uint64_t frameID, const WebCore::ResourceError&, CoreIPC::ArgumentDecoder* arguments);
1133
1134 #if ENABLE(TIZEN_WEBKIT2_FORM_DATABASE)
1135     void willSubmitForm(uint64_t frameID, uint64_t sourceFrameID, const StringPairVector& textFieldValues, bool containsPasswordData, bool isAutoComplete, uint64_t listenerID, CoreIPC::ArgumentDecoder*);
1136 #else
1137     void willSubmitForm(uint64_t frameID, uint64_t sourceFrameID, const StringPairVector& textFieldValues, uint64_t listenerID, CoreIPC::ArgumentDecoder*);
1138 #endif
1139
1140     // Resource load client
1141     void didInitiateLoadForResource(uint64_t frameID, uint64_t resourceIdentifier, const WebCore::ResourceRequest&, bool pageIsProvisionallyLoading);
1142     void didSendRequestForResource(uint64_t frameID, uint64_t resourceIdentifier, const WebCore::ResourceRequest&, const WebCore::ResourceResponse& redirectResponse);
1143     void didReceiveResponseForResource(uint64_t frameID, uint64_t resourceIdentifier, const WebCore::ResourceResponse&);
1144     void didReceiveContentLengthForResource(uint64_t frameID, uint64_t resourceIdentifier, uint64_t contentLength);
1145     void didFinishLoadForResource(uint64_t frameID, uint64_t resourceIdentifier);
1146     void didFailLoadForResource(uint64_t frameID, uint64_t resourceIdentifier, const WebCore::ResourceError&);
1147
1148     // UI client
1149     void createNewPage(const WebCore::ResourceRequest&, const WebCore::WindowFeatures&, uint32_t modifiers, int32_t mouseButton, uint64_t& newPageID, WebPageCreationParameters&);
1150     void showPage();
1151     void closePage(bool stopResponsivenessTimer);
1152 #if OS(TIZEN)
1153     void runJavaScriptAlert(uint64_t frameID, const String&, PassRefPtr<Messages::WebPageProxy::RunJavaScriptAlert::DelayedReply>);
1154     void runJavaScriptConfirm(uint64_t frameID, const String&, PassRefPtr<Messages::WebPageProxy::RunJavaScriptConfirm::DelayedReply>);
1155     void runJavaScriptPrompt(uint64_t frameID, const String&, const String&, PassRefPtr<Messages::WebPageProxy::RunJavaScriptPrompt::DelayedReply>);
1156 #else
1157     void runJavaScriptAlert(uint64_t frameID, const String&);
1158     void runJavaScriptConfirm(uint64_t frameID, const String&, bool& result);
1159     void runJavaScriptPrompt(uint64_t frameID, const String&, const String&, String& result);
1160 #endif
1161     void shouldInterruptJavaScript(bool& result);
1162     void setStatusText(const String&);
1163     void mouseDidMoveOverElement(const WebHitTestResult::Data& hitTestResultData, uint32_t modifiers, CoreIPC::ArgumentDecoder*);
1164     void unavailablePluginButtonClicked(uint32_t opaquePluginUnavailabilityReason, const String& mimeType, const String& url, const String& pluginsPageURL);
1165     void setToolbarsAreVisible(bool toolbarsAreVisible);
1166     void getToolbarsAreVisible(bool& toolbarsAreVisible);
1167     void setMenuBarIsVisible(bool menuBarIsVisible);
1168     void getMenuBarIsVisible(bool& menuBarIsVisible);
1169     void setStatusBarIsVisible(bool statusBarIsVisible);
1170     void getStatusBarIsVisible(bool& statusBarIsVisible);
1171     void setIsResizable(bool isResizable);
1172     void getIsResizable(bool& isResizable);
1173     void setWindowFrame(const WebCore::FloatRect&);
1174     void getWindowFrame(WebCore::FloatRect&);
1175     void screenToWindow(const WebCore::IntPoint& screenPoint, WebCore::IntPoint& windowPoint);
1176     void windowToScreen(const WebCore::IntRect& viewRect, WebCore::IntRect& result);
1177 #if ENABLE(TIZEN_SUPPORT_BEFORE_UNLOAD_CONFIRM_PANEL)
1178     void runBeforeUnloadConfirmPanel(const String& message, uint64_t frameID, PassRefPtr<Messages::WebPageProxy::RunBeforeUnloadConfirmPanel::DelayedReply>);
1179 #else
1180     void runBeforeUnloadConfirmPanel(const String& message, uint64_t frameID, bool& shouldClose);
1181 #endif
1182     void didChangeViewportProperties(const WebCore::ViewportAttributes&);
1183     void pageDidScroll();
1184     void runOpenPanel(uint64_t frameID, const WebCore::FileChooserSettings&);
1185     void printFrame(uint64_t frameID);
1186 #if ENABLE(TIZEN_SQL_DATABASE)
1187     void exceededDatabaseQuota(uint64_t frameID, const String& originIdentifier, const String& displayName, uint64_t expectedUsage, PassRefPtr<Messages::WebPageProxy::ExceededDatabaseQuota::DelayedReply>);
1188 #else
1189     void exceededDatabaseQuota(uint64_t frameID, const String& originIdentifier, const String& databaseName, const String& displayName, uint64_t currentQuota, uint64_t currentOriginUsage, uint64_t currentDatabaseUsage, uint64_t expectedUsage, uint64_t& newQuota);
1190 #endif
1191 #if ENABLE(TIZEN_APPLICATION_CACHE)
1192     void requestApplicationCachePermission(uint64_t frameID, const String& originIdentifier, PassRefPtr<Messages::WebPageProxy::RequestApplicationCachePermission::DelayedReply>);
1193 #endif
1194     void requestGeolocationPermissionForFrame(uint64_t geolocationID, uint64_t frameID, String originIdentifier);
1195     void runModal();
1196     void notifyScrollerThumbIsVisibleInRect(const WebCore::IntRect&);
1197     void recommendedScrollbarStyleDidChange(int32_t newStyle);
1198     void didChangeScrollbarsForMainFrame(bool hasHorizontalScrollbar, bool hasVerticalScrollbar);
1199     void didChangeScrollOffsetPinningForMainFrame(bool pinnedToLeftSide, bool pinnedToRightSide);
1200 #if PLATFORM(EFL)
1201     void didChangeScrollPositionForMainFrame(const WebCore::IntPoint&);
1202 #endif
1203     void didChangePageCount(unsigned);
1204     void didFailToInitializePlugin(const String& mimeType);
1205     void didBlockInsecurePluginVersion(const String& mimeType, const String& urlString);
1206     void setCanShortCircuitHorizontalWheelEvents(bool canShortCircuitHorizontalWheelEvents) { m_canShortCircuitHorizontalWheelEvents = canShortCircuitHorizontalWheelEvents; }
1207
1208     void reattachToWebProcess();
1209     void reattachToWebProcessWithItem(WebBackForwardListItem*);
1210
1211     void requestNotificationPermission(uint64_t notificationID, const String& originString);
1212
1213     void showNotification(const String& title, const String& body, const String& iconURL, const String& tag, const String& originString, uint64_t notificationID);
1214
1215 #if ENABLE(TIZEN_MEDIA_STREAM)
1216     void requestUserMediaPermission(uint64_t userMediaID);
1217 #endif
1218
1219 #if USE(TILED_BACKING_STORE)
1220     void pageDidRequestScroll(const WebCore::IntPoint&);
1221 #endif
1222
1223 #if ENABLE(TIZEN_WEBKIT2_HISTORICAL_RESTORE_VISIBLE_CONTENT_RECT)
1224     void pageDidRequestRestoreVisibleContentRect(const WebCore::IntPoint&, float);
1225 #endif
1226
1227 #if PLATFORM(QT) || OS(TIZEN)
1228     void didChangeContentsSize(const WebCore::IntSize&);
1229     void didFindZoomableArea(const WebCore::IntPoint&, const WebCore::IntRect&);
1230 #endif
1231 #if ENABLE(TOUCH_EVENTS)
1232     void needTouchEvents(bool);
1233 #endif
1234
1235 #if ENABLE(TIZEN_SUPPORT_WEBAPP_META_TAG)
1236     void didGetWebAppCapable(const bool capable, uint64_t callbackID);
1237     void didGetWebAppIconURL(const String& iconURL, uint64_t callbackID);
1238     void didGetWebAppIconURLs(const StringPairVector& iconURLs, uint64_t callbackID);
1239 #endif
1240 #if ENABLE(TIZEN_ICON_DATABASE)
1241     void didReceiveIcon();
1242 #endif
1243
1244 #if ENABLE(INPUT_TYPE_COLOR)
1245     void showColorChooser(const WebCore::Color& initialColor);
1246 #if !ENABLE(TIZEN_INPUT_COLOR_PICKER) // wait for upstream
1247     void setColorChooserColor(const WebCore::Color&);
1248     void endColorChooser();
1249 #endif
1250     void didChooseColor(const WebCore::Color&);
1251     void didEndColorChooser();
1252 #endif
1253
1254     void editorStateChanged(const EditorState&);
1255     // Back/Forward list management
1256     void backForwardAddItem(uint64_t itemID);
1257     void backForwardGoToItem(uint64_t itemID, SandboxExtension::Handle&);
1258     void backForwardItemAtIndex(int32_t index, uint64_t& itemID);
1259     void backForwardBackListCount(int32_t& count);
1260     void backForwardForwardListCount(int32_t& count);
1261     void backForwardClear();
1262
1263     // Undo management
1264     void registerEditCommandForUndo(uint64_t commandID, uint32_t editAction);
1265     void clearAllEditCommands();
1266     void canUndoRedo(uint32_t action, bool& result);
1267     void executeUndoRedo(uint32_t action, bool& result);
1268
1269     // Keyboard handling
1270 #if PLATFORM(MAC)
1271     void interpretQueuedKeyEvent(const EditorState&, bool& handled, Vector<WebCore::KeypressCommand>&);
1272     void executeSavedCommandBySelector(const String& selector, bool& handled);
1273 #endif
1274
1275 #if PLATFORM(GTK)
1276     void getEditorCommandsForKeyEvent(const AtomicString&, Vector<String>&);
1277     void bindAccessibilityTree(const String&);
1278 #endif
1279 #if PLATFORM(EFL)
1280     void getEditorCommandsForKeyEvent(Vector<String>&);
1281 #endif
1282
1283     // Popup Menu.
1284     void showPopupMenu(const WebCore::IntRect& rect, uint64_t textDirection, const Vector<WebPopupItem>& items, int32_t selectedIndex, const PlatformPopupMenuData&);
1285     void hidePopupMenu();
1286 #if PLATFORM(WIN)
1287     void setPopupMenuSelectedIndex(int32_t);
1288 #endif
1289 #if ENABLE(TIZEN_WEBKIT2_POPUP_INTERNAL)
1290     void updatePopupMenu(uint64_t textDirection, const Vector<WebPopupItem>& items, int32_t selectedIndex);
1291 #endif
1292
1293 #if ENABLE(CONTEXT_MENUS)
1294     // Context Menu.
1295     void showContextMenu(const WebCore::IntPoint& menuLocation, const WebHitTestResult::Data&, const Vector<WebContextMenuItemData>&, CoreIPC::ArgumentDecoder*);
1296     void internalShowContextMenu(const WebCore::IntPoint& menuLocation, const WebHitTestResult::Data&, const Vector<WebContextMenuItemData>&, CoreIPC::ArgumentDecoder*);
1297 #endif
1298
1299     // Search popup results
1300     void saveRecentSearches(const String&, const Vector<String>&);
1301     void loadRecentSearches(const String&, Vector<String>&);
1302
1303 #if PLATFORM(MAC)
1304     // Speech.
1305     void getIsSpeaking(bool&);
1306     void speak(const String&);
1307     void stopSpeaking();
1308
1309     // Spotlight.
1310     void searchWithSpotlight(const String&);
1311
1312     // Dictionary.
1313     void didPerformDictionaryLookup(const String&, const DictionaryPopupInfo&);
1314 #endif
1315
1316     // Spelling and grammar.
1317     int64_t spellDocumentTag();
1318 #if USE(UNIFIED_TEXT_CHECKING)
1319     void checkTextOfParagraph(const String& text, uint64_t checkingTypes, Vector<WebCore::TextCheckingResult>& results);
1320 #endif
1321     void checkSpellingOfString(const String& text, int32_t& misspellingLocation, int32_t& misspellingLength);
1322     void checkGrammarOfString(const String& text, Vector<WebCore::GrammarDetail>&, int32_t& badGrammarLocation, int32_t& badGrammarLength);
1323     void spellingUIIsShowing(bool&);
1324     void updateSpellingUIWithMisspelledWord(const String& misspelledWord);
1325     void updateSpellingUIWithGrammarString(const String& badGrammarPhrase, const WebCore::GrammarDetail&);
1326     void getGuessesForWord(const String& word, const String& context, Vector<String>& guesses);
1327 #if PLATFORM(EFL)
1328 #if ENABLE(TIZEN_WEBKIT2_FORM_DATABASE)
1329     void textChangeInTextField(const String&, const String&);
1330 #endif
1331 #endif
1332     void learnWord(const String& word);
1333     void ignoreWord(const String& word);
1334
1335     void setFocus(bool focused);
1336     void takeFocus(uint32_t direction);
1337     void setToolTip(const String&);
1338     void setCursor(const WebCore::Cursor&);
1339     void setCursorHiddenUntilMouseMoves(bool);
1340
1341     void didReceiveEvent(uint32_t opaqueType, bool handled);
1342     void stopResponsivenessTimer();
1343
1344     void voidCallback(uint64_t);
1345     void dataCallback(const CoreIPC::DataReference&, uint64_t);
1346     void stringCallback(const String&, uint64_t);
1347     void scriptValueCallback(const CoreIPC::DataReference&, uint64_t);
1348     void computedPagesCallback(const Vector<WebCore::IntRect>&, double totalScaleFactorForPrinting, uint64_t);
1349     void validateCommandCallback(const String&, bool, int, uint64_t);
1350 #if PLATFORM(GTK)
1351     void printFinishedCallback(const WebCore::ResourceError&, uint64_t);
1352 #endif
1353
1354     void focusedFrameChanged(uint64_t frameID);
1355     void frameSetLargestFrameChanged(uint64_t frameID);
1356
1357     void canAuthenticateAgainstProtectionSpaceInFrame(uint64_t frameID, const WebCore::ProtectionSpace&, bool& canAuthenticate);
1358 #if ENABLE(TIZEN_ON_AUTHENTICATION_REQUESTED)
1359     void didReceiveAuthenticationChallenge(uint64_t frameID, const WebCore::AuthenticationChallenge&, uint64_t challengeID, PassRefPtr<Messages::WebPageProxy::DidReceiveAuthenticationChallenge::DelayedReply>);
1360 #else
1361     void didReceiveAuthenticationChallenge(uint64_t frameID, const WebCore::AuthenticationChallenge&, uint64_t challengeID);
1362 #endif
1363
1364     void didFinishLoadingDataForCustomRepresentation(const String& suggestedFilename, const CoreIPC::DataReference&);
1365
1366 #if PLATFORM(MAC)
1367     void pluginFocusOrWindowFocusChanged(uint64_t pluginComplexTextInputIdentifier, bool pluginHasFocusAndWindowHasFocus);
1368     void setPluginComplexTextInputState(uint64_t pluginComplexTextInputIdentifier, uint64_t complexTextInputState);
1369 #endif
1370
1371     void clearPendingAPIRequestURL() { m_pendingAPIRequestURL = String(); }
1372     void setPendingAPIRequestURL(const String& pendingAPIRequestURL) { m_pendingAPIRequestURL = pendingAPIRequestURL; }
1373
1374     bool maybeInitializeSandboxExtensionHandle(const WebCore::KURL&, SandboxExtension::Handle&);
1375
1376 #if PLATFORM(MAC)
1377     void substitutionsPanelIsShowing(bool&);
1378 #if __MAC_OS_X_VERSION_MIN_REQUIRED >= 1070
1379     void showCorrectionPanel(int32_t panelType, const WebCore::FloatRect& boundingBoxOfReplacedString, const String& replacedString, const String& replacementString, const Vector<String>& alternativeReplacementStrings);
1380     void dismissCorrectionPanel(int32_t reason);
1381     void dismissCorrectionPanelSoon(int32_t reason, String& result);
1382     void recordAutocorrectionResponse(int32_t responseType, const String& replacedString, const String& replacementString);
1383 #endif // __MAC_OS_X_VERSION_MIN_REQUIRED >= 1070
1384
1385 #if USE(DICTATION_ALTERNATIVES)
1386     void showDictationAlternativeUI(const WebCore::FloatRect& boundingBoxOfDictatedText, uint64_t dictationContext);
1387     void dismissDictationAlternativeUI();
1388     void removeDictationAlternatives(uint64_t dictationContext);
1389     void dictationAlternatives(uint64_t dictationContext, Vector<String>& result);
1390 #endif
1391 #endif // PLATFORM(MAC)
1392
1393 #if USE(SOUP)
1394     void didReceiveURIRequest(String uriString, uint64_t requestID);
1395 #endif
1396
1397     void clearLoadDependentCallbacks();
1398
1399     void performDragControllerAction(DragControllerAction, WebCore::DragData*, const String& dragStorageName, const SandboxExtension::Handle&, const SandboxExtension::HandleArray&);
1400
1401     void updateBackingStoreDiscardableState();
1402
1403 #if PLATFORM(WIN)
1404     void scheduleChildWindowGeometryUpdate(const WindowGeometry&);
1405 #endif
1406
1407     void setRenderTreeSize(uint64_t treeSize) { m_renderTreeSize = treeSize; }
1408
1409 #if PLUGIN_ARCHITECTURE(X11)
1410     void createPluginContainer(uint64_t& windowID);
1411     void windowedPluginGeometryDidChange(const WebCore::IntRect& frameRect, const WebCore::IntRect& clipRect, uint64_t windowID);
1412 #endif
1413
1414     void processNextQueuedWheelEvent();
1415     void sendWheelEvent(const WebWheelEvent&);
1416
1417 #if ENABLE(TIZEN_CERTIFICATE_HANDLING)
1418     void decidePolicyForCertificateError(const String& url, const String& certificate, int error, PassRefPtr<Messages::WebPageProxy::DecidePolicyForCertificateError::DelayedReply>);
1419 #endif
1420
1421 #if ENABLE(TIZEN_WEBKIT2_ROTATION_WHILE_JAVASCRIPT_POPUP)
1422     bool isWaitingForJavaScriptPopupReply();
1423 #endif
1424
1425 #if ENABLE(TIZEN_LINK_MAGNIFIER)
1426     void didGetLinkMagnifierRect(const WebCore::IntPoint&, const WebCore::IntRect&);
1427 #endif
1428
1429 #if ENABLE(TIZEN_INDEXED_DATABASE)
1430     void exceededIndexedDatabaseQuota(uint64_t frameID, const String& originIdentifier, int64_t currentUsage, PassRefPtr<Messages::WebPageProxy::ExceededIndexedDatabaseQuota::DelayedReply> reply);
1431 #endif
1432
1433 #if ENABLE(TIZEN_FILE_SYSTEM)
1434     void exceededLocalFileSystemQuota(uint64_t frameID, const String& originIdentifier, int64_t currentUsage, PassRefPtr<Messages::WebPageProxy::ExceededLocalFileSystemQuota::DelayedReply> reply);
1435 #endif
1436
1437 #if ENABLE(TIZEN_WEBKIT2_NOTIFY_SUSPEND_BY_REMOTE_WEB_INSPECTOR)
1438     void setContentSuspendedByInspector(bool);
1439 #endif
1440
1441     PageClient* m_pageClient;
1442     WebLoaderClient m_loaderClient;
1443     WebPolicyClient m_policyClient;
1444     WebFormClient m_formClient;
1445     WebResourceLoadClient m_resourceLoadClient;
1446     WebUIClient m_uiClient;
1447     WebFindClient m_findClient;
1448     WebFindMatchesClient m_findMatchesClient;
1449 #if ENABLE(CONTEXT_MENUS)
1450     WebPageContextMenuClient m_contextMenuClient;
1451 #endif
1452 #if OS(TIZEN)
1453     WebTizenClient m_tizenClient;
1454 #endif
1455
1456     OwnPtr<DrawingAreaProxy> m_drawingArea;
1457     RefPtr<WebProcessProxy> m_process;
1458     RefPtr<WebPageGroup> m_pageGroup;
1459     RefPtr<WebFrameProxy> m_mainFrame;
1460     RefPtr<WebFrameProxy> m_focusedFrame;
1461     RefPtr<WebFrameProxy> m_frameSetLargestFrame;
1462
1463     String m_userAgent;
1464     String m_applicationNameForUserAgent;
1465     String m_customUserAgent;
1466     String m_customTextEncodingName;
1467
1468 #if ENABLE(INSPECTOR)
1469     RefPtr<WebInspectorProxy> m_inspector;
1470 #endif
1471
1472 #if ENABLE(FULLSCREEN_API)
1473     RefPtr<WebFullScreenManagerProxy> m_fullScreenManager;
1474 #endif
1475
1476 #if ENABLE(TIZEN_SUPPORT_WEBAPP_META_TAG)
1477     HashMap<uint64_t, RefPtr<BooleanCallback> > m_booleanCallbacks;
1478     HashMap<uint64_t, RefPtr<DictionaryCallback> > m_dictionaryCallbacks;
1479 #endif
1480     HashMap<uint64_t, RefPtr<VoidCallback> > m_voidCallbacks;
1481     HashMap<uint64_t, RefPtr<DataCallback> > m_dataCallbacks;
1482     HashMap<uint64_t, RefPtr<StringCallback> > m_stringCallbacks;
1483     HashSet<uint64_t> m_loadDependentStringCallbackIDs;
1484     HashMap<uint64_t, RefPtr<ScriptValueCallback> > m_scriptValueCallbacks;
1485     HashMap<uint64_t, RefPtr<ComputedPagesCallback> > m_computedPagesCallbacks;
1486     HashMap<uint64_t, RefPtr<ValidateCommandCallback> > m_validateCommandCallbacks;
1487 #if PLATFORM(GTK)
1488     HashMap<uint64_t, RefPtr<PrintFinishedCallback> > m_printFinishedCallbacks;
1489 #endif
1490 #if ENABLE(TIZEN_WEB_STORAGE)
1491     HashMap<uint64_t, RefPtr<WebStorageQuotaCallback> > m_quotaCallbacks;
1492 #endif
1493
1494     HashSet<WebEditCommandProxy*> m_editCommandSet;
1495
1496 #if PLATFORM(MAC)
1497     HashSet<String> m_knownKeypressCommandNames;
1498 #endif
1499
1500     RefPtr<WebPopupMenuProxy> m_activePopupMenu;
1501     RefPtr<WebContextMenuProxy> m_activeContextMenu;
1502     WebHitTestResult::Data m_activeContextMenuHitTestResultData;
1503     RefPtr<WebOpenPanelResultListenerProxy> m_openPanelResultListener;
1504     GeolocationPermissionRequestManagerProxy m_geolocationPermissionRequestManager;
1505     NotificationPermissionRequestManagerProxy m_notificationPermissionRequestManager;
1506 #if ENABLE(TIZEN_MEDIA_STREAM)
1507     UserMediaPermissionRequestManagerProxy m_userMediaPermissionRequestManager;
1508 #endif
1509     double m_estimatedProgress;
1510
1511     // Whether the web page is contained in a top-level window.
1512     bool m_isInWindow;
1513
1514     // Whether the page is visible; if the backing view is visible and inserted into a window.
1515     bool m_isVisible;
1516
1517     bool m_canGoBack;
1518     bool m_canGoForward;
1519     RefPtr<WebBackForwardList> m_backForwardList;
1520
1521     bool m_maintainsInactiveSelection;
1522
1523     String m_toolTip;
1524
1525     String m_urlAtProcessExit;
1526     WebFrameProxy::LoadState m_loadStateAtProcessExit;
1527
1528     EditorState m_editorState;
1529
1530     double m_textZoomFactor;
1531     double m_pageZoomFactor;
1532     double m_pageScaleFactor;
1533     float m_intrinsicDeviceScaleFactor;
1534     float m_customDeviceScaleFactor;
1535
1536     LayerHostingMode m_layerHostingMode;
1537
1538     bool m_drawsBackground;
1539     bool m_drawsTransparentBackground;
1540
1541     bool m_areMemoryCacheClientCallsEnabled;
1542
1543     bool m_useFixedLayout;
1544     WebCore::IntSize m_fixedLayoutSize;
1545
1546     WebCore::Page::Pagination::Mode m_paginationMode;
1547     bool m_paginationBehavesLikeColumns;
1548     double m_pageLength;
1549     double m_gapBetweenPages;
1550
1551     // If the process backing the web page is alive and kicking.
1552     bool m_isValid;
1553
1554     // Whether WebPageProxy::close() has been called on this page.
1555     bool m_isClosed;
1556
1557     // Whether it can run modal child web pages.
1558     bool m_canRunModal;
1559
1560     bool m_isInPrintingMode;
1561     bool m_isPerformingDOMPrintOperation;
1562
1563     bool m_inDecidePolicyForResponse;
1564     bool m_syncMimeTypePolicyActionIsValid;
1565     WebCore::PolicyAction m_syncMimeTypePolicyAction;
1566     uint64_t m_syncMimeTypePolicyDownloadID;
1567
1568     bool m_inDecidePolicyForNavigationAction;
1569     bool m_syncNavigationActionPolicyActionIsValid;
1570     WebCore::PolicyAction m_syncNavigationActionPolicyAction;
1571     uint64_t m_syncNavigationActionPolicyDownloadID;
1572
1573 #if ENABLE(TIZEN_WEBKIT2_ROTATION_WHILE_JAVASCRIPT_POPUP)
1574 #if ENABLE(GESTURE_EVENTS)
1575     Deque<QueuedUIEvents<WebGestureEvent> > m_gestureEventQueue;
1576 #endif
1577     Deque<QueuedUIEvents<NativeWebKeyboardEvent> > m_keyEventQueue;
1578 #else
1579 #if ENABLE(GESTURE_EVENTS)
1580     Deque<WebGestureEvent> m_gestureEventQueue;
1581 #endif
1582     Deque<NativeWebKeyboardEvent> m_keyEventQueue;
1583 #endif
1584     Deque<NativeWebWheelEvent> m_wheelEventQueue;
1585     Deque<OwnPtr<Vector<NativeWebWheelEvent> > > m_currentlyProcessedWheelEvents;
1586
1587     bool m_processingMouseMoveEvent;
1588     OwnPtr<NativeWebMouseEvent> m_nextMouseMoveEvent;
1589     OwnPtr<NativeWebMouseEvent> m_currentlyProcessedMouseDownEvent;
1590
1591 #if ENABLE(TOUCH_EVENTS)
1592     bool m_needTouchEvents;
1593 #if ENABLE(TIZEN_WEBKIT2_ROTATION_WHILE_JAVASCRIPT_POPUP)
1594     Deque<QueuedUIEvents<NativeWebTouchEvent> > m_touchEventQueue;
1595 #else
1596     Deque<QueuedTouchEvents> m_touchEventQueue;
1597 #endif
1598 #endif
1599 #if ENABLE(INPUT_TYPE_COLOR)
1600     RefPtr<WebColorChooserProxy> m_colorChooser;
1601 #if ENABLE(TIZEN_INPUT_COLOR_PICKER) // wait for upstream
1602     RefPtr<WebColorPickerResultListenerProxy> m_colorPickerResultListener;
1603 #endif
1604 #endif
1605 #if ENABLE(TIZEN_CSS_OVERFLOW_SCROLL_ACCELERATION)
1606     bool m_isLoadingFinished;    //if the page loading is finished, then set to true.
1607     bool m_askOverflow;
1608 #endif
1609
1610     uint64_t m_pageID;
1611
1612     bool m_isPageSuspended;
1613
1614 #if PLATFORM(MAC)
1615     bool m_isSmartInsertDeleteEnabled;
1616 #endif
1617
1618 #if PLATFORM(GTK)
1619     String m_accessibilityPlugID;
1620 #endif
1621
1622     int64_t m_spellDocumentTag;
1623     bool m_hasSpellDocumentTag;
1624     unsigned m_pendingLearnOrIgnoreWordMessageCount;
1625
1626     bool m_mainFrameHasCustomRepresentation;
1627
1628 #if ENABLE(DRAG_SUPPORT)
1629     WebCore::DragSession m_currentDragSession;
1630 #endif
1631
1632 #if ENABLE(TIZEN_WEBKIT2_NOTIFY_SUSPEND_BY_REMOTE_WEB_INSPECTOR)
1633     bool m_contentSuspendedByInspector;
1634 #endif
1635
1636     String m_pendingAPIRequestURL;
1637
1638     bool m_mainFrameHasHorizontalScrollbar;
1639     bool m_mainFrameHasVerticalScrollbar;
1640
1641     // Whether horizontal wheel events can be handled directly for swiping purposes.
1642     bool m_canShortCircuitHorizontalWheelEvents;
1643
1644     bool m_mainFrameIsPinnedToLeftSide;
1645     bool m_mainFrameIsPinnedToRightSide;
1646
1647 #if PLATFORM(EFL)
1648     WebCore::IntPoint m_scrollPosition;
1649     WebCore::IntSize m_contentsSize;
1650 #endif
1651     unsigned m_pageCount;
1652
1653     WebCore::IntRect m_visibleScrollerThumbRect;
1654
1655     uint64_t m_renderTreeSize;
1656
1657     static WKPageDebugPaintFlags s_debugPaintFlags;
1658
1659     bool m_shouldSendEventsSynchronously;
1660
1661     bool m_suppressVisibilityUpdates;
1662
1663     float m_mediaVolume;
1664
1665 #if PLATFORM(QT)
1666     WTF::HashSet<RefPtr<QtRefCountedNetworkRequestData> > m_applicationSchemeRequests;
1667 #endif
1668
1669 #if ENABLE(PAGE_VISIBILITY_API)
1670     WebCore::PageVisibilityState m_visibilityState;
1671 #endif
1672
1673 #if OS(TIZEN)
1674     RefPtr<Messages::WebPageProxy::RunJavaScriptAlert::DelayedReply> m_alertReply;
1675     RefPtr<Messages::WebPageProxy::RunJavaScriptConfirm::DelayedReply> m_confirmReply;
1676     RefPtr<Messages::WebPageProxy::RunJavaScriptPrompt::DelayedReply> m_promptReply;
1677 #if ENABLE(TIZEN_SUPPORT_BEFORE_UNLOAD_CONFIRM_PANEL)
1678     RefPtr<Messages::WebPageProxy::RunBeforeUnloadConfirmPanel::DelayedReply> m_beforeUnloadConfirmPanelReply;
1679 #endif
1680 #if ENABLE(TIZEN_APPLICATION_CACHE)
1681     RefPtr<Messages::WebPageProxy::RequestApplicationCachePermission::DelayedReply> m_applicationCacheReply;
1682 #endif
1683 #if ENABLE(TIZEN_SQL_DATABASE)
1684     RefPtr<Messages::WebPageProxy::ExceededDatabaseQuota::DelayedReply> m_exceededDatabaseQuotaReply;
1685 #endif
1686 #endif
1687
1688 #if ENABLE(TIZEN_ON_AUTHENTICATION_REQUESTED)
1689     RefPtr<Messages::WebPageProxy::DidReceiveAuthenticationChallenge::DelayedReply> m_AuthReply;
1690 #endif
1691
1692 #if ENABLE(TIZEN_CERTIFICATE_HANDLING)
1693     RefPtr<Messages::WebPageProxy::DecidePolicyForCertificateError::DelayedReply> m_allowedReply;
1694 #endif
1695
1696 #if ENABLE(TIZEN_REDUCE_KEY_LAGGING)
1697     Ecore_Timer* m_pageContentResumeTimer;
1698 #endif
1699
1700 #if ENABLE(TIZEN_ISF_PORT)
1701     bool m_didCancelCompositionFromWebProcess;
1702 #endif
1703
1704 #if ENABLE(TIZEN_INDEXED_DATABASE)
1705     RefPtr<Messages::WebPageProxy::ExceededIndexedDatabaseQuota::DelayedReply> m_exceededIndexedDatabaseQuotaReply;
1706 #endif
1707
1708 #if ENABLE(TIZEN_FILE_SYSTEM)
1709     RefPtr<Messages::WebPageProxy::ExceededLocalFileSystemQuota::DelayedReply> m_exceededLocalFileSystemQuotaReply;
1710 #endif
1711
1712 #if ENABLE(TIZEN_FOCUS_UI)
1713     bool m_focusUIEnabled;
1714 #endif
1715 };
1716
1717 } // namespace WebKit
1718
1719 #endif // WebPageProxy_h