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