From 4cd3a0d082d0b9d44fd78eef3d53d4360e99a674 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bj=C3=B6rn=20Terelius?= Date: Thu, 9 Jun 2022 15:27:53 +0000 Subject: [PATCH] Revert "TaskQueue: unexpose delayed task convenience methods." MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit This reverts commit 08bb6295ea1f438a26f8c1ab01769cfa63943756. Reason for revert: Breaks downstream tests Original change's description: > TaskQueue: unexpose delayed task convenience methods. > > Bug: webrtc:14165 > Change-Id: Ieb8580670e9e521580afd68cca6ff631fb6df3f8 > Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/265400 > Reviewed-by: Harald Alvestrand > Auto-Submit: Markus Handell > Commit-Queue: Harald Alvestrand > Cr-Commit-Position: refs/heads/main@{#37166} Bug: webrtc:14165 Change-Id: Ia7368cf205622be448ec0ead5d22f211aa071a29 No-Presubmit: true No-Tree-Checks: true No-Try: true Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/265411 Bot-Commit: rubber-stamper@appspot.gserviceaccount.com Owners-Override: Björn Terelius Auto-Submit: Björn Terelius Commit-Queue: Björn Terelius Cr-Commit-Position: refs/heads/main@{#37167} --- common_video/incoming_video_stream.cc | 4 +-- logging/rtc_event_log/rtc_event_log_impl.cc | 2 +- modules/audio_device/audio_device_buffer.cc | 4 +-- modules/pacing/task_queue_paced_sender.cc | 5 ++-- rtc_base/task_queue.h | 28 +++++++++++++++++++ rtc_base/task_queue_unittest.cc | 4 +-- test/fake_decoder.cc | 11 ++++---- test/pc/e2e/test_activities_executor.cc | 7 ++--- test/scenario/scenario.cc | 3 +- .../simulated_time_controller_unittest.cc | 3 +- video/video_send_stream_impl_unittest.cc | 8 +++--- 11 files changed, 50 insertions(+), 29 deletions(-) diff --git a/common_video/incoming_video_stream.cc b/common_video/incoming_video_stream.cc index 6279f8330d..1511c9f30c 100644 --- a/common_video/incoming_video_stream.cc +++ b/common_video/incoming_video_stream.cc @@ -57,8 +57,8 @@ void IncomingVideoStream::Dequeue() { if (render_buffers_.HasPendingFrames()) { uint32_t wait_time = render_buffers_.TimeToNextFrameRelease(); - incoming_render_queue_.PostDelayedHighPrecisionTask( - ToQueuedTask([this]() { Dequeue(); }), wait_time); + incoming_render_queue_.PostDelayedHighPrecisionTask([this]() { Dequeue(); }, + wait_time); } } diff --git a/logging/rtc_event_log/rtc_event_log_impl.cc b/logging/rtc_event_log/rtc_event_log_impl.cc index c45352b67b..0766b4a884 100644 --- a/logging/rtc_event_log/rtc_event_log_impl.cc +++ b/logging/rtc_event_log/rtc_event_log_impl.cc @@ -181,7 +181,7 @@ void RtcEventLogImpl::ScheduleOutput() { const int64_t time_since_output_ms = now_ms - last_output_ms_; const uint32_t delay = rtc::SafeClamp( *output_period_ms_ - time_since_output_ms, 0, *output_period_ms_); - task_queue_->PostDelayedTask(ToQueuedTask(std::move(output_task)), delay); + task_queue_->PostDelayedTask(output_task, delay); } } diff --git a/modules/audio_device/audio_device_buffer.cc b/modules/audio_device/audio_device_buffer.cc index c7c31b7667..873e5d6088 100644 --- a/modules/audio_device/audio_device_buffer.cc +++ b/modules/audio_device/audio_device_buffer.cc @@ -477,9 +477,7 @@ void AudioDeviceBuffer::LogStats(LogState state) { // Keep posting new (delayed) tasks until state is changed to kLogStop. task_queue_.PostDelayedTask( - ToQueuedTask([this] { - AudioDeviceBuffer::LogStats(AudioDeviceBuffer::LOG_ACTIVE); - }), + [this] { AudioDeviceBuffer::LogStats(AudioDeviceBuffer::LOG_ACTIVE); }, time_to_wait_ms); } diff --git a/modules/pacing/task_queue_paced_sender.cc b/modules/pacing/task_queue_paced_sender.cc index ebb67ac014..43c4c965e4 100644 --- a/modules/pacing/task_queue_paced_sender.cc +++ b/modules/pacing/task_queue_paced_sender.cc @@ -317,9 +317,8 @@ void TaskQueuePacedSender::MaybeProcessPackets( } task_queue_.PostDelayedTaskWithPrecision( - precision, ToQueuedTask([this, next_send_time]() { - MaybeProcessPackets(next_send_time); - }), + precision, + [this, next_send_time]() { MaybeProcessPackets(next_send_time); }, time_to_next_process.RoundUpTo(TimeDelta::Millis(1)).ms()); next_process_time_ = next_send_time; } diff --git a/rtc_base/task_queue.h b/rtc_base/task_queue.h index fe381b993e..ef97646988 100644 --- a/rtc_base/task_queue.h +++ b/rtc_base/task_queue.h @@ -115,6 +115,34 @@ class RTC_LOCKABLE RTC_EXPORT TaskQueue { void PostTask(Closure&& closure) { PostTask(webrtc::ToQueuedTask(std::forward(closure))); } + template >::value>::type* = nullptr> + void PostDelayedTask(Closure&& closure, uint32_t milliseconds) { + PostDelayedTask(webrtc::ToQueuedTask(std::forward(closure)), + milliseconds); + } + template >::value>::type* = nullptr> + void PostDelayedHighPrecisionTask(Closure&& closure, uint32_t milliseconds) { + PostDelayedHighPrecisionTask( + webrtc::ToQueuedTask(std::forward(closure)), milliseconds); + } + template >::value>::type* = nullptr> + void PostDelayedTaskWithPrecision( + webrtc::TaskQueueBase::DelayPrecision precision, + Closure&& closure, + uint32_t milliseconds) { + PostDelayedTaskWithPrecision( + precision, webrtc::ToQueuedTask(std::forward(closure)), + milliseconds); + } private: webrtc::TaskQueueBase* const impl_; diff --git a/rtc_base/task_queue_unittest.cc b/rtc_base/task_queue_unittest.cc index bd07a408a6..0c79858630 100644 --- a/rtc_base/task_queue_unittest.cc +++ b/rtc_base/task_queue_unittest.cc @@ -66,9 +66,7 @@ TEST(TaskQueueTest, DISABLED_PostDelayedHighRes) { webrtc::TaskQueueForTest queue(kQueueName, TaskQueue::Priority::HIGH); uint32_t start = Time(); - queue.PostDelayedTask( - webrtc::ToQueuedTask([&event, &queue] { CheckCurrent(&event, &queue); }), - 3); + queue.PostDelayedTask([&event, &queue] { CheckCurrent(&event, &queue); }, 3); EXPECT_TRUE(event.Wait(1000)); uint32_t end = TimeMillis(); // These tests are a little relaxed due to how "powerful" our test bots can diff --git a/test/fake_decoder.cc b/test/fake_decoder.cc index 6fa6596953..72783bcd0c 100644 --- a/test/fake_decoder.cc +++ b/test/fake_decoder.cc @@ -61,11 +61,12 @@ int32_t FakeDecoder::Decode(const EncodedImage& input, if (decode_delay_ms_ == 0 || !task_queue_) { callback_->Decoded(frame); } else { - task_queue_->PostDelayedHighPrecisionTask(ToQueuedTask([frame, this]() { - VideoFrame copy = frame; - callback_->Decoded(copy); - }), - decode_delay_ms_); + task_queue_->PostDelayedHighPrecisionTask( + [frame, this]() { + VideoFrame copy = frame; + callback_->Decoded(copy); + }, + decode_delay_ms_); } return WEBRTC_VIDEO_CODEC_OK; diff --git a/test/pc/e2e/test_activities_executor.cc b/test/pc/e2e/test_activities_executor.cc index 4454695ce6..68f6760bba 100644 --- a/test/pc/e2e/test_activities_executor.cc +++ b/test/pc/e2e/test_activities_executor.cc @@ -103,10 +103,9 @@ void TestActivitiesExecutor::PostActivity(ScheduledActivity activity) { return; } - task_queue_->PostDelayedTask(ToQueuedTask([activity, start_time, this]() { - activity.func(Now() - start_time); - }), - remaining_delay.ms()); + task_queue_->PostDelayedTask( + [activity, start_time, this]() { activity.func(Now() - start_time); }, + remaining_delay.ms()); } Timestamp TestActivitiesExecutor::Now() const { diff --git a/test/scenario/scenario.cc b/test/scenario/scenario.cc index 3c3a106cd2..239aad9dfe 100644 --- a/test/scenario/scenario.cc +++ b/test/scenario/scenario.cc @@ -266,8 +266,7 @@ void Scenario::Post(std::function function) { void Scenario::At(TimeDelta offset, std::function function) { RTC_DCHECK_GT(offset, TimeSinceStart()); - task_queue_.PostDelayedTask(ToQueuedTask(std::move(function)), - TimeUntilTarget(offset).ms()); + task_queue_.PostDelayedTask(function, TimeUntilTarget(offset).ms()); } void Scenario::RunFor(TimeDelta duration) { diff --git a/test/time_controller/simulated_time_controller_unittest.cc b/test/time_controller/simulated_time_controller_unittest.cc index dd5774078c..51bdf0fd08 100644 --- a/test/time_controller/simulated_time_controller_unittest.cc +++ b/test/time_controller/simulated_time_controller_unittest.cc @@ -120,8 +120,7 @@ TEST(SimulatedTimeControllerTest, DelayTaskRunOnTime) { "TestQueue", TaskQueueFactory::Priority::NORMAL)); bool delay_task_executed = false; - task_queue.PostDelayedTask(ToQueuedTask([&] { delay_task_executed = true; }), - 10); + task_queue.PostDelayedTask([&] { delay_task_executed = true; }, 10); time_simulation.AdvanceTime(TimeDelta::Millis(10)); EXPECT_TRUE(delay_task_executed); diff --git a/video/video_send_stream_impl_unittest.cc b/video/video_send_stream_impl_unittest.cc index 4e4eba9743..e639aaf8cf 100644 --- a/video/video_send_stream_impl_unittest.cc +++ b/video/video_send_stream_impl_unittest.cc @@ -867,13 +867,13 @@ TEST_F(VideoSendStreamImplTest, DisablesPaddingOnPausedEncoder) { rtc::Event done; test_queue_.PostDelayedTask( - ToQueuedTask([&] { + [&] { // No padding supposed to be sent for paused observer EXPECT_EQ(0, padding_bitrate); testing::Mock::VerifyAndClearExpectations(&bitrate_allocator_); vss_impl->Stop(); done.Set(); - }), + }, 5000); // Pause the test suite so that the last delayed task executes. @@ -905,11 +905,11 @@ TEST_F(VideoSendStreamImplTest, KeepAliveOnDroppedFrame) { rtc::Event done; test_queue_.PostDelayedTask( - ToQueuedTask([&] { + [&] { testing::Mock::VerifyAndClearExpectations(&bitrate_allocator_); vss_impl->Stop(); done.Set(); - }), + }, 2000); ASSERT_TRUE(done.Wait(5000)); }