[CoordinatedGraphics] Use ScrollingCoordinator to track fixed layers
[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 "CoordinatedImageBacking.h"
25 #include "CoordinatedLayerInfo.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
48 class CoordinatedGraphicsLayerClient {
49 public:
50     virtual bool isFlushingLayerChanges() const = 0;
51
52     // CoordinatedTileClient
53     virtual void createTile(CoordinatedLayerID, uint32_t tileID, const SurfaceUpdateInfo&, const IntRect&) = 0;
54     virtual void updateTile(CoordinatedLayerID, uint32_t tileID, const SurfaceUpdateInfo&, const IntRect&) = 0;
55     virtual void removeTile(CoordinatedLayerID, uint32_t tileID) = 0;
56
57     virtual FloatRect visibleContentsRect() const = 0;
58     virtual PassRefPtr<CoordinatedImageBacking> createImageBackingIfNeeded(Image*) = 0;
59     virtual void syncLayerState(CoordinatedLayerID, const CoordinatedLayerInfo&) = 0;
60     virtual void syncLayerChildren(CoordinatedLayerID, const Vector<CoordinatedLayerID>&) = 0;
61 #if ENABLE(CSS_FILTERS)
62     virtual void syncLayerFilters(CoordinatedLayerID, const FilterOperations&) = 0;
63 #endif
64 #if USE(GRAPHICS_SURFACE)
65     virtual void createCanvas(CoordinatedLayerID, PlatformLayer*) = 0;
66     virtual void syncCanvas(CoordinatedLayerID, PlatformLayer*) = 0;
67     virtual void destroyCanvas(CoordinatedLayerID) = 0;
68 #endif
69
70     virtual void setLayerRepaintCount(CoordinatedLayerID, int) = 0;
71
72     virtual void setLayerAnimations(CoordinatedLayerID, const GraphicsLayerAnimations&) = 0;
73
74     virtual void detachLayer(CoordinatedGraphicsLayer*) = 0;
75     virtual PassOwnPtr<GraphicsContext> beginContentUpdate(const IntSize&, CoordinatedSurface::Flags, uint32_t& atlasID, IntPoint&) = 0;
76 };
77
78 class CoordinatedGraphicsLayer : public GraphicsLayer
79     , public TiledBackingStoreClient
80     , public CoordinatedImageBacking::Host
81     , public CoordinatedTileClient {
82 public:
83     explicit CoordinatedGraphicsLayer(GraphicsLayerClient*);
84     virtual ~CoordinatedGraphicsLayer();
85
86     // Reimplementations from GraphicsLayer.h.
87     virtual bool setChildren(const Vector<GraphicsLayer*>&) OVERRIDE;
88     virtual void addChild(GraphicsLayer*) OVERRIDE;
89     virtual void addChildAtIndex(GraphicsLayer*, int) OVERRIDE;
90     virtual void addChildAbove(GraphicsLayer*, GraphicsLayer*) OVERRIDE;
91     virtual void addChildBelow(GraphicsLayer*, GraphicsLayer*) OVERRIDE;
92     virtual bool replaceChild(GraphicsLayer*, GraphicsLayer*) OVERRIDE;
93     virtual void removeFromParent() OVERRIDE;
94     virtual void setPosition(const FloatPoint&) OVERRIDE;
95     virtual void setAnchorPoint(const FloatPoint3D&) OVERRIDE;
96     virtual void setSize(const FloatSize&) OVERRIDE;
97     virtual void setTransform(const TransformationMatrix&) OVERRIDE;
98     virtual void setChildrenTransform(const TransformationMatrix&) OVERRIDE;
99     virtual void setPreserves3D(bool) OVERRIDE;
100     virtual void setMasksToBounds(bool) OVERRIDE;
101     virtual void setDrawsContent(bool) OVERRIDE;
102     virtual void setContentsVisible(bool) OVERRIDE;
103     virtual void setContentsOpaque(bool) OVERRIDE;
104     virtual void setBackfaceVisibility(bool) OVERRIDE;
105     virtual void setOpacity(float) OVERRIDE;
106     virtual void setContentsRect(const IntRect&) OVERRIDE;
107     virtual void setContentsToImage(Image*) OVERRIDE;
108     virtual void setContentsToSolidColor(const Color&) OVERRIDE;
109     virtual void setShowDebugBorder(bool) OVERRIDE;
110     virtual void setShowRepaintCounter(bool) OVERRIDE;
111     virtual bool shouldDirectlyCompositeImage(Image*) const OVERRIDE;
112     virtual void setContentsToCanvas(PlatformLayer*) OVERRIDE;
113     virtual void setMaskLayer(GraphicsLayer*) OVERRIDE;
114     virtual void setReplicatedByLayer(GraphicsLayer*) OVERRIDE;
115     virtual void setNeedsDisplay() OVERRIDE;
116     virtual void setNeedsDisplayInRect(const FloatRect&) OVERRIDE;
117     virtual void setContentsNeedsDisplay() OVERRIDE;
118     virtual void deviceOrPageScaleFactorChanged() OVERRIDE;
119     virtual void flushCompositingState(const FloatRect&) OVERRIDE;
120     virtual void flushCompositingStateForThisLayerOnly() OVERRIDE;
121 #if ENABLE(CSS_FILTERS)
122     virtual bool setFilters(const FilterOperations&) OVERRIDE;
123 #endif
124     virtual bool addAnimation(const KeyframeValueList&, const IntSize&, const Animation*, const String&, double) OVERRIDE;
125     virtual void pauseAnimation(const String&, double) OVERRIDE;
126     virtual void removeAnimation(const String&) OVERRIDE;
127     virtual void suspendAnimations(double time) OVERRIDE;
128     virtual void resumeAnimations() OVERRIDE;
129
130     FloatPoint computePositionRelativeToBase();
131     void computePixelAlignment(FloatPoint& position, FloatSize&, FloatPoint3D& anchorPoint, FloatSize& alignmentOffset);
132
133     void setVisibleContentRectTrajectoryVector(const FloatPoint&);
134
135     void setRootLayer(bool);
136
137     CoordinatedLayerID id() const;
138
139     void setFixedToViewport(bool isFixed);
140
141     IntRect coverRect() const { return m_mainBackingStore ? m_mainBackingStore->mapToContents(m_mainBackingStore->coverRect()) : IntRect(); }
142
143     // TiledBackingStoreClient
144     virtual void tiledBackingStorePaintBegin() OVERRIDE;
145     virtual void tiledBackingStorePaint(GraphicsContext*, const IntRect&) OVERRIDE;
146     virtual void tiledBackingStorePaintEnd(const Vector<IntRect>& paintedArea) OVERRIDE;
147     virtual void tiledBackingStoreHasPendingTileCreation() OVERRIDE;
148     virtual IntRect tiledBackingStoreContentsRect() OVERRIDE;
149     virtual IntRect tiledBackingStoreVisibleRect() OVERRIDE;
150     virtual Color tiledBackingStoreBackgroundColor() const OVERRIDE;
151
152     // CoordinatedTileClient
153     virtual void createTile(uint32_t tileID, const SurfaceUpdateInfo&, const IntRect&) OVERRIDE;
154     virtual void updateTile(uint32_t tileID, const SurfaceUpdateInfo&, const IntRect&) OVERRIDE;
155     virtual void removeTile(uint32_t tileID) OVERRIDE;
156     virtual PassOwnPtr<GraphicsContext> beginContentUpdate(const IntSize&, uint32_t& atlasID, IntPoint&) OVERRIDE;
157
158     void setCoordinator(CoordinatedGraphicsLayerClient*);
159
160     void setNeedsVisibleRectAdjustment();
161     void purgeBackingStores();
162     bool hasPendingVisibleChanges();
163
164 private:
165 #if USE(GRAPHICS_SURFACE)
166     enum PendingCanvasOperation {
167         None = 0x00,
168         CreateCanvas = 0x01,
169         DestroyCanvas = 0x02,
170         SyncCanvas = 0x04,
171         CreateAndSyncCanvas = CreateCanvas | SyncCanvas,
172         RecreateCanvas = CreateAndSyncCanvas | DestroyCanvas
173     };
174
175     void syncCanvas();
176     void destroyCanvasIfNeeded();
177     void createCanvasIfNeeded();
178 #endif
179
180     virtual void setDebugBorder(const Color&, float width) OVERRIDE;
181
182     bool fixedToViewport() const { return m_fixedToViewport; }
183
184     void didChangeLayerState();
185     void didChangeAnimations();
186     void didChangeGeometry();
187     void didChangeChildren();
188 #if ENABLE(CSS_FILTERS)
189     void didChangeFilters();
190 #endif
191     void didChangeImageBacking();
192
193     void syncLayerState();
194     void syncAnimations();
195     void syncChildren();
196 #if ENABLE(CSS_FILTERS)
197     void syncFilters();
198 #endif
199     void syncImageBacking();
200     void computeTransformedVisibleRect();
201     void updateContentBuffers();
202
203     void createBackingStore();
204     void releaseImageBackingIfNeeded();
205
206     // CoordinatedImageBacking::Host
207     virtual bool imageBackingVisible() OVERRIDE;
208     bool shouldHaveBackingStore() const;
209     bool selfOrAncestorHasActiveTransformAnimation() const;
210     bool selfOrAncestorHaveNonAffineTransforms();
211     void adjustContentsScale();
212
213     void setShouldUpdateVisibleRect();
214     float effectiveContentsScale();
215
216     void animationStartedTimerFired(Timer<CoordinatedGraphicsLayer>*);
217
218     CoordinatedLayerID m_id;
219     CoordinatedLayerInfo m_layerInfo;
220     GraphicsLayerTransform m_layerTransform;
221     TransformationMatrix m_cachedInverseTransform;
222     FloatSize m_pixelAlignmentOffset;
223     FloatSize m_adjustedSize;
224     FloatPoint m_adjustedPosition;
225     FloatPoint3D m_adjustedAnchorPoint;
226
227 #ifndef NDEBUG
228     bool m_isPurging;
229 #endif
230     bool m_shouldUpdateVisibleRect: 1;
231     bool m_shouldSyncLayerState: 1;
232     bool m_shouldSyncChildren: 1;
233     bool m_shouldSyncFilters: 1;
234     bool m_shouldSyncImageBacking: 1;
235     bool m_shouldSyncAnimations: 1;
236     bool m_fixedToViewport : 1;
237     bool m_pendingContentsScaleAdjustment : 1;
238     bool m_pendingVisibleRectAdjustment : 1;
239 #if USE(GRAPHICS_SURFACE)
240     bool m_isValidCanvas : 1;
241     unsigned m_pendingCanvasOperation : 3;
242 #endif
243
244     CoordinatedGraphicsLayerClient* m_coordinator;
245     OwnPtr<TiledBackingStore> m_mainBackingStore;
246     OwnPtr<TiledBackingStore> m_previousBackingStore;
247
248     RefPtr<Image> m_compositedImage;
249     NativeImagePtr m_compositedNativeImagePtr;
250     RefPtr<CoordinatedImageBacking> m_coordinatedImageBacking;
251
252     PlatformLayer* m_canvasPlatformLayer;
253 #if USE(GRAPHICS_SURFACE)
254     IntSize m_canvasSize;
255     GraphicsSurfaceToken m_canvasToken;
256 #endif
257     Timer<CoordinatedGraphicsLayer> m_animationStartedTimer;
258     GraphicsLayerAnimations m_animations;
259     double m_lastAnimationStartTime;
260 };
261
262 CoordinatedGraphicsLayer* toCoordinatedGraphicsLayer(GraphicsLayer*);
263
264 } // namespace WebCore
265 #endif // USE(COORDINATED_GRAPHICS)
266
267 #endif // CoordinatedGraphicsLayer_h