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