diff --git a/pc/channel_unittest.cc b/pc/channel_unittest.cc index d88b70681e..8ce3729f45 100644 --- a/pc/channel_unittest.cc +++ b/pc/channel_unittest.cc @@ -476,11 +476,9 @@ class ChannelTest : public ::testing::Test, public sigslot::has_slots<> { public: template explicit ScopedCallThread(FunctorT&& functor) - : thread_(rtc::Thread::Create()), - task_(new rtc::FunctorMessageHandler( - std::forward(functor))) { + : thread_(rtc::Thread::Create()) { thread_->Start(); - thread_->Post(RTC_FROM_HERE, task_.get()); + thread_->PostTask(RTC_FROM_HERE, std::forward(functor)); } ~ScopedCallThread() { thread_->Stop(); } @@ -489,7 +487,6 @@ class ChannelTest : public ::testing::Test, public sigslot::has_slots<> { private: std::unique_ptr thread_; - std::unique_ptr task_; }; bool CodecMatches(const typename T::Codec& c1, const typename T::Codec& c2) { diff --git a/rtc_base/BUILD.gn b/rtc_base/BUILD.gn index 2b10d1e07c..9ff86ddb39 100644 --- a/rtc_base/BUILD.gn +++ b/rtc_base/BUILD.gn @@ -1234,6 +1234,7 @@ if (rtc_include_tests) { "../test:test_main", "../test:test_support", "memory:unittests", + "task_utils:to_queued_task", "third_party/base64", "third_party/sigslot", "//third_party/abseil-cpp/absl/base:core_headers", @@ -1385,6 +1386,7 @@ if (rtc_include_tests) { "../test:test_support", "memory:fifo_buffer", "synchronization:synchronization_unittests", + "task_utils:to_queued_task", "third_party/sigslot", "//third_party/abseil-cpp/absl/algorithm:container", "//third_party/abseil-cpp/absl/memory", diff --git a/rtc_base/message_handler.h b/rtc_base/message_handler.h index 983659484e..85cb785485 100644 --- a/rtc_base/message_handler.h +++ b/rtc_base/message_handler.h @@ -13,6 +13,7 @@ #include +#include "api/function_view.h" #include "rtc_base/constructor_magic.h" #include "rtc_base/system/rtc_export.h" @@ -21,7 +22,6 @@ namespace rtc { struct Message; // Messages get dispatched to a MessageHandler - class RTC_EXPORT MessageHandler { public: virtual ~MessageHandler(); @@ -34,38 +34,6 @@ class RTC_EXPORT MessageHandler { RTC_DISALLOW_COPY_AND_ASSIGN(MessageHandler); }; -// Helper class to facilitate executing a functor on a thread. -template -class FunctorMessageHandler : public MessageHandler { - public: - explicit FunctorMessageHandler(FunctorT&& functor) - : functor_(std::forward(functor)) {} - virtual void OnMessage(Message* msg) { result_ = functor_(); } - const ReturnT& result() const { return result_; } - - // Returns moved result. Should not call result() or MoveResult() again - // after this. - ReturnT MoveResult() { return std::move(result_); } - - private: - FunctorT functor_; - ReturnT result_; -}; - -// Specialization for ReturnT of void. -template -class FunctorMessageHandler : public MessageHandler { - public: - explicit FunctorMessageHandler(FunctorT&& functor) - : functor_(std::forward(functor)) {} - virtual void OnMessage(Message* msg) { functor_(); } - void result() const {} - void MoveResult() {} - - private: - FunctorT functor_; -}; - } // namespace rtc #endif // RTC_BASE_MESSAGE_HANDLER_H_ diff --git a/rtc_base/message_queue_unittest.cc b/rtc_base/message_queue_unittest.cc index b31ea6c1b2..0c0cfc4b41 100644 --- a/rtc_base/message_queue_unittest.cc +++ b/rtc_base/message_queue_unittest.cc @@ -20,12 +20,15 @@ #include "rtc_base/null_socket_server.h" #include "rtc_base/ref_count.h" #include "rtc_base/ref_counted_object.h" +#include "rtc_base/task_utils/to_queued_task.h" #include "rtc_base/thread.h" #include "rtc_base/time_utils.h" namespace rtc { namespace { +using ::webrtc::ToQueuedTask; + class MessageQueueTest : public ::testing::Test, public MessageQueue { public: MessageQueueTest() : MessageQueue(SocketServer::CreateDefault(), true) {} @@ -132,26 +135,25 @@ TEST(MessageQueueManager, ProcessAllMessageQueues) { b->Start(); volatile int messages_processed = 0; - FunctorMessageHandler> incrementer( - [&messages_processed, &entered_process_all_message_queues] { - // Wait for event as a means to ensure Increment doesn't occur outside - // of ProcessAllMessageQueues. The event is set by a message posted to - // the main thread, which is guaranteed to be handled inside - // ProcessAllMessageQueues. - entered_process_all_message_queues.Wait(Event::kForever); - AtomicOps::Increment(&messages_processed); - }); - FunctorMessageHandler> event_signaler( - [&entered_process_all_message_queues] { - entered_process_all_message_queues.Set(); - }); + auto incrementer = [&messages_processed, + &entered_process_all_message_queues] { + // Wait for event as a means to ensure Increment doesn't occur outside + // of ProcessAllMessageQueues. The event is set by a message posted to + // the main thread, which is guaranteed to be handled inside + // ProcessAllMessageQueues. + entered_process_all_message_queues.Wait(Event::kForever); + AtomicOps::Increment(&messages_processed); + }; + auto event_signaler = [&entered_process_all_message_queues] { + entered_process_all_message_queues.Set(); + }; // Post messages (both delayed and non delayed) to both threads. - a->Post(RTC_FROM_HERE, &incrementer); - b->Post(RTC_FROM_HERE, &incrementer); - a->PostDelayed(RTC_FROM_HERE, 0, &incrementer); - b->PostDelayed(RTC_FROM_HERE, 0, &incrementer); - rtc::Thread::Current()->Post(RTC_FROM_HERE, &event_signaler); + a->PostTask(ToQueuedTask(incrementer)); + b->PostTask(ToQueuedTask(incrementer)); + a->PostDelayedTask(ToQueuedTask(incrementer), 0); + b->PostDelayedTask(ToQueuedTask(incrementer), 0); + rtc::Thread::Current()->PostTask(ToQueuedTask(event_signaler)); MessageQueueManager::ProcessAllMessageQueuesForTesting(); EXPECT_EQ(4, AtomicOps::AcquireLoad(&messages_processed)); @@ -172,23 +174,21 @@ TEST(MessageQueueManager, ProcessAllMessageQueuesWithClearedQueue) { auto t = Thread::CreateWithSocketServer(); t->Start(); - FunctorMessageHandler> clearer( - [&entered_process_all_message_queues] { - // Wait for event as a means to ensure Clear doesn't occur outside of - // ProcessAllMessageQueues. The event is set by a message posted to the - // main thread, which is guaranteed to be handled inside - // ProcessAllMessageQueues. - entered_process_all_message_queues.Wait(Event::kForever); - rtc::Thread::Current()->Clear(nullptr); - }); - FunctorMessageHandler> event_signaler( - [&entered_process_all_message_queues] { - entered_process_all_message_queues.Set(); - }); + auto clearer = [&entered_process_all_message_queues] { + // Wait for event as a means to ensure Clear doesn't occur outside of + // ProcessAllMessageQueues. The event is set by a message posted to the + // main thread, which is guaranteed to be handled inside + // ProcessAllMessageQueues. + entered_process_all_message_queues.Wait(Event::kForever); + rtc::Thread::Current()->Clear(nullptr); + }; + auto event_signaler = [&entered_process_all_message_queues] { + entered_process_all_message_queues.Set(); + }; // Post messages (both delayed and non delayed) to both threads. - t->Post(RTC_FROM_HERE, &clearer); - rtc::Thread::Current()->Post(RTC_FROM_HERE, &event_signaler); + t->PostTask(RTC_FROM_HERE, clearer); + rtc::Thread::Current()->PostTask(RTC_FROM_HERE, event_signaler); MessageQueueManager::ProcessAllMessageQueuesForTesting(); } diff --git a/rtc_base/time_utils_unittest.cc b/rtc_base/time_utils_unittest.cc index aeb9daf881..824c2c056b 100644 --- a/rtc_base/time_utils_unittest.cc +++ b/rtc_base/time_utils_unittest.cc @@ -18,6 +18,7 @@ #include "rtc_base/helpers.h" #include "rtc_base/location.h" #include "rtc_base/message_handler.h" +#include "rtc_base/task_utils/to_queued_task.h" #include "rtc_base/thread.h" #include "test/gtest.h" @@ -269,11 +270,10 @@ TEST(FakeClock, SettingTimeWakesThreads) { // Post an event that won't be executed for 10 seconds. Event message_handler_dispatched; - auto functor = [&message_handler_dispatched] { - message_handler_dispatched.Set(); - }; - FunctorMessageHandler handler(std::move(functor)); - worker->PostDelayed(RTC_FROM_HERE, 60000, &handler); + worker->PostDelayedTask(webrtc::ToQueuedTask([&message_handler_dispatched] { + message_handler_dispatched.Set(); + }), + /*milliseconds=*/60000); // Wait for a bit for the worker thread to be started and enter its socket // select(). Otherwise this test would be trivial since the worker thread