Injecting Clock in video receive.

Bug: webrtc:10365
Change-Id: Id20fca5b8ad13c133e05efa8972d8f5679507064
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/125192
Commit-Queue: Sebastian Jansson <srte@webrtc.org>
Reviewed-by: Åsa Persson <asapersson@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#26958}

call/call.cc

@@ -890,7 +890,7 @@ webrtc::VideoReceiveStream* Call::CreateVideoReceiveStream(
   VideoReceiveStream* receive_stream = new VideoReceiveStream(
       task_queue_factory_, &video_receiver_controller_, num_cpu_cores_,
       transport_send_ptr_->packet_router(), std::move(configuration),
-      module_process_thread_.get(), call_stats_.get());
+      module_process_thread_.get(), call_stats_.get(), clock_);
 
   const webrtc::VideoReceiveStream::Config& config = receive_stream->config();
   {
@@ -962,7 +962,7 @@ FlexfecReceiveStream* Call::CreateFlexfecReceiveStream(
     // TODO(nisse): Fix constructor so that it can be moved outside of
     // this locked scope.
     receive_stream = new FlexfecReceiveStreamImpl(
-        &video_receiver_controller_, config, recovered_packet_receiver,
+        clock_, &video_receiver_controller_, config, recovered_packet_receiver,
         call_stats_.get(), module_process_thread_.get());
 
     RTC_DCHECK(receive_rtp_config_.find(config.remote_ssrc) ==

call/flexfec_receive_stream_impl.cc

@@ -80,6 +80,7 @@ namespace {
 
 // TODO(brandtr): Update this function when we support multistream protection.
 std::unique_ptr<FlexfecReceiver> MaybeCreateFlexfecReceiver(
+    Clock* clock,
     const FlexfecReceiveStream::Config& config,
     RecoveredPacketReceiver* recovered_packet_receiver) {
   if (config.payload_type < 0) {
@@ -112,19 +113,20 @@ std::unique_ptr<FlexfecReceiver> MaybeCreateFlexfecReceiver(
     return nullptr;
   }
   RTC_DCHECK_EQ(1U, config.protected_media_ssrcs.size());
-  return std::unique_ptr<FlexfecReceiver>(
+  return std::unique_ptr<FlexfecReceiver>(new FlexfecReceiver(
-      new FlexfecReceiver(config.remote_ssrc, config.protected_media_ssrcs[0],
+      clock, config.remote_ssrc, config.protected_media_ssrcs[0],
-                          recovered_packet_receiver));
+      recovered_packet_receiver));
 }
 
 std::unique_ptr<RtpRtcp> CreateRtpRtcpModule(
+    Clock* clock,
     ReceiveStatistics* receive_statistics,
     Transport* rtcp_send_transport,
     RtcpRttStats* rtt_stats) {
   RtpRtcp::Configuration configuration;
   configuration.audio = false;
   configuration.receiver_only = true;
-  configuration.clock = Clock::GetRealTimeClock();
+  configuration.clock = clock;
   configuration.receive_statistics = receive_statistics;
   configuration.outgoing_transport = rtcp_send_transport;
   configuration.rtt_stats = rtt_stats;
@@ -135,16 +137,19 @@ std::unique_ptr<RtpRtcp> CreateRtpRtcpModule(
 }  // namespace
 
 FlexfecReceiveStreamImpl::FlexfecReceiveStreamImpl(
+    Clock* clock,
     RtpStreamReceiverControllerInterface* receiver_controller,
     const Config& config,
     RecoveredPacketReceiver* recovered_packet_receiver,
     RtcpRttStats* rtt_stats,
     ProcessThread* process_thread)
     : config_(config),
-      receiver_(MaybeCreateFlexfecReceiver(config_, recovered_packet_receiver)),
+      receiver_(MaybeCreateFlexfecReceiver(clock,
-      rtp_receive_statistics_(
+                                           config_,
-          ReceiveStatistics::Create(Clock::GetRealTimeClock())),
+                                           recovered_packet_receiver)),
-      rtp_rtcp_(CreateRtpRtcpModule(rtp_receive_statistics_.get(),
+      rtp_receive_statistics_(ReceiveStatistics::Create(clock)),
+      rtp_rtcp_(CreateRtpRtcpModule(clock,
+                                    rtp_receive_statistics_.get(),
                                     config_.rtcp_send_transport,
                                     rtt_stats)),
       process_thread_(process_thread) {

call/flexfec_receive_stream_impl.h

@@ -15,6 +15,7 @@
 
 #include "call/flexfec_receive_stream.h"
 #include "call/rtp_packet_sink_interface.h"
+#include "system_wrappers/include/clock.h"
 
 namespace webrtc {
 
@@ -31,6 +32,7 @@ class RtpStreamReceiverInterface;
 class FlexfecReceiveStreamImpl : public FlexfecReceiveStream {
  public:
   FlexfecReceiveStreamImpl(
+      Clock* clock,
       RtpStreamReceiverControllerInterface* receiver_controller,
       const Config& config,
       RecoveredPacketReceiver* recovered_packet_receiver,

call/flexfec_receive_stream_unittest.cc

@@ -89,8 +89,8 @@ class FlexfecReceiveStreamTest : public ::testing::Test {
       : config_(CreateDefaultConfig(&rtcp_send_transport_)) {
     EXPECT_CALL(process_thread_, RegisterModule(_, _)).Times(1);
     receive_stream_ = absl::make_unique<FlexfecReceiveStreamImpl>(
-        &rtp_stream_receiver_controller_, config_, &recovered_packet_receiver_,
+        Clock::GetRealTimeClock(), &rtp_stream_receiver_controller_, config_,
-        &rtt_stats_, &process_thread_);
+        &recovered_packet_receiver_, &rtt_stats_, &process_thread_);
   }
 
   ~FlexfecReceiveStreamTest() {
@@ -145,9 +145,9 @@ TEST_F(FlexfecReceiveStreamTest, RecoversPacket) {
 
   testing::StrictMock<MockRecoveredPacketReceiver> recovered_packet_receiver;
   EXPECT_CALL(process_thread_, RegisterModule(_, _)).Times(1);
-  FlexfecReceiveStreamImpl receive_stream(&rtp_stream_receiver_controller_,
+  FlexfecReceiveStreamImpl receive_stream(
-                                          config_, &recovered_packet_receiver,
+      Clock::GetRealTimeClock(), &rtp_stream_receiver_controller_, config_,
-                                          &rtt_stats_, &process_thread_);
+      &recovered_packet_receiver, &rtt_stats_, &process_thread_);
 
   EXPECT_CALL(recovered_packet_receiver,
               OnRecoveredPacket(_, kRtpHeaderSize + kPayloadLength[1]));

modules/rtp_rtcp/include/flexfec_receiver.h

@@ -30,6 +30,10 @@ class FlexfecReceiver {
   FlexfecReceiver(uint32_t ssrc,
                   uint32_t protected_media_ssrc,
                   RecoveredPacketReceiver* recovered_packet_receiver);
+  FlexfecReceiver(Clock* clock,
+                  uint32_t ssrc,
+                  uint32_t protected_media_ssrc,
+                  RecoveredPacketReceiver* recovered_packet_receiver);
   ~FlexfecReceiver();
 
   // Inserts a received packet (can be either media or FlexFEC) into the

modules/rtp_rtcp/source/flexfec_receiver.cc

@@ -33,6 +33,16 @@ constexpr int kPacketLogIntervalMs = 10000;
 }  // namespace
 
 FlexfecReceiver::FlexfecReceiver(
+    uint32_t ssrc,
+    uint32_t protected_media_ssrc,
+    RecoveredPacketReceiver* recovered_packet_receiver)
+    : FlexfecReceiver(Clock::GetRealTimeClock(),
+                      ssrc,
+                      protected_media_ssrc,
+                      recovered_packet_receiver) {}
+
+FlexfecReceiver::FlexfecReceiver(
+    Clock* clock,
     uint32_t ssrc,
     uint32_t protected_media_ssrc,
     RecoveredPacketReceiver* recovered_packet_receiver)
@@ -41,7 +51,7 @@ FlexfecReceiver::FlexfecReceiver(
       erasure_code_(
           ForwardErrorCorrection::CreateFlexfec(ssrc, protected_media_ssrc)),
       recovered_packet_receiver_(recovered_packet_receiver),
-      clock_(Clock::GetRealTimeClock()),
+      clock_(clock),
       last_recovered_packet_ms_(-1) {
   // It's OK to create this object on a different thread/task queue than
   // the one used during main operation.

modules/rtp_rtcp/source/flexfec_receiver_unittest.cc

@@ -49,8 +49,10 @@ class FlexfecReceiverForTest : public FlexfecReceiver {
   FlexfecReceiverForTest(uint32_t ssrc,
                          uint32_t protected_media_ssrc,
                          RecoveredPacketReceiver* recovered_packet_receiver)
-      : FlexfecReceiver(ssrc, protected_media_ssrc, recovered_packet_receiver) {
+      : FlexfecReceiver(Clock::GetRealTimeClock(),
-  }
+                        ssrc,
+                        protected_media_ssrc,
+                        recovered_packet_receiver) {}
   // Expose methods for tests.
   using FlexfecReceiver::AddReceivedPacket;
   using FlexfecReceiver::ProcessReceivedPacket;
@@ -466,7 +468,7 @@ TEST_F(FlexfecReceiverTest, SurvivesOldRecoveredPacketBeingReinserted) {
   } loopback_recovered_packet_receiver;
 
   // Feed recovered packets back into |receiver|.
-  FlexfecReceiver receiver(kFlexfecSsrc, kMediaSsrc,
+  FlexfecReceiver receiver(Clock::GetRealTimeClock(), kFlexfecSsrc, kMediaSsrc,
                            &loopback_recovered_packet_receiver);
   loopback_recovered_packet_receiver.SetReceiver(&receiver);
 
@@ -590,7 +592,7 @@ TEST_F(FlexfecReceiverTest, RecoveryCallbackDoesNotLoopInfinitely) {
   } loopback_recovered_packet_receiver;
 
   // Feed recovered packets back into |receiver|.
-  FlexfecReceiver receiver(kFlexfecSsrc, kMediaSsrc,
+  FlexfecReceiver receiver(Clock::GetRealTimeClock(), kFlexfecSsrc, kMediaSsrc,
                            &loopback_recovered_packet_receiver);
   loopback_recovered_packet_receiver.SetReceiver(&receiver);
 

video/rtp_video_stream_receiver.cc

@@ -52,12 +52,14 @@ constexpr int kPacketBufferMaxSize = 2048;
 }  // namespace
 
 std::unique_ptr<RtpRtcp> CreateRtpRtcpModule(
+    Clock* clock,
     ReceiveStatistics* receive_statistics,
     Transport* outgoing_transport,
     RtcpRttStats* rtt_stats,
     RtcpPacketTypeCounterObserver* rtcp_packet_type_counter_observer,
     TransportSequenceNumberAllocator* transport_sequence_number_allocator) {
   RtpRtcp::Configuration configuration;
+  configuration.clock = clock;
   configuration.audio = false;
   configuration.receiver_only = true;
   configuration.receive_statistics = receive_statistics;
@@ -83,6 +85,7 @@ std::unique_ptr<RtpRtcp> CreateRtpRtcpModule(
 static const int kPacketLogIntervalMs = 10000;
 
 RtpVideoStreamReceiver::RtpVideoStreamReceiver(
+    Clock* clock,
     Transport* transport,
     RtcpRttStats* rtt_stats,
     PacketRouter* packet_router,
@@ -94,17 +97,18 @@ RtpVideoStreamReceiver::RtpVideoStreamReceiver(
     KeyFrameRequestSender* keyframe_request_sender,
     video_coding::OnCompleteFrameCallback* complete_frame_callback,
     rtc::scoped_refptr<FrameDecryptorInterface> frame_decryptor)
-    : clock_(Clock::GetRealTimeClock()),
+    : clock_(clock),
       config_(*config),
       packet_router_(packet_router),
       process_thread_(process_thread),
-      ntp_estimator_(clock_),
+      ntp_estimator_(clock),
       rtp_header_extensions_(config_.rtp.extensions),
       rtp_receive_statistics_(rtp_receive_statistics),
       ulpfec_receiver_(UlpfecReceiver::Create(config->rtp.remote_ssrc, this)),
       receiving_(false),
       last_packet_log_ms_(-1),
-      rtp_rtcp_(CreateRtpRtcpModule(rtp_receive_statistics_,
+      rtp_rtcp_(CreateRtpRtcpModule(clock,
+                                    rtp_receive_statistics_,
                                     transport,
                                     rtt_stats,
                                     receive_stats_proxy,

video/rtp_video_stream_receiver.h

@@ -67,6 +67,7 @@ class RtpVideoStreamReceiver : public LossNotificationSender,
                                public OnDecryptionStatusChangeCallback {
  public:
   RtpVideoStreamReceiver(
+      Clock* clock,
       Transport* transport,
       RtcpRttStats* rtt_stats,
       PacketRouter* packet_router,

video/rtp_video_stream_receiver_unittest.cc

@@ -130,8 +130,8 @@ class RtpVideoStreamReceiverTest : public testing::Test {
     rtp_receive_statistics_ =
         absl::WrapUnique(ReceiveStatistics::Create(Clock::GetRealTimeClock()));
     rtp_video_stream_receiver_ = absl::make_unique<RtpVideoStreamReceiver>(
-        &mock_transport_, nullptr, &packet_router_, &config_,
+        Clock::GetRealTimeClock(), &mock_transport_, nullptr, &packet_router_,
-        rtp_receive_statistics_.get(), nullptr, process_thread_.get(),
+        &config_, rtp_receive_statistics_.get(), nullptr, process_thread_.get(),
         &mock_nack_sender_, &mock_key_frame_request_sender_,
         &mock_on_complete_frame_callback_, nullptr);
   }

video/video_receive_stream.cc

@@ -192,7 +192,8 @@ VideoReceiveStream::VideoReceiveStream(
                       timing_.get(),
                       this,   // NackSender
                       this),  // KeyFrameRequestSender
-      rtp_video_stream_receiver_(&transport_adapter_,
+      rtp_video_stream_receiver_(clock_,
+                                 &transport_adapter_,
                                  call_stats,
                                  packet_router,
                                  &config_,
@@ -259,7 +260,8 @@ VideoReceiveStream::VideoReceiveStream(
     PacketRouter* packet_router,
     VideoReceiveStream::Config config,
     ProcessThread* process_thread,
-    CallStats* call_stats)
+    CallStats* call_stats,
+    Clock* clock)
     : VideoReceiveStream(task_queue_factory,
                          receiver_controller,
                          num_cpu_cores,
@@ -267,8 +269,8 @@ VideoReceiveStream::VideoReceiveStream(
                          std::move(config),
                          process_thread,
                          call_stats,
-                         Clock::GetRealTimeClock(),
+                         clock,
-                         new VCMTiming(Clock::GetRealTimeClock())) {}
+                         new VCMTiming(clock)) {}
 
 VideoReceiveStream::~VideoReceiveStream() {
   RTC_DCHECK_CALLED_SEQUENTIALLY(&worker_sequence_checker_);

video/video_receive_stream.h

@@ -68,7 +68,8 @@ class VideoReceiveStream : public webrtc::VideoReceiveStream,
                      PacketRouter* packet_router,
                      VideoReceiveStream::Config config,
                      ProcessThread* process_thread,
-                     CallStats* call_stats);
+                     CallStats* call_stats,
+                     Clock* clock);
   ~VideoReceiveStream() override;
 
   const Config& config() const { return config_; }