Replace WTF::move with WTFMove
[WebKit-https.git] / Source / WTF / wtf / MessageQueue.h
1 /*
2  * Copyright (C) 2008, 2015 Apple Inc. All rights reserved.
3  * Copyright (C) 2009 Google 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  *
9  * 1.  Redistributions of source code must retain the above copyright
10  *     notice, this list of conditions and the following disclaimer.
11  * 2.  Redistributions in binary form must reproduce the above copyright
12  *     notice, this list of conditions and the following disclaimer in the
13  *     documentation and/or other materials provided with the distribution.
14  * 3.  Neither the name of Apple Inc. ("Apple") nor the names of
15  *     its contributors may be used to endorse or promote products derived
16  *     from this software without specific prior written permission.
17  *
18  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
19  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
20  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
21  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
22  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
23  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
24  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
25  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
27  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28  */
29
30 #ifndef MessageQueue_h
31 #define MessageQueue_h
32
33 #include <limits>
34 #include <wtf/Assertions.h>
35 #include <wtf/Condition.h>
36 #include <wtf/Deque.h>
37 #include <wtf/Lock.h>
38 #include <wtf/Noncopyable.h>
39 #include <wtf/Threading.h>
40
41 namespace WTF {
42
43     enum MessageQueueWaitResult {
44         MessageQueueTerminated,       // Queue was destroyed while waiting for message.
45         MessageQueueTimeout,          // Timeout was specified and it expired.
46         MessageQueueMessageReceived   // A message was successfully received and returned.
47     };
48
49     // The queue takes ownership of messages and transfer it to the new owner
50     // when messages are fetched from the queue.
51     // Essentially, MessageQueue acts as a queue of std::unique_ptr<DataType>.
52     template<typename DataType>
53     class MessageQueue {
54         WTF_MAKE_NONCOPYABLE(MessageQueue);
55     public:
56         MessageQueue() : m_killed(false) { }
57         ~MessageQueue();
58
59         void append(std::unique_ptr<DataType>);
60         void appendAndKill(std::unique_ptr<DataType>);
61         bool appendAndCheckEmpty(std::unique_ptr<DataType>);
62         void prepend(std::unique_ptr<DataType>);
63
64         std::unique_ptr<DataType> waitForMessage();
65         std::unique_ptr<DataType> tryGetMessage();
66         std::unique_ptr<DataType> tryGetMessageIgnoringKilled();
67         template<typename Predicate>
68         std::unique_ptr<DataType> waitForMessageFilteredWithTimeout(MessageQueueWaitResult&, Predicate&&, double absoluteTime);
69
70         template<typename Predicate>
71         void removeIf(Predicate&&);
72
73         void kill();
74         bool killed() const;
75
76         // The result of isEmpty() is only valid if no other thread is manipulating the queue at the same time.
77         bool isEmpty();
78
79         static double infiniteTime() { return std::numeric_limits<double>::max(); }
80
81     private:
82         mutable Lock m_mutex;
83         Condition m_condition;
84         Deque<std::unique_ptr<DataType>> m_queue;
85         bool m_killed;
86     };
87
88     template<typename DataType>
89     MessageQueue<DataType>::~MessageQueue()
90     {
91     }
92
93     template<typename DataType>
94     inline void MessageQueue<DataType>::append(std::unique_ptr<DataType> message)
95     {
96         LockHolder lock(m_mutex);
97         m_queue.append(WTFMove(message));
98         m_condition.notifyOne();
99     }
100
101     template<typename DataType>
102     inline void MessageQueue<DataType>::appendAndKill(std::unique_ptr<DataType> message)
103     {
104         LockHolder lock(m_mutex);
105         m_queue.append(WTFMove(message));
106         m_killed = true;
107         m_condition.notifyAll();
108     }
109
110     // Returns true if the queue was empty before the item was added.
111     template<typename DataType>
112     inline bool MessageQueue<DataType>::appendAndCheckEmpty(std::unique_ptr<DataType> message)
113     {
114         LockHolder lock(m_mutex);
115         bool wasEmpty = m_queue.isEmpty();
116         m_queue.append(WTFMove(message));
117         m_condition.notifyOne();
118         return wasEmpty;
119     }
120
121     template<typename DataType>
122     inline void MessageQueue<DataType>::prepend(std::unique_ptr<DataType> message)
123     {
124         LockHolder lock(m_mutex);
125         m_queue.prepend(WTFMove(message));
126         m_condition.notifyOne();
127     }
128
129     template<typename DataType>
130     inline auto MessageQueue<DataType>::waitForMessage() -> std::unique_ptr<DataType>
131     {
132         MessageQueueWaitResult exitReason; 
133         std::unique_ptr<DataType> result = waitForMessageFilteredWithTimeout(exitReason, [](const DataType&) { return true; }, infiniteTime());
134         ASSERT(exitReason == MessageQueueTerminated || exitReason == MessageQueueMessageReceived);
135         return result;
136     }
137
138     template<typename DataType>
139     template<typename Predicate>
140     inline auto MessageQueue<DataType>::waitForMessageFilteredWithTimeout(MessageQueueWaitResult& result, Predicate&& predicate, double absoluteTime) -> std::unique_ptr<DataType>
141     {
142         LockHolder lock(m_mutex);
143         bool timedOut = false;
144
145         auto found = m_queue.end();
146         while (!m_killed && !timedOut) {
147             found = m_queue.findIf([&predicate](const std::unique_ptr<DataType>& ptr) -> bool {
148                 ASSERT(ptr);
149                 return predicate(*ptr);
150             });
151             if (found != m_queue.end())
152                 break;
153
154             timedOut = !m_condition.waitUntilWallClockSeconds(m_mutex, absoluteTime);
155         }
156
157         ASSERT(!timedOut || absoluteTime != infiniteTime());
158
159         if (m_killed) {
160             result = MessageQueueTerminated;
161             return nullptr;
162         }
163
164         if (timedOut) {
165             result = MessageQueueTimeout;
166             return nullptr;
167         }
168
169         ASSERT(found != m_queue.end());
170         std::unique_ptr<DataType> message = WTFMove(*found);
171         m_queue.remove(found);
172         result = MessageQueueMessageReceived;
173         return message;
174     }
175
176     template<typename DataType>
177     inline auto MessageQueue<DataType>::tryGetMessage() -> std::unique_ptr<DataType>
178     {
179         LockHolder lock(m_mutex);
180         if (m_killed)
181             return nullptr;
182         if (m_queue.isEmpty())
183             return nullptr;
184
185         return m_queue.takeFirst();
186     }
187
188     template<typename DataType>
189     inline auto MessageQueue<DataType>::tryGetMessageIgnoringKilled() -> std::unique_ptr<DataType>
190     {
191         LockHolder lock(m_mutex);
192         if (m_queue.isEmpty())
193             return nullptr;
194
195         return m_queue.takeFirst();
196     }
197
198     template<typename DataType>
199     template<typename Predicate>
200     inline void MessageQueue<DataType>::removeIf(Predicate&& predicate)
201     {
202         LockHolder lock(m_mutex);
203         while (true) {
204             auto found = m_queue.findIf([&predicate](const std::unique_ptr<DataType>& ptr) -> bool {
205                 ASSERT(ptr);
206                 return predicate(*ptr);
207             });
208
209             if (found == m_queue.end())
210                 break;
211
212             m_queue.remove(found);
213         }
214     }
215
216     template<typename DataType>
217     inline bool MessageQueue<DataType>::isEmpty()
218     {
219         LockHolder lock(m_mutex);
220         if (m_killed)
221             return true;
222         return m_queue.isEmpty();
223     }
224
225     template<typename DataType>
226     inline void MessageQueue<DataType>::kill()
227     {
228         LockHolder lock(m_mutex);
229         m_killed = true;
230         m_condition.notifyAll();
231     }
232
233     template<typename DataType>
234     inline bool MessageQueue<DataType>::killed() const
235     {
236         LockHolder lock(m_mutex);
237         return m_killed;
238     }
239 } // namespace WTF
240
241 using WTF::MessageQueue;
242 // MessageQueueWaitResult enum and all its values.
243 using WTF::MessageQueueWaitResult;
244 using WTF::MessageQueueTerminated;
245 using WTF::MessageQueueTimeout;
246 using WTF::MessageQueueMessageReceived;
247
248 #endif // MessageQueue_h