Google Git
Sign in
webrtc/src/7e3a9ce99d^!/.
commit
7e3a9ce99d832687d1eef3eaa270754970a761b0
[log]
author
Danil Chapovalov <danilchap@webrtc.org>
Fri May 08 12:09:35 2026
committer
webrtc-scoped@luci-project-accounts.iam.gserviceaccount.com <webrtc-scoped@luci-project-accounts.iam.gserviceaccount.com>
Fri May 08 13:43:10 2026
tree
b43d5985a6a36a0df522060c846ecb1581349aea
parent
5ab65fdd4d3f7de5510524ba810c0c49dd16b2aa [diff]
Rely on TaskQueueBase interface in modules/rtp_rtcp

Instead of requiring Thread to be passed to the
RtpVideoStreamReceiverFrameTransformerDelegate. This class already uses
it only though the TaskQueueBase interface.

In tests rely on RunLoop helper when test makes calls that are required
to be done on the same task queue, and rely on TaskQueueForTests where
test does not make such calls.

Bug: webrtc:42225410
Change-Id: I7aba5c696436d8ce43c85ccba5b9448e852ea81d
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/470880
Auto-Submit: Danil Chapovalov <danilchap@webrtc.org>
Commit-Queue: Erik Språng <sprang@webrtc.org>
Reviewed-by: Erik Språng <sprang@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#47662}

diff --git a/modules/rtp_rtcp/BUILD.gn b/modules/rtp_rtcp/BUILD.gn
index 5a96a14..e911269 100644
--- a/modules/rtp_rtcp/BUILD.gn
+++ b/modules/rtp_rtcp/BUILD.gn

@@ -335,7 +335,6 @@
     "../../rtc_base:rtp_to_ntp_estimator",
     "../../rtc_base:safe_conversions",
     "../../rtc_base:safe_minmax",
-    "../../rtc_base:threading",
     "../../rtc_base:timeutils",
     "../../rtc_base/containers:flat_map",
     "../../rtc_base/experiments:field_trial_parser",

diff --git a/modules/rtp_rtcp/source/rtp_video_stream_receiver_frame_transformer_delegate.cc b/modules/rtp_rtcp/source/rtp_video_stream_receiver_frame_transformer_delegate.cc
index 8950ec4..8bb3561 100644
--- a/modules/rtp_rtcp/source/rtp_video_stream_receiver_frame_transformer_delegate.cc
+++ b/modules/rtp_rtcp/source/rtp_video_stream_receiver_frame_transformer_delegate.cc

@@ -23,6 +23,7 @@
 #include "api/rtp_packet_infos.h"
 #include "api/scoped_refptr.h"
 #include "api/sequence_checker.h"
+#include "api/task_queue/task_queue_base.h"
 #include "api/units/time_delta.h"
 #include "api/units/timestamp.h"
 #include "api/video/encoded_image.h"
@@ -32,7 +33,6 @@
 #include "modules/rtp_rtcp/source/frame_object.h"
 #include "modules/rtp_rtcp/source/rtp_video_header.h"
 #include "rtc_base/checks.h"
-#include "rtc_base/thread.h"
 #include "system_wrappers/include/clock.h"
 #include "system_wrappers/include/ntp_time.h"
 
@@ -135,11 +135,11 @@
         RtpVideoFrameReceiver* receiver,
         Clock* clock,
         scoped_refptr<FrameTransformerInterface> frame_transformer,
-        Thread* network_thread,
+        TaskQueueBase* task_queue,
         uint32_t ssrc)
     : receiver_(receiver),
       frame_transformer_(std::move(frame_transformer)),
-      network_thread_(network_thread),
+      network_thread_(task_queue),
       ssrc_(ssrc),
       clock_(clock) {}
 

diff --git a/modules/rtp_rtcp/source/rtp_video_stream_receiver_frame_transformer_delegate.h b/modules/rtp_rtcp/source/rtp_video_stream_receiver_frame_transformer_delegate.h
index fa6ccf8..10405ad 100644
--- a/modules/rtp_rtcp/source/rtp_video_stream_receiver_frame_transformer_delegate.h
+++ b/modules/rtp_rtcp/source/rtp_video_stream_receiver_frame_transformer_delegate.h

@@ -20,7 +20,6 @@
 #include "api/task_queue/task_queue_base.h"
 #include "modules/rtp_rtcp/source/frame_object.h"
 #include "rtc_base/system/no_unique_address.h"
-#include "rtc_base/thread.h"
 #include "rtc_base/thread_annotations.h"
 #include "system_wrappers/include/clock.h"
 
@@ -37,7 +36,7 @@
 };
 
 // Delegates calls to FrameTransformerInterface to transform frames, and to
