[chromium] LayerRendererChromium is not getting visibility messages in single threade...
[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 void setVisible(bool) OVERRIDE;
60     virtual bool initializeLayerRenderer() OVERRIDE;
61     virtual bool recreateContext() OVERRIDE;
62     virtual int compositorIdentifier() const OVERRIDE;
63     virtual const LayerRendererCapabilities& layerRendererCapabilities() const OVERRIDE;
64     virtual void loseContext() OVERRIDE;
65     virtual void setNeedsAnimate() OVERRIDE;
66     virtual void setNeedsCommit() 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
84     // CCSchedulerClient implementation
85     virtual bool canDraw() OVERRIDE;
86     virtual bool hasMoreResourceUpdates() const OVERRIDE;
87     virtual void scheduledActionBeginFrame() OVERRIDE;
88     virtual CCScheduledActionDrawAndSwapResult scheduledActionDrawAndSwapIfPossible() OVERRIDE;
89     virtual CCScheduledActionDrawAndSwapResult scheduledActionDrawAndSwapForced() OVERRIDE;
90     virtual void scheduledActionUpdateMoreResources() OVERRIDE;
91     virtual void scheduledActionCommit() OVERRIDE;
92     virtual void scheduledActionBeginContextRecreation() OVERRIDE;
93     virtual void scheduledActionAcquireLayerTexturesForMainThread() OVERRIDE;
94
95 private:
96     explicit CCThreadProxy(CCLayerTreeHost*);
97     friend class CCThreadProxyContextRecreationTimer;
98
99     // Set on impl thread, read on main thread.
100     struct BeginFrameAndCommitState {
101         BeginFrameAndCommitState()
102             : monotonicFrameBeginTime(0)
103             , updater(0)
104         {
105         }
106
107         double monotonicFrameBeginTime;
108         OwnPtr<CCScrollAndScaleSet> scrollInfo;
109         CCTextureUpdater* updater;
110         bool contentsTexturesWereDeleted;
111         size_t memoryAllocationLimitBytes;
112     };
113     OwnPtr<BeginFrameAndCommitState> m_pendingBeginFrameRequest;
114
115     // Called on main thread
116     void beginFrame();
117     void didCommitAndDrawFrame();
118     void didCompleteSwapBuffers();
119     void setAnimationEvents(PassOwnPtr<CCAnimationEventsVector>, double wallClockTime);
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 beginFrameAbortedOnImplThread();
133     void requestReadbackOnImplThread(ReadbackRequest*);
134     void requestStartPageScaleAnimationOnImplThread(IntSize targetPosition, bool useAnchor, float scale, double durationSec);
135     void finishAllRenderingOnImplThread(CCCompletionEvent*);
136     void initializeImplOnImplThread(CCCompletionEvent*);
137     void setSurfaceReadyOnImplThread();
138     void setVisibleOnImplThread(CCCompletionEvent*, bool);
139     void initializeContextOnImplThread(CCGraphicsContext*);
140     void initializeLayerRendererOnImplThread(CCCompletionEvent*, bool* initializeSucceeded, LayerRendererCapabilities*);
141     void layerTreeHostClosedOnImplThread(CCCompletionEvent*);
142     void setFullRootLayerDamageOnImplThread();
143     void acquireLayerTexturesForMainThreadOnImplThread(CCCompletionEvent*);
144     void recreateContextOnImplThread(CCCompletionEvent*, CCGraphicsContext*, bool* recreateSucceeded, LayerRendererCapabilities*);
145     CCScheduledActionDrawAndSwapResult scheduledActionDrawAndSwapInternal(bool forcedDraw);
146     void setFontAtlasOnImplThread(PassOwnPtr<CCFontAtlas>);
147     void forceSerializeOnSwapBuffersOnImplThread(CCCompletionEvent*);
148     void setNeedsForcedCommitOnImplThread();
149
150     // Accessed on main thread only.
151     bool m_animateRequested;
152     bool m_commitRequested;
153     bool m_forcedCommitRequested;
154     bool m_contextLost;
155     OwnPtr<CCThreadProxyContextRecreationTimer> m_contextRecreationTimer;
156     CCLayerTreeHost* m_layerTreeHost;
157     int m_compositorIdentifier;
158     bool m_layerRendererInitialized;
159     LayerRendererCapabilities m_layerRendererCapabilitiesMainThreadCopy;
160     bool m_started;
161     bool m_texturesAcquired;
162     bool m_inCompositeAndReadback;
163
164     OwnPtr<CCLayerTreeHostImpl> m_layerTreeHostImpl;
165
166     OwnPtr<CCInputHandler> m_inputHandlerOnImplThread;
167
168     OwnPtr<CCScheduler> m_schedulerOnImplThread;
169
170     RefPtr<CCScopedThreadProxy> m_mainThreadProxy;
171
172     // Holds on to the context we might use for compositing in between initializeContext()
173     // and initializeLayerRenderer() calls.
174     RefPtr<CCGraphicsContext> m_contextBeforeInitializationOnImplThread;
175
176     // Set when the main thread is waiting on a scheduledActionBeginFrame to be issued.
177     CCCompletionEvent* m_beginFrameCompletionEventOnImplThread;
178
179     // Set when the main thread is waiting on a readback.
180     ReadbackRequest* m_readbackRequestOnImplThread;
181
182     // Set when the main thread is waiting on a commit to complete.
183     CCCompletionEvent* m_commitCompletionEventOnImplThread;
184
185     // Set when the main thread is waiting on layers to be drawn.
186     CCCompletionEvent* m_textureAcquisitionCompletionEventOnImplThread;
187
188     OwnPtr<CCTextureUpdater> m_currentTextureUpdaterOnImplThread;
189
190     // Set when the next draw should post didCommitAndDrawFrame to the main thread.
191     bool m_nextFrameIsNewlyCommittedFrameOnImplThread;
192 };
193
194 }
195
196 #endif