Accelerated overflow scrolling for Coordinated Graphics.
[WebKit-https.git] / Source / WebCore / platform / graphics / texmap / coordinated / CoordinatedGraphicsLayer.h
1 /*
2  Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)
3
4  This library is free software; you can redistribute it and/or
5  modify it under the terms of the GNU Library 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  Library General Public License for more details.
13
14  You should have received a copy of the GNU Library General Public License
15  along with this library; see the file COPYING.LIB.  If not, write to
16  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
17  Boston, MA 02110-1301, USA.
18  */
19
20
21 #ifndef CoordinatedGraphicsLayer_h
22 #define CoordinatedGraphicsLayer_h
23
24 #include "CoordinatedGraphicsState.h"
25 #include "CoordinatedImageBacking.h"
26 #include "CoordinatedTile.h"
27 #include "FloatPoint3D.h"
28 #include "GraphicsLayer.h"
29 #include "GraphicsLayerAnimation.h"
30 #include "GraphicsLayerTransform.h"
31 #include "Image.h"
32 #include "IntSize.h"
33 #include "RunLoop.h"
34 #include "TiledBackingStore.h"
35 #include "TiledBackingStoreClient.h"
36 #include "TransformationMatrix.h"
37 #if USE(GRAPHICS_SURFACE)
38 #include "GraphicsSurfaceToken.h"
39 #endif
40 #include <wtf/text/StringHash.h>
41
42 #if USE(COORDINATED_GRAPHICS)
43
44 namespace WebCore {
45 class CoordinatedGraphicsLayer;
46 class GraphicsLayerAnimations;
47 class ScrollableArea;
48
49 class CoordinatedGraphicsLayerClient {
50 public:
51     virtual bool isFlushingLayerChanges() const = 0;
52     virtual FloatRect visibleContentsRect() const = 0;
53     virtual PassRefPtr<CoordinatedImageBacking> createImageBackingIfNeeded(Image*) = 0;
54     virtual void detachLayer(CoordinatedGraphicsLayer*) = 0;
55     virtual PassOwnPtr<GraphicsContext> beginContentUpdate(const IntSize&, CoordinatedSurface::Flags, uint32_t& atlasID, IntPoint&) = 0;
56
57     virtual void syncLayerState(CoordinatedLayerID, CoordinatedGraphicsLayerState&) = 0;
58 };
59
60 class CoordinatedGraphicsLayer : public GraphicsLayer
61     , public TiledBackingStoreClient
62     , public CoordinatedImageBacking::Host
63     , public CoordinatedTileClient {
64 public:
65     explicit CoordinatedGraphicsLayer(GraphicsLayerClient*);
66     virtual ~CoordinatedGraphicsLayer();
67
68     // Reimplementations from GraphicsLayer.h.
69     virtual bool setChildren(const Vector<GraphicsLayer*>&) OVERRIDE;
70     virtual void addChild(GraphicsLayer*) OVERRIDE;
71     virtual void addChildAtIndex(GraphicsLayer*, int) OVERRIDE;
72     virtual void addChildAbove(GraphicsLayer*, GraphicsLayer*) OVERRIDE;
73     virtual void addChildBelow(GraphicsLayer*, GraphicsLayer*) OVERRIDE;
74     virtual bool replaceChild(GraphicsLayer*, GraphicsLayer*) OVERRIDE;
75     virtual void removeFromParent() OVERRIDE;
76     virtual void setPosition(const FloatPoint&) OVERRIDE;
77     virtual void setAnchorPoint(const FloatPoint3D&) OVERRIDE;
78     virtual void setSize(const FloatSize&) OVERRIDE;
79     virtual void setTransform(const TransformationMatrix&) OVERRIDE;
80     virtual void setChildrenTransform(const TransformationMatrix&) OVERRIDE;
81     virtual void setPreserves3D(bool) OVERRIDE;
82     virtual void setMasksToBounds(bool) OVERRIDE;
83     virtual void setDrawsContent(bool) OVERRIDE;
84     virtual void setContentsVisible(bool) OVERRIDE;
85     virtual void setContentsOpaque(bool) OVERRIDE;
86     virtual void setBackfaceVisibility(bool) OVERRIDE;
87     virtual void setOpacity(float) OVERRIDE;
88     virtual void setContentsRect(const IntRect&) OVERRIDE;
89     virtual void setContentsToImage(Image*) OVERRIDE;
90     virtual void setContentsToSolidColor(const Color&) OVERRIDE;
91     virtual void setShowDebugBorder(bool) OVERRIDE;
92     virtual void setShowRepaintCounter(bool) OVERRIDE;
93     virtual bool shouldDirectlyCompositeImage(Image*) const OVERRIDE;
94     virtual void setContentsToCanvas(PlatformLayer*) OVERRIDE;
95     virtual void setMaskLayer(GraphicsLayer*) OVERRIDE;
96     virtual void setReplicatedByLayer(GraphicsLayer*) OVERRIDE;
97     virtual void setNeedsDisplay() OVERRIDE;
98     virtual void setNeedsDisplayInRect(const FloatRect&) OVERRIDE;
99     virtual void setContentsNeedsDisplay() OVERRIDE;
100     virtual void deviceOrPageScaleFactorChanged() OVERRIDE;
101     virtual void flushCompositingState(const FloatRect&) OVERRIDE;
102     virtual void flushCompositingStateForThisLayerOnly() OVERRIDE;
103 #if ENABLE(CSS_FILTERS)
104     virtual bool setFilters(const FilterOperations&) OVERRIDE;
105 #endif
106     virtual bool addAnimation(const KeyframeValueList&, const IntSize&, const Animation*, const String&, double) OVERRIDE;
107     virtual void pauseAnimation(const String&, double) OVERRIDE;
108     virtual void removeAnimation(const String&) OVERRIDE;
109     virtual void suspendAnimations(double time) OVERRIDE;
110     virtual void resumeAnimations() OVERRIDE;
111
112     FloatPoint computePositionRelativeToBase();
113     void computePixelAlignment(FloatPoint& position, FloatSize&, FloatPoint3D& anchorPoint, FloatSize& alignmentOffset);
114
115     void setVisibleContentRectTrajectoryVector(const FloatPoint&);
116
117     void setRootLayer(bool);
118
119     void setScrollableArea(ScrollableArea*);
120     bool isScrollable() const { return !!m_scrollableArea; }
121     void commitScrollOffset(const IntSize&);
122
123     CoordinatedLayerID id() const;
124
125     void setFixedToViewport(bool isFixed);
126
127     IntRect coverRect() const { return m_mainBackingStore ? m_mainBackingStore->mapToContents(m_mainBackingStore->coverRect()) : IntRect(); }
128
129     // TiledBackingStoreClient
130     virtual void tiledBackingStorePaintBegin() OVERRIDE;
131     virtual void tiledBackingStorePaint(GraphicsContext*, const IntRect&) OVERRIDE;
132     virtual void tiledBackingStorePaintEnd(const Vector<IntRect>& paintedArea) OVERRIDE;
133     virtual void tiledBackingStoreHasPendingTileCreation() OVERRIDE;
134     virtual IntRect tiledBackingStoreContentsRect() OVERRIDE;
135     virtual IntRect tiledBackingStoreVisibleRect() OVERRIDE;
136     virtual Color tiledBackingStoreBackgroundColor() const OVERRIDE;
137
138     // CoordinatedTileClient
139     virtual void createTile(uint32_t tileID, const SurfaceUpdateInfo&, const IntRect&) OVERRIDE;
140     virtual void updateTile(uint32_t tileID, const SurfaceUpdateInfo&, const IntRect&) OVERRIDE;
141     virtual void removeTile(uint32_t tileID) OVERRIDE;
142     virtual PassOwnPtr<GraphicsContext> beginContentUpdate(const IntSize&, uint32_t& atlasID, IntPoint&) OVERRIDE;
143
144     void setCoordinator(CoordinatedGraphicsLayerClient*);
145
146     void setNeedsVisibleRectAdjustment();
147     void purgeBackingStores();
148     bool hasPendingVisibleChanges();
149
150 private:
151 #if USE(GRAPHICS_SURFACE)
152     enum PendingCanvasOperation {
153         None = 0x00,
154         CreateCanvas = 0x01,
155         DestroyCanvas = 0x02,
156         SyncCanvas = 0x04,
157         CreateAndSyncCanvas = CreateCanvas | SyncCanvas,
158         RecreateCanvas = CreateAndSyncCanvas | DestroyCanvas
159     };
160
161     void syncCanvas();
162     void destroyCanvasIfNeeded();
163     void createCanvasIfNeeded();
164 #endif
165
166     virtual void setDebugBorder(const Color&, float width) OVERRIDE;
167
168     bool fixedToViewport() const { return m_fixedToViewport; }
169
170     void didChangeLayerState();
171     void didChangeAnimations();
172     void didChangeGeometry();
173     void didChangeChildren();
174 #if ENABLE(CSS_FILTERS)
175     void didChangeFilters();
176 #endif
177     void didChangeImageBacking();
178
179     void resetLayerState();
180     void syncLayerState();
181     void syncAnimations();
182     void syncChildren();
183 #if ENABLE(CSS_FILTERS)
184     void syncFilters();
185 #endif
186     void syncImageBacking();
187     void computeTransformedVisibleRect();
188     void updateContentBuffers();
189
190     void createBackingStore();
191     void releaseImageBackingIfNeeded();
192
193     // CoordinatedImageBacking::Host
194     virtual bool imageBackingVisible() OVERRIDE;
195     bool shouldHaveBackingStore() const;
196     bool selfOrAncestorHasActiveTransformAnimation() const;
197     bool selfOrAncestorHaveNonAffineTransforms();
198     void adjustContentsScale();
199
200     void setShouldUpdateVisibleRect();
201     float effectiveContentsScale();
202
203     void animationStartedTimerFired(Timer<CoordinatedGraphicsLayer>*);
204
205     CoordinatedLayerID m_id;
206     CoordinatedGraphicsLayerState m_layerState;
207     GraphicsLayerTransform m_layerTransform;
208     TransformationMatrix m_cachedInverseTransform;
209     FloatSize m_pixelAlignmentOffset;
210     FloatSize m_adjustedSize;
211     FloatPoint m_adjustedPosition;
212     FloatPoint3D m_adjustedAnchorPoint;
213
214 #ifndef NDEBUG
215     bool m_isPurging;
216 #endif
217     bool m_shouldUpdateVisibleRect: 1;
218     bool m_shouldSyncLayerState: 1;
219     bool m_shouldSyncChildren: 1;
220     bool m_shouldSyncFilters: 1;
221     bool m_shouldSyncImageBacking: 1;
222     bool m_shouldSyncAnimations: 1;
223     bool m_fixedToViewport : 1;
224     bool m_movingVisibleRect : 1;
225     bool m_pendingContentsScaleAdjustment : 1;
226     bool m_pendingVisibleRectAdjustment : 1;
227 #if USE(GRAPHICS_SURFACE)
228     bool m_isValidCanvas : 1;
229     unsigned m_pendingCanvasOperation : 3;
230 #endif
231
232     CoordinatedGraphicsLayerClient* m_coordinator;
233     OwnPtr<TiledBackingStore> m_mainBackingStore;
234     OwnPtr<TiledBackingStore> m_previousBackingStore;
235
236     RefPtr<Image> m_compositedImage;
237     NativeImagePtr m_compositedNativeImagePtr;
238     RefPtr<CoordinatedImageBacking> m_coordinatedImageBacking;
239
240     PlatformLayer* m_canvasPlatformLayer;
241 #if USE(GRAPHICS_SURFACE)
242     IntSize m_canvasSize;
243     GraphicsSurfaceToken m_canvasToken;
244 #endif
245     Timer<CoordinatedGraphicsLayer> m_animationStartedTimer;
246     GraphicsLayerAnimations m_animations;
247     double m_lastAnimationStartTime;
248
249     ScrollableArea* m_scrollableArea;
250 };
251
252 CoordinatedGraphicsLayer* toCoordinatedGraphicsLayer(GraphicsLayer*);
253
254 } // namespace WebCore
255 #endif // USE(COORDINATED_GRAPHICS)
256
257 #endif // CoordinatedGraphicsLayer_h