Unreviewed, EFL build fix since r176459.
[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 "TiledBackingStore.h"
34 #include "TiledBackingStoreClient.h"
35 #include "TransformationMatrix.h"
36 #if USE(GRAPHICS_SURFACE)
37 #include "GraphicsSurfaceToken.h"
38 #endif
39 #include <wtf/text/StringHash.h>
40
41 #if USE(COORDINATED_GRAPHICS)
42
43 namespace WebCore {
44 class CoordinatedGraphicsLayer;
45 class GraphicsLayerAnimations;
46 class ScrollableArea;
47
48 class CoordinatedGraphicsLayerClient {
49 public:
50     virtual bool isFlushingLayerChanges() const = 0;
51     virtual FloatRect visibleContentsRect() const = 0;
52     virtual PassRefPtr<CoordinatedImageBacking> createImageBackingIfNeeded(Image*) = 0;
53     virtual void detachLayer(CoordinatedGraphicsLayer*) = 0;
54     virtual bool paintToSurface(const IntSize&, CoordinatedSurface::Flags, uint32_t& atlasID, IntPoint&, CoordinatedSurface::Client*) = 0;
55
56     virtual void syncLayerState(CoordinatedLayerID, CoordinatedGraphicsLayerState&) = 0;
57 };
58
59 class CoordinatedGraphicsLayer : public GraphicsLayer
60     , public TiledBackingStoreClient
61     , public CoordinatedImageBacking::Host
62     , public CoordinatedTileClient {
63 public:
64     explicit CoordinatedGraphicsLayer(GraphicsLayerClient&);
65     virtual ~CoordinatedGraphicsLayer();
66
67     // Reimplementations from GraphicsLayer.h.
68     virtual bool setChildren(const Vector<GraphicsLayer*>&) override;
69     virtual void addChild(GraphicsLayer*) override;
70     virtual void addChildAtIndex(GraphicsLayer*, int) override;
71     virtual void addChildAbove(GraphicsLayer*, GraphicsLayer*) override;
72     virtual void addChildBelow(GraphicsLayer*, GraphicsLayer*) override;
73     virtual bool replaceChild(GraphicsLayer*, GraphicsLayer*) override;
74     virtual void removeFromParent() override;
75     virtual void setPosition(const FloatPoint&) override;
76     virtual void setAnchorPoint(const FloatPoint3D&) override;
77     virtual void setSize(const FloatSize&) override;
78     virtual void setTransform(const TransformationMatrix&) override;
79     virtual void setChildrenTransform(const TransformationMatrix&) override;
80     virtual void setPreserves3D(bool) override;
81     virtual void setMasksToBounds(bool) override;
82     virtual void setDrawsContent(bool) override;
83     virtual void setContentsVisible(bool) override;
84     virtual void setContentsOpaque(bool) override;
85     virtual void setBackfaceVisibility(bool) override;
86     virtual void setOpacity(float) override;
87     virtual void setContentsRect(const FloatRect&) override;
88     virtual void setContentsTilePhase(const FloatPoint&) override;
89     virtual void setContentsTileSize(const FloatSize&) override;
90     virtual void setContentsToImage(Image*) override;
91     virtual void setContentsToSolidColor(const Color&) override;
92     virtual void setShowDebugBorder(bool) override;
93     virtual void setShowRepaintCounter(bool) override;
94     virtual bool shouldDirectlyCompositeImage(Image*) const override;
95     virtual void setContentsToPlatformLayer(PlatformLayer*, ContentsLayerPurpose) override;
96     virtual void setMaskLayer(GraphicsLayer*) override;
97     virtual void setReplicatedByLayer(GraphicsLayer*) override;
98     virtual void setNeedsDisplay() override;
99     virtual void setNeedsDisplayInRect(const FloatRect&, ShouldClipToLayer = ClipToLayer) override;
100     virtual void setContentsNeedsDisplay() override;
101     virtual void deviceOrPageScaleFactorChanged() override;
102     virtual void flushCompositingState(const FloatRect&) override;
103     virtual void flushCompositingStateForThisLayerOnly() override;
104     virtual bool setFilters(const FilterOperations&) override;
105     virtual bool addAnimation(const KeyframeValueList&, const FloatSize&, const Animation*, const String&, double) override;
106     virtual void pauseAnimation(const String&, double) override;
107     virtual void removeAnimation(const String&) override;
108     virtual void suspendAnimations(double time) override;
109     virtual void resumeAnimations() override;
110     virtual bool usesContentsLayer() const override { return m_platformLayer || m_compositedImage; }
111
112     void syncPendingStateChangesIncludingSubLayers();
113     void updateContentBuffersIncludingSubLayers();
114
115     FloatPoint computePositionRelativeToBase();
116     void computePixelAlignment(FloatPoint& position, FloatSize&, FloatPoint3D& anchorPoint, FloatSize& alignmentOffset);
117
118     void setVisibleContentRectTrajectoryVector(const FloatPoint&);
119
120     void setScrollableArea(ScrollableArea*);
121     bool isScrollable() const { return !!m_scrollableArea; }
122     void commitScrollOffset(const IntSize&);
123
124     CoordinatedLayerID id() const;
125
126     void setFixedToViewport(bool isFixed);
127
128     IntRect coverRect() const { return m_mainBackingStore ? m_mainBackingStore->mapToContents(m_mainBackingStore->coverRect()) : IntRect(); }
129
130     // TiledBackingStoreClient
131     virtual void tiledBackingStorePaintBegin() override;
132     virtual void tiledBackingStorePaint(GraphicsContext*, const IntRect&) override;
133     virtual void tiledBackingStorePaintEnd(const Vector<IntRect>& paintedArea) override;
134     virtual void tiledBackingStoreHasPendingTileCreation() override;
135     virtual IntRect tiledBackingStoreContentsRect() override;
136     virtual IntRect tiledBackingStoreVisibleRect() override;
137     virtual Color tiledBackingStoreBackgroundColor() const override;
138
139     // CoordinatedTileClient
140     virtual void createTile(uint32_t tileID, const SurfaceUpdateInfo&, const IntRect&) override;
141     virtual void updateTile(uint32_t tileID, const SurfaceUpdateInfo&, const IntRect&) override;
142     virtual void removeTile(uint32_t tileID) override;
143     virtual bool paintToSurface(const IntSize&, uint32_t& /* atlasID */, IntPoint&, CoordinatedSurface::Client*) override;
144
145     void setCoordinator(CoordinatedGraphicsLayerClient*);
146
147     void setNeedsVisibleRectAdjustment();
148     void purgeBackingStores();
149
150     static void setShouldSupportContentsTiling(bool);
151     CoordinatedGraphicsLayer* findFirstDescendantWithContentsRecursively();
152
153 private:
154 #if USE(GRAPHICS_SURFACE)
155     enum PendingPlatformLayerOperation {
156         None = 0x00,
157         CreatePlatformLayer = 0x01,
158         DestroyPlatformLayer = 0x02,
159         SyncPlatformLayer = 0x04,
160         CreateAndSyncPlatformLayer = CreatePlatformLayer | SyncPlatformLayer,
161         RecreatePlatformLayer = CreateAndSyncPlatformLayer | DestroyPlatformLayer
162     };
163
164     void syncPlatformLayer();
165     void destroyPlatformLayerIfNeeded();
166     void createPlatformLayerIfNeeded();
167 #endif
168
169     virtual void setDebugBorder(const Color&, float width) override;
170
171     bool fixedToViewport() const { return m_fixedToViewport; }
172
173     void didChangeLayerState();
174     void didChangeAnimations();
175     void didChangeGeometry();
176     void didChangeChildren();
177     void didChangeFilters();
178     void didChangeImageBacking();
179
180     void resetLayerState();
181     void syncLayerState();
182     void syncAnimations();
183     void syncChildren();
184     void syncFilters();
185     void syncImageBacking();
186     void computeTransformedVisibleRect();
187     void updateContentBuffers();
188
189     void createBackingStore();
190     void releaseImageBackingIfNeeded();
191
192     bool notifyFlushRequired();
193
194     // CoordinatedImageBacking::Host
195     virtual bool imageBackingVisible() override;
196     bool shouldHaveBackingStore() const;
197     bool selfOrAncestorHasActiveTransformAnimation() const;
198     bool selfOrAncestorHaveNonAffineTransforms();
199     void adjustContentsScale();
200
201     void setShouldUpdateVisibleRect();
202     float effectiveContentsScale();
203
204     void animationStartedTimerFired();
205
206     CoordinatedLayerID m_id;
207     CoordinatedGraphicsLayerState m_layerState;
208     GraphicsLayerTransform m_layerTransform;
209     TransformationMatrix m_cachedInverseTransform;
210     FloatSize m_pixelAlignmentOffset;
211     FloatSize m_adjustedSize;
212     FloatPoint m_adjustedPosition;
213     FloatPoint3D m_adjustedAnchorPoint;
214
215 #ifndef NDEBUG
216     bool m_isPurging;
217 #endif
218     bool m_shouldUpdateVisibleRect: 1;
219     bool m_shouldSyncLayerState: 1;
220     bool m_shouldSyncChildren: 1;
221     bool m_shouldSyncFilters: 1;
222     bool m_shouldSyncImageBacking: 1;
223     bool m_shouldSyncAnimations: 1;
224     bool m_fixedToViewport : 1;
225     bool m_movingVisibleRect : 1;
226     bool m_pendingContentsScaleAdjustment : 1;
227     bool m_pendingVisibleRectAdjustment : 1;
228 #if USE(GRAPHICS_SURFACE)
229     bool m_isValidPlatformLayer : 1;
230     unsigned m_pendingPlatformLayerOperation : 3;
231 #endif
232
233     CoordinatedGraphicsLayerClient* m_coordinator;
234     std::unique_ptr<TiledBackingStore> m_mainBackingStore;
235     std::unique_ptr<TiledBackingStore> m_previousBackingStore;
236
237     RefPtr<Image> m_compositedImage;
238     NativeImagePtr m_compositedNativeImagePtr;
239     RefPtr<CoordinatedImageBacking> m_coordinatedImageBacking;
240
241     PlatformLayer* m_platformLayer;
242 #if USE(GRAPHICS_SURFACE)
243     IntSize m_platformLayerSize;
244     GraphicsSurfaceToken m_platformLayerToken;
245 #endif
246     Timer m_animationStartedTimer;
247     GraphicsLayerAnimations m_animations;
248     double m_lastAnimationStartTime;
249
250     ScrollableArea* m_scrollableArea;
251 };
252
253 CoordinatedGraphicsLayer* toCoordinatedGraphicsLayer(GraphicsLayer*);
254
255 } // namespace WebCore
256 #endif // USE(COORDINATED_GRAPHICS)
257
258 #endif // CoordinatedGraphicsLayer_h