Add animationDidEnd callbacks on GraphicsLayer
[WebKit-https.git] / Source / WebCore / platform / graphics / texmap / coordinated / CompositingCoordinator.h
1 /*
2  * Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies)
3  * Copyright (C) 2013 Company 100, Inc. All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
15  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
16  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
17  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
18  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
19  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
20  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
21  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
22  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
23  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
24  * THE POSSIBILITY OF SUCH DAMAGE.
25  */
26
27 #ifndef CompositingCoordinator_h
28 #define CompositingCoordinator_h
29
30 #if USE(COORDINATED_GRAPHICS)
31
32 #include "CoordinatedGraphicsLayer.h"
33 #include "CoordinatedGraphicsState.h"
34 #include "CoordinatedImageBacking.h"
35 #include "FloatPoint.h"
36 #include "GraphicsLayerClient.h"
37 #include "GraphicsLayerFactory.h"
38 #include "IntRect.h"
39 #include "Timer.h"
40 #include "UpdateAtlas.h"
41
42 namespace WebCore {
43
44 class Page;
45 class GraphicsContext;
46 class GraphicsLayer;
47 class CoordinatedSurface;
48
49 class CompositingCoordinator : public GraphicsLayerClient
50     , public CoordinatedGraphicsLayerClient
51     , public CoordinatedImageBacking::Client
52     , public UpdateAtlas::Client
53     , public GraphicsLayerFactory {
54     WTF_MAKE_NONCOPYABLE(CompositingCoordinator); WTF_MAKE_FAST_ALLOCATED;
55 public:
56     class Client {
57     public:
58         virtual void didFlushRootLayer(const FloatRect& visibleContentRect) = 0;
59         virtual void notifyFlushRequired() = 0;
60         virtual void commitSceneState(const CoordinatedGraphicsState&) = 0;
61         virtual void paintLayerContents(const GraphicsLayer*, GraphicsContext&, const IntRect& clipRect) = 0;
62     };
63
64     CompositingCoordinator(Page*, CompositingCoordinator::Client*);
65     virtual ~CompositingCoordinator();
66
67     void setRootCompositingLayer(GraphicsLayer* compositingLayer, GraphicsLayer* overlayLayer);
68     void sizeDidChange(const IntSize& newSize);
69     void deviceOrPageScaleFactorChanged();
70
71     void setVisibleContentsRect(const FloatRect&, const FloatPoint&);
72     void renderNextFrame();
73     void purgeBackingStores();
74     void commitScrollOffset(uint32_t layerID, const IntSize& offset);
75
76     void createRootLayer(const IntSize&);
77     void clearRootLayer() { m_rootLayer = nullptr; }
78     GraphicsLayer* rootLayer() const { return m_rootLayer.get(); }
79     CoordinatedGraphicsLayer* mainContentsLayer();
80
81     bool flushPendingLayerChanges();
82     CoordinatedGraphicsState& state() { return m_state; }
83
84     void syncDisplayState();
85
86 #if ENABLE(REQUEST_ANIMATION_FRAME)
87     double nextAnimationServiceTime() const;
88 #endif
89
90 private:
91     // GraphicsLayerClient
92     virtual void notifyAnimationStarted(const GraphicsLayer*, const String&, double time) override;
93     virtual void notifyFlushRequired(const GraphicsLayer*) override;
94     virtual void paintContents(const GraphicsLayer*, GraphicsContext&, GraphicsLayerPaintingPhase, const FloatRect& clipRect) override;
95     virtual float deviceScaleFactor() const override;
96     virtual float pageScaleFactor() const override;
97
98     // CoordinatedImageBacking::Client
99     virtual void createImageBacking(CoordinatedImageBackingID) override;
100     virtual void updateImageBacking(CoordinatedImageBackingID, PassRefPtr<CoordinatedSurface>) override;
101     virtual void clearImageBackingContents(CoordinatedImageBackingID) override;
102     virtual void removeImageBacking(CoordinatedImageBackingID) override;
103
104     // CoordinatedGraphicsLayerClient
105     virtual bool isFlushingLayerChanges() const override { return m_isFlushingLayerChanges; }
106     virtual FloatRect visibleContentsRect() const override;
107     virtual PassRefPtr<CoordinatedImageBacking> createImageBackingIfNeeded(Image*) override;
108     virtual void detachLayer(CoordinatedGraphicsLayer*) override;
109     virtual bool paintToSurface(const WebCore::IntSize&, WebCore::CoordinatedSurface::Flags, uint32_t& /* atlasID */, WebCore::IntPoint&, WebCore::CoordinatedSurface::Client*) override;
110     virtual void syncLayerState(CoordinatedLayerID, CoordinatedGraphicsLayerState&) override;
111
112     // UpdateAtlas::Client
113     virtual void createUpdateAtlas(uint32_t atlasID, PassRefPtr<CoordinatedSurface>) override;
114     virtual void removeUpdateAtlas(uint32_t atlasID) override;
115
116     // GraphicsLayerFactory
117     virtual std::unique_ptr<GraphicsLayer> createGraphicsLayer(GraphicsLayerClient&) override;
118
119     void initializeRootCompositingLayerIfNeeded();
120     void flushPendingImageBackingChanges();
121     void clearPendingStateChanges();
122
123     void scheduleReleaseInactiveAtlases();
124
125     void releaseInactiveAtlasesTimerFired(Timer<CompositingCoordinator>*);
126
127     Page* m_page;
128     CompositingCoordinator::Client* m_client;
129
130     std::unique_ptr<GraphicsLayer> m_rootLayer;
131     GraphicsLayer* m_rootCompositingLayer;
132
133     CoordinatedGraphicsState m_state;
134
135     typedef HashMap<CoordinatedLayerID, CoordinatedGraphicsLayer*> LayerMap;
136     LayerMap m_registeredLayers;
137     typedef HashMap<CoordinatedImageBackingID, RefPtr<CoordinatedImageBacking> > ImageBackingMap;
138     ImageBackingMap m_imageBackings;
139     Vector<std::unique_ptr<UpdateAtlas>> m_updateAtlases;
140
141     // We don't send the messages related to releasing resources to renderer during purging, because renderer already had removed all resources.
142     bool m_isPurging;
143     bool m_isFlushingLayerChanges;
144
145     FloatRect m_visibleContentsRect;
146
147     bool m_shouldSyncFrame;
148     bool m_didInitializeRootCompositingLayer;
149     Timer<CompositingCoordinator> m_releaseInactiveAtlasesTimer;
150
151 #if ENABLE(REQUEST_ANIMATION_FRAME)
152     double m_lastAnimationServiceTime;
153 #endif
154 };
155
156 }
157
158 #endif
159
160 #endif // CompositingCoordinator_h