Source/WebKit2/UIProcess/API/efl/PageClientImpl.h

   1 /*
   2  * Copyright (C) 2011 Samsung Electronics
   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 PageClientImpl_h
  27 #define PageClientImpl_h
  28
  29 #include "PageClient.h"
  30 #include <Evas.h>
  31
  32 #if OS(TIZEN)
  33 #include "WebEditCommandProxy.h"
  34 #include <WebCore/ViewportArguments.h>
  35
  36 #if ENABLE(TIZEN_WEBKIT2_TILED_BACKING_STORE)
  37 #if ENABLE(TIZEN_WEBKIT2_TILED_AC)
  38 #include "DrawingAreaProxyImpl.h"
  39 #include <WebCore/Color.h>
  40 #endif
  41 #endif
  42 #if ENABLE(TIZEN_WEBKIT2_TEXT_SELECTION)
  43 #include "TextSelection.h"
  44 #endif
  45 #if ENABLE(TIZEN_OFFLINE_PAGE_SAVE)
  46 #include "OfflinePageSave.h"
  47 #endif
  48 #if ENABLE(TIZEN_DRAG_SUPPORT)
  49 #include "Drag.h"
  50 #endif
  51 #if ENABLE(TIZEN_WEBKIT2_FORM_DATABASE)
  52 #include "FormDataCandidate.h"
  53 #endif
  54 #endif // #if OS(TIZEN)
  55
  56 class EwkViewImpl;
  57
  58 namespace WebKit {
  59
  60 #if ENABLE(TIZEN_WEBKIT2_TILED_SCROLLBAR)
  61 class MainFrameScrollbarTizen;
  62 #endif
  63
  64 #if ENABLE(TIZEN_WEBKIT2_TEXT_SELECTION)
  65 class TextSelection;
  66 #endif
  67
  68 #if ENABLE(TIZEN_WEBKIT2_CLIPBOARD_HELPER)
  69 class ClipboardHelper;
  70 #endif
  71
  72 #if ENABLE(TIZEN_DRAG_SUPPORT)
  73 class Drag;
  74 #endif
  75
  76 #if ENABLE(TIZEN_WEBKIT2_FORM_DATABASE)
  77 class FormDataCandidate;
  78 #endif
  79
  80 class PageClientImpl : public PageClient {
  81 public:
  82     static PassOwnPtr<PageClientImpl> create(EwkViewImpl* viewImpl)
  83     {
  84         return adoptPtr(new PageClientImpl(viewImpl));
  85     }
  86     virtual ~PageClientImpl();
  87
  88     EwkViewImpl* viewImpl() const;
  89
  90 #if OS(TIZEN)
  91     struct ViewportConstraints {
  92         ViewportConstraints()
  93             : initialScale(1.0)
  94             , minimumScale(1.0)
  95             , maximumScale(1.0)
  96             , userScalable(true)
  97             , contentsDefinedInitialScale(false)
  98             , layoutSize(WebCore::IntSize())
  99         {
 100         }
 101         double initialScale;
 102         double minimumScale;
 103         double maximumScale;
 104         bool userScalable;
 105         bool contentsDefinedInitialScale;
 106         WebCore::IntSize layoutSize;
 107     };
 108
 109     ViewportConstraints viewportConstraints() { return m_viewportConstraints; }
 110     ViewportConstraints computeViewportConstraints(const WebCore::ViewportAttributes&);
 111     double adjustScaleWithViewport(double);
 112 #if USE(TILED_BACKING_STORE) && ENABLE(TIZEN_WEBKIT2_TILED_BACKING_STORE)
 113     TIZEN_VIRTUAL void updateViewportSize(const WebCore::IntSize&, const int);
 114 #endif
 115     void initializeVisibleContentRect();
 116     double availableMinimumScale();
 117     void fitViewportToContent();
 118     bool wasViewportFitsToContent() { return m_viewportFitsToContent; }
 119
 120     void setFocusedNodeRect(const WebCore::IntRect&);
 121     WebCore::IntRect focusedNodeRect() { return m_focusedNodeRect; };
 122
 123 #if ENABLE(TIZEN_WEBKIT2_FORM_DATABASE)
 124     void textChangeInTextField(const String& name, const String& value);
 125 #endif
 126
 127     void setViewFocused(bool focused) { m_viewFocused = focused; }
 128     void setViewWindowActive(bool active) { m_viewWindowActive = active; }
 129     void updateFormNavigation(int length, int offset);
 130
 131 #if ENABLE(TIZEN_WEBKIT2_TILED_BACKING_STORE)
 132 #if ENABLE(TIZEN_WEBKIT2_TILED_AC)
 133     DrawingAreaProxy* drawingArea() const;
 134 #endif
 135     float scaleFactor();
 136     const WebCore::IntPoint scrollPosition();
 137     WebCore::IntRect adjustVisibleContentRect(WebCore::IntRect, float);
 138     void setVisibleContentRect(const WebCore::IntRect&, float newScale, const WebCore::FloatPoint& trajectory = WebCore::FloatPoint());
 139     TIZEN_VIRTUAL void displayViewport();
 140     TIZEN_VIRTUAL void drawContents();
 141 #if ENABLE(TIZEN_RUNTIME_BACKEND_SELECTION)
 142     virtual void drawContents(BackingStore::PlatformGraphicsContext);
 143 #endif
 144     void scaleImage(double, WebCore::IntPoint);
 145     void scaleContents(double, const WebCore::IntPoint&);
 146     WebCore::IntRect visibleContentRect() { return m_visibleContentRect; }
 147
 148 #if ENABLE(TIZEN_WEBKIT2_TILED_SCROLLBAR)
 149     void updateScrollbar();
 150     void frameRectChanged();
 151     void updateVisibility();
 152 #endif
 153
 154     // FIXME: The concept of suspending content comes from webkit opensource's PageViewportController,
 155     // so below code should be replaced when PageViewportController codes are merged.
 156     // Please do not use below codes. They are only for scaling contents.
 157     void suspendContent();
 158     void resumeContent();
 159     WebCore::FloatPoint boundContentsPositionAtScale(const WebCore::FloatPoint&, float scale);
 160 #else
 161     float scaleFactor() { return page()->pageScaleFactor(); }
 162     WebCore::IntPoint scrollPosition() { return page()->scrollPosition(); }
 163 #endif // #if ENABLE(TIZEN_WEBKIT2_TILED_BACKING_STORE)
 164
 165 #if ENABLE(TIZEN_WEBKIT2_TEXT_SELECTION)
 166     bool isTextSelectionDowned();
 167     bool isTextSelectionMode();
 168     void setIsTextSelectionMode(bool isTextSelectionMode);
 169     void updateTextSelectionHandlesAndContextMenu(bool isShow, bool isScrolling = false);
 170     bool textSelectionDown(const WebCore::IntPoint& point, bool isStartedTextSelectionFromOutside = false);
 171     void textSelectionMove(const WebCore::IntPoint& point, bool isStartedTextSelectionFromOutside = false);
 172     void textSelectionUp(const WebCore::IntPoint& point, bool isStartedTextSelectionFromOutside = false);
 173     bool isTextSelectionHandleDowned();
 174 #if ENABLE(TIZEN_WEBKIT2_FOR_MOVING_TEXT_SELECTION_HANDLE_FROM_OSP)
 175     void textSelectonHandleDown(const WebCore::IntPoint& point);
 176     void textSelectonHandleMove(const WebCore::IntPoint& point);
 177     void textSelectonHandleUp();
 178 #endif
 179     void requestToShowTextSelectionHandlesAndContextMenu();
 180 #endif
 181
 182 #if ENABLE(TIZEN_OFFLINE_PAGE_SAVE)
 183     void saveSerializedHTMLDataForMainPage(const String& serializedData, const String& fileName);
 184     void saveSubresourcesData(Vector<WebSubresourceTizen>& subresourceData);
 185     void startOfflinePageSave(String& path, String& url, String& title);
 186 #endif
 187
 188 #if ENABLE(TIZEN_CLIPBOARD) || ENABLE(TIZEN_PASTEBOARD)
 189     void setClipboardData(const String& data, const String& type);
 190     void clearClipboardData();
 191 #endif
 192
 193 #if ENABLE(TIZEN_WEBKIT2_CLIPBOARD_HELPER)
 194     void pasteContextMenuSelected();
 195 #endif
 196
 197
 198 #if ENABLE(TIZEN_WEBKIT2_VIEW_VISIBILITY)
 199     void setIsVisible(bool isVisible);
 200 #endif
 201
 202 #if ENABLE(TIZEN_WEBKIT2_TILED_BACKING_STORE)
 203     bool scrollBy(WebCore::IntSize);
 204     void scrollTo(WebCore::IntPoint);
 205 #endif
 206
 207     void setIsScrollableLayerFocused(const bool b) { m_isScrollableLayerFocused = b; }
 208     bool isScrollableLayerFocused() const { return m_isScrollableLayerFocused; }
 209
 210     void setIsScrollableNodeFocused(const bool b) { m_isScrollableNodeFocused = b; }
 211     bool isScrollableNodeFocused() const { return m_isScrollableNodeFocused; }
 212
 213 #if ENABLE(TIZEN_CSS_OVERFLOW_SCROLL_ACCELERATION)
 214     void setOverflowResult(bool pressed, WebLayerID);
 215     void findScrollableNode(const WebCore::IntPoint&);
 216 #endif
 217
 218 #if ENABLE(TIZEN_CONTEXT_MENU_WEBKIT_2)
 219     bool isContextMenuVisible() { return m_isContextMenuVisible; }
 220     void setIsContextMenuVisible(bool isVisible) { m_isContextMenuVisible = isVisible; }
 221 #endif
 222     TIZEN_VIRTUAL void didRenderFrame();
 223 #if ENABLE(TIZEN_WEBKIT2_TILED_AC)
 224     void setBackgroundColor(double red, double green, double blue, double alpha);
 225     TIZEN_VIRTUAL bool makeContextCurrent() { return true; }
 226 #endif
 227 #if ENABLE(TIZEN_WEBKIT2_GET_TEXT_STYLE_FOR_SELECTION)
 228     void didGetTextStyleStateForSelection(int underlineState, int italicState, int boldState);
 229 #endif
 230
 231     virtual void didFindZoomableArea(const WebCore::IntPoint&, const WebCore::IntRect&);
 232
 233 #if ENABLE(TIZEN_ICON_DATABASE)
 234     virtual void didReceiveIcon();
 235 #endif
 236
 237 #if ENABLE(TIZEN_WEBKIT2_CONTEXT_MENU_CLIPBOARD)
 238     void clipboardContextMenuSelected();
 239     bool isClipboardWindowOpened();
 240     void closeClipboardWindow();
 241 #endif
 242
 243 #if ENABLE(TIZEN_DRAG_SUPPORT)
 244     void setDragPoint(const WebCore::IntPoint& point);
 245     bool isDragMode();
 246     void setDragMode(bool isDragMode);
 247 #endif
 248
 249 #if ENABLE(TIZEN_WEBKIT2_FOCUS_RING)
 250     void hideFocusRing();
 251 #endif
 252
 253 #if ENABLE(TIZEN_WEBKIT2_FORM_DATABASE)
 254     bool isShowingFormDataCandidate();
 255     void updateFormDataCandidate(const Vector<String>& data);
 256     void hideFormDataCandidate();
 257     void showFormDataCandidate(const WebCore::IntRect& rect);
 258 #endif
 259
 260 #if ENABLE(TIZEN_PRERENDERING_FOR_ROTATION)
 261     void setWaitFrameOfNewViewortSize(bool waitFrameOfNewViewortSize) { m_waitFrameOfNewViewortSize = waitFrameOfNewViewortSize; }
 262 #endif
 263
 264 #endif // #if OS(TIZEN)
 265
 266 private:
 267     // PageClient
 268     virtual PassOwnPtr<DrawingAreaProxy> createDrawingAreaProxy();
 269     virtual void setViewNeedsDisplay(const WebCore::IntRect&);
 270     virtual void displayView();
 271     virtual void scrollView(const WebCore::IntRect&, const WebCore::IntSize&);
 272     virtual bool isViewWindowActive() { return m_viewWindowActive; }
 273     virtual bool isViewFocused() { return m_viewFocused; }
 274     virtual bool isViewVisible();
 275     virtual bool isViewInWindow();
 276
 277     virtual void processDidCrash();
 278     virtual void didRelaunchProcess();
 279     virtual void pageClosed();
 280
 281     virtual void toolTipChanged(const String&, const String&);
 282
 283     virtual void setCursor(const WebCore::Cursor&);
 284     virtual void setCursorHiddenUntilMouseMoves(bool);
 285     virtual void didChangeViewportProperties(const WebCore::ViewportAttributes&);
 286
 287     virtual void registerEditCommand(PassRefPtr<WebEditCommandProxy>, WebPageProxy::UndoOrRedo);
 288     virtual void clearAllEditCommands();
 289     virtual bool canUndoRedo(WebPageProxy::UndoOrRedo);
 290     virtual void executeUndoRedo(WebPageProxy::UndoOrRedo);
 291     virtual WebCore::FloatRect convertToDeviceSpace(const WebCore::FloatRect&);
 292     virtual WebCore::FloatRect convertToUserSpace(const WebCore::FloatRect&);
 293     virtual WebCore::IntPoint screenToWindow(const WebCore::IntPoint&);
 294     virtual WebCore::IntRect windowToScreen(const WebCore::IntRect&);
 295
 296     void updateTextInputState();
 297     virtual void handleDownloadRequest(DownloadProxy*);
 298
 299     virtual void doneWithKeyEvent(const NativeWebKeyboardEvent&, bool);
 300 #if ENABLE(GESTURE_EVENTS)
 301     virtual void doneWithGestureEvent(const WebGestureEvent&, bool wasEventHandled);
 302 #endif
 303 #if ENABLE(TOUCH_EVENTS)
 304     virtual void doneWithTouchEvent(const NativeWebTouchEvent&, bool wasEventHandled);
 305 #endif
 306
 307     virtual PassRefPtr<WebPopupMenuProxy> createPopupMenuProxy(WebPageProxy*);
 308     virtual PassRefPtr<WebContextMenuProxy> createContextMenuProxy(WebPageProxy*);
 309
 310 #if ENABLE(INPUT_TYPE_COLOR)
 311     virtual PassRefPtr<WebColorChooserProxy> createColorChooserProxy(WebPageProxy*, const WebCore::Color& initialColor);
 312 #endif
 313
 314     virtual void setFindIndicator(PassRefPtr<FindIndicator>, bool, bool);
 315 #if ENABLE(TIZEN_WEBKIT2_TILED_AC)
 316     TIZEN_VIRTUAL void initializeAcceleratedCompositingMode();
 317     TIZEN_VIRTUAL void finalizeAcceleratedCompositingMode() {}
 318     virtual void enterAcceleratedCompositingMode(const LayerTreeContext&) {}
 319     virtual void exitAcceleratedCompositingMode() {}
 320
 321     virtual void updateAcceleratedCompositingMode(const LayerTreeContext&);
 322 #endif
 323
 324     virtual void didChangeScrollbarsForMainFrame() const;
 325
 326 #if OS(TIZEN)
 327 #if ENABLE(TIZEN_WEBKIT2_TILED_SCROLLBAR)
 328     void createScrollbarIfNeeded(bool horizontalBar, bool verticalBar);
 329 #endif
 330
 331     virtual void didFirstVisuallyNonEmptyLayoutForMainFrame();
 332     virtual void didChangeContentsSize(const WebCore::IntSize);
 333     virtual void pageScaleFactorDidChange();
 334 #endif
 335
 336     virtual void didCommitLoadForMainFrame(bool);
 337     virtual void didFinishLoadingDataForCustomRepresentation(const String&, const CoreIPC::DataReference&);
 338     virtual double customRepresentationZoomFactor();
 339     virtual void setCustomRepresentationZoomFactor(double);
 340
 341     virtual void flashBackingStoreUpdates(const Vector<WebCore::IntRect>&);
 342     virtual void findStringInCustomRepresentation(const String&, FindOptions, unsigned);
 343     virtual void countStringMatchesInCustomRepresentation(const String&, FindOptions, unsigned);
 344
 345 #if USE(TILED_BACKING_STORE)
 346     virtual void pageDidRequestScroll(const WebCore::IntPoint&);
 347 #endif
 348
 349 #if ENABLE(TIZEN_WEBKIT2_HISTORICAL_RESTORE_VISIBLE_CONTENT_RECT)
 350     virtual void pageDidRequestRestoreVisibleContentRect(const WebCore::IntPoint&, float);
 351 #endif
 352
 353 #if ENABLE(TIZEN_DRAG_SUPPORT)
 354     virtual void startDrag(const WebCore::DragData&, PassRefPtr<ShareableBitmap> dragImage);
 355 #endif
 356
 357 #if ENABLE(TIZEN_REGISTER_PROTOCOL_HANDLER)
 358     virtual void registerProtocolHandler(const String& scheme, const String& baseURL, const String& url, const String& title);
 359 #endif
 360 #if ENABLE(TIZEN_CUSTOM_SCHEME_HANDLER)
 361     virtual unsigned int isProtocolHandlerRegistered(const String& scheme, const String& baseURL, const String& url);
 362     virtual void unregisterProtocolHandler(const String& scheme, const String& baseURL, const String& url);
 363 #endif
 364 #if ENABLE(TIZEN_REGISTER_CONTENT_HANDLER)
 365     virtual void registerContentHandler(const String& mimeType, const String& baseURL, const String& url, const String& title);
 366     virtual unsigned int isContentHandlerRegistered(const String& mimeType, const String& baseURL, const String& url);
 367     virtual void unregisterContentHandler(const String& mimeType, const String& baseURL, const String& url);
 368 #endif
 369 #if ENABLE(TIZEN_SEARCH_PROVIDER)
 370     virtual void addSearchProvider(const String& baseURL, const String& engineURL);
 371     virtual unsigned long isSearchProviderInstalled(const String& baseURL, const String& engineURL);
 372 #endif
 373
 374 #if ENABLE(TIZEN_SUPPORT_WEBAPP_META_TAG)
 375     virtual bool getStandaloneStatus();
 376 #endif
 377
 378 #if ENABLE(SCREEN_ORIENTATION_SUPPORT) && ENABLE(TIZEN_SCREEN_ORIENTATION_SUPPORT)
 379     virtual bool lockOrientation(int willLockOrientation);
 380     virtual void unlockOrientation();
 381 #endif
 382
 383 protected:
 384     explicit PageClientImpl(EwkViewImpl*);
 385
 386     virtual WebCore::IntSize viewSize();
 387
 388     EwkViewImpl* m_viewImpl;
 389
 390 #if OS(TIZEN)
 391     ViewportConstraints m_viewportConstraints;
 392
 393     bool m_viewFocused;
 394     bool m_viewWindowActive;
 395
 396     bool m_pageDidRendered;
 397
 398     // Both angle and wasMinimized are added to handle device rotation
 399     int m_viewportAngle;
 400     bool m_viewportFitsToContent;
 401
 402     WebCore::IntRect m_focusedNodeRect;
 403
 404 #if ENABLE(TIZEN_WEBKIT2_TILED_BACKING_STORE)
 405     WebCore::IntRect m_visibleContentRect;
 406     float m_scaleFactor;
 407
 408     // FIXME: The concept of suspending content comes from webkit opensource's PageViewportController,
 409     // so below code should be replaced when PageViewportController codes are merged.
 410     // Please do not use below codes. They are only for scaling contents.
 411     bool m_hasSuspendedContent;
 412 #endif // ENABLE(TIZEN_WEBKIT2_TILED_BACKING_STORE)
 413
 414 #if ENABLE(TIZEN_WEBKIT2_HISTORICAL_RESTORE_VISIBLE_CONTENT_RECT)
 415     WebCore::IntPoint m_restoredScrollPosition;
 416     float m_restoredScaleFactor;
 417 #endif
 418
 419 #if ENABLE(TIZEN_WEBKIT2_TILED_SCROLLBAR)
 420     RefPtr<MainFrameScrollbarTizen> m_horizontalScrollbar;
 421     RefPtr<MainFrameScrollbarTizen> m_verticalScrollbar;
 422 #endif
 423 #if ENABLE(TIZEN_WEBKIT2_TEXT_SELECTION)
 424     OwnPtr<TextSelection> m_textSelection;
 425 #endif
 426 #if ENABLE(TIZEN_OFFLINE_PAGE_SAVE)
 427     OwnPtr<OfflinePageSave> m_offlinePageSave;
 428 #endif
 429 #if ENABLE(TIZEN_WEBKIT2_CLIPBOARD_HELPER)
 430     OwnPtr<ClipboardHelper> m_clipboardHelper;
 431 #endif
 432 #if ENABLE(TIZEN_DRAG_SUPPORT)
 433     OwnPtr<Drag> m_drag;
 434 #endif
 435 #if ENABLE(TIZEN_WEBKIT2_FORM_DATABASE)
 436     OwnPtr<FormDataCandidate> m_formDataCandidate;
 437 #endif
 438     bool m_suspendPainting;
 439     bool m_suspendResource;
 440     bool m_suspendRequested;
 441     bool m_isVisible;
 442
 443     bool m_isScrollableLayerFocused;
 444     bool m_isScrollableNodeFocused;
 445
 446 #if ENABLE(TIZEN_WEBKIT2_TILED_AC_SHARED_PLATFORM_SURFACE_BACKUP_IMAGE)
 447     bool m_shouldMakeBackupTexture;
 448     bool m_shouldShowBackupTexture;
 449     WebCore::IntRect m_initialViewRect;
 450 #endif
 451
 452 #if ENABLE(TIZEN_CONTEXT_MENU_WEBKIT_2)
 453     bool m_isContextMenuVisible;
 454 #endif
 455
 456     WebCore::Color m_bgColor;
 457
 458     Vector<RefPtr<WebKit::WebEditCommandProxy> > m_undoCommands;
 459     Vector<RefPtr<WebKit::WebEditCommandProxy> > m_redoCommands;
 460
 461 #if ENABLE(TIZEN_PRERENDERING_FOR_ROTATION)
 462     bool m_waitFrameOfNewViewortSize;
 463 #endif
 464
 465 #endif // #if OS(TIZEN)
 466 };
 467
 468
 469 #if ENABLE(TIZEN_WEBKIT2_TILED_AC) && ENABLE(TIZEN_RUNTIME_BACKEND_SELECTION)
 470 class PageClientEvasGL : public PageClientImpl {
 471 public:
 472     static PassOwnPtr<PageClientEvasGL> create(EwkViewImpl* viewImpl)
 473     {
 474         return adoptPtr(new PageClientEvasGL(viewImpl));
 475     }
 476     ~PageClientEvasGL();
 477
 478     virtual void updateViewportSize(const WebCore::IntSize&, const int);
 479     virtual void setViewNeedsDisplay(const WebCore::IntRect&);
 480     virtual void displayViewport();
 481     virtual void drawContents();
 482     virtual void didRenderFrame();
 483     virtual bool makeContextCurrent();
 484
 485 private:
 486     explicit PageClientEvasGL(EwkViewImpl* viewImpl);
 487
 488     virtual void initializeAcceleratedCompositingMode();
 489     virtual void finalizeAcceleratedCompositingMode();
 490     virtual void enterAcceleratedCompositingMode(const LayerTreeContext&);
 491     virtual void exitAcceleratedCompositingMode();
 492
 493     void setTargetSurface();
 494
 495     Evas_GL* m_evasGL;
 496     Evas_GL_API* m_evasGlApi;
 497     Evas_GL_Context* m_context;
 498     Evas_GL_Surface* m_surface;
 499     Evas_GL_Config* m_config;
 500 #if ENABLE(TIZEN_WEBKIT2_DIRECT_RENDERING)
 501     int m_angle;
 502 #endif
 503
 504     bool m_isAcceleratedCompositingModeInitialized;
 505 };
 506 #endif
 507
 508 } // namespace WebKit
 509
 510 #endif // PageClientImpl_h