5521f2f063c1eada0c9f7612f48f97bc8589d348
[WebKit-https.git] / Source / WebCore / platform / graphics / chromium / cc / CCThreadProxy.h
1 /*
2  * Copyright (C) 2011 Google Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1.  Redistributions of source code must retain the above copyright
8  *     notice, this list of conditions and the following disclaimer.
9  * 2.  Redistributions in binary form must reproduce the above copyright
10  *     notice, this list of conditions and the following disclaimer in the
11  *     documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' AND ANY
14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
15  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
16  * DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS BE LIABLE FOR ANY
17  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
18  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
19  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
20  * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
21  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
22  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
23  */
24
25 #ifndef CCThreadProxy_h
26 #define CCThreadProxy_h
27
28 #include "cc/CCAnimationEvents.h"
29 #include "cc/CCCompletionEvent.h"
30 #include "cc/CCLayerTreeHostImpl.h"
31 #include "cc/CCProxy.h"
32 #include "cc/CCScheduler.h"
33 #include <wtf/OwnPtr.h>
34
35 namespace WebCore {
36
37 class CCInputHandler;
38 class CCLayerTreeHost;
39 class CCScheduler;
40 class CCScopedThreadProxy;
41 class CCTextureUpdater;
42 class CCThread;
43 class CCThreadProxyContextRecreationTimer;
44
45 class CCThreadProxy : public CCProxy, CCLayerTreeHostImplClient, CCSchedulerClient {
46 public:
47     static PassOwnPtr<CCProxy> create(CCLayerTreeHost*);
48
49     virtual ~CCThreadProxy();
50
51     // CCProxy implementation
52     virtual bool compositeAndReadback(void *pixels, const IntRect&) OVERRIDE;
53     virtual void startPageScaleAnimation(const IntSize& targetPosition, bool useAnchor, float scale, double duration) OVERRIDE;
54     virtual CCGraphicsContext* context() OVERRIDE;
55     virtual void finishAllRendering() OVERRIDE;
56     virtual bool isStarted() const OVERRIDE;
57     virtual bool initializeContext() OVERRIDE;
58     virtual void setSurfaceReady() OVERRIDE;
59     virtual bool initializeLayerRenderer() OVERRIDE;
60     virtual bool recreateContext() OVERRIDE;
61     virtual int compositorIdentifier() const OVERRIDE;
62     virtual const LayerRendererCapabilities& layerRendererCapabilities() const OVERRIDE;
63     virtual void loseContext() OVERRIDE;
64     virtual void setNeedsAnimate() OVERRIDE;
65     virtual void setNeedsCommit() OVERRIDE;
66     virtual void setNeedsForcedCommit() OVERRIDE;
67     virtual void setNeedsRedraw() OVERRIDE;
68     virtual bool commitRequested() const OVERRIDE;
69     virtual void didAddAnimation() OVERRIDE { }
70     virtual void start() OVERRIDE;
71     virtual void stop() OVERRIDE;
72     virtual size_t maxPartialTextureUpdates() const OVERRIDE;
73     virtual void acquireLayerTextures() OVERRIDE;
74     virtual void setFontAtlas(PassOwnPtr<CCFontAtlas>) OVERRIDE;
75     virtual void forceSerializeOnSwapBuffers() OVERRIDE;
76
77     // CCLayerTreeHostImplClient implementation
78     virtual void didLoseContextOnImplThread() OVERRIDE;
79     virtual void onSwapBuffersCompleteOnImplThread() OVERRIDE;
80     virtual void setNeedsRedrawOnImplThread() OVERRIDE;
81     virtual void setNeedsCommitOnImplThread() OVERRIDE;
82     virtual void postAnimationEventsToMainThreadOnImplThread(PassOwnPtr<CCAnimationEventsVector>, double wallClockTime) OVERRIDE;
83     virtual void postSetContentsMemoryAllocationLimitBytesToMainThreadOnImplThread(size_t) OVERRIDE;
84
85     // CCSchedulerClient implementation
86     virtual bool canDraw() OVERRIDE;
87     virtual bool hasMoreResourceUpdates() const OVERRIDE;
88     virtual void scheduledActionBeginFrame() OVERRIDE;
89     virtual CCScheduledActionDrawAndSwapResult scheduledActionDrawAndSwapIfPossible() OVERRIDE;
90     virtual CCScheduledActionDrawAndSwapResult scheduledActionDrawAndSwapForced() OVERRIDE;
91     virtual void scheduledActionUpdateMoreResources() OVERRIDE;
92     virtual void scheduledActionCommit() OVERRIDE;
93     virtual void scheduledActionBeginContextRecreation() OVERRIDE;
94     virtual void scheduledActionAcquireLayerTexturesForMainThread() OVERRIDE;
95
96 private:
97     explicit CCThreadProxy(CCLayerTreeHost*);
98     friend class CCThreadProxyContextRecreationTimer;
99
100     // Set on impl thread, read on main thread.
101     struct BeginFrameAndCommitState {
102         BeginFrameAndCommitState()
103             : monotonicFrameBeginTime(0)
104             , updater(0)
105         {
106         }
107
108         double monotonicFrameBeginTime;
109         OwnPtr<CCScrollAndScaleSet> scrollInfo;
110         CCTextureUpdater* updater;
111     };
112     OwnPtr<BeginFrameAndCommitState> m_pendingBeginFrameRequest;
113
114     // Called on main thread
115     void beginFrame();
116     void didCommitAndDrawFrame();
117     void didCompleteSwapBuffers();
118     void setAnimationEvents(PassOwnPtr<CCAnimationEventsVector>, double wallClockTime);
119     void setContentsMemoryAllocationLimitBytes(size_t);
120     void beginContextRecreation();
121     void tryToRecreateContext();
122
123     // Called on impl thread
124     struct ReadbackRequest {
125         CCCompletionEvent completion;
126         bool success;
127         void* pixels;
128         IntRect rect;
129     };
130     void forceBeginFrameOnImplThread(CCCompletionEvent*);
131     void beginFrameCompleteOnImplThread(CCCompletionEvent*);
132     void requestReadbackOnImplThread(ReadbackRequest*);
133     void requestStartPageScaleAnimationOnImplThread(IntSize targetPosition, bool useAnchor, float scale, double durationSec);
134     void finishAllRenderingOnImplThread(CCCompletionEvent*);
135     void initializeImplOnImplThread(CCCompletionEvent*);
136     void setSurfaceReadyOnImplThread();
137     void initializeContextOnImplThread(CCGraphicsContext*);
138     void initializeLayerRendererOnImplThread(CCCompletionEvent*, bool* initializeSucceeded, LayerRendererCapabilities*);
139     void layerTreeHostClosedOnImplThread(CCCompletionEvent*);
140     void setFullRootLayerDamageOnImplThread();
141     void acquireLayerTexturesForMainThreadOnImplThread(CCCompletionEvent*);
142     void recreateContextOnImplThread(CCCompletionEvent*, CCGraphicsContext*, bool* recreateSucceeded, LayerRendererCapabilities*);
143     CCScheduledActionDrawAndSwapResult scheduledActionDrawAndSwapInternal(bool forcedDraw);
144     void setFontAtlasOnImplThread(PassOwnPtr<CCFontAtlas>);
145     void forceSerializeOnSwapBuffersOnImplThread(CCCompletionEvent*);
146     void setNeedsForcedCommitOnImplThread();
147
148     // Accessed on main thread only.
149     bool m_animateRequested;
150     bool m_commitRequested;
151     bool m_forcedCommitRequested;
152     bool m_contextLost;
153     OwnPtr<CCThreadProxyContextRecreationTimer> m_contextRecreationTimer;
154     CCLayerTreeHost* m_layerTreeHost;
155     int m_compositorIdentifier;
156     bool m_layerRendererInitialized;
157     LayerRendererCapabilities m_layerRendererCapabilitiesMainThreadCopy;
158     bool m_started;
159     bool m_texturesAcquired;
160
161     OwnPtr<CCLayerTreeHostImpl> m_layerTreeHostImpl;
162
163     OwnPtr<CCInputHandler> m_inputHandlerOnImplThread;
164
165     OwnPtr<CCScheduler> m_schedulerOnImplThread;
166
167     RefPtr<CCScopedThreadProxy> m_mainThreadProxy;
168
169     // Holds on to the context we might use for compositing in between initializeContext()
170     // and initializeLayerRenderer() calls.
171     RefPtr<CCGraphicsContext> m_contextBeforeInitializationOnImplThread;
172
173     // Set when the main thread is waiting on a scheduledActionBeginFrame to be issued.
174     CCCompletionEvent* m_beginFrameCompletionEventOnImplThread;
175
176     // Set when the main thread is waiting on a readback.
177     ReadbackRequest* m_readbackRequestOnImplThread;
178
179     // Set when the main thread is waiting on a commit to complete.
180     CCCompletionEvent* m_commitCompletionEventOnImplThread;
181
182     // Set when the main thread is waiting on layers to be drawn.
183     CCCompletionEvent* m_textureAcquisitionCompletionEventOnImplThread;
184
185     OwnPtr<CCTextureUpdater> m_currentTextureUpdaterOnImplThread;
186
187     // Set when the next draw should post didCommitAndDrawFrame to the main thread.
188     bool m_nextFrameIsNewlyCommittedFrameOnImplThread;
189 };
190
191 }
192
193 #endif