henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 1 | /* |
| 2 | * Copyright 2004 The WebRTC Project Authors. All rights reserved. |
| 3 | * |
| 4 | * Use of this source code is governed by a BSD-style license |
| 5 | * that can be found in the LICENSE file in the root of the source |
| 6 | * tree. An additional intellectual property rights grant can be found |
| 7 | * in the file PATENTS. All contributing project authors may |
| 8 | * be found in the AUTHORS file in the root of the source tree. |
| 9 | */ |
| 10 | |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 11 | #include "rtc_base/messagequeue.h" |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 12 | |
Taylor Brandstetter | fe7d091 | 2016-09-15 17:47:42 -0700 | [diff] [blame] | 13 | #include <functional> |
| 14 | |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 15 | #include "rtc_base/atomicops.h" |
| 16 | #include "rtc_base/bind.h" |
| 17 | #include "rtc_base/event.h" |
| 18 | #include "rtc_base/gunit.h" |
| 19 | #include "rtc_base/logging.h" |
| 20 | #include "rtc_base/nullsocketserver.h" |
| 21 | #include "rtc_base/refcount.h" |
| 22 | #include "rtc_base/refcountedobject.h" |
| 23 | #include "rtc_base/thread.h" |
| 24 | #include "rtc_base/timeutils.h" |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 25 | |
| 26 | using namespace rtc; |
| 27 | |
decurtis@webrtc.org | 2af3057 | 2015-02-21 01:59:50 +0000 | [diff] [blame] | 28 | class MessageQueueTest: public testing::Test, public MessageQueue { |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 29 | public: |
danilchap | bebf54c | 2016-04-28 01:32:48 -0700 | [diff] [blame] | 30 | MessageQueueTest() : MessageQueue(SocketServer::CreateDefault(), true) {} |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 31 | bool IsLocked_Worker() { |
| 32 | if (!crit_.TryEnter()) { |
| 33 | return true; |
| 34 | } |
| 35 | crit_.Leave(); |
| 36 | return false; |
| 37 | } |
| 38 | bool IsLocked() { |
| 39 | // We have to do this on a worker thread, or else the TryEnter will |
| 40 | // succeed, since our critical sections are reentrant. |
tommi | e725159 | 2017-07-14 14:44:46 -0700 | [diff] [blame] | 41 | std::unique_ptr<Thread> worker(Thread::CreateWithSocketServer()); |
| 42 | worker->Start(); |
| 43 | return worker->Invoke<bool>( |
Taylor Brandstetter | 5d97a9a | 2016-06-10 14:17:27 -0700 | [diff] [blame] | 44 | RTC_FROM_HERE, rtc::Bind(&MessageQueueTest::IsLocked_Worker, this)); |
decurtis@webrtc.org | 2bffc3c | 2015-02-21 01:45:04 +0000 | [diff] [blame] | 45 | } |
decurtis@webrtc.org | 2bffc3c | 2015-02-21 01:45:04 +0000 | [diff] [blame] | 46 | }; |
| 47 | |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 48 | struct DeletedLockChecker { |
decurtis@webrtc.org | 2af3057 | 2015-02-21 01:59:50 +0000 | [diff] [blame] | 49 | DeletedLockChecker(MessageQueueTest* test, bool* was_locked, bool* deleted) |
| 50 | : test(test), was_locked(was_locked), deleted(deleted) { } |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 51 | ~DeletedLockChecker() { |
| 52 | *deleted = true; |
decurtis@webrtc.org | 2af3057 | 2015-02-21 01:59:50 +0000 | [diff] [blame] | 53 | *was_locked = test->IsLocked(); |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 54 | } |
decurtis@webrtc.org | 2af3057 | 2015-02-21 01:59:50 +0000 | [diff] [blame] | 55 | MessageQueueTest* test; |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 56 | bool* was_locked; |
| 57 | bool* deleted; |
| 58 | }; |
| 59 | |
| 60 | static void DelayedPostsWithIdenticalTimesAreProcessedInFifoOrder( |
| 61 | MessageQueue* q) { |
deadbeef | 37f5ecf | 2017-02-27 14:06:41 -0800 | [diff] [blame] | 62 | EXPECT_TRUE(q != nullptr); |
Honghai Zhang | 82d7862 | 2016-05-06 11:29:15 -0700 | [diff] [blame] | 63 | int64_t now = TimeMillis(); |
deadbeef | 37f5ecf | 2017-02-27 14:06:41 -0800 | [diff] [blame] | 64 | q->PostAt(RTC_FROM_HERE, now, nullptr, 3); |
| 65 | q->PostAt(RTC_FROM_HERE, now - 2, nullptr, 0); |
| 66 | q->PostAt(RTC_FROM_HERE, now - 1, nullptr, 1); |
| 67 | q->PostAt(RTC_FROM_HERE, now, nullptr, 4); |
| 68 | q->PostAt(RTC_FROM_HERE, now - 1, nullptr, 2); |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 69 | |
| 70 | Message msg; |
| 71 | for (size_t i=0; i<5; ++i) { |
| 72 | memset(&msg, 0, sizeof(msg)); |
| 73 | EXPECT_TRUE(q->Get(&msg, 0)); |
| 74 | EXPECT_EQ(i, msg.message_id); |
| 75 | } |
| 76 | |
| 77 | EXPECT_FALSE(q->Get(&msg, 0)); // No more messages |
| 78 | } |
| 79 | |
| 80 | TEST_F(MessageQueueTest, |
| 81 | DelayedPostsWithIdenticalTimesAreProcessedInFifoOrder) { |
danilchap | bebf54c | 2016-04-28 01:32:48 -0700 | [diff] [blame] | 82 | MessageQueue q(SocketServer::CreateDefault(), true); |
decurtis@webrtc.org | 2af3057 | 2015-02-21 01:59:50 +0000 | [diff] [blame] | 83 | DelayedPostsWithIdenticalTimesAreProcessedInFifoOrder(&q); |
danilchap | bebf54c | 2016-04-28 01:32:48 -0700 | [diff] [blame] | 84 | |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 85 | NullSocketServer nullss; |
danilchap | bebf54c | 2016-04-28 01:32:48 -0700 | [diff] [blame] | 86 | MessageQueue q_nullss(&nullss, true); |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 87 | DelayedPostsWithIdenticalTimesAreProcessedInFifoOrder(&q_nullss); |
| 88 | } |
| 89 | |
henrike@webrtc.org | c732a3e | 2014-10-09 22:08:15 +0000 | [diff] [blame] | 90 | TEST_F(MessageQueueTest, DisposeNotLocked) { |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 91 | bool was_locked = true; |
| 92 | bool deleted = false; |
decurtis@webrtc.org | 2af3057 | 2015-02-21 01:59:50 +0000 | [diff] [blame] | 93 | DeletedLockChecker* d = new DeletedLockChecker(this, &was_locked, &deleted); |
| 94 | Dispose(d); |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 95 | Message msg; |
decurtis@webrtc.org | 2af3057 | 2015-02-21 01:59:50 +0000 | [diff] [blame] | 96 | EXPECT_FALSE(Get(&msg, 0)); |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 97 | EXPECT_TRUE(deleted); |
| 98 | EXPECT_FALSE(was_locked); |
| 99 | } |
| 100 | |
| 101 | class DeletedMessageHandler : public MessageHandler { |
| 102 | public: |
| 103 | explicit DeletedMessageHandler(bool* deleted) : deleted_(deleted) { } |
Steve Anton | 9de3aac | 2017-10-24 10:08:26 -0700 | [diff] [blame] | 104 | ~DeletedMessageHandler() override { *deleted_ = true; } |
| 105 | void OnMessage(Message* msg) override {} |
| 106 | |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 107 | private: |
| 108 | bool* deleted_; |
| 109 | }; |
| 110 | |
decurtis@webrtc.org | 2af3057 | 2015-02-21 01:59:50 +0000 | [diff] [blame] | 111 | TEST_F(MessageQueueTest, DiposeHandlerWithPostedMessagePending) { |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 112 | bool deleted = false; |
| 113 | DeletedMessageHandler *handler = new DeletedMessageHandler(&deleted); |
| 114 | // First, post a dispose. |
decurtis@webrtc.org | 2af3057 | 2015-02-21 01:59:50 +0000 | [diff] [blame] | 115 | Dispose(handler); |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 116 | // Now, post a message, which should *not* be returned by Get(). |
Taylor Brandstetter | 5d97a9a | 2016-06-10 14:17:27 -0700 | [diff] [blame] | 117 | Post(RTC_FROM_HERE, handler, 1); |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 118 | Message msg; |
decurtis@webrtc.org | 2af3057 | 2015-02-21 01:59:50 +0000 | [diff] [blame] | 119 | EXPECT_FALSE(Get(&msg, 0)); |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 120 | EXPECT_TRUE(deleted); |
| 121 | } |
| 122 | |
| 123 | struct UnwrapMainThreadScope { |
deadbeef | 37f5ecf | 2017-02-27 14:06:41 -0800 | [diff] [blame] | 124 | UnwrapMainThreadScope() : rewrap_(Thread::Current() != nullptr) { |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 125 | if (rewrap_) ThreadManager::Instance()->UnwrapCurrentThread(); |
| 126 | } |
| 127 | ~UnwrapMainThreadScope() { |
| 128 | if (rewrap_) ThreadManager::Instance()->WrapCurrentThread(); |
| 129 | } |
| 130 | private: |
| 131 | bool rewrap_; |
| 132 | }; |
| 133 | |
decurtis@webrtc.org | 2af3057 | 2015-02-21 01:59:50 +0000 | [diff] [blame] | 134 | TEST(MessageQueueManager, Clear) { |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 135 | UnwrapMainThreadScope s; |
| 136 | if (MessageQueueManager::IsInitialized()) { |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 137 | RTC_LOG(LS_INFO) |
| 138 | << "Unable to run MessageQueueManager::Clear test, since the " |
| 139 | << "MessageQueueManager was already initialized by some " |
| 140 | << "other test in this run."; |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 141 | return; |
| 142 | } |
| 143 | bool deleted = false; |
| 144 | DeletedMessageHandler* handler = new DeletedMessageHandler(&deleted); |
| 145 | delete handler; |
| 146 | EXPECT_TRUE(deleted); |
| 147 | EXPECT_FALSE(MessageQueueManager::IsInitialized()); |
| 148 | } |
Taylor Brandstetter | fe7d091 | 2016-09-15 17:47:42 -0700 | [diff] [blame] | 149 | |
| 150 | // Ensure that ProcessAllMessageQueues does its essential function; process |
| 151 | // all messages (both delayed and non delayed) up until the current time, on |
| 152 | // all registered message queues. |
| 153 | TEST(MessageQueueManager, ProcessAllMessageQueues) { |
| 154 | Event entered_process_all_message_queues(true, false); |
tommi | e725159 | 2017-07-14 14:44:46 -0700 | [diff] [blame] | 155 | auto a = Thread::CreateWithSocketServer(); |
| 156 | auto b = Thread::CreateWithSocketServer(); |
| 157 | a->Start(); |
| 158 | b->Start(); |
Taylor Brandstetter | fe7d091 | 2016-09-15 17:47:42 -0700 | [diff] [blame] | 159 | |
| 160 | volatile int messages_processed = 0; |
| 161 | FunctorMessageHandler<void, std::function<void()>> incrementer( |
| 162 | [&messages_processed, &entered_process_all_message_queues] { |
| 163 | // Wait for event as a means to ensure Increment doesn't occur outside |
| 164 | // of ProcessAllMessageQueues. The event is set by a message posted to |
| 165 | // the main thread, which is guaranteed to be handled inside |
| 166 | // ProcessAllMessageQueues. |
| 167 | entered_process_all_message_queues.Wait(Event::kForever); |
| 168 | AtomicOps::Increment(&messages_processed); |
| 169 | }); |
| 170 | FunctorMessageHandler<void, std::function<void()>> event_signaler( |
| 171 | [&entered_process_all_message_queues] { |
| 172 | entered_process_all_message_queues.Set(); |
| 173 | }); |
| 174 | |
| 175 | // Post messages (both delayed and non delayed) to both threads. |
tommi | e725159 | 2017-07-14 14:44:46 -0700 | [diff] [blame] | 176 | a->Post(RTC_FROM_HERE, &incrementer); |
| 177 | b->Post(RTC_FROM_HERE, &incrementer); |
| 178 | a->PostDelayed(RTC_FROM_HERE, 0, &incrementer); |
| 179 | b->PostDelayed(RTC_FROM_HERE, 0, &incrementer); |
Taylor Brandstetter | fe7d091 | 2016-09-15 17:47:42 -0700 | [diff] [blame] | 180 | rtc::Thread::Current()->Post(RTC_FROM_HERE, &event_signaler); |
| 181 | |
| 182 | MessageQueueManager::ProcessAllMessageQueues(); |
| 183 | EXPECT_EQ(4, AtomicOps::AcquireLoad(&messages_processed)); |
| 184 | } |
| 185 | |
| 186 | // Test that ProcessAllMessageQueues doesn't hang if a thread is quitting. |
| 187 | TEST(MessageQueueManager, ProcessAllMessageQueuesWithQuittingThread) { |
tommi | e725159 | 2017-07-14 14:44:46 -0700 | [diff] [blame] | 188 | auto t = Thread::CreateWithSocketServer(); |
| 189 | t->Start(); |
| 190 | t->Quit(); |
Taylor Brandstetter | fe7d091 | 2016-09-15 17:47:42 -0700 | [diff] [blame] | 191 | MessageQueueManager::ProcessAllMessageQueues(); |
| 192 | } |
| 193 | |
| 194 | // Test that ProcessAllMessageQueues doesn't hang if a queue clears its |
| 195 | // messages. |
| 196 | TEST(MessageQueueManager, ProcessAllMessageQueuesWithClearedQueue) { |
| 197 | Event entered_process_all_message_queues(true, false); |
tommi | e725159 | 2017-07-14 14:44:46 -0700 | [diff] [blame] | 198 | auto t = Thread::CreateWithSocketServer(); |
| 199 | t->Start(); |
Taylor Brandstetter | fe7d091 | 2016-09-15 17:47:42 -0700 | [diff] [blame] | 200 | |
| 201 | FunctorMessageHandler<void, std::function<void()>> clearer( |
| 202 | [&entered_process_all_message_queues] { |
| 203 | // Wait for event as a means to ensure Clear doesn't occur outside of |
| 204 | // ProcessAllMessageQueues. The event is set by a message posted to the |
| 205 | // main thread, which is guaranteed to be handled inside |
| 206 | // ProcessAllMessageQueues. |
| 207 | entered_process_all_message_queues.Wait(Event::kForever); |
| 208 | rtc::Thread::Current()->Clear(nullptr); |
| 209 | }); |
| 210 | FunctorMessageHandler<void, std::function<void()>> event_signaler( |
| 211 | [&entered_process_all_message_queues] { |
| 212 | entered_process_all_message_queues.Set(); |
| 213 | }); |
| 214 | |
| 215 | // Post messages (both delayed and non delayed) to both threads. |
tommi | e725159 | 2017-07-14 14:44:46 -0700 | [diff] [blame] | 216 | t->Post(RTC_FROM_HERE, &clearer); |
Taylor Brandstetter | fe7d091 | 2016-09-15 17:47:42 -0700 | [diff] [blame] | 217 | rtc::Thread::Current()->Post(RTC_FROM_HERE, &event_signaler); |
| 218 | MessageQueueManager::ProcessAllMessageQueues(); |
| 219 | } |
jbauch | 5b36173 | 2017-07-06 23:51:37 -0700 | [diff] [blame] | 220 | |
| 221 | class RefCountedHandler |
| 222 | : public MessageHandler, |
| 223 | public rtc::RefCountInterface { |
| 224 | public: |
| 225 | void OnMessage(Message* msg) override {} |
| 226 | }; |
| 227 | |
| 228 | class EmptyHandler : public MessageHandler { |
| 229 | public: |
| 230 | void OnMessage(Message* msg) override {} |
| 231 | }; |
| 232 | |
| 233 | TEST(MessageQueueManager, ClearReentrant) { |
tommi | e725159 | 2017-07-14 14:44:46 -0700 | [diff] [blame] | 234 | std::unique_ptr<Thread> t(Thread::Create()); |
jbauch | 5b36173 | 2017-07-06 23:51:37 -0700 | [diff] [blame] | 235 | EmptyHandler handler; |
| 236 | RefCountedHandler* inner_handler( |
| 237 | new rtc::RefCountedObject<RefCountedHandler>()); |
| 238 | // When the empty handler is destroyed, it will clear messages queued for |
| 239 | // itself. The message to be cleared itself wraps a MessageHandler object |
| 240 | // (RefCountedHandler) so this will cause the message queue to be cleared |
| 241 | // again in a re-entrant fashion, which previously triggered a DCHECK. |
| 242 | // The inner handler will be removed in a re-entrant fashion from the |
| 243 | // message queue of the thread while the outer handler is removed, verifying |
| 244 | // that the iterator is not invalidated in "MessageQueue::Clear". |
tommi | e725159 | 2017-07-14 14:44:46 -0700 | [diff] [blame] | 245 | t->Post(RTC_FROM_HERE, inner_handler, 0); |
| 246 | t->Post(RTC_FROM_HERE, &handler, 0, |
| 247 | new ScopedRefMessageData<RefCountedHandler>(inner_handler)); |
jbauch | 5b36173 | 2017-07-06 23:51:37 -0700 | [diff] [blame] | 248 | } |