-// RtpVideoStreamReceiver to manage transformed frames on the `network_thread_`.
+// RtpVideoStreamReceiver to manage transformed frames on the `task_queue`.
 class RtpVideoStreamReceiverFrameTransformerDelegate
     : public TransformedFrameCallback {
  public:
@@ -45,7 +44,7 @@
       RtpVideoFrameReceiver* receiver,
       Clock* clock,
       scoped_refptr<FrameTransformerInterface> frame_transformer,
-      Thread* network_thread,
+      TaskQueueBase* task_queue,
       uint32_t ssrc);
 
   void Init();

diff --git a/modules/rtp_rtcp/source/rtp_video_stream_receiver_frame_transformer_delegate_unittest.cc b/modules/rtp_rtcp/source/rtp_video_stream_receiver_frame_transformer_delegate_unittest.cc
index c7cf59e..7e63a84 100644
--- a/modules/rtp_rtcp/source/rtp_video_stream_receiver_frame_transformer_delegate_unittest.cc
+++ b/modules/rtp_rtcp/source/rtp_video_stream_receiver_frame_transformer_delegate_unittest.cc

@@ -38,7 +38,7 @@
 #include "modules/rtp_rtcp/source/frame_object.h"
 #include "modules/rtp_rtcp/source/rtp_video_header.h"
 #include "modules/video_coding/codecs/vp8/include/vp8_globals.h"
-#include "rtc_base/thread.h"
+#include "rtc_base/task_queue_for_test.h"
 #include "system_wrappers/include/clock.h"
 #include "system_wrappers/include/ntp_time.h"
 #include "test/gmock.h"
@@ -48,6 +48,7 @@
 namespace webrtc {
 namespace {
 
+using ::testing::_;
 using ::testing::ElementsAre;
 using ::testing::NiceMock;
 using ::testing::NotNull;
@@ -91,39 +92,41 @@
 TEST(RtpVideoStreamReceiverFrameTransformerDelegateTest,
      RegisterTransformedFrameCallbackSinkOnInit) {
   TestRtpVideoFrameReceiver receiver;
-  auto frame_transformer(make_ref_counted<MockFrameTransformer>());
+  auto frame_transformer = make_ref_counted<MockFrameTransformer>();
   SimulatedClock clock(0);
-  auto delegate(
+  TaskQueueForTest task_queue;
+  auto delegate =
       make_ref_counted<RtpVideoStreamReceiverFrameTransformerDelegate>(
-          &receiver, &clock, frame_transformer, Thread::Current(),
-          /*remote_ssrc*/ 1111));
+          &receiver, &clock, frame_transformer, task_queue.Get(),
+          /*remote_ssrc*/ 1111);
   EXPECT_CALL(*frame_transformer,
-              RegisterTransformedFrameSinkCallback(testing::_, 1111));
+              RegisterTransformedFrameSinkCallback(_, 1111));
   delegate->Init();
 }
 
 TEST(RtpVideoStreamReceiverFrameTransformerDelegateTest,
      UnregisterTransformedFrameSinkCallbackOnReset) {
   TestRtpVideoFrameReceiver receiver;
-  auto frame_transformer(make_ref_counted<MockFrameTransformer>());
+  auto frame_transformer = make_ref_counted<MockFrameTransformer>();
   SimulatedClock clock(0);
-  auto delegate(
+  TaskQueueForTest task_queue;
+  auto delegate =
       make_ref_counted<RtpVideoStreamReceiverFrameTransformerDelegate>(
-          &receiver, &clock, frame_transformer, Thread::Current(),
-          /*remote_ssrc*/ 1111));
+          &receiver, &clock, frame_transformer, task_queue.Get(),
+          /*remote_ssrc*/ 1111);
   EXPECT_CALL(*frame_transformer, UnregisterTransformedFrameSinkCallback(1111));
   delegate->Reset();
 }
 
 TEST(RtpVideoStreamReceiverFrameTransformerDelegateTest, TransformFrame) {
   TestRtpVideoFrameReceiver receiver;
-  auto frame_transformer(
-      make_ref_counted<testing::NiceMock<MockFrameTransformer>>());
+  auto frame_transformer = make_ref_counted<NiceMock<MockFrameTransformer>>();
   SimulatedClock clock(0);
-  auto delegate(
+  TaskQueueForTest task_queue;
+  auto delegate =
       make_ref_counted<RtpVideoStreamReceiverFrameTransformerDelegate>(
-          &receiver, &clock, frame_transformer, Thread::Current(),
-          /*remote_ssrc*/ 1111));
+          &receiver, &clock, frame_transformer, task_queue.Get(),
+          /*remote_ssrc*/ 1111);
   auto frame = CreateRtpFrameObject();
   EXPECT_CALL(*frame_transformer, Transform);
   delegate->TransformFrame(std::move(frame));
