Source/WebKit2/WebProcess/WebPage/WebPage.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 WebPage_h
  27 #define WebPage_h
  28
  29 #include "APIObject.h"
  30 #include "DrawingArea.h"
  31 #include "FindController.h"
  32 #include "GeolocationPermissionRequestManager.h"
  33 #include "ImageOptions.h"
  34 #include "ImmutableArray.h"
  35 #if ENABLE(CONTEXT_MENUS)
  36 #include "InjectedBundlePageContextMenuClient.h"
  37 #endif
  38 #include "InjectedBundlePageDiagnosticLoggingClient.h"
  39 #include "InjectedBundlePageEditorClient.h"
  40 #include "InjectedBundlePageFormClient.h"
  41 #include "InjectedBundlePageFullScreenClient.h"
  42 #include "InjectedBundlePageLoaderClient.h"
  43 #include "InjectedBundlePagePolicyClient.h"
  44 #include "InjectedBundlePageResourceLoadClient.h"
  45 #include "InjectedBundlePageUIClient.h"
  46 #include "MessageSender.h"
  47 #include "TapHighlightController.h"
  48 #include "Plugin.h"
  49 #include "SandboxExtension.h"
  50 #include "ShareableBitmap.h"
  51 #include "WebHitTestResult.h"
  52 #include "WebUndoStep.h"
  53 #include <WebCore/DictationAlternative.h>
  54 #include <WebCore/DragData.h>
  55 #include <WebCore/Editor.h>
  56 #include <WebCore/FrameLoaderTypes.h>
  57 #include <WebCore/IntRect.h>
  58 #include <WebCore/Page.h>
  59 #if ENABLE(PAGE_VISIBILITY_API)
  60 #include <WebCore/PageVisibilityState.h>
  61 #endif
  62 #include <WebCore/PlatformScreen.h>
  63 #include <WebCore/ScrollTypes.h>
  64 #include <WebCore/WebCoreKeyboardUIMode.h>
  65 #include <wtf/HashMap.h>
  66 #include <wtf/OwnPtr.h>
  67 #include <wtf/PassRefPtr.h>
  68 #include <wtf/RefPtr.h>
  69 #include <wtf/text/WTFString.h>
  70
  71 #if PLATFORM(QT)
  72 #include "ArgumentCodersQt.h"
  73 #include "QtNetworkAccessManager.h"
  74 #include "QtNetworkReply.h"
  75 #include "QtNetworkReplyData.h"
  76 #include "QtNetworkRequestData.h"
  77 #include <QNetworkReply>
  78 #include <QNetworkRequest>
  79 #endif
  80
  81 #if PLATFORM(GTK)
  82 #include "ArgumentCodersGtk.h"
  83 #include "WebPageAccessibilityObject.h"
  84 #include "WebPrintOperationGtk.h"
  85 #endif
  86
  87 #if ENABLE(TOUCH_EVENTS)
  88 #include <WebCore/PlatformTouchEvent.h>
  89 #endif
  90
  91 #if PLATFORM(MAC)
  92 #include "DictionaryPopupInfo.h"
  93 #include "LayerHostingContext.h"
  94 #include <wtf/RetainPtr.h>
  95 OBJC_CLASS NSDictionary;
  96 OBJC_CLASS NSObject;
  97 OBJC_CLASS WKAccessibilityWebPageObject;
  98 #endif
  99
 100 #if ENABLE(TIZEN_PAGE_VISIBILITY_API)
 101 #include <WebCore/PageVisibilityState.h>
 102 #endif
 103
 104 #if ENABLE(TIZEN_CUSTOM_HEADERS)
 105 #include <WebCore/HTTPHeaderMap.h>
 106 #endif
 107
 108 #if ENABLE(TIZEN_DATALIST_ELEMENT)
 109 #include "HTMLDataListElement.h"
 110 #endif
 111
 112 #if ENABLE(TIZEN_DRAG_SUPPORT)
 113 #include "ArgumentCodersTizen.h"
 114 #endif
 115
 116 #if ENABLE(TIZEN_SCREEN_READER)
 117 #include "ScreenReader.h"
 118 #endif
 119
 120 #if ENABLE(TIZEN_WEBKIT2_TEXT_SELECTION)
 121 #include "EditorState.h"
 122 #endif
 123
 124 namespace CoreIPC {
 125     class ArgumentDecoder;
 126     class Connection;
 127     class MessageID;
 128 }
 129
 130 namespace WebCore {
 131     class GraphicsContext;
 132     class Frame;
 133     class FrameView;
 134     class HTMLPlugInElement;
 135     class KeyboardEvent;
 136     class Page;
 137     class PrintContext;
 138     class Range;
 139     class ResourceRequest;
 140     class SharedBuffer;
 141     class VisibleSelection;
 142     struct KeypressCommand;
 143
 144 #if ENABLE(TIZEN_DATALIST_ELEMENT)
 145     class HTMLDataListElement;
 146 #endif
 147 }
 148
 149 namespace WebKit {
 150
 151 class DrawingArea;
 152 class InjectedBundleBackForwardList;
 153 class NotificationPermissionRequestManager;
 154 class PageOverlay;
 155 class PluginView;
 156 class SessionState;
 157 class WebColorChooser;
 158 class WebContextMenu;
 159 class WebContextMenuItemData;
 160 class WebEvent;
 161 class WebFrame;
 162 class WebFullScreenManager;
 163 class WebImage;
 164 class WebInspector;
 165 class WebInspectorClient;
 166 class WebKeyboardEvent;
 167 class WebMouseEvent;
 168 class WebNotificationClient;
 169 class WebOpenPanelResultListener;
 170 class WebPageGroupProxy;
 171 class WebPopupMenu;
 172 class WebWheelEvent;
 173 struct AttributedString;
 174 struct EditorState;
 175 struct PrintInfo;
 176 struct WebPageCreationParameters;
 177 struct WebPreferencesStore;
 178
 179 #if ENABLE(WEB_INTENTS)
 180 struct IntentData;
 181 #endif
 182
 183 #if ENABLE(GESTURE_EVENTS)
 184 class WebGestureEvent;
 185 #endif
 186
 187 #if ENABLE(TOUCH_EVENTS)
 188 class WebTouchEvent;
 189 #endif
 190
 191 #if ENABLE(TIZEN_MEDIA_STREAM)
 192 class UserMediaPermissionRequestManager;
 193 class WebUserMediaClient;
 194 #endif
 195
 196 #if ENABLE(TIZEN_ISF_PORT)
 197 class NativeWebKeyboardEvent;
 198 #endif
 199
 200 class WebPage : public APIObject, public CoreIPC::MessageSender<WebPage> {
 201 public:
 202     static const Type APIType = TypeBundlePage;
 203
 204     static PassRefPtr<WebPage> create(uint64_t pageID, const WebPageCreationParameters&);
 205     virtual ~WebPage();
 206
 207     // Used by MessageSender.
 208     CoreIPC::Connection* connection() const;
 209     uint64_t destinationID() const { return pageID(); }
 210
 211     void close();
 212
 213     WebCore::Page* corePage() const { return m_page.get(); }
 214     uint64_t pageID() const { return m_pageID; }
 215
 216     void setSize(const WebCore::IntSize&);
 217     const WebCore::IntSize& size() const { return m_viewSize; }
 218     WebCore::IntRect bounds() const { return WebCore::IntRect(WebCore::IntPoint(), size()); }
 219
 220     InjectedBundleBackForwardList* backForwardList();
 221     DrawingArea* drawingArea() const { return m_drawingArea.get(); }
 222
 223     WebPageGroupProxy* pageGroup() const { return m_pageGroup.get(); }
 224
 225     void scrollMainFrameIfNotAtMaxScrollPosition(const WebCore::IntSize& scrollOffset);
 226
 227     void scrollBy(uint32_t scrollDirection, uint32_t scrollGranularity);
 228
 229     void centerSelectionInVisibleArea();
 230
 231 #if PLATFORM(EFL)
 232 #if ENABLE(TIZEN_TEXT_CARET_HANDLING_WK2)
 233     bool setCaretPosition(const WebCore::IntPoint&);
 234     void getCaretPosition(WebCore::IntRect&);
 235 #endif
 236 #if ENABLE(TIZEN_ISF_PORT)
 237     void didCancelComposition(WebCore::Node*);
 238
 239     void getCursorOffset(int&);
 240     void getSurroundingTextAndCursorOffset(String&, int&);
 241     void getSelectionRect(bool, WebCore::IntRect&);
 242     void deleteSurroundingText(int, int);
 243 #endif
 244     void scrollMainFrameBy(const WebCore::IntSize&);
 245     void scrollMainFrameTo(const WebCore::IntPoint&);
 246     void createSnapshot(const WebCore::IntRect, float, ShareableBitmap::Handle&);
 247     void requestUpdateFormNavigation();
 248     void moveFocus(int newIndex);
 249 #if ENABLE(TIZEN_MOBILE_WEB_PRINT)
 250         void createPagesToPDF(const WebCore::IntSize&, const WebCore::IntSize&, const String&);
 251 #endif
 252 #if ENABLE(TIZEN_WEBKIT2_HIT_TEST)
 253     void hitTestResultAtPoint(const WebCore::IntPoint&, int hitTestMode, WebHitTestResult::Data&);
 254 #endif
 255
 256 #if ENABLE(TIZEN_WEB_STORAGE)
 257     void getStorageQuotaBytes(uint64_t callbackID);
 258     void setStorageQuotaBytes(uint32_t quota);
 259 #endif
 260
 261 #if ENABLE(TIZEN_CLIPBOARD) || ENABLE(TIZEN_PASTEBOARD)
 262     void setClipboardDataForPaste(const String& data, const String& type);
 263 #endif
 264
 265     void suspendJavaScriptAndResources();
 266     void resumeJavaScriptAndResources();
 267 #if ENABLE(TIZEN_SYNC_REQUEST_ANIMATION_FRAME)
 268     void suspendAnimationController();
 269     void resumeAnimationController();
 270 #endif
 271 #if ENABLE(TIZEN_PLUGIN_SUSPEND_RESUME)
 272     void suspendPlugin();
 273     void resumePlugin();
 274 #endif
 275 #endif
 276 #if ENABLE(TIZEN_REMOTE_WEB_INSPECTOR)
 277     void startInspectorServer(uint32_t port,  uint32_t& assignedPort);
 278     void stopInspectorServer(bool& result);
 279 #endif
 280 #if ENABLE(TIZEN_ORIENTATION_EVENTS)
 281     void sendOrientationChangeEvent(int orientation);
 282 #endif
 283
 284 #if ENABLE(INSPECTOR)
 285     WebInspector* inspector();
 286 #endif
 287
 288 #if ENABLE(FULLSCREEN_API)
 289     WebFullScreenManager* fullScreenManager();
 290 #endif
 291
 292     // -- Called by the DrawingArea.
 293     // FIXME: We could genericize these into a DrawingArea client interface. Would that be beneficial?
 294     void drawRect(WebCore::GraphicsContext&, const WebCore::IntRect&);
 295 #if ENABLE(TIZEN_WEBKIT2_TEXT_SELECTION)
 296     void selectClosestWord(const WebCore::IntPoint&, bool isStartedTextSelectionFromOutside, bool& result);
 297     void setLeftSelection(const WebCore::IntPoint&, bool& result);
 298     void setRightSelection(const WebCore::IntPoint&, bool& result);
 299     void getSelectionHandlers(WebCore::IntRect& leftRect, WebCore::IntRect& rightRect);
 300     void getSelectionText(String& result);
 301     void selectionRangeClear(bool& result);
 302     void selectionClearAllSelection(WebCore::Frame* frame);
 303     void scrollContentByCharacter(const WebCore::IntPoint&, int direction, bool& result);
 304 #endif
 305
 306 #if ENABLE(TIZEN_OFFLINE_PAGE_SAVE)
 307     void startOfflinePageSave(String subresourceFolderName);
 308 #endif
 309
 310 #if ENABLE(TIZEN_WEBKIT2_CONTEXT_MENU_TEXT_SELECTION_MODE)
 311     void selectLink(WebCore::IntPoint positionForSelection, bool& result);
 312 #endif
 313
 314     void drawPageOverlay(WebCore::GraphicsContext&, const WebCore::IntRect&);
 315     void layoutIfNeeded();
 316
 317     // -- Called from WebCore clients.
 318 #if PLATFORM(MAC)
 319     bool handleEditingKeyboardEvent(WebCore::KeyboardEvent*, bool saveCommands);
 320 #elif !PLATFORM(GTK)
 321     bool handleEditingKeyboardEvent(WebCore::KeyboardEvent*);
 322 #endif
 323
 324     void show();
 325     String userAgent() const { return m_userAgent; }
 326     WebCore::IntRect windowResizerRect() const;
 327     WebCore::KeyboardUIMode keyboardUIMode();
 328
 329     WebUndoStep* webUndoStep(uint64_t);
 330     void addWebUndoStep(uint64_t, WebUndoStep*);
 331     void removeWebEditCommand(uint64_t);
 332     bool isInRedo() const { return m_isInRedo; }
 333
 334     void setActivePopupMenu(WebPopupMenu*);
 335
 336 #if ENABLE(INPUT_TYPE_COLOR)
 337     WebColorChooser* activeColorChooser() const { return m_activeColorChooser; }
 338     void setActiveColorChooser(WebColorChooser*);
 339     void didChooseColor(const WebCore::Color&);
 340     void didEndColorChooser();
 341 #endif
 342
 343     WebOpenPanelResultListener* activeOpenPanelResultListener() const { return m_activeOpenPanelResultListener.get(); }
 344     void setActiveOpenPanelResultListener(PassRefPtr<WebOpenPanelResultListener>);
 345 #if OS(TIZEN)
 346     void cancelForOpenPanel();
 347 #endif
 348
 349     // -- Called from WebProcess.
 350     void didReceiveMessage(CoreIPC::Connection*, CoreIPC::MessageID, CoreIPC::ArgumentDecoder*);
 351     void didReceiveSyncMessage(CoreIPC::Connection*, CoreIPC::MessageID, CoreIPC::ArgumentDecoder*, OwnPtr<CoreIPC::ArgumentEncoder>&);
 352
 353     // -- InjectedBundle methods
 354 #if ENABLE(CONTEXT_MENUS)
 355     void initializeInjectedBundleContextMenuClient(WKBundlePageContextMenuClient*);
 356 #endif
 357     void initializeInjectedBundleEditorClient(WKBundlePageEditorClient*);
 358     void initializeInjectedBundleFormClient(WKBundlePageFormClient*);
 359     void initializeInjectedBundleLoaderClient(WKBundlePageLoaderClient*);
 360     void initializeInjectedBundlePolicyClient(WKBundlePagePolicyClient*);
 361     void initializeInjectedBundleResourceLoadClient(WKBundlePageResourceLoadClient*);
 362     void initializeInjectedBundleUIClient(WKBundlePageUIClient*);
 363 #if ENABLE(FULLSCREEN_API)
 364     void initializeInjectedBundleFullScreenClient(WKBundlePageFullScreenClient*);
 365 #endif
 366     void initializeInjectedBundleDiagnosticLoggingClient(WKBundlePageDiagnosticLoggingClient*);
 367
 368 #if ENABLE(CONTEXT_MENUS)
 369     InjectedBundlePageContextMenuClient& injectedBundleContextMenuClient() { return m_contextMenuClient; }
 370 #endif
 371     InjectedBundlePageEditorClient& injectedBundleEditorClient() { return m_editorClient; }
 372     InjectedBundlePageFormClient& injectedBundleFormClient() { return m_formClient; }
 373     InjectedBundlePageLoaderClient& injectedBundleLoaderClient() { return m_loaderClient; }
 374     InjectedBundlePagePolicyClient& injectedBundlePolicyClient() { return m_policyClient; }
 375     InjectedBundlePageResourceLoadClient& injectedBundleResourceLoadClient() { return m_resourceLoadClient; }
 376     InjectedBundlePageUIClient& injectedBundleUIClient() { return m_uiClient; }
 377     InjectedBundlePageDiagnosticLoggingClient& injectedBundleDiagnosticLoggingClient() { return m_logDiagnosticMessageClient; }
 378 #if ENABLE(FULLSCREEN_API)
 379     InjectedBundlePageFullScreenClient& injectedBundleFullScreenClient() { return m_fullScreenClient; }
 380 #endif
 381
 382     void setUnderlayPage(PassRefPtr<WebPage> underlayPage) { m_underlayPage = underlayPage; }
 383
 384     bool findStringFromInjectedBundle(const String&, FindOptions);
 385
 386     WebFrame* mainWebFrame() const { return m_mainFrame.get(); }
 387
 388     WebCore::Frame* mainFrame() const; // May return 0.
 389     WebCore::FrameView* mainFrameView() const; // May return 0.
 390
 391     PassRefPtr<Plugin> createPlugin(WebFrame*, WebCore::HTMLPlugInElement*, const Plugin::Parameters&);
 392
 393     EditorState editorState() const;
 394 #if ENABLE(TIZEN_WEBKIT2_TEXT_SELECTION)
 395     void setEditorState(const EditorState& editorState) { m_editorState = editorState;}
 396 #endif
 397
 398     String renderTreeExternalRepresentation() const;
 399     uint64_t renderTreeSize() const;
 400     void setPaintedObjectsCounterThreshold(uint64_t);
 401
 402     void setTracksRepaints(bool);
 403     bool isTrackingRepaints() const;
 404     void resetTrackedRepaints();
 405     PassRefPtr<ImmutableArray> trackedRepaintRects();
 406
 407     void executeEditingCommand(const String& commandName, const String& argument);
 408     bool isEditingCommandEnabled(const String& commandName);
 409     void clearMainFrameName();
 410     void sendClose();
 411
 412     double textZoomFactor() const;
 413     void setTextZoomFactor(double);
 414     double pageZoomFactor() const;
 415     void setPageZoomFactor(double);
 416     void setPageAndTextZoomFactors(double pageZoomFactor, double textZoomFactor);
 417     void windowScreenDidChange(uint64_t);
 418     void setViewMode(WebCore::Page::ViewMode);
 419
 420     void scalePage(double scale, const WebCore::IntPoint& origin);
 421     double pageScaleFactor() const;
 422
 423     void setUseFixedLayout(bool);
 424     bool useFixedLayout() const { return m_useFixedLayout; }
 425     void setFixedLayoutSize(const WebCore::IntSize&);
 426
 427     void setPaginationMode(uint32_t /* WebCore::Page::Pagination::Mode */);
 428     void setPaginationBehavesLikeColumns(bool);
 429     void setPageLength(double);
 430     void setGapBetweenPages(double);
 431
 432     bool drawsBackground() const { return m_drawsBackground; }
 433     bool drawsTransparentBackground() const { return m_drawsTransparentBackground; }
 434
 435     void stopLoading();
 436     void stopLoadingFrame(uint64_t frameID);
 437     void setDefersLoading(bool deferLoading);
 438
 439 #if USE(ACCELERATED_COMPOSITING)
 440     void enterAcceleratedCompositingMode(WebCore::GraphicsLayer*);
 441     void exitAcceleratedCompositingMode();
 442 #endif
 443
 444     void addPluginView(PluginView*);
 445     void removePluginView(PluginView*);
 446
 447 #if PLATFORM(MAC)
 448     LayerHostingMode layerHostingMode() const { return m_layerHostingMode; }
 449     void setLayerHostingMode(LayerHostingMode);
 450
 451     bool windowIsVisible() const { return m_windowIsVisible; }
 452     void updatePluginsActiveAndFocusedState();
 453     const WebCore::IntRect& windowFrameInScreenCoordinates() const { return m_windowFrameInScreenCoordinates; }
 454     const WebCore::IntRect& viewFrameInWindowCoordinates() const { return m_viewFrameInWindowCoordinates; }
 455 #elif PLATFORM(WIN)
 456     HWND nativeWindow() const { return m_nativeWindow; }
 457 #endif
 458
 459     bool windowIsFocused() const;
 460     bool windowAndWebPageAreFocused() const;
 461     void installPageOverlay(PassRefPtr<PageOverlay>);
 462     void uninstallPageOverlay(PageOverlay*, bool fadeOut);
 463     bool hasPageOverlay() const { return m_pageOverlay; }
 464     WebCore::IntPoint screenToWindow(const WebCore::IntPoint&);
 465     WebCore::IntRect windowToScreen(const WebCore::IntRect&);
 466
 467     PassRefPtr<WebImage> snapshotInViewCoordinates(const WebCore::IntRect&, ImageOptions);
 468     PassRefPtr<WebImage> scaledSnapshotInViewCoordinates(const WebCore::IntRect&, double scaleFactor, ImageOptions);
 469     PassRefPtr<WebImage> snapshotInDocumentCoordinates(const WebCore::IntRect&, ImageOptions);
 470     PassRefPtr<WebImage> scaledSnapshotInDocumentCoordinates(const WebCore::IntRect&, double scaleFactor, ImageOptions);
 471
 472     static const WebEvent* currentEvent();
 473
 474     FindController& findController() { return m_findController; }
 475 #if ENABLE(TOUCH_EVENTS) && PLATFORM(QT)
 476     TapHighlightController& tapHighlightController() { return m_tapHighlightController; }
 477 #endif
 478
 479 #if ENABLE(GEOLOCATION)
 480     GeolocationPermissionRequestManager& geolocationPermissionRequestManager() { return m_geolocationPermissionRequestManager; }
 481 #endif
 482
 483     NotificationPermissionRequestManager* notificationPermissionRequestManager();
 484 #if ENABLE(TIZEN_MEDIA_STREAM)
 485     UserMediaPermissionRequestManager* userMediaPermissionRequestManager();
 486 #endif
 487     void pageDidScroll();
 488 #if USE(TILED_BACKING_STORE)
 489     void pageDidRequestScroll(const WebCore::IntPoint&);
 490
 491 #if ENABLE(TIZEN_WEBKIT2_HISTORICAL_RESTORE_VISIBLE_CONTENT_RECT)
 492     void pageDidRequestRestoreVisibleContentRect(const WebCore::IntPoint&, float);
 493 #endif
 494
 495     void setFixedVisibleContentRect(const WebCore::IntRect&);
 496     void setResizesToContentsUsingLayoutSize(const WebCore::IntSize&);
 497     void resizeToContentsIfNeeded();
 498     void sendViewportAttributesChanged();
 499     void setViewportSize(const WebCore::IntSize&);
 500     WebCore::IntSize viewportSize() const { return m_viewportSize; }
 501
 502 #if ENABLE(TIZEN_WEBKIT2_TILED_BACKING_STORE)
 503     WebCore::IntSize contentsSize() const;
 504 #endif
 505
 506 #endif
 507
 508 #if ENABLE(CONTEXT_MENUS)
 509     WebContextMenu* contextMenu();
 510 #endif
 511
 512     bool hasLocalDataForURL(const WebCore::KURL&);
 513     String cachedResponseMIMETypeForURL(const WebCore::KURL&);
 514     String cachedSuggestedFilenameForURL(const WebCore::KURL&);
 515     PassRefPtr<WebCore::SharedBuffer> cachedResponseDataForURL(const WebCore::KURL&);
 516
 517     static bool canHandleRequest(const WebCore::ResourceRequest&);
 518
 519     class SandboxExtensionTracker {
 520     public:
 521         ~SandboxExtensionTracker();
 522
 523         void invalidate();
 524
 525         void beginLoad(WebFrame*, const SandboxExtension::Handle& handle);
 526         void willPerformLoadDragDestinationAction(PassRefPtr<SandboxExtension> pendingDropSandboxExtension);
 527         void didStartProvisionalLoad(WebFrame*);
 528         void didCommitProvisionalLoad(WebFrame*);
 529         void didFailProvisionalLoad(WebFrame*);
 530
 531     private:
 532         void setPendingProvisionalSandboxExtension(PassRefPtr<SandboxExtension>);
 533
 534         RefPtr<SandboxExtension> m_pendingProvisionalSandboxExtension;
 535         RefPtr<SandboxExtension> m_provisionalSandboxExtension;
 536         RefPtr<SandboxExtension> m_committedSandboxExtension;
 537     };
 538
 539     SandboxExtensionTracker& sandboxExtensionTracker() { return m_sandboxExtensionTracker; }
 540
 541 #if PLATFORM(EFL)
 542     void setThemePath(const String&);
 543 #endif
 544
 545 #if PLATFORM(QT)
 546     void setComposition(const String& text, Vector<WebCore::CompositionUnderline> underlines, uint64_t selectionStart, uint64_t selectionEnd, uint64_t replacementRangeStart, uint64_t replacementRangeEnd);
 547     void confirmComposition(const String& text, int64_t selectionStart, int64_t selectionLength);
 548     void cancelComposition();
 549 #endif
 550
 551 #if PLATFORM(MAC)
 552     void registerUIProcessAccessibilityTokens(const CoreIPC::DataReference& elemenToken, const CoreIPC::DataReference& windowToken);
 553     WKAccessibilityWebPageObject* accessibilityRemoteObject();
 554     WebCore::IntPoint accessibilityPosition() const { return m_accessibilityPosition; }
 555
 556     void sendComplexTextInputToPlugin(uint64_t pluginComplexTextInputIdentifier, const String& textInput);
 557
 558     void setComposition(const String& text, Vector<WebCore::CompositionUnderline> underlines, uint64_t selectionStart, uint64_t selectionEnd, uint64_t replacementRangeStart, uint64_t replacementRangeEnd, EditorState& newState);
 559     void confirmComposition(EditorState& newState);
 560     void cancelComposition(EditorState& newState);
 561     void insertText(const String& text, uint64_t replacementRangeStart, uint64_t replacementRangeEnd, bool& handled, EditorState& newState);
 562     void getMarkedRange(uint64_t& location, uint64_t& length);
 563     void getSelectedRange(uint64_t& location, uint64_t& length);
 564     void getAttributedSubstringFromRange(uint64_t location, uint64_t length, AttributedString&);
 565     void characterIndexForPoint(const WebCore::IntPoint point, uint64_t& result);
 566     void firstRectForCharacterRange(uint64_t location, uint64_t length, WebCore::IntRect& resultRect);
 567     void executeKeypressCommands(const Vector<WebCore::KeypressCommand>&, bool& handled, EditorState& newState);
 568     void readSelectionFromPasteboard(const WTF::String& pasteboardName, bool& result);
 569     void getStringSelectionForPasteboard(WTF::String& stringValue);
 570     void getDataSelectionForPasteboard(const WTF::String pasteboardType, SharedMemory::Handle& handle, uint64_t& size);
 571     void shouldDelayWindowOrderingEvent(const WebKit::WebMouseEvent&, bool& result);
 572     void acceptsFirstMouse(int eventNumber, const WebKit::WebMouseEvent&, bool& result);
 573     bool performNonEditingBehaviorForSelector(const String&);
 574     void insertDictatedText(const String& text, uint64_t replacementRangeStart, uint64_t replacementRangeEnd, const Vector<WebCore::DictationAlternative>& dictationAlternativeLocations, bool& handled, EditorState& newState);
 575 #elif PLATFORM(WIN)
 576     void confirmComposition(const String& compositionString);
 577     void setComposition(const WTF::String& compositionString, const WTF::Vector<WebCore::CompositionUnderline>& underlines, uint64_t cursorPosition);
 578     void firstRectForCharacterInSelectedRange(const uint64_t characterPosition, WebCore::IntRect& resultRect);
 579     void getSelectedText(WTF::String&);
 580
 581     void gestureWillBegin(const WebCore::IntPoint&, bool& canBeginPanning);
 582     void gestureDidScroll(const WebCore::IntSize&);
 583     void gestureDidEnd();
 584 #elif PLATFORM(EFL)
 585     void confirmComposition(const String& compositionString);
 586     void setComposition(const WTF::String& compositionString, const WTF::Vector<WebCore::CompositionUnderline>& underlines, uint64_t cursorPosition);
 587     void cancelComposition();
 588 #elif PLATFORM(GTK)
 589     void updateAccessibilityTree();
 590     bool handleMousePressedEvent(const WebCore::PlatformMouseEvent&);
 591 #if USE(TEXTURE_MAPPER_GL)
 592     void widgetMapped(int64_t nativeWindowHandle);
 593 #endif
 594 #endif
 595
 596     void setCompositionForTesting(const String& compositionString, uint64_t from, uint64_t length);
 597     bool hasCompositionForTesting();
 598     void confirmCompositionForTesting(const String& compositionString);
 599
 600     // FIXME: This a dummy message, to avoid breaking the build for platforms that don't require
 601     // any synchronous messages, and should be removed when <rdar://problem/8775115> is fixed.
 602     void dummy(bool&);
 603
 604 #if PLATFORM(MAC)
 605     void performDictionaryLookupForSelection(DictionaryPopupInfo::Type, WebCore::Frame*, const WebCore::VisibleSelection&);
 606
 607     bool isSpeaking();
 608     void speak(const String&);
 609     void stopSpeaking();
 610
 611     bool isSmartInsertDeleteEnabled() const { return m_isSmartInsertDeleteEnabled; }
 612 #endif
 613
 614 #if ENABLE(WEB_INTENTS)
 615     void deliverIntentToFrame(uint64_t frameID, const IntentData&);
 616 #endif
 617
 618     void replaceSelectionWithText(WebCore::Frame*, const String&);
 619     void clearSelection();
 620
 621 #if ENABLE(DRAG_SUPPORT)
 622 #if PLATFORM(WIN)
 623     void performDragControllerAction(uint64_t action, WebCore::IntPoint clientPosition, WebCore::IntPoint globalPosition, uint64_t draggingSourceOperationMask, const WebCore::DragDataMap&, uint32_t flags);
 624 #elif PLATFORM(QT) || PLATFORM(GTK)
 625     void performDragControllerAction(uint64_t action, WebCore::DragData);
 626 #else
 627 #if ENABLE(TIZEN_DRAG_SUPPORT)
 628     void performDragControllerAction(uint64_t action, WebCore::DragData);
 629 #else
 630     void performDragControllerAction(uint64_t action, WebCore::IntPoint clientPosition, WebCore::IntPoint globalPosition, uint64_t draggingSourceOperationMask, const WTF::String& dragStorageName, uint32_t flags, const SandboxExtension::Handle&, const SandboxExtension::HandleArray&);
 631 #endif
 632 #endif
 633     void dragEnded(WebCore::IntPoint clientPosition, WebCore::IntPoint globalPosition, uint64_t operation);
 634
 635     void willPerformLoadDragDestinationAction();
 636     void mayPerformUploadDragDestinationAction();
 637 #endif // ENABLE(DRAG_SUPPORT)
 638
 639     void beginPrinting(uint64_t frameID, const PrintInfo&);
 640     void endPrinting();
 641     void computePagesForPrinting(uint64_t frameID, const PrintInfo&, uint64_t callbackID);
 642 #if PLATFORM(MAC) || PLATFORM(WIN)
 643     void drawRectToPDF(uint64_t frameID, const PrintInfo&, const WebCore::IntRect&, uint64_t callbackID);
 644     void drawPagesToPDF(uint64_t frameID, const PrintInfo&, uint32_t first, uint32_t count, uint64_t callbackID);
 645 #elif PLATFORM(GTK)
 646     void drawPagesForPrinting(uint64_t frameID, const PrintInfo&, uint64_t callbackID);
 647 #endif
 648
 649 #if ENABLE(TIZEN_SUPPORT_WEBAPP_META_TAG)
 650     void getWebAppCapable(uint64_t callbackID);
 651     void getWebAppIconURL(uint64_t callbackID);
 652     void getWebAppIconURLs(uint64_t callbackID);
 653 #endif
 654
 655     void setMediaVolume(float);
 656
 657     bool mainFrameHasCustomRepresentation() const;
 658
 659     void didChangeScrollOffsetForMainFrame();
 660
 661     void mainFrameDidLayout();
 662
 663     bool canRunBeforeUnloadConfirmPanel() const { return m_canRunBeforeUnloadConfirmPanel; }
 664     void setCanRunBeforeUnloadConfirmPanel(bool canRunBeforeUnloadConfirmPanel) { m_canRunBeforeUnloadConfirmPanel = canRunBeforeUnloadConfirmPanel; }
 665
 666     bool canRunModal() const { return m_canRunModal; }
 667     void setCanRunModal(bool canRunModal) { m_canRunModal = canRunModal; }
 668
 669     void runModal();
 670
 671     void setDeviceScaleFactor(float);
 672     float deviceScaleFactor() const;
 673
 674     void setMemoryCacheMessagesEnabled(bool);
 675
 676     void forceRepaintWithoutCallback();
 677
 678     void unmarkAllMisspellings();
 679     void unmarkAllBadGrammar();
 680 #if PLATFORM(MAC) && __MAC_OS_X_VERSION_MIN_REQUIRED >= 1070
 681     void handleAlternativeTextUIResult(const String&);
 682 #endif
 683
 684     // For testing purpose.
 685     void simulateMouseDown(int button, WebCore::IntPoint, int clickCount, WKEventModifiers, double time);
 686     void simulateMouseUp(int button, WebCore::IntPoint, int clickCount, WKEventModifiers, double time);
 687     void simulateMouseMotion(WebCore::IntPoint, double time);
 688
 689 #if ENABLE(CONTEXT_MENUS)
 690     void contextMenuShowing() { m_isShowingContextMenu = true; }
 691 #endif
 692
 693 #if PLATFORM(QT)
 694     void registerApplicationScheme(const String& scheme);
 695     void applicationSchemeReply(const QtNetworkReplyData&);
 696     void receivedApplicationSchemeRequest(const QNetworkRequest&, QtNetworkReply*);
 697     void setUserScripts(const Vector<String>&);
 698 #endif
 699     void wheelEvent(const WebWheelEvent&);
 700 #if ENABLE(GESTURE_EVENTS)
 701     void gestureEvent(const WebGestureEvent&);
 702 #endif
 703
 704     void numWheelEventHandlersChanged(unsigned);
 705     void recomputeShortCircuitHorizontalWheelEventsState();
 706
 707     bool willGoToBackForwardItemCallbackEnabled() const { return m_willGoToBackForwardItemCallbackEnabled; }
 708
 709 #if ENABLE(PAGE_VISIBILITY_API)
 710     void setVisibilityState(int visibilityState, bool isInitialState);
 711 #endif
 712
 713 #if ENABLE(TIZEN_INPUT_TAG_EXTENSION) || ENABLE(TIZEN_WEBKIT2_FORM_DATABASE)
 714     void setFocusedInputElementValue(const String& inputValue);
 715     void getFocusedInputElementValue(String& inputValue);
 716 #endif
 717
 718 #if ENABLE(TIZEN_DATALIST_ELEMENT)
 719     void getFocusedInputElementDataList(Vector<String>&);
 720 #endif
 721
 722 #if ENABLE(TIZEN_CSS_OVERFLOW_SCROLL_ACCELERATION)
 723     void scrollOverflow(const WebCore::FloatPoint&, bool& scrolled);
 724     void setPressedNodeAtPoint(const WebCore::IntPoint&, bool checkOverflowLayer, bool& pressed, uint32_t& id);
 725 #endif
 726
 727 #if ENABLE(TIZEN_CSS_OVERFLOW_SCROLL_ACCELERATION_ON_UI_SIDE)
 728     void scrollOverflowWithTrajectoryVector(const WebCore::FloatPoint&);
 729 #endif
 730
 731 #if ENABLE(TIZEN_CUSTOM_HEADERS)
 732     void addCustomHeader(const String& name, const String& value);
 733     void removeCustomHeader(const String& name);
 734     void clearCustomHeaders();
 735     WebCore::HTTPHeaderMap customHeaders();
 736 #endif
 737
 738 #if ENABLE(TIZEN_WEBKIT2_GET_TEXT_STYLE_FOR_SELECTION)
 739     void getTextStyleStateForSelection();
 740 #endif
 741
 742 #if PLATFORM(GTK) && USE(TEXTURE_MAPPER_GL)
 743     uint64_t nativeWindowHandle() { return m_nativeWindowHandle; }
 744 #endif
 745
 746 #if ENABLE(TIZEN_MULTIPLE_SELECT)
 747     void didChangeSelectedIndexForActivePopupMenuMultiple(Vector<int32_t>);
 748 #endif
 749
 750 #if ENABLE(TIZEN_LINK_MAGNIFIER)
 751     void getLinkMagnifierRect(const WebCore::IntPoint&, const WebCore::IntSize&);
 752 #endif
 753
 754 #if ENABLE(TIZEN_SCREEN_READER)
 755     void raiseTapEvent(const WebCore::IntPoint&, const WebCore::IntPoint&);
 756     void moveScreenReaderFocus(bool, bool&);
 757     void moveScreenReaderFocusByPoint(const WebCore::IntPoint&);
 758     void recalcScreenReaderFocusRect();
 759     void updateScreenReaderFocus(WebCore::RenderObject*);
 760     void clearScreenReader();
 761 #endif
 762
 763 #if ENABLE(TIZEN_WEBKIT2_POPUP_INTERNAL)
 764     void notifyTransitionToCommitted(bool);
 765 #endif
 766
 767 #if ENABLE(TIZEN_CSP)
 768     void setContentSecurityPolicy(const String& policy, uint32_t headerType);
 769 #endif
 770
 771 #if ENABLE(TIZEN_INDEXED_DATABASE)
 772     void setIndexedDatabaseDirectory(const String& path);
 773 #endif
 774
 775 #if ENABLE(TIZEN_WEB_STORAGE)
 776     void setLocalStorageDirectory(const String& path);
 777 #endif
 778
 779 #if ENABLE(TIZEN_USE_SETTINGS_FONT)
 780     void useSettingsFont();
 781 #endif
 782
 783 private:
 784     WebPage(uint64_t pageID, const WebPageCreationParameters&);
 785
 786     virtual Type type() const { return APIType; }
 787
 788     void platformInitialize();
 789
 790     void didReceiveWebPageMessage(CoreIPC::Connection*, CoreIPC::MessageID, CoreIPC::ArgumentDecoder*);
 791     void didReceiveSyncWebPageMessage(CoreIPC::Connection*, CoreIPC::MessageID, CoreIPC::ArgumentDecoder*, OwnPtr<CoreIPC::ArgumentEncoder>&);
 792
 793 #if !PLATFORM(MAC)
 794     static const char* interpretKeyEvent(const WebCore::KeyboardEvent*);
 795 #endif
 796     bool performDefaultBehaviorForKeyEvent(const WebKeyboardEvent&);
 797
 798 #if PLATFORM(MAC)
 799     bool executeKeypressCommandsInternal(const Vector<WebCore::KeypressCommand>&, WebCore::KeyboardEvent*);
 800 #endif
 801
 802     String sourceForFrame(WebFrame*);
 803
 804     void loadData(PassRefPtr<WebCore::SharedBuffer>, const String& MIMEType, const String& encodingName, const WebCore::KURL& baseURL, const WebCore::KURL& failingURL);
 805
 806     bool platformHasLocalDataForURL(const WebCore::KURL&);
 807
 808     // Actions
 809     void tryClose();
 810     void loadURL(const String&, const SandboxExtension::Handle&);
 811     void loadURLRequest(const WebCore::ResourceRequest&, const SandboxExtension::Handle&);
 812     void loadHTMLString(const String& htmlString, const String& baseURL);
 813     void loadAlternateHTMLString(const String& htmlString, const String& baseURL, const String& unreachableURL);
 814     void loadPlainTextString(const String&);
 815     void loadWebArchiveData(const CoreIPC::DataReference&);
 816 #if OS(TIZEN)
 817     void loadContentsbyMimeType(const CoreIPC::DataReference&, const String& mimeType, const String& encoding, const String& baseURL);
 818 #endif
 819     void linkClicked(const String& url, const WebMouseEvent&);
 820     void reload(bool reloadFromOrigin, const SandboxExtension::Handle&);
 821     void goForward(uint64_t);
 822     void goBack(uint64_t);
 823     void goToBackForwardItem(uint64_t);
 824     void tryRestoreScrollPosition();
 825     void setActive(bool);
 826     void setFocused(bool);
 827     void setInitialFocus(bool forward, bool isKeyboardEventValid, const WebKeyboardEvent&);
 828     void setWindowResizerSize(const WebCore::IntSize&);
 829     void setIsInWindow(bool);
 830     void validateCommand(const String&, uint64_t);
 831     void executeEditCommand(const String&);
 832 #if OS(TIZEN)
 833     void executeEditCommandWithArgument(const String& command, const String& argument);
 834 #endif
 835
 836     void mouseEvent(const WebMouseEvent&);
 837     void mouseEventSyncForTesting(const WebMouseEvent&, bool&);
 838     void wheelEventSyncForTesting(const WebWheelEvent&, bool&);
 839 #if ENABLE(TIZEN_ISF_PORT)
 840     void keyEvent(const NativeWebKeyboardEvent&);
 841 #else
 842     void keyEvent(const WebKeyboardEvent&);
 843 #endif
 844     void keyEventSyncForTesting(const WebKeyboardEvent&, bool&);
 845 #if ENABLE(TOUCH_EVENTS)
 846     void touchEvent(const WebTouchEvent&);
 847     void touchEventSyncForTesting(const WebTouchEvent&, bool& handled);
 848 #if PLATFORM(QT)
 849     void highlightPotentialActivation(const WebCore::IntPoint&, const WebCore::IntSize& area);
 850 #endif
 851 #endif
 852 #if ENABLE(CONTEXT_MENUS)
 853     void contextMenuHidden() { m_isShowingContextMenu = false; }
 854 #endif
 855
 856     static void scroll(WebCore::Page*, WebCore::ScrollDirection, WebCore::ScrollGranularity);
 857     static void logicalScroll(WebCore::Page*, WebCore::ScrollLogicalDirection, WebCore::ScrollGranularity);
 858
 859     uint64_t restoreSession(const SessionState&);
 860     void restoreSessionAndNavigateToCurrentItem(const SessionState&);
 861
 862     void didRemoveBackForwardItem(uint64_t);
 863
 864     void setWillGoToBackForwardItemCallbackEnabled(bool enabled) { m_willGoToBackForwardItemCallbackEnabled = enabled; }
 865
 866     void setDrawsBackground(bool);
 867     void setDrawsTransparentBackground(bool);
 868
 869     void viewWillStartLiveResize();
 870     void viewWillEndLiveResize();
 871
 872     void getContentsAsString(uint64_t callbackID);
 873 #if ENABLE(MHTML)
 874     void getContentsAsMHTMLData(uint64_t callbackID, bool useBinaryEncoding);
 875 #endif
 876     void getMainResourceDataOfFrame(uint64_t frameID, uint64_t callbackID);
 877     void getResourceDataFromFrame(uint64_t frameID, const String& resourceURL, uint64_t callbackID);
 878     void getRenderTreeExternalRepresentation(uint64_t callbackID);
 879     void getSelectionOrContentsAsString(uint64_t callbackID);
 880     void getSourceForFrame(uint64_t frameID, uint64_t callbackID);
 881     void getWebArchiveOfFrame(uint64_t frameID, uint64_t callbackID);
 882     void runJavaScriptInMainFrame(const String&, uint64_t callbackID);
 883     void forceRepaint(uint64_t callbackID);
 884
 885     void preferencesDidChange(const WebPreferencesStore&);
 886     void platformPreferencesDidChange(const WebPreferencesStore&);
 887     void updatePreferences(const WebPreferencesStore&);
 888
 889     void didReceivePolicyDecision(uint64_t frameID, uint64_t listenerID, uint32_t policyAction, uint64_t downloadID);
 890     void setUserAgent(const String&);
 891     void setCustomTextEncodingName(const String&);
 892     void suspendActiveDOMObjectsAndAnimations();
 893     void resumeActiveDOMObjectsAndAnimations();
 894
 895 #if PLATFORM(MAC)
 896     void performDictionaryLookupAtLocation(const WebCore::FloatPoint&);
 897     void performDictionaryLookupForRange(DictionaryPopupInfo::Type, WebCore::Frame*, WebCore::Range*, NSDictionary *options);
 898
 899     void setWindowIsVisible(bool windowIsVisible);
 900     void windowAndViewFramesChanged(const WebCore::IntRect& windowFrameInScreenCoordinates, const WebCore::IntRect& viewFrameInWindowCoordinates, const WebCore::IntPoint& accessibilityViewCoordinates);
 901
 902     RetainPtr<PDFDocument> pdfDocumentForPrintingFrame(WebCore::Frame*);
 903     void computePagesForPrintingPDFDocument(uint64_t frameID, const PrintInfo&, Vector<WebCore::IntRect>& resultPageRects);
 904     void drawRectToPDFFromPDFDocument(CGContextRef, PDFDocument *, const PrintInfo&, const WebCore::IntRect&);
 905     void drawPagesToPDFFromPDFDocument(CGContextRef, PDFDocument *, const PrintInfo&, uint32_t first, uint32_t count);
 906 #endif
 907
 908     void unapplyEditCommand(uint64_t commandID);
 909     void reapplyEditCommand(uint64_t commandID);
 910     void didRemoveEditCommand(uint64_t commandID);
 911
 912     void findString(const String&, uint32_t findOptions, uint32_t maxMatchCount);
 913     void findStringMatches(const String&, uint32_t findOptions, uint32_t maxMatchCount);
 914     void getImageForFindMatch(uint32_t matchIndex);
 915     void selectFindMatch(uint32_t matchIndex);
 916     void hideFindUI();
 917     void countStringMatches(const String&, uint32_t findOptions, uint32_t maxMatchCount);
 918
 919 #if PLATFORM(QT) || OS(TIZEN)
 920     void findZoomableAreaForPoint(const WebCore::IntPoint&, const WebCore::IntSize& area);
 921 #endif
 922
 923     void didChangeSelectedIndexForActivePopupMenu(int32_t newIndex);
 924     void setTextForActivePopupMenu(int32_t index);
 925
 926 #if PLATFORM(GTK)
 927     void failedToShowPopupMenu();
 928 #endif
 929 #if PLATFORM(QT)
 930     void hidePopupMenu();
 931     void selectedIndex(int32_t newIndex);
 932 #endif
 933
 934     void didChooseFilesForOpenPanel(const Vector<String>&);
 935     void didCancelForOpenPanel();
 936 #if ENABLE(WEB_PROCESS_SANDBOX)
 937     void extendSandboxForFileFromOpenPanel(const SandboxExtension::Handle&);
 938 #endif
 939
 940     void didReceiveGeolocationPermissionDecision(uint64_t geolocationID, bool allowed);
 941
 942     void didReceiveNotificationPermissionDecision(uint64_t notificationID, bool allowed);
 943 #if ENABLE(TIZEN_MEDIA_STREAM)
 944     void didReceiveUserMediaPermissionDecision(uint64_t userMediaID, bool allowed);
 945 #endif
 946
 947     void advanceToNextMisspelling(bool startBeforeSelection);
 948     void changeSpellingToWord(const String& word);
 949 #if USE(APPKIT)
 950     void uppercaseWord();
 951     void lowercaseWord();
 952     void capitalizeWord();
 953 #endif
 954
 955 #if PLATFORM(MAC)
 956     void setSmartInsertDeleteEnabled(bool isSmartInsertDeleteEnabled) { m_isSmartInsertDeleteEnabled = isSmartInsertDeleteEnabled; }
 957 #endif
 958
 959 #if ENABLE(CONTEXT_MENUS)
 960     void didSelectItemFromActiveContextMenu(const WebContextMenuItemData&);
 961 #endif
 962
 963     void changeSelectedIndex(int32_t index);
 964     void setCanStartMediaTimerFired();
 965
 966     static bool platformCanHandleRequest(const WebCore::ResourceRequest&);
 967 #if ENABLE(TIZEN_NATIVE_MEMORY_SNAPSHOT)
 968     void dumpMemorySnapshot();
 969 #endif
 970     OwnPtr<WebCore::Page> m_page;
 971     RefPtr<WebFrame> m_mainFrame;
 972     RefPtr<InjectedBundleBackForwardList> m_backForwardList;
 973
 974     RefPtr<WebPageGroupProxy> m_pageGroup;
 975
 976     String m_userAgent;
 977
 978     WebCore::IntSize m_viewSize;
 979     OwnPtr<DrawingArea> m_drawingArea;
 980
 981     HashSet<PluginView*> m_pluginViews;
 982
 983     bool m_useFixedLayout;
 984
 985     bool m_drawsBackground;
 986     bool m_drawsTransparentBackground;
 987
 988     bool m_isInRedo;
 989     bool m_isClosed;
 990
 991     bool m_tabToLinks;
 992 #if ENABLE(TIZEN_CUSTOM_HEADERS)
 993     WebCore::HTTPHeaderMap m_customHeaders;
 994 #endif
 995
 996 #if PLATFORM(MAC)
 997     // Whether the containing window is visible or not.
 998     bool m_windowIsVisible;
 999
1000     // Whether smart insert/delete is enabled or not.
1001     bool m_isSmartInsertDeleteEnabled;
1002
1003     // The frame of the containing window in screen coordinates.
1004     WebCore::IntRect m_windowFrameInScreenCoordinates;
1005
1006     // The frame of the view in window coordinates.
1007     WebCore::IntRect m_viewFrameInWindowCoordinates;
1008
1009     // The accessibility position of the view.
1010     WebCore::IntPoint m_accessibilityPosition;
1011
1012     // The layer hosting mode.
1013     LayerHostingMode m_layerHostingMode;
1014
1015     RetainPtr<WKAccessibilityWebPageObject> m_mockAccessibilityElement;
1016
1017     WebCore::KeyboardEvent* m_keyboardEventBeingInterpreted;
1018
1019 #elif PLATFORM(WIN)
1020     // Our view's window (in the UI process).
1021     HWND m_nativeWindow;
1022
1023     RefPtr<WebCore::Node> m_gestureTargetNode;
1024 #elif PLATFORM(GTK)
1025     WebPageAccessibilityObject* m_accessibilityObject;
1026
1027 #if USE(TEXTURE_MAPPER_GL)
1028     // Our view's window in the UI process.
1029     uint64_t m_nativeWindowHandle;
1030 #endif
1031 #endif
1032
1033     WebCore::RunLoop::Timer<WebPage> m_setCanStartMediaTimer;
1034
1035     HashMap<uint64_t, RefPtr<WebUndoStep> > m_undoStepMap;
1036
1037     WebCore::IntSize m_windowResizerSize;
1038
1039 #if ENABLE(CONTEXT_MENUS)
1040     InjectedBundlePageContextMenuClient m_contextMenuClient;
1041 #endif
1042     InjectedBundlePageEditorClient m_editorClient;
1043     InjectedBundlePageFormClient m_formClient;
1044     InjectedBundlePageLoaderClient m_loaderClient;
1045     InjectedBundlePagePolicyClient m_policyClient;
1046     InjectedBundlePageResourceLoadClient m_resourceLoadClient;
1047     InjectedBundlePageUIClient m_uiClient;
1048 #if ENABLE(FULLSCREEN_API)
1049     InjectedBundlePageFullScreenClient m_fullScreenClient;
1050 #endif
1051     InjectedBundlePageDiagnosticLoggingClient m_logDiagnosticMessageClient;
1052
1053 #if USE(TILED_BACKING_STORE)
1054     WebCore::IntSize m_viewportSize;
1055 #endif
1056
1057     FindController m_findController;
1058 #if ENABLE(TOUCH_EVENTS) && PLATFORM(QT)
1059     TapHighlightController m_tapHighlightController;
1060 #endif
1061     RefPtr<PageOverlay> m_pageOverlay;
1062
1063     RefPtr<WebPage> m_underlayPage;
1064
1065 #if ENABLE(INSPECTOR)
1066     RefPtr<WebInspector> m_inspector;
1067 #endif
1068 #if ENABLE(FULLSCREEN_API)
1069     RefPtr<WebFullScreenManager> m_fullScreenManager;
1070 #endif
1071     RefPtr<WebPopupMenu> m_activePopupMenu;
1072 #if ENABLE(CONTEXT_MENUS)
1073     RefPtr<WebContextMenu> m_contextMenu;
1074 #endif
1075 #if ENABLE(INPUT_TYPE_COLOR)
1076     WebColorChooser* m_activeColorChooser;
1077 #endif
1078     RefPtr<WebOpenPanelResultListener> m_activeOpenPanelResultListener;
1079     RefPtr<NotificationPermissionRequestManager> m_notificationPermissionRequestManager;
1080 #if ENABLE(TIZEN_MEDIA_STREAM)
1081     RefPtr<UserMediaPermissionRequestManager> m_userMediaPermissionRequestManager;
1082 #endif
1083
1084 #if ENABLE(GEOLOCATION)
1085     GeolocationPermissionRequestManager m_geolocationPermissionRequestManager;
1086 #endif
1087
1088     OwnPtr<WebCore::PrintContext> m_printContext;
1089 #if PLATFORM(GTK)
1090     RefPtr<WebPrintOperationGtk> m_printOperation;
1091 #endif
1092
1093     SandboxExtensionTracker m_sandboxExtensionTracker;
1094     uint64_t m_pageID;
1095
1096     RefPtr<SandboxExtension> m_pendingDropSandboxExtension;
1097     Vector<RefPtr<SandboxExtension> > m_pendingDropExtensionsForFileUpload;
1098
1099     bool m_canRunBeforeUnloadConfirmPanel;
1100
1101     bool m_canRunModal;
1102     bool m_isRunningModal;
1103
1104     bool m_cachedMainFrameIsPinnedToLeftSide;
1105     bool m_cachedMainFrameIsPinnedToRightSide;
1106     bool m_canShortCircuitHorizontalWheelEvents;
1107     unsigned m_numWheelEventHandlers;
1108
1109     unsigned m_cachedPageCount;
1110
1111 #if ENABLE(CONTEXT_MENUS)
1112     bool m_isShowingContextMenu;
1113 #endif
1114
1115     bool m_willGoToBackForwardItemCallbackEnabled;
1116
1117 #if PLATFORM(WIN)
1118     bool m_gestureReachedScrollingLimit;
1119 #endif
1120
1121 #if PLATFORM(QT)
1122     HashMap<String, QtNetworkReply*> m_applicationSchemeReplies;
1123 #endif
1124 #if ENABLE(PAGE_VISIBILITY_API)
1125     WebCore::PageVisibilityState m_visibilityState;
1126 #endif
1127 #if ENABLE(TIZEN_SYNC_REQUEST_ANIMATION_FRAME)
1128     bool m_suspendedAnimationController;
1129 #endif
1130
1131     WebInspectorClient* m_inspectorClient;
1132
1133 #if ENABLE(TIZEN_SCREEN_READER)
1134     OwnPtr<ScreenReader> m_screenReader;
1135 #endif
1136
1137 #if ENABLE(TIZEN_WEBKIT2_TEXT_SELECTION)
1138     EditorState m_editorState;
1139 #endif
1140 };
1141
1142 #if ENABLE(TIZEN_NATIVE_MEMORY_SNAPSHOT)
1143 void dumpMemorySnapshot();
1144 #endif
1145
1146 } // namespace WebKit
1147
1148 #endif // WebPage_h