Delete unused constructor arguments from VCMJitterBuffer

The NackSender* and KeyFrameRequestSender* arguments were unused.

Bug: webrtc:7408
Change-Id: Iab3b443373953e88c48867d031cb114b4891ab78
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/130503
Reviewed-by: Åsa Persson <asapersson@webrtc.org>
Commit-Queue: Niels Moller <nisse@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#27377}

modules/video_coding/jitter_buffer.cc

@@ -218,9 +218,7 @@ void Vp9SsMap::UpdateFrames(FrameList* frames) {
 }
 
 VCMJitterBuffer::VCMJitterBuffer(Clock* clock,
-                                 std::unique_ptr<EventWrapper> event,
-                                 NackSender* nack_sender,
-                                 KeyFrameRequestSender* keyframe_request_sender)
+                                 std::unique_ptr<EventWrapper> event)
     : clock_(clock),
       running_(false),
       frame_event_(std::move(event)),

modules/video_coding/jitter_buffer.h

@@ -106,10 +106,7 @@ class Vp9SsMap {
 
 class VCMJitterBuffer {
  public:
-  VCMJitterBuffer(Clock* clock,
-                  std::unique_ptr<EventWrapper> event,
-                  NackSender* nack_sender = nullptr,
-                  KeyFrameRequestSender* keyframe_request_sender = nullptr);
+  VCMJitterBuffer(Clock* clock, std::unique_ptr<EventWrapper> event);
 
   ~VCMJitterBuffer();
 

modules/video_coding/jitter_buffer_unittest.cc

@@ -14,6 +14,7 @@
 #include <memory>
 #include <vector>
 
+#include "absl/memory/memory.h"
 #include "common_video/h264/h264_common.h"
 #include "modules/video_coding/frame_buffer.h"
 #include "modules/video_coding/jitter_buffer.h"
@@ -200,26 +201,13 @@ TEST_F(Vp9SsMapTest, UpdatePacket) {
   EXPECT_EQ(1, vp9_header.pid_diff[0]);
 }
 
-class TestBasicJitterBuffer : public ::testing::TestWithParam<std::string>,
-                              public NackSender,
-                              public KeyFrameRequestSender {
- public:
-  void SendNack(const std::vector<uint16_t>& sequence_numbers) override {
-    nack_sent_.insert(nack_sent_.end(), sequence_numbers.begin(),
-                      sequence_numbers.end());
-  }
-
-  void RequestKeyFrame() override { ++keyframe_requests_; }
-
-  std::vector<uint16_t> nack_sent_;
-  int keyframe_requests_;
-
+class TestBasicJitterBuffer : public ::testing::Test {
  protected:
   TestBasicJitterBuffer() {}
   void SetUp() override {
     clock_.reset(new SimulatedClock(0));
     jitter_buffer_.reset(new VCMJitterBuffer(
-        clock_.get(), absl::WrapUnique(EventWrapper::Create()), this, this));
+        clock_.get(), absl::WrapUnique(EventWrapper::Create())));
     jitter_buffer_->Start();
     seq_num_ = 1234;
     timestamp_ = 0;
@@ -305,20 +293,7 @@ class TestBasicJitterBuffer : public ::testing::TestWithParam<std::string>,
   std::unique_ptr<VCMJitterBuffer> jitter_buffer_;
 };
 
-class TestRunningJitterBuffer : public ::testing::TestWithParam<std::string>,
-                                public NackSender,
-                                public KeyFrameRequestSender {
- public:
-  void SendNack(const std::vector<uint16_t>& sequence_numbers) {
-    nack_sent_.insert(nack_sent_.end(), sequence_numbers.begin(),
-                      sequence_numbers.end());
-  }
-
-  void RequestKeyFrame() { ++keyframe_requests_; }
-
-  std::vector<uint16_t> nack_sent_;
-  int keyframe_requests_;
-
+class TestRunningJitterBuffer : public ::testing::Test {
  protected:
   enum { kDataBufferSize = 10 };
 
@@ -327,7 +302,7 @@ class TestRunningJitterBuffer : public ::testing::TestWithParam<std::string>,
     max_nack_list_size_ = 150;
     oldest_packet_to_nack_ = 250;
     jitter_buffer_ = new VCMJitterBuffer(
-        clock_.get(), absl::WrapUnique(EventWrapper::Create()), this, this);
+        clock_.get(), absl::WrapUnique(EventWrapper::Create()));
     stream_generator_ = new StreamGenerator(0, clock_->TimeInMilliseconds());
     jitter_buffer_->Start();
     jitter_buffer_->SetNackSettings(max_nack_list_size_, oldest_packet_to_nack_,

modules/video_coding/receiver.cc

@@ -34,45 +34,14 @@ VCMReceiver::VCMReceiver(VCMTiming* timing, Clock* clock)
     : VCMReceiver::VCMReceiver(timing,
                                clock,
                                absl::WrapUnique(EventWrapper::Create()),
-                               absl::WrapUnique(EventWrapper::Create()),
-                               nullptr,  // NackSender
-                               nullptr)  // KeyframeRequestSender
-{}
-
-VCMReceiver::VCMReceiver(VCMTiming* timing,
-                         Clock* clock,
-                         NackSender* nack_sender,
-                         KeyFrameRequestSender* keyframe_request_sender)
-    : VCMReceiver(timing,
-                  clock,
-                  absl::WrapUnique(EventWrapper::Create()),
-                  absl::WrapUnique(EventWrapper::Create()),
-                  nack_sender,
-                  keyframe_request_sender) {}
+                               absl::WrapUnique(EventWrapper::Create())) {}
 
 VCMReceiver::VCMReceiver(VCMTiming* timing,
                          Clock* clock,
                          std::unique_ptr<EventWrapper> receiver_event,
                          std::unique_ptr<EventWrapper> jitter_buffer_event)
-    : VCMReceiver::VCMReceiver(timing,
-                               clock,
-                               std::move(receiver_event),
-                               std::move(jitter_buffer_event),
-                               nullptr,  // NackSender
-                               nullptr)  // KeyframeRequestSender
-{}
-
-VCMReceiver::VCMReceiver(VCMTiming* timing,
-                         Clock* clock,
-                         std::unique_ptr<EventWrapper> receiver_event,
-                         std::unique_ptr<EventWrapper> jitter_buffer_event,
-                         NackSender* nack_sender,
-                         KeyFrameRequestSender* keyframe_request_sender)
     : clock_(clock),
-      jitter_buffer_(clock_,
-                     std::move(jitter_buffer_event),
-                     nack_sender,
-                     keyframe_request_sender),
+      jitter_buffer_(clock_, std::move(jitter_buffer_event)),
       timing_(timing),
       render_wait_event_(std::move(receiver_event)),
       max_video_delay_ms_(kMaxVideoDelayMs) {

modules/video_coding/receiver.h

@@ -29,36 +29,17 @@ class VCMEncodedFrame;
 
 class VCMReceiver {
  public:
-  // Constructor for current interface, will be removed when the
-  // new jitter buffer is in place.
   VCMReceiver(VCMTiming* timing, Clock* clock);
 
-  // Create method for the new jitter buffer.
-  VCMReceiver(VCMTiming* timing,
-              Clock* clock,
-              NackSender* nack_sender,
-              KeyFrameRequestSender* keyframe_request_sender);
-
   // Using this constructor, you can specify a different event implemetation for
   // the jitter buffer. Useful for unit tests when you want to simulate incoming
   // packets, in which case the jitter buffer's wait event is different from
   // that of VCMReceiver itself.
-  //
-  // Constructor for current interface, will be removed when the
-  // new jitter buffer is in place.
   VCMReceiver(VCMTiming* timing,
               Clock* clock,
               std::unique_ptr<EventWrapper> receiver_event,
               std::unique_ptr<EventWrapper> jitter_buffer_event);
 
-  // Create method for the new jitter buffer.
-  VCMReceiver(VCMTiming* timing,
-              Clock* clock,
-              std::unique_ptr<EventWrapper> receiver_event,
-              std::unique_ptr<EventWrapper> jitter_buffer_event,
-              NackSender* nack_sender,
-              KeyFrameRequestSender* keyframe_request_sender);
-
   ~VCMReceiver();
 
   void Reset();

modules/video_coding/video_coding_impl.cc

@@ -42,12 +42,10 @@ namespace {
 
 class VideoCodingModuleImpl : public VideoCodingModule {
  public:
-  VideoCodingModuleImpl(Clock* clock,
-                        NackSender* nack_sender,
-                        KeyFrameRequestSender* keyframe_request_sender)
+  explicit VideoCodingModuleImpl(Clock* clock)
       : VideoCodingModule(),
         timing_(new VCMTiming(clock)),
-        receiver_(clock, timing_.get(), nack_sender, keyframe_request_sender) {}
+        receiver_(clock, timing_.get()) {}
 
   ~VideoCodingModuleImpl() override {}
 
@@ -120,7 +118,7 @@ class VideoCodingModuleImpl : public VideoCodingModule {
 // new jitter buffer is in place.
 VideoCodingModule* VideoCodingModule::Create(Clock* clock) {
   RTC_DCHECK(clock);
-  return new VideoCodingModuleImpl(clock, nullptr, nullptr);
+  return new VideoCodingModuleImpl(clock);
 }
 
 }  // namespace webrtc

modules/video_coding/video_coding_impl.h

@@ -57,10 +57,7 @@ class VCMProcessTimer {
 
 class VideoReceiver : public Module {
  public:
-  VideoReceiver(Clock* clock,
-                VCMTiming* timing,
-                NackSender* nack_sender = nullptr,
-                KeyFrameRequestSender* keyframe_request_sender = nullptr);
+  VideoReceiver(Clock* clock, VCMTiming* timing);
   ~VideoReceiver() override;
 
   int32_t RegisterReceiveCodec(const VideoCodec* receiveCodec,

modules/video_coding/video_receiver.cc

@@ -41,16 +41,10 @@
 namespace webrtc {
 namespace vcm {
 
-VideoReceiver::VideoReceiver(Clock* clock,
-                             VCMTiming* timing,
-                             NackSender* nack_sender,
-                             KeyFrameRequestSender* keyframe_request_sender)
+VideoReceiver::VideoReceiver(Clock* clock, VCMTiming* timing)
     : clock_(clock),
       _timing(timing),
-      _receiver(_timing,
-                clock_,
-                nack_sender,
-                keyframe_request_sender),
+      _receiver(_timing, clock_),
       _decodedFrameCallback(_timing, clock_),
       _frameTypeCallback(nullptr),
       _packetRequestCallback(nullptr),

video/video_receive_stream.cc

@@ -193,10 +193,7 @@ VideoReceiveStream::VideoReceiveStream(
       rtp_receive_statistics_(
           ReceiveStatistics::Create(clock_, &stats_proxy_, &stats_proxy_)),
       timing_(timing),
-      video_receiver_(clock_,
-                      timing_.get(),
-                      this,   // NackSender
-                      this),  // KeyFrameRequestSender
+      video_receiver_(clock_, timing_.get()),
       rtp_video_stream_receiver_(clock_,
                                  &transport_adapter_,
                                  call_stats,