@@ -131,15 +134,15 @@
 
 TEST(RtpVideoStreamReceiverFrameTransformerDelegateTest,
      ManageFrameOnTransformedFrame) {
-  test::RunLoop main_thread_;
+  test::RunLoop main_thread;
   TestRtpVideoFrameReceiver receiver;
-  auto mock_frame_transformer(
-      make_ref_counted<NiceMock<MockFrameTransformer>>());
+  auto mock_frame_transformer =
+      make_ref_counted<NiceMock<MockFrameTransformer>>();
   SimulatedClock clock(0);
   std::vector<uint32_t> csrcs = {234, 345, 456};
   auto delegate =
       make_ref_counted<RtpVideoStreamReceiverFrameTransformerDelegate>(
-          &receiver, &clock, mock_frame_transformer, Thread::Current(),
+          &receiver, &clock, mock_frame_transformer, main_thread.task_queue(),
           /*remote_ssrc*/ 1111);
 
   scoped_refptr<TransformedFrameCallback> callback;
@@ -161,18 +164,19 @@
             callback->OnTransformedFrame(std::move(frame));
           });
   delegate->TransformFrame(CreateRtpFrameObject(RTPVideoHeader(), csrcs));
-  ThreadManager::ProcessAllMessageQueuesForTesting();
+  main_thread.Flush();
 }
 
 TEST(RtpVideoStreamReceiverFrameTransformerDelegateTest,
      TransformableFrameMetadataHasCorrectValue) {
+  TaskQueueForTest task_queue;
   TestRtpVideoFrameReceiver receiver;
   auto mock_frame_transformer =
       make_ref_counted<NiceMock<MockFrameTransformer>>();
   SimulatedClock clock(0);
   auto delegate =
       make_ref_counted<RtpVideoStreamReceiverFrameTransformerDelegate>(
-          &receiver, &clock, mock_frame_transformer, Thread::Current(), 1111);
+          &receiver, &clock, mock_frame_transformer, task_queue.Get(), 1111);
   delegate->Init();
   RTPVideoHeader video_header;
   video_header.width = 1280u;
@@ -227,13 +231,14 @@
 
 TEST(RtpVideoStreamReceiverFrameTransformerDelegateTest,
      TransformableFrameWithNegativeSenderCaptureTimeOffsetIsCorrect) {
+  TaskQueueForTest task_queue;
   TestRtpVideoFrameReceiver receiver;
   auto mock_frame_transformer =
       make_ref_counted<NiceMock<MockFrameTransformer>>();
   SimulatedClock clock(0);
   auto delegate =
       make_ref_counted<RtpVideoStreamReceiverFrameTransformerDelegate>(
-          &receiver, &clock, mock_frame_transformer, Thread::Current(), 1111);
+          &receiver, &clock, mock_frame_transformer, task_queue.Get(), 1111);
   delegate->Init();
   RTPVideoHeader video_header;
   Timestamp capture_time = Timestamp::Millis(1234);
@@ -267,7 +272,8 @@
   SimulatedClock clock(1000);
   auto delegate =
       make_ref_counted<RtpVideoStreamReceiverFrameTransformerDelegate>(
-          &receiver, &clock, mock_frame_transformer, Thread::Current(), 1111);
+          &receiver, &clock, mock_frame_transformer, main_thread.task_queue(),
+          1111);
 
   scoped_refptr<TransformedFrameCallback> callback;
   EXPECT_CALL(*mock_frame_transformer, RegisterTransformedFrameSinkCallback)
@@ -318,19 +324,19 @@
 
   // The delegate creates a transformable frame from the RtpFrameObject.
   delegate->TransformFrame(CreateRtpFrameObject(video_header, csrcs));
-  ThreadManager::ProcessAllMessageQueuesForTesting();
+  main_thread.Flush();
 }
 
 TEST(RtpVideoStreamReceiverFrameTransformerDelegateTest,
      SenderFramesAreConvertedToReceiverFrames) {
-  test::RunLoop main_thread_;
+  test::RunLoop main_thread;
   TestRtpVideoFrameReceiver receiver;
   auto mock_frame_transformer =
       make_ref_counted<NiceMock<MockFrameTransformer>>();
   SimulatedClock clock(/*initial_time_us=*/12345000);
   auto delegate =
       make_ref_counted<RtpVideoStreamReceiverFrameTransformerDelegate>(
-          &receiver, &clock, mock_frame_transformer, Thread::Current(),
+          &receiver, &clock, mock_frame_transformer, main_thread.task_queue(),
           /*remote_ssrc*/ 1111);
 
   auto mock_sender_frame =
@@ -358,12 +364,12 @@
         EXPECT_EQ(frame->ReceivedTimestamp(), Timestamp::Micros(12345000));
       });
   callback->OnTransformedFrame(std::move(mock_sender_frame));
-  ThreadManager::ProcessAllMessageQueuesForTesting();
+  main_thread.Flush();
 }
 
 TEST(RtpVideoStreamReceiverFrameTransformerDelegateTest,
      ManageFrameFromDifferentReceiver) {
-  test::RunLoop main_thread_;
+  test::RunLoop main_thread;
   std::vector<uint32_t> csrcs = {234, 345, 456};
   const int frame_id = 11;
 
@@ -373,7 +379,7 @@
   SimulatedClock clock(0);
   auto delegate1 =
       make_ref_counted<RtpVideoStreamReceiverFrameTransformerDelegate>(
-          &receiver1, &clock, mock_frame_transformer1, Thread::Current(),
+          &receiver1, &clock, mock_frame_transformer1, main_thread.task_queue(),
           /*remote_ssrc*/ 1111);
 
   TestRtpVideoFrameReceiver receiver2;
@@ -381,7 +387,7 @@
       make_ref_counted<NiceMock<MockFrameTransformer>>());
   auto delegate2 =
       make_ref_counted<RtpVideoStreamReceiverFrameTransformerDelegate>(
-          &receiver2, &clock, mock_frame_transformer2, Thread::Current(),
+          &receiver2, &clock, mock_frame_transformer2, main_thread.task_queue(),
           /*remote_ssrc*/ 1111);
 
   delegate1->Init();
@@ -410,23 +416,24 @@
       CreateRtpFrameObject(RTPVideoHeader(), csrcs);
   untransformed_frame->SetId(frame_id);
   delegate1->TransformFrame(std::move(untransformed_frame));
-  ThreadManager::ProcessAllMessageQueuesForTesting();
+  main_thread.Flush();
 }
 
 TEST(RtpVideoStreamReceiverFrameTransformerDelegateTest,
      ShortCircuitingSkipsTransform) {
-  test::RunLoop main_thread_;
+  test::RunLoop main_thread;
   TestRtpVideoFrameReceiver receiver;
   auto mock_frame_transformer =
       make_ref_counted<NiceMock<MockFrameTransformer>>();
   SimulatedClock clock(0);
   auto delegate =
       make_ref_counted<RtpVideoStreamReceiverFrameTransformerDelegate>(
-          &receiver, &clock, mock_frame_transformer, Thread::Current(), 1111);
+          &receiver, &clock, mock_frame_transformer, main_thread.task_queue(),
+          1111);
   delegate->Init();
 
   delegate->StartShortCircuiting();
-  ThreadManager::ProcessAllMessageQueuesForTesting();
+  main_thread.Flush();
 
   // Will not call the actual transformer.
   EXPECT_CALL(*mock_frame_transformer, Transform).Times(0);

diff --git a/video/rtp_video_stream_receiver2.cc b/video/rtp_video_stream_receiver2.cc
index 1b821bb..ca1f642 100644
--- a/video/rtp_video_stream_receiver2.cc
+++ b/video/rtp_video_stream_receiver2.cc

@@ -88,7 +88,6 @@
 #include "rtc_base/logging.h"
 #include "rtc_base/numerics/sequence_number_util.h"
 #include "rtc_base/strings/string_builder.h"
-#include "rtc_base/thread.h"
 #include "system_wrappers/include/ntp_time.h"
 #include "video/buffered_frame_decryptor.h"
 
@@ -379,7 +378,7 @@
     frame_transformer_delegate_ =
         make_ref_counted<RtpVideoStreamReceiverFrameTransformerDelegate>(
             this, &env_.clock(), std::move(frame_transformer),
-            Thread::Current(), config_.rtp.remote_ssrc);
+            TaskQueueBase::Current(), config_.rtp.remote_ssrc);
     frame_transformer_delegate_->Init();
   }
 }
@@ -1034,8 +1033,8 @@
   RTC_DCHECK_RUN_ON(&worker_task_checker_);
   frame_transformer_delegate_ =
       make_ref_counted<RtpVideoStreamReceiverFrameTransformerDelegate>(
-          this, &env_.clock(), std::move(frame_transformer), Thread::Current(),
-          config_.rtp.remote_ssrc);
+          this, &env_.clock(), std::move(frame_transformer),
+          TaskQueueBase::Current(), config_.rtp.remote_ssrc);
   frame_transformer_delegate_->Init();
 }