Reland "TaskQueue: unexpose delayed task convenience methods."

This reverts commit 4cd3a0d082d0b9d44fd78eef3d53d4360e99a674.

Reason for revert: Downstream build should be fixed.

Original change's description:
> Revert "TaskQueue: unexpose delayed task convenience methods."
>
> 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 <hta@webrtc.org>
> > Auto-Submit: Markus Handell <handellm@webrtc.org>
> > Commit-Queue: Harald Alvestrand <hta@webrtc.org>
> > 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 <rubber-stamper@appspot.gserviceaccount.com>
> Owners-Override: Björn Terelius <terelius@webrtc.org>
> Auto-Submit: Björn Terelius <terelius@webrtc.org>
> Commit-Queue: Björn Terelius <terelius@webrtc.org>
> Cr-Commit-Position: refs/heads/main@{#37167}

Bug: webrtc:14165
Change-Id: I3d963d272e8a1431103a5d5fb4568ccacd81119c
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/265395
Bot-Commit: rubber-stamper@appspot.gserviceaccount.com <rubber-stamper@appspot.gserviceaccount.com>
Reviewed-by: Harald Alvestrand <hta@webrtc.org>
Commit-Queue: Markus Handell <handellm@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#37186}

11 files changed, 29 insertions, 50 deletions

diff --git a/common_video/incoming_video_stream.cc b/common_video/incoming_video_stream.cc
index 1511c9f30c..6279f8330d 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([this]() { Dequeue(); },
-                                                        wait_time);
+    incoming_render_queue_.PostDelayedHighPrecisionTask(
+        ToQueuedTask([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 0766b4a884..c45352b67b 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(output_task, delay);
+    task_queue_->PostDelayedTask(ToQueuedTask(std::move(output_task)), delay);
   }
 }
 
diff --git a/modules/audio_device/audio_device_buffer.cc b/modules/audio_device/audio_device_buffer.cc
index 873e5d6088..c7c31b7667 100644
--- a/modules/audio_device/audio_device_buffer.cc
+++ b/modules/audio_device/audio_device_buffer.cc
@@ -477,7 +477,9 @@ void AudioDeviceBuffer::LogStats(LogState state) {
 
   // Keep posting new (delayed) tasks until state is changed to kLogStop.
   task_queue_.PostDelayedTask(
-      [this] { AudioDeviceBuffer::LogStats(AudioDeviceBuffer::LOG_ACTIVE); },
+      ToQueuedTask([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 43c4c965e4..ebb67ac014 100644
--- a/modules/pacing/task_queue_paced_sender.cc
+++ b/modules/pacing/task_queue_paced_sender.cc
@@ -317,8 +317,9 @@ void TaskQueuePacedSender::MaybeProcessPackets(
     }
 
     task_queue_.PostDelayedTaskWithPrecision(
-        precision,
-        [this, next_send_time]() { MaybeProcessPackets(next_send_time); },
+        precision, ToQueuedTask([this, next_send_time]() {
+          MaybeProcessPackets(next_send_time);
+        }),
         time_to_next_process.RoundUpTo(TimeDelta::Millis(1)).ms<uint32_t>());
     next_process_time_ = next_send_time;
   }
diff --git a/rtc_base/task_queue.h b/rtc_base/task_queue.h
index ef97646988..fe381b993e 100644
--- a/rtc_base/task_queue.h
+++ b/rtc_base/task_queue.h
@@ -115,34 +115,6 @@ class RTC_LOCKABLE RTC_EXPORT TaskQueue {
   void PostTask(Closure&& closure) {
     PostTask(webrtc::ToQueuedTask(std::forward<Closure>(closure)));
   }
-  template <class Closure,
-            typename std::enable_if<!std::is_convertible<
-                Closure,
-                std::unique_ptr<webrtc::QueuedTask>>::value>::type* = nullptr>
-  void PostDelayedTask(Closure&& closure, uint32_t milliseconds) {
-    PostDelayedTask(webrtc::ToQueuedTask(std::forward<Closure>(closure)),
-                    milliseconds);
-  }
-  template <class Closure,
-            typename std::enable_if<!std::is_convertible<
-                Closure,
-                std::unique_ptr<webrtc::QueuedTask>>::value>::type* = nullptr>
-  void PostDelayedHighPrecisionTask(Closure&& closure, uint32_t milliseconds) {
-    PostDelayedHighPrecisionTask(
-        webrtc::ToQueuedTask(std::forward<Closure>(closure)), milliseconds);
-  }
-  template <class Closure,
-            typename std::enable_if<!std::is_convertible<
-                Closure,
-                std::unique_ptr<webrtc::QueuedTask>>::value>::type* = nullptr>
-  void PostDelayedTaskWithPrecision(
-      webrtc::TaskQueueBase::DelayPrecision precision,
-      Closure&& closure,
-      uint32_t milliseconds) {
-    PostDelayedTaskWithPrecision(
-        precision, webrtc::ToQueuedTask(std::forward<Closure>(closure)),
-        milliseconds);
-  }
 
  private:
   webrtc::TaskQueueBase* const impl_;
diff --git a/rtc_base/task_queue_unittest.cc b/rtc_base/task_queue_unittest.cc
index 0c79858630..bd07a408a6 100644
--- a/rtc_base/task_queue_unittest.cc
+++ b/rtc_base/task_queue_unittest.cc
@@ -66,7 +66,9 @@ TEST(TaskQueueTest, DISABLED_PostDelayedHighRes) {
   webrtc::TaskQueueForTest queue(kQueueName, TaskQueue::Priority::HIGH);
 
   uint32_t start = Time();
-  queue.PostDelayedTask([&event, &queue] { CheckCurrent(&event, &queue); }, 3);
+  queue.PostDelayedTask(
+      webrtc::ToQueuedTask([&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 72783bcd0c..6fa6596953 100644
--- a/test/fake_decoder.cc
+++ b/test/fake_decoder.cc
@@ -61,12 +61,11 @@ int32_t FakeDecoder::Decode(const EncodedImage& input,
   if (decode_delay_ms_ == 0 || !task_queue_) {
     callback_->Decoded(frame);
   } else {
-    task_queue_->PostDelayedHighPrecisionTask(
-        [frame, this]() {
-          VideoFrame copy = frame;
-          callback_->Decoded(copy);
-        },
-        decode_delay_ms_);
+    task_queue_->PostDelayedHighPrecisionTask(ToQueuedTask([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 68f6760bba..4454695ce6 100644
--- a/test/pc/e2e/test_activities_executor.cc
+++ b/test/pc/e2e/test_activities_executor.cc
@@ -103,9 +103,10 @@ void TestActivitiesExecutor::PostActivity(ScheduledActivity activity) {
     return;
   }
 
-  task_queue_->PostDelayedTask(
-      [activity, start_time, this]() { activity.func(Now() - start_time); },
-      remaining_delay.ms());
+  task_queue_->PostDelayedTask(ToQueuedTask([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 239aad9dfe..3c3a106cd2 100644
--- a/test/scenario/scenario.cc
+++ b/test/scenario/scenario.cc
@@ -266,7 +266,8 @@ void Scenario::Post(std::function<void()> function) {
 
 void Scenario::At(TimeDelta offset, std::function<void()> function) {
   RTC_DCHECK_GT(offset, TimeSinceStart());
-  task_queue_.PostDelayedTask(function, TimeUntilTarget(offset).ms());
+  task_queue_.PostDelayedTask(ToQueuedTask(std::move(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 51bdf0fd08..dd5774078c 100644
--- a/test/time_controller/simulated_time_controller_unittest.cc
+++ b/test/time_controller/simulated_time_controller_unittest.cc
@@ -120,7 +120,8 @@ TEST(SimulatedTimeControllerTest, DelayTaskRunOnTime) {
           "TestQueue", TaskQueueFactory::Priority::NORMAL));
 
   bool delay_task_executed = false;
-  task_queue.PostDelayedTask([&] { delay_task_executed = true; }, 10);
+  task_queue.PostDelayedTask(ToQueuedTask([&] { 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 e639aaf8cf..4e4eba9743 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));
 }