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