ed3739c228bc653ba98709d012ccaedb36033a8e
[WebKit-https.git] / Source / WebKit / blackberry / Api / WebPage_p.h
1 /*
2  * Copyright (C) 2009, 2010, 2011, 2012 Research In Motion Limited. All rights reserved.
3  *
4  * This library is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Lesser General Public
6  * License as published by the Free Software Foundation; either
7  * version 2 of the License, or (at your option) any later version.
8  *
9  * This library is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12  * Lesser General Public License for more details.
13  *
14  * You should have received a copy of the GNU Lesser General Public
15  * License along with this library; if not, write to the Free Software
16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
17  */
18
19 #ifndef WebPage_p_h
20 #define WebPage_p_h
21
22 #include "ChromeClient.h"
23 #if USE(ACCELERATED_COMPOSITING)
24 #include "LayerRenderer.h"
25 #endif
26 #include "PageClientBlackBerry.h"
27 #include "PlatformMouseEvent.h"
28 #include "ScriptSourceCode.h"
29 #include "Timer.h"
30 #include "ViewportArguments.h"
31 #include "WebPage.h"
32 #include "WebSettings.h"
33
34 #include <BlackBerryPlatformMessage.h>
35
36 namespace WebCore {
37 class DOMWrapperWorld;
38 class Document;
39 class Frame;
40 class GeolocationControllerClientBlackBerry;
41 class JavaScriptDebuggerBlackBerry;
42 class KURL;
43 class Node;
44 class Page;
45 class PluginView;
46 class RenderLayer;
47 class RenderObject;
48 class ScrollView;
49 class TransformationMatrix;
50 template<typename T> class Timer;
51 }
52
53 namespace BlackBerry {
54 namespace WebKit {
55
56 class BackingStore;
57 class BackingStoreClient;
58 class BackingStoreTile;
59 class DumpRenderTreeClient;
60 class InPageSearchManager;
61 class InputHandler;
62 class SelectionHandler;
63 class TouchEventHandler;
64 class WebPageClient;
65
66 #if USE(ACCELERATED_COMPOSITING)
67 class FrameLayers;
68 class WebPageCompositor;
69 #endif
70
71 // In the client code, there is screen size and viewport.
72 // In WebPagePrivate, the screen size is called the transformedViewportSize,
73 // the viewport position is called the transformedScrollPosition,
74 // and the viewport size is called the transformedActualVisibleSize.
75 class WebPagePrivate : public PageClientBlackBerry, public WebSettingsDelegate, public Platform::GuardedPointerBase {
76 public:
77     enum ViewMode { Mobile, Desktop, FixedDesktop };
78     enum LoadState { None /* on instantiation of page */, Provisional, Committed, Finished, Failed };
79
80     WebPagePrivate(WebPage*, WebPageClient*, const WebCore::IntRect&);
81     virtual ~WebPagePrivate();
82
83     static WebCore::Page* core(const WebPage*);
84
85     void init(const WebString& pageGroupName);
86     bool handleMouseEvent(WebCore::PlatformMouseEvent&);
87     bool handleWheelEvent(WebCore::PlatformWheelEvent&);
88
89     void load(const char* url, const char* networkToken, const char* method, Platform::NetworkRequest::CachePolicy, const char* data, size_t dataLength, const char* const* headers, size_t headersLength, bool isInitial, bool mustHandleInternally = false, bool forceDownload = false, const char* overrideContentType = "");
90     void loadString(const char* string, const char* baseURL, const char* mimeType, const char* failingURL = 0);
91     bool executeJavaScript(const char* script, JavaScriptDataType& returnType, WebString& returnValue);
92     bool executeJavaScriptInIsolatedWorld(const WebCore::ScriptSourceCode&, JavaScriptDataType& returnType, WebString& returnValue);
93
94     void stopCurrentLoad();
95     void prepareToDestroy();
96
97     LoadState loadState() const { return m_loadState; }
98     bool isLoading() const { return m_loadState == WebPagePrivate::Provisional || m_loadState == WebPagePrivate::Committed; }
99
100     // Called from within WebKit via FrameLoaderClientBlackBerry.
101     void setLoadState(LoadState);
102
103     // Clamp the scale.
104     double clampedScale(double scale) const;
105
106     // Determine if we should zoom, clamping the scale parameter if required.
107     bool shouldZoomAboutPoint(double scale, const WebCore::FloatPoint& anchor, bool enforeScaleClamping, double* clampedScale);
108
109     // Scale the page to the given scale and anchor about the point which is specified in untransformed content coordinates.
110     bool zoomAboutPoint(double scale, const WebCore::FloatPoint& anchor, bool enforceScaleClamping = true, bool forceRendering = false, bool isRestoringZoomLevel = false);
111     bool scheduleZoomAboutPoint(double scale, const WebCore::FloatPoint& anchor, bool enforceScaleClamping = true, bool forceRendering = false);
112     void unscheduleZoomAboutPoint();
113     WebCore::IntPoint calculateReflowedScrollPosition(const WebCore::FloatPoint& anchorOffset, double inverseScale);
114     void setTextReflowAnchorPoint(const Platform::IntPoint& focalPoint);
115
116     void schedulePinchZoomAboutPoint(double scale, const WebCore::IntPoint& anchor);
117
118     // Perform actual zoom for block zoom.
119     void zoomBlock();
120
121     // Called by the backing store as well as the method below.
122     void requestLayoutIfNeeded() const;
123     void setNeedsLayout();
124
125     WebCore::IntPoint scrollPosition() const;
126     WebCore::IntPoint maximumScrollPosition() const;
127     void setScrollPosition(const WebCore::IntPoint&);
128     bool scrollBy(int deltaX, int deltaY, bool scrollMainFrame = true);
129
130     void enqueueRenderingOfClippedContentOfScrollableNodeAfterInRegionScrolling(WebCore::Node*);
131     std::vector<Platform::ScrollViewBase> inRegionScrollableAreasForPoint(const Platform::IntPoint&);
132     void notifyInRegionScrollStatusChanged(bool status);
133     void setScrollOriginPoint(const Platform::IntPoint&);
134     void setHasInRegionScrollableAreas(bool);
135
136     // The actual visible size as reported by the client, but in WebKit coordinates.
137     WebCore::IntSize actualVisibleSize() const;
138
139     // The viewport size is the same as the client's window size, but in webkit coordinates.
140     WebCore::IntSize viewportSize() const;
141
142     // Modifies the zoomToFit algorithm logic to construct a scale such that the viewportSize above is equal to this size.
143     bool hasVirtualViewport() const;
144     bool isUserScalable() const { return m_userScalable; }
145     void setUserScalable(bool userScalable) { m_userScalable = userScalable; }
146
147     // Sets default layout size without doing layout or marking as needing layout.
148     void setDefaultLayoutSize(const WebCore::IntSize&);
149
150     // Updates WebCore when the viewportSize() or actualVisibleSize() change.
151     void updateViewportSize(bool setFixedReportedSize = true, bool sendResizeEvent = true);
152
153     WebCore::FloatPoint centerOfVisibleContentsRect() const;
154     WebCore::IntRect visibleContentsRect() const;
155     WebCore::IntSize contentsSize() const;
156     WebCore::IntSize absoluteVisibleOverflowSize() const;
157
158     // Virtual functions inherited from PageClientBlackBerry.
159     virtual void setCursor(WebCore::PlatformCursorHandle);
160     virtual Platform::NetworkStreamFactory* networkStreamFactory();
161     virtual Platform::Graphics::Window* platformWindow() const;
162     virtual void setPreventsScreenDimming(bool preventDimming);
163     virtual void showVirtualKeyboard(bool showKeyboard);
164     virtual void ensureContentVisible(bool centerInView = true);
165     virtual void zoomToContentRect(const WebCore::IntRect&);
166     virtual void registerPlugin(WebCore::PluginView*, bool);
167     virtual void notifyPageOnLoad();
168     virtual bool shouldPluginEnterFullScreen(WebCore::PluginView*, const char*);
169     virtual void didPluginEnterFullScreen(WebCore::PluginView*, const char*);
170     virtual void didPluginExitFullScreen(WebCore::PluginView*, const char*);
171     virtual void onPluginStartBackgroundPlay(WebCore::PluginView*, const char*);
172     virtual void onPluginStopBackgroundPlay(WebCore::PluginView*, const char*);
173     virtual bool lockOrientation(bool landscape);
174     virtual void unlockOrientation();
175     virtual int orientation() const;
176     virtual double currentZoomFactor() const;
177     virtual int showAlertDialog(WebPageClient::AlertType atype);
178     virtual bool isActive() const;
179
180     // Called from within WebKit via ChromeClientBlackBerry.
181     void enterFullscreenForNode(WebCore::Node*);
182     void exitFullscreenForNode(WebCore::Node*);
183     void contentsSizeChanged(const WebCore::IntSize&);
184     void overflowExceedsContentsSize() { m_overflowExceedsContentsSize = true; }
185     void layoutFinished();
186     void setNeedTouchEvents(bool);
187
188     // Called according to our heuristic or from setLoadState depending on whether we have a virtual viewport.
189     void zoomToInitialScaleOnLoad();
190
191     // Various scale factors.
192     double currentScale() const { return m_transformationMatrix->m11(); }
193     double zoomToFitScale() const;
194     double initialScale() const;
195     void setInitialScale(double scale) { m_initialScale = scale; }
196     double minimumScale() const
197     {
198         return (m_minimumScale > zoomToFitScale() && m_minimumScale <= maximumScale()) ? m_minimumScale : zoomToFitScale();
199     }
200
201     void setMinimumScale(double scale) { m_minimumScale = scale; }
202     double maximumScale() const;
203     void setMaximumScale(double scale) { m_maximumScale = scale; }
204     void resetScales();
205
206     // Note: to make this reflow width transform invariant just use
207     // transformedActualVisibleSize() here instead!
208     int reflowWidth() const { return actualVisibleSize().width(); }
209
210     // These methods give the real geometry of the device given the currently set transform.
211     WebCore::IntPoint transformedScrollPosition() const;
212     WebCore::IntPoint transformedMaximumScrollPosition() const;
213     WebCore::IntSize transformedActualVisibleSize() const;
214     WebCore::IntSize transformedViewportSize() const;
215     WebCore::IntRect transformedVisibleContentsRect() const;
216     WebCore::IntSize transformedContentsSize() const;
217
218     // Generic conversions of points, rects, relative to and from contents and viewport.
219     WebCore::IntPoint mapFromContentsToViewport(const WebCore::IntPoint&) const;
220     WebCore::IntPoint mapFromViewportToContents(const WebCore::IntPoint&) const;
221     WebCore::IntRect mapFromContentsToViewport(const WebCore::IntRect&) const;
222     WebCore::IntRect mapFromViewportToContents(const WebCore::IntRect&) const;
223
224     // Generic conversions of points, rects, relative to and from transformed contents and transformed viewport.
225     WebCore::IntPoint mapFromTransformedContentsToTransformedViewport(const WebCore::IntPoint&) const;
226     WebCore::IntPoint mapFromTransformedViewportToTransformedContents(const WebCore::IntPoint&) const;
227     WebCore::IntRect mapFromTransformedContentsToTransformedViewport(const WebCore::IntRect&) const;
228     WebCore::IntRect mapFromTransformedViewportToTransformedContents(const WebCore::IntRect&) const;
229
230     // Generic conversions of points, rects, and sizes to and from transformed coordinates.
231     WebCore::IntPoint mapToTransformed(const WebCore::IntPoint&) const;
232     WebCore::FloatPoint mapToTransformedFloatPoint(const WebCore::FloatPoint&) const;
233     WebCore::IntPoint mapFromTransformed(const WebCore::IntPoint&) const;
234     WebCore::FloatPoint mapFromTransformedFloatPoint(const WebCore::FloatPoint&) const;
235     WebCore::FloatRect mapFromTransformedFloatRect(const WebCore::FloatRect&) const;
236     WebCore::IntSize mapToTransformed(const WebCore::IntSize&) const;
237     WebCore::IntSize mapFromTransformed(const WebCore::IntSize&) const;
238     WebCore::IntRect mapToTransformed(const WebCore::IntRect&) const;
239     void clipToTransformedContentsRect(WebCore::IntRect&) const;
240     WebCore::IntRect mapFromTransformed(const WebCore::IntRect&) const;
241     bool transformedPointEqualsUntransformedPoint(const WebCore::IntPoint& transformedPoint, const WebCore::IntPoint& untransformedPoint);
242
243     // Notification methods that deliver changes to the real geometry of the device as specified above.
244     void notifyTransformChanged();
245     void notifyTransformedContentsSizeChanged();
246     void notifyTransformedScrollChanged();
247
248     void assignFocus(Platform::FocusDirection);
249     Platform::IntRect focusNodeRect();
250     WebCore::IntRect getRecursiveVisibleWindowRect(WebCore::ScrollView*, bool noClipOfMainFrame = false);
251
252     WebCore::IntPoint frameOffset(const WebCore::Frame*) const;
253
254     WebCore::Node* bestNodeForZoomUnderPoint(const WebCore::IntPoint&);
255     WebCore::Node* bestChildNodeForClickRect(WebCore::Node* parentNode, const WebCore::IntRect& clickRect);
256     WebCore::Node* nodeForZoomUnderPoint(const WebCore::IntPoint&);
257     WebCore::Node* adjustedBlockZoomNodeForZoomLimits(WebCore::Node*);
258     WebCore::IntRect rectForNode(WebCore::Node*);
259     WebCore::IntRect blockZoomRectForNode(WebCore::Node*);
260     WebCore::IntRect adjustRectOffsetForFrameOffset(const WebCore::IntRect&, const WebCore::Node*);
261     bool compareNodesForBlockZoom(WebCore::Node* n1, WebCore::Node* n2);
262     double newScaleForBlockZoomRect(const WebCore::IntRect&, double oldScale, double margin);
263     double maxBlockZoomScale() const;
264
265     // Plugin Methods.
266     void notifyPluginRectChanged(int id, const WebCore::IntRect& rectChanged);
267
268     // Context Methods.
269     ActiveNodeContext activeNodeContext(TargetDetectionStrategy);
270     PassRefPtr<WebCore::Node> contextNode(TargetDetectionStrategy);
271
272 #if ENABLE(VIEWPORT_REFLOW)
273     void toggleTextReflowIfEnabledForBlockZoomOnly(bool shouldEnableTextReflow = false);
274 #endif
275
276     void selectionChanged(WebCore::Frame*);
277
278     void updateDelegatedOverlays(bool dispatched = false);
279
280     void updateCursor();
281
282     void onInputLocaleChanged(bool isRTL);
283
284     ViewMode viewMode() const { return m_viewMode; }
285     bool setViewMode(ViewMode); // Returns true if the change requires re-layout.
286
287     void setShouldUseFixedDesktopMode(bool b) { m_shouldUseFixedDesktopMode = b; }
288
289     bool useFixedLayout() const;
290     WebCore::IntSize fixedLayoutSize(bool snapToIncrement = false) const;
291
292     // ZoomToFitOnLoad can lead to a large recursion depth in FrameView::layout() as we attempt
293     // to determine the zoom scale factor so as to have the content of the page fit within the
294     // area of the frame. From observation, we can bail out after a recursion depth of 10 and
295     // still have reasonable results.
296     bool didLayoutExceedMaximumIterations() const { return m_nestedLayoutFinishedCount > 10; }
297
298     void clearFocusNode();
299     WebCore::Frame* focusedOrMainFrame() const;
300     WebCore::Frame* mainFrame() const { return m_mainFrame; }
301
302     bool scrollNodeRecursively(WebCore::Node* originalNode, const WebCore::IntSize& delta);
303     bool scrollRenderer(WebCore::RenderObject* renderer, const WebCore::IntSize& delta);
304     void adjustScrollDelta(const WebCore::IntPoint& maxOffset, const WebCore::IntPoint& currentOffset, WebCore::IntSize& delta) const;
305
306     bool canScrollRenderBox(WebCore::RenderBox*);
307     bool canScrollInnerFrame(WebCore::Frame*) const;
308
309 #if ENABLE(EVENT_MODE_METATAGS)
310     void didReceiveCursorEventMode(WebCore::CursorEventMode);
311     void didReceiveTouchEventMode(WebCore::TouchEventMode);
312 #endif
313
314     void dispatchViewportPropertiesDidChange(const WebCore::ViewportArguments&);
315     WebCore::IntSize recomputeVirtualViewportFromViewportArguments();
316
317     void resetBlockZoom();
318
319     void zoomAboutPointTimerFired(WebCore::Timer<WebPagePrivate>*);
320     bool shouldSendResizeEvent();
321     void scrollEventTimerFired(WebCore::Timer<WebPagePrivate>*);
322     void resizeEventTimerFired(WebCore::Timer<WebPagePrivate>*);
323
324     // If this url should be handled as a pattern, returns the pattern
325     // otherwise, returns an empty string.
326     String findPatternStringForUrl(const WebCore::KURL&) const;
327
328     void suspendBackingStore();
329     void resumeBackingStore();
330
331     void setShouldResetTilesWhenShown(bool flag) { m_shouldResetTilesWhenShown = flag; }
332     bool shouldResetTilesWhenShown() const { return m_shouldResetTilesWhenShown; }
333
334     void setScreenOrientation(int);
335
336     // Scroll and/or zoom so that the WebPage fits the new actual
337     // visible size.
338     void setViewportSize(const WebCore::IntSize& transformedActualVisibleSize, bool ensureFocusElementVisible);
339     void screenRotated(); // Helper method for setViewportSize().
340
341     void scheduleDeferrableTimer(WebCore::Timer<WebPagePrivate>*, double timeOut);
342     void unscheduleAllDeferrableTimers();
343     void willDeferLoading();
344     void didResumeLoading();
345
346     // Returns true if the escape key handler should zoom.
347     bool shouldZoomOnEscape() const;
348
349     WebCore::TransformationMatrix* transformationMatrix() const
350     {
351         return m_transformationMatrix;
352     }
353
354 #if USE(ACCELERATED_COMPOSITING)
355     // WebKit thread.
356     bool needsOneShotDrawingSynchronization();
357     void rootLayerCommitTimerFired(WebCore::Timer<WebPagePrivate>*);
358     bool commitRootLayerIfNeeded();
359     WebCore::LayerRenderingResults lastCompositingResults() const;
360
361     // WebKit thread, plumbed through from ChromeClientBlackBerry.
362     void setRootLayerWebKitThread(WebCore::Frame*, WebCore::LayerWebKitThread*);
363     void setNeedsOneShotDrawingSynchronization();
364     void scheduleRootLayerCommit();
365
366     // Thread safe.
367     void resetCompositingSurface();
368     void drawLayersOnCommit(); // Including backing store blit.
369     bool drawSubLayers(const WebCore::IntRect& dstRect, const WebCore::FloatRect& contents);
370     bool drawSubLayers(); // Draw them at last known position.
371
372     // Compositing thread.
373     void setRootLayerCompositingThread(WebCore::LayerCompositingThread*);
374     void commitRootLayer(const WebCore::IntRect&, const WebCore::IntSize&);
375     void setIsAcceleratedCompositingActive(bool);
376     bool isAcceleratedCompositingActive() const { return m_isAcceleratedCompositingActive; }
377     void destroyCompositor();
378     void syncDestroyCompositorOnCompositingThread();
379     void destroyLayerResources();
380     void suspendRootLayerCommit();
381     void resumeRootLayerCommit();
382     void blitVisibleContents();
383 #endif
384
385     bool dispatchTouchEventToFullScreenPlugin(WebCore::PluginView*, const Platform::TouchEvent&);
386     bool dispatchTouchPointAsMouseEventToFullScreenPlugin(WebCore::PluginView*, const Platform::TouchPoint&);
387     bool dispatchMouseEventToFullScreenPlugin(WebCore::PluginView*, const Platform::MouseEvent&);
388
389     BackingStoreClient* backingStoreClientForFrame(const WebCore::Frame*) const;
390     void addBackingStoreClientForFrame(const WebCore::Frame*, BackingStoreClient*);
391     void removeBackingStoreClientForFrame(const WebCore::Frame*);
392
393     // Clean up any document related data we might be holding.
394     void clearDocumentData(const WebCore::Document*);
395
396     void frameUnloaded(const WebCore::Frame*);
397
398     static WebCore::RenderLayer* enclosingPositionedAncestorOrSelfIfPositioned(WebCore::RenderLayer*);
399     static WebCore::RenderLayer* enclosingFixedPositionedAncestorOrSelfIfFixedPositioned(WebCore::RenderLayer*);
400
401     static WebCore::IntSize defaultMaxLayoutSize();
402
403     WebPage* m_webPage;
404     WebPageClient* m_client;
405     WebCore::Page* m_page;
406     WebCore::Frame* m_mainFrame;
407     RefPtr<WebCore::Node> m_currentContextNode;
408     WebSettings* m_webSettings;
409
410 #if ENABLE(JAVASCRIPT_DEBUGGER)
411     OwnPtr<WebCore::JavaScriptDebuggerBlackBerry> m_scriptDebugger;
412 #endif
413
414     bool m_visible;
415     bool m_shouldResetTilesWhenShown;
416     bool m_userScalable;
417     bool m_userPerformedManualZoom;
418     bool m_userPerformedManualScroll;
419     bool m_contentsSizeChanged;
420     bool m_overflowExceedsContentsSize;
421     bool m_resetVirtualViewportOnCommitted;
422     bool m_shouldUseFixedDesktopMode;
423     bool m_needTouchEvents;
424     int m_preventIdleDimmingCount;
425
426 #if ENABLE(TOUCH_EVENTS)
427     bool m_preventDefaultOnTouchStart;
428 #endif
429     unsigned m_nestedLayoutFinishedCount;
430     WebCore::IntSize m_previousContentsSize;
431     int m_actualVisibleWidth;
432     int m_actualVisibleHeight;
433     int m_virtualViewportWidth;
434     int m_virtualViewportHeight;
435     WebCore::IntSize m_defaultLayoutSize;
436     WebCore::ViewportArguments m_viewportArguments; // We keep this around since we may need to re-evaluate the arguments on rotation.
437     bool m_didRestoreFromPageCache;
438     ViewMode m_viewMode;
439     LoadState m_loadState;
440     WebCore::TransformationMatrix* m_transformationMatrix;
441     BackingStore* m_backingStore;
442     BackingStoreClient* m_backingStoreClient;
443     InPageSearchManager* m_inPageSearchManager;
444     InputHandler* m_inputHandler;
445     SelectionHandler* m_selectionHandler;
446     TouchEventHandler* m_touchEventHandler;
447
448 #if ENABLE(EVENT_MODE_METATAGS)
449     WebCore::CursorEventMode m_cursorEventMode;
450     WebCore::TouchEventMode m_touchEventMode;
451 #endif
452
453     Platform::BlackBerryCursor m_currentCursor;
454
455     DumpRenderTreeClient* m_dumpRenderTree;
456
457     double m_initialScale;
458     double m_minimumScale;
459     double m_maximumScale;
460
461     // Block zoom animation data.
462     WebCore::FloatPoint m_finalBlockPoint;
463     WebCore::FloatPoint m_finalBlockPointReflowOffset;
464     double m_blockZoomFinalScale;
465     RefPtr<WebCore::Node> m_currentPinchZoomNode;
466     WebCore::FloatPoint m_anchorInNodeRectRatio;
467     RefPtr<WebCore::Node> m_currentBlockZoomNode;
468     RefPtr<WebCore::Node> m_currentBlockZoomAdjustedNode;
469     bool m_shouldReflowBlock;
470
471     // Delayed zoomAboutPoint.
472     OwnPtr<WebCore::Timer<WebPagePrivate> > m_delayedZoomTimer;
473     struct {
474         double scale;
475         WebCore::FloatPoint anchor;
476         bool enforceScaleClamping;
477         bool forceRendering;
478     } m_delayedZoomArguments;
479
480     double m_lastUserEventTimestamp; // Used to detect user scrolling.
481
482     WebCore::PlatformMouseEvent m_lastMouseEvent;
483     bool m_pluginMouseButtonPressed; // Used to track mouse button for full screen plugins.
484     bool m_pluginMayOpenNewTab;
485
486     WebCore::GeolocationControllerClientBlackBerry* m_geolocationClient;
487
488     HashSet<WebCore::PluginView*> m_pluginViews;
489
490     RefPtr<WebCore::Node> m_inRegionScrollStartingNode;
491
492 #if USE(ACCELERATED_COMPOSITING)
493     bool m_isAcceleratedCompositingActive;
494     OwnPtr<FrameLayers> m_frameLayers; // WebKit thread only.
495     OwnPtr<WebPageCompositor> m_compositor; // Compositing thread only.
496     OwnPtr<WebCore::Timer<WebPagePrivate> > m_rootLayerCommitTimer;
497     bool m_needsOneShotDrawingSynchronization;
498     bool m_needsCommit;
499     bool m_suspendRootLayerCommit;
500 #endif
501
502     int m_pendingOrientation;
503
504     RefPtr<WebCore::Node> m_fullscreenVideoNode;
505     RefPtr<WebCore::PluginView> m_fullScreenPluginView;
506
507     typedef HashMap<const WebCore::Frame*, BackingStoreClient*> BackingStoreClientForFrameMap;
508     BackingStoreClientForFrameMap m_backingStoreClientForFrameMap;
509
510     // WebSettingsDelegate methods.
511     virtual void didChangeSettings(WebSettings*);
512
513     RefPtr<WebCore::DOMWrapperWorld> m_isolatedWorld;
514     bool m_hasInRegionScrollableAreas;
515     bool m_updateDelegatedOverlaysDispatched;
516 };
517 }
518 }
519
520 #endif // WebPage_p_h