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