Replace WTF::move with WTFMove
[WebKit-https.git] / Source / WebCore / platform / graphics / texmap / TextureMapperPlatformLayerProxy.cpp
1 /*
2  * Copyright (C) 2015 Igalia S.L.
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''
14  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
15  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
17  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
18  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
19  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
20  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
21  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
22  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
23  * THE POSSIBILITY OF SUCH DAMAGE.
24  */
25
26 #include "config.h"
27 #include "TextureMapperPlatformLayerProxy.h"
28
29 #if USE(COORDINATED_GRAPHICS_THREADED)
30
31 #include "BitmapTextureGL.h"
32 #include "TextureMapperGL.h"
33 #include "TextureMapperLayer.h"
34 #include "TextureMapperPlatformLayerBuffer.h"
35
36 const double s_releaseUnusedSecondsTolerance = 1;
37 const double s_releaseUnusedBuffersTimerInterval = 0.5;
38
39 namespace WebCore {
40
41 TextureMapperPlatformLayerProxy::TextureMapperPlatformLayerProxy()
42     : m_compositor(nullptr)
43     , m_targetLayer(nullptr)
44     , m_releaseUnusedBuffersTimer(RunLoop::current(), this, &TextureMapperPlatformLayerProxy::releaseUnusedBuffersTimerFired)
45 {
46 }
47
48 TextureMapperPlatformLayerProxy::~TextureMapperPlatformLayerProxy()
49 {
50     LockHolder locker(m_lock);
51     if (m_targetLayer)
52         m_targetLayer->setContentsLayer(nullptr);
53 }
54
55 void TextureMapperPlatformLayerProxy::activateOnCompositingThread(Compositor* compositor, TextureMapperLayer* targetLayer)
56 {
57 #ifndef NDEBUG
58     m_compositorThreadID = m_compositorThreadID ? m_compositorThreadID : WTF::currentThread();
59 #endif
60     ASSERT(m_compositorThreadID == WTF::currentThread());
61     ASSERT(compositor);
62     ASSERT(targetLayer);
63     LockHolder locker(m_lock);
64     m_compositor = compositor;
65     m_targetLayer = targetLayer;
66     m_compositorThreadUpdateTimer = std::make_unique<RunLoop::Timer<TextureMapperPlatformLayerProxy>>(RunLoop::current(), this, &TextureMapperPlatformLayerProxy::compositorThreadUpdateTimerFired);
67 }
68
69 void TextureMapperPlatformLayerProxy::invalidate()
70 {
71     ASSERT(m_compositorThreadID == WTF::currentThread());
72     LockHolder locker(m_lock);
73     m_compositor = nullptr;
74     m_targetLayer = nullptr;
75 }
76
77 bool TextureMapperPlatformLayerProxy::isActive()
78 {
79     ASSERT(m_lock.isHeld());
80     return !!m_targetLayer && !!m_compositor;
81 }
82
83 void TextureMapperPlatformLayerProxy::pushNextBuffer(std::unique_ptr<TextureMapperPlatformLayerBuffer> newBuffer)
84 {
85     ASSERT(m_lock.isHeld());
86     m_pendingBuffer = WTFMove(newBuffer);
87
88     if (m_compositor)
89         m_compositor->onNewBufferAvailable();
90 }
91
92 std::unique_ptr<TextureMapperPlatformLayerBuffer> TextureMapperPlatformLayerProxy::getAvailableBuffer(const IntSize& size, GC3Dint internalFormat)
93 {
94     ASSERT(m_lock.isHeld());
95     std::unique_ptr<TextureMapperPlatformLayerBuffer> availableBuffer;
96
97     auto buffers = WTFMove(m_usedBuffers);
98     for (auto& buffer : buffers) {
99         if (!buffer)
100             continue;
101
102         if (!availableBuffer && buffer->canReuseWithoutReset(size, internalFormat)) {
103             availableBuffer = WTFMove(buffer);
104             availableBuffer->markUsed();
105             continue;
106         }
107         m_usedBuffers.append(WTFMove(buffer));
108     }
109
110     if (!m_usedBuffers.isEmpty())
111         scheduleReleaseUnusedBuffers();
112     return availableBuffer;
113 }
114
115 void TextureMapperPlatformLayerProxy::scheduleReleaseUnusedBuffers()
116 {
117     if (!m_releaseUnusedBuffersTimer.isActive())
118         m_releaseUnusedBuffersTimer.startOneShot(s_releaseUnusedBuffersTimerInterval);
119 }
120
121 void TextureMapperPlatformLayerProxy::releaseUnusedBuffersTimerFired()
122 {
123     LockHolder locker(m_lock);
124     if (m_usedBuffers.isEmpty())
125         return;
126
127     auto buffers = WTFMove(m_usedBuffers);
128     double minUsedTime = monotonicallyIncreasingTime() - s_releaseUnusedSecondsTolerance;
129
130     for (auto& buffer : buffers) {
131         if (buffer && buffer->lastUsedTime() >= minUsedTime)
132             m_usedBuffers.append(WTFMove(buffer));
133     }
134 }
135
136 void TextureMapperPlatformLayerProxy::swapBuffer()
137 {
138     ASSERT(m_compositorThreadID == WTF::currentThread());
139     std::unique_ptr<TextureMapperPlatformLayerBuffer> prevBuffer;
140
141     {
142         LockHolder locker(m_lock);
143         if (!m_targetLayer || !m_pendingBuffer)
144             return;
145
146         prevBuffer = WTFMove(m_currentBuffer);
147
148         m_currentBuffer = WTFMove(m_pendingBuffer);
149         m_targetLayer->setContentsLayer(m_currentBuffer.get());
150     }
151
152     if (prevBuffer && prevBuffer->hasManagedTexture())
153         m_usedBuffers.append(WTFMove(prevBuffer));
154 }
155
156 bool TextureMapperPlatformLayerProxy::scheduleUpdateOnCompositorThread(std::function<void()>&& updateFunction)
157 {
158     LockHolder locker(m_lock);
159     if (!m_compositorThreadUpdateTimer)
160         return false;
161
162     m_compositorThreadUpdateFunction = WTFMove(updateFunction);
163     m_compositorThreadUpdateTimer->startOneShot(0);
164     return true;
165 }
166
167 void TextureMapperPlatformLayerProxy::compositorThreadUpdateTimerFired()
168 {
169     std::function<void()> updateFunction;
170     {
171         LockHolder locker(m_lock);
172         if (!m_compositorThreadUpdateFunction)
173             return;
174         updateFunction = WTFMove(m_compositorThreadUpdateFunction);
175     }
176
177     updateFunction();
178 }
179
180 } // namespace WebCore
181
182 #endif // USE(COORDINATED_GRAPHICS_THREADED)