Move FrameCountObserver from RTPSender to RtpVideoSender

Tbr: sprang@webrtc.org # Trivial change to rtp_video_stream_receiver.cc Bug: webrtc:7135 Change-Id: Ic292fb02046ea800d7f0876900997d96ed0099d6 Reviewed-on: https://webrtc-review.googlesource.com/c/120161 Reviewed-by: Niels Moller <nisse@webrtc.org> Reviewed-by: Danil Chapovalov <danilchap@webrtc.org> Reviewed-by: Sebastian Jansson <srte@webrtc.org> Commit-Queue: Niels Moller <nisse@webrtc.org> Cr-Commit-Position: refs/heads/master@{#26441}
2019-01-29 09:44:24 +01:00 · 2019-01-29 09:44:24 +01:00 · 949f0fdc10
commit 949f0fdc10
parent 3e8b7e9b6b
9 changed files with 122 additions and 123 deletions
--- a/call/rtp_video_sender.cc
+++ b/call/rtp_video_sender.cc
@ -49,7 +49,6 @@ std::vector<std::unique_ptr<RtpRtcp>> CreateRtpRtcpModules(
    RtcpRttStats* rtt_stats,
    FlexfecSender* flexfec_sender,
    BitrateStatisticsObserver* bitrate_observer,
-    FrameCountObserver* frame_count_observer,
    RtcpPacketTypeCounterObserver* rtcp_type_observer,
    SendSideDelayObserver* send_delay_observer,
    SendPacketObserver* send_packet_observer,
@ -75,7 +74,6 @@ std::vector<std::unique_ptr<RtpRtcp>> CreateRtpRtcpModules(
  configuration.transport_sequence_number_allocator =
      transport->packet_router();
  configuration.send_bitrate_observer = bitrate_observer;
-  configuration.send_frame_count_observer = frame_count_observer;
  configuration.send_side_delay_observer = send_delay_observer;
  configuration.send_packet_observer = send_packet_observer;
  configuration.event_log = event_log;
@ -209,7 +207,6 @@ RtpVideoSender::RtpVideoSender(
                                        observers.rtcp_rtt_stats,
                                        flexfec_sender_.get(),
                                        observers.bitrate_observer,
-                                        observers.frame_count_observer,
                                        observers.rtcp_type_observer,
                                        observers.send_delay_observer,
                                        observers.send_packet_observer,
@ -223,7 +220,9 @@ RtpVideoSender::RtpVideoSender(
      transport_(transport),
      transport_overhead_bytes_per_packet_(0),
      overhead_bytes_per_packet_(0),
-      encoder_target_rate_bps_(0) {
+      encoder_target_rate_bps_(0),
+      frame_counts_(rtp_config.ssrcs.size()),
+      frame_count_observer_(observers.frame_count_observer) {
  RTC_DCHECK_EQ(rtp_config.ssrcs.size(), rtp_modules_.size());
  module_process_thread_checker_.DetachFromThread();
  // SSRCs are assumed to be sorted in the same order as |rtp_modules|.
@ -379,6 +378,19 @@ EncodedImageCallback::Result RtpVideoSender::OnEncodedImage(
      encoded_image.Timestamp(), encoded_image.capture_time_ms_,
      encoded_image.data(), encoded_image.size(), fragmentation,
      &rtp_video_header, &frame_id);
+
+  if (frame_count_observer_) {
+    FrameCounts& counts = frame_counts_[stream_index];
+    if (encoded_image._frameType == kVideoFrameKey) {
+      ++counts.key_frames;
+    } else if (encoded_image._frameType == kVideoFrameDelta) {
+      ++counts.delta_frames;
+    } else {
+      RTC_DCHECK_EQ(encoded_image._frameType, kEmptyFrame);
+    }
+    frame_count_observer_->FrameCountUpdated(counts,
+                                             rtp_config_.ssrcs[stream_index]);
+  }
  if (!send_result)
    return Result(Result::ERROR_SEND_FAILED);

--- a/call/rtp_video_sender.h
+++ b/call/rtp_video_sender.h
@ -164,6 +164,9 @@ class RtpVideoSender : public RtpVideoSenderInterface,
  std::unordered_set<uint16_t> feedback_packet_seq_num_set_;
  std::vector<bool> loss_mask_vector_ RTC_GUARDED_BY(crit_);

+  std::vector<FrameCounts> frame_counts_ RTC_GUARDED_BY(crit_);
+  FrameCountObserver* const frame_count_observer_;
+
  RTC_DISALLOW_COPY_AND_ASSIGN(RtpVideoSender);
 };

--- a/call/rtp_video_sender_unittest.cc
+++ b/call/rtp_video_sender_unittest.cc
@ -30,6 +30,7 @@ using ::testing::AnyNumber;
 using ::testing::Invoke;
 using ::testing::NiceMock;
 using ::testing::Return;
+using ::testing::SaveArg;
 using ::testing::Unused;

 namespace webrtc {
@ -76,7 +77,8 @@ class RtpVideoSenderTestFixture {
  RtpVideoSenderTestFixture(
      const std::vector<uint32_t>& ssrcs,
      int payload_type,
-      const std::map<uint32_t, RtpPayloadState>& suspended_payload_states)
+      const std::map<uint32_t, RtpPayloadState>& suspended_payload_states,
+      FrameCountObserver* frame_count_observer)
      : clock_(0),
        config_(&transport_),
        send_delay_stats_(&clock_),
@ -96,12 +98,20 @@ class RtpVideoSenderTestFixture {
        suspended_ssrcs, suspended_payload_states, config_.rtp,
        config_.rtcp_report_interval_ms, &transport_,
        CreateObservers(&call_stats_, &encoder_feedback_, &stats_proxy_,
-                        &stats_proxy_, &stats_proxy_, &stats_proxy_,
+                        &stats_proxy_, &stats_proxy_, frame_count_observer,
                        &stats_proxy_, &stats_proxy_, &send_delay_stats_),
        &transport_controller_, &event_log_, &retransmission_rate_limiter_,
        absl::make_unique<FecControllerDefault>(&clock_), nullptr,
        CryptoOptions{});
  }
+  RtpVideoSenderTestFixture(
+      const std::vector<uint32_t>& ssrcs,
+      int payload_type,
+      const std::map<uint32_t, RtpPayloadState>& suspended_payload_states)
+      : RtpVideoSenderTestFixture(ssrcs,
+                                  payload_type,
+                                  suspended_payload_states,
+                                  /*frame_count_observer=*/nullptr) {}

  RtpVideoSender* router() { return router_.get(); }

@ -292,4 +302,56 @@ TEST_P(RtpVideoSenderTest, CreateWithPreviousStates) {
  EXPECT_EQ(kState2SharedFrameId, initial_states[kSsrc1].shared_frame_id);
  EXPECT_EQ(kState2SharedFrameId, initial_states[kSsrc2].shared_frame_id);
 }
+
+TEST_P(RtpVideoSenderTest, FrameCountCallbacks) {
+  class MockFrameCountObserver : public FrameCountObserver {
+   public:
+    MOCK_METHOD2(FrameCountUpdated,
+                 void(const FrameCounts& frame_counts, uint32_t ssrc));
+  } callback;
+
+  RtpVideoSenderTestFixture test({kSsrc1}, kPayloadType, {}, &callback);
+
+  uint8_t payload = 'a';
+  EncodedImage encoded_image;
+  encoded_image.SetTimestamp(1);
+  encoded_image.capture_time_ms_ = 2;
+  encoded_image._frameType = kVideoFrameKey;
+  encoded_image.set_buffer(&payload, 1);
+  encoded_image.set_size(1);
+
+  encoded_image._frameType = kVideoFrameKey;
+
+  // No callbacks when not active.
+  EXPECT_CALL(callback, FrameCountUpdated).Times(0);
+  EXPECT_NE(
+      EncodedImageCallback::Result::OK,
+      test.router()->OnEncodedImage(encoded_image, nullptr, nullptr).error);
+  testing::Mock::VerifyAndClearExpectations(&callback);
+
+  test.router()->SetActive(true);
+
+  FrameCounts frame_counts;
+  EXPECT_CALL(callback, FrameCountUpdated(_, kSsrc1))
+      .WillOnce(SaveArg<0>(&frame_counts));
+  EXPECT_EQ(
+      EncodedImageCallback::Result::OK,
+      test.router()->OnEncodedImage(encoded_image, nullptr, nullptr).error);
+
+  EXPECT_EQ(1, frame_counts.key_frames);
+  EXPECT_EQ(0, frame_counts.delta_frames);
+
+  testing::Mock::VerifyAndClearExpectations(&callback);
+
+  encoded_image._frameType = kVideoFrameDelta;
+  EXPECT_CALL(callback, FrameCountUpdated(_, kSsrc1))
+      .WillOnce(SaveArg<0>(&frame_counts));
+  EXPECT_EQ(
+      EncodedImageCallback::Result::OK,
+      test.router()->OnEncodedImage(encoded_image, nullptr, nullptr).error);
+
+  EXPECT_EQ(1, frame_counts.key_frames);
+  EXPECT_EQ(1, frame_counts.delta_frames);
+}
+
 }  // namespace webrtc
--- a/modules/rtp_rtcp/include/rtp_rtcp.h
+++ b/modules/rtp_rtcp/include/rtp_rtcp.h
@ -87,7 +87,6 @@ class RtpRtcp : public Module, public RtcpFeedbackSenderInterface {
    TransportSequenceNumberAllocator* transport_sequence_number_allocator =
        nullptr;
    BitrateStatisticsObserver* send_bitrate_observer = nullptr;
-    FrameCountObserver* send_frame_count_observer = nullptr;
    SendSideDelayObserver* send_side_delay_observer = nullptr;
    RtcEventLog* event_log = nullptr;
    SendPacketObserver* send_packet_observer = nullptr;
--- a/modules/rtp_rtcp/source/rtp_rtcp_impl.cc
+++ b/modules/rtp_rtcp/source/rtp_rtcp_impl.cc
@ -105,7 +105,6 @@ ModuleRtpRtcpImpl::ModuleRtpRtcpImpl(const Configuration& configuration)
        configuration.transport_sequence_number_allocator,
        configuration.transport_feedback_callback,
        configuration.send_bitrate_observer,
-        configuration.send_frame_count_observer,
        configuration.send_side_delay_observer, configuration.event_log,
        configuration.send_packet_observer,
        configuration.retransmission_rate_limiter,
--- a/modules/rtp_rtcp/source/rtp_sender.cc
+++ b/modules/rtp_rtcp/source/rtp_sender.cc
@ -114,7 +114,6 @@ RTPSender::RTPSender(
    TransportSequenceNumberAllocator* sequence_number_allocator,
    TransportFeedbackObserver* transport_feedback_observer,
    BitrateStatisticsObserver* bitrate_callback,
-    FrameCountObserver* frame_count_observer,
    SendSideDelayObserver* send_side_delay_observer,
    RtcEventLog* event_log,
    SendPacketObserver* send_packet_observer,
@ -155,7 +154,6 @@ RTPSender::RTPSender(
      total_bitrate_sent_(kBitrateStatisticsWindowMs,
                          RateStatistics::kBpsScale),
      nack_bitrate_sent_(kBitrateStatisticsWindowMs, RateStatistics::kBpsScale),
-      frame_count_observer_(frame_count_observer),
      send_side_delay_observer_(send_side_delay_observer),
      event_log_(event_log),
      send_packet_observer_(send_packet_observer),
@ -401,17 +399,6 @@ bool RTPSender::SendOutgoingData(FrameType frame_type,
                               expected_retransmission_time_ms);
  }

-  rtc::CritScope cs(&statistics_crit_);
-  // Note: This is currently only counting for video.
-  if (frame_type == kVideoFrameKey) {
-    ++frame_counts_.key_frames;
-  } else if (frame_type == kVideoFrameDelta) {
-    ++frame_counts_.delta_frames;
-  }
-  if (frame_count_observer_) {
-    frame_count_observer_->FrameCountUpdated(frame_counts_, ssrc);
-  }
-
  return result;
 }

--- a/modules/rtp_rtcp/source/rtp_sender.h
+++ b/modules/rtp_rtcp/source/rtp_sender.h
@ -57,7 +57,6 @@ class RTPSender {
            TransportSequenceNumberAllocator* sequence_number_allocator,
            TransportFeedbackObserver* transport_feedback_callback,
            BitrateStatisticsObserver* bitrate_callback,
-            FrameCountObserver* frame_count_observer,
            SendSideDelayObserver* send_side_delay_observer,
            RtcEventLog* event_log,
            SendPacketObserver* send_packet_observer,
@ -302,14 +301,12 @@ class RTPSender {
  SendDelayMap send_delays_ RTC_GUARDED_BY(statistics_crit_);
  SendDelayMap::const_iterator max_delay_it_ RTC_GUARDED_BY(statistics_crit_);
  int64_t sum_delays_ms_ RTC_GUARDED_BY(statistics_crit_);
-  FrameCounts frame_counts_ RTC_GUARDED_BY(statistics_crit_);
  StreamDataCounters rtp_stats_ RTC_GUARDED_BY(statistics_crit_);
  StreamDataCounters rtx_rtp_stats_ RTC_GUARDED_BY(statistics_crit_);
  StreamDataCountersCallback* rtp_stats_callback_
      RTC_GUARDED_BY(statistics_crit_);
  RateStatistics total_bitrate_sent_ RTC_GUARDED_BY(statistics_crit_);
  RateStatistics nack_bitrate_sent_ RTC_GUARDED_BY(statistics_crit_);
-  FrameCountObserver* const frame_count_observer_;
  SendSideDelayObserver* const send_side_delay_observer_;
  RtcEventLog* const event_log_;
  SendPacketObserver* const send_packet_observer_;
--- a/modules/rtp_rtcp/source/rtp_sender_unittest.cc
+++ b/modules/rtp_rtcp/source/rtp_sender_unittest.cc
@ -190,7 +190,7 @@ class RtpSenderTest : public ::testing::TestWithParam<bool> {
  void SetUpRtpSender(bool pacer, bool populate_network2) {
    rtp_sender_.reset(new RTPSender(
        false, &fake_clock_, &transport_, pacer ? &mock_paced_sender_ : nullptr,
-        nullptr, &seq_num_allocator_, nullptr, nullptr, nullptr, nullptr,
+        nullptr, &seq_num_allocator_, nullptr, nullptr, nullptr,
        &mock_rtc_event_log_, &send_packet_observer_,
        &retransmission_rate_limiter_, nullptr, populate_network2, nullptr,
        false, false));
@ -391,9 +391,8 @@ TEST_P(RtpSenderTest, AssignSequenceNumberAllowsPaddingOnAudio) {
  const bool kEnableAudio = true;
  rtp_sender_.reset(new RTPSender(
      kEnableAudio, &fake_clock_, &transport, &mock_paced_sender_, nullptr,
-      nullptr, nullptr, nullptr, nullptr, nullptr, &mock_rtc_event_log_,
-      nullptr, &retransmission_rate_limiter_, nullptr, false, nullptr, false,
-      false));
+      nullptr, nullptr, nullptr, nullptr, &mock_rtc_event_log_, nullptr,
+      &retransmission_rate_limiter_, nullptr, false, nullptr, false, false));
  rtp_sender_->SetTimestampOffset(0);
  rtp_sender_->SetSSRC(kSsrc);

@ -438,9 +437,9 @@ TEST_P(RtpSenderTestWithoutPacer,
  testing::NiceMock<MockOverheadObserver> mock_overhead_observer;
  rtp_sender_.reset(new RTPSender(
      false, &fake_clock_, &transport_, nullptr, nullptr, &seq_num_allocator_,
-      &feedback_observer_, nullptr, nullptr, nullptr, &mock_rtc_event_log_,
-      nullptr, &retransmission_rate_limiter_, &mock_overhead_observer, false,
-      nullptr, false, false));
+      &feedback_observer_, nullptr, nullptr, &mock_rtc_event_log_, nullptr,
+      &retransmission_rate_limiter_, &mock_overhead_observer, false, nullptr,
+      false, false));
  rtp_sender_->SetSSRC(kSsrc);
  EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
                   kRtpExtensionTransportSequenceNumber,
@ -466,7 +465,7 @@ TEST_P(RtpSenderTestWithoutPacer,
 TEST_P(RtpSenderTestWithoutPacer, SendsPacketsWithTransportSequenceNumber) {
  rtp_sender_.reset(new RTPSender(
      false, &fake_clock_, &transport_, nullptr, nullptr, &seq_num_allocator_,
-      &feedback_observer_, nullptr, nullptr, nullptr, &mock_rtc_event_log_,
+      &feedback_observer_, nullptr, nullptr, &mock_rtc_event_log_,
      &send_packet_observer_, &retransmission_rate_limiter_, nullptr, false,
      nullptr, false, false));
  rtp_sender_->SetSSRC(kSsrc);
@ -498,7 +497,7 @@ TEST_P(RtpSenderTestWithoutPacer, SendsPacketsWithTransportSequenceNumber) {
 TEST_P(RtpSenderTestWithoutPacer, PacketOptionsNoRetransmission) {
  rtp_sender_.reset(new RTPSender(
      false, &fake_clock_, &transport_, nullptr, nullptr, &seq_num_allocator_,
-      &feedback_observer_, nullptr, nullptr, nullptr, &mock_rtc_event_log_,
+      &feedback_observer_, nullptr, nullptr, &mock_rtc_event_log_,
      &send_packet_observer_, &retransmission_rate_limiter_, nullptr, false,
      nullptr, false, false));
  rtp_sender_->SetSSRC(kSsrc);
@ -553,8 +552,8 @@ TEST_P(RtpSenderTestWithoutPacer, OnSendSideDelayUpdated) {
  testing::StrictMock<MockSendSideDelayObserver> send_side_delay_observer_;
  rtp_sender_.reset(new RTPSender(
      false, &fake_clock_, &transport_, nullptr, nullptr, nullptr, nullptr,
-      nullptr, nullptr, &send_side_delay_observer_, &mock_rtc_event_log_,
-      nullptr, nullptr, nullptr, false, nullptr, false, false));
+      nullptr, &send_side_delay_observer_, &mock_rtc_event_log_, nullptr,
+      nullptr, nullptr, false, nullptr, false, false));
  rtp_sender_->SetSSRC(kSsrc);

  const uint8_t kPayloadType = 127;
@ -630,7 +629,7 @@ TEST_P(RtpSenderTestWithoutPacer, OnSendPacketUpdated) {
 TEST_P(RtpSenderTest, SendsPacketsWithTransportSequenceNumber) {
  rtp_sender_.reset(new RTPSender(
      false, &fake_clock_, &transport_, &mock_paced_sender_, nullptr,
-      &seq_num_allocator_, &feedback_observer_, nullptr, nullptr, nullptr,
+      &seq_num_allocator_, &feedback_observer_, nullptr, nullptr,
      &mock_rtc_event_log_, &send_packet_observer_,
      &retransmission_rate_limiter_, nullptr, false, nullptr, false, false));
  rtp_sender_->SetSequenceNumber(kSeqNum);
@ -1016,8 +1015,8 @@ TEST_P(RtpSenderTest, OnSendPacketNotUpdatedWithoutSeqNumAllocator) {
  rtp_sender_.reset(new RTPSender(
      false, &fake_clock_, &transport_, &mock_paced_sender_, nullptr,
      nullptr /* TransportSequenceNumberAllocator */, nullptr, nullptr, nullptr,
-      nullptr, nullptr, &send_packet_observer_, &retransmission_rate_limiter_,
-      nullptr, false, nullptr, false, false));
+      nullptr, &send_packet_observer_, &retransmission_rate_limiter_, nullptr,
+      false, nullptr, false, false));
  rtp_sender_->SetSequenceNumber(kSeqNum);
  rtp_sender_->SetSSRC(kSsrc);
  EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
@ -1042,7 +1041,7 @@ TEST_P(RtpSenderTest, SendRedundantPayloads) {
  MockTransport transport;
  rtp_sender_.reset(new RTPSender(
      false, &fake_clock_, &transport, &mock_paced_sender_, nullptr, nullptr,
-      nullptr, nullptr, nullptr, nullptr, &mock_rtc_event_log_, nullptr,
+      nullptr, nullptr, nullptr, &mock_rtc_event_log_, nullptr,
      &retransmission_rate_limiter_, nullptr, false, nullptr, false, false));
  rtp_sender_->SetSequenceNumber(kSeqNum);
  rtp_sender_->SetSSRC(kSsrc);
@ -1164,9 +1163,9 @@ TEST_P(RtpSenderTest, SendFlexfecPackets) {
  // Reset |rtp_sender_| to use FlexFEC.
  rtp_sender_.reset(new RTPSender(
      false, &fake_clock_, &transport_, &mock_paced_sender_, &flexfec_sender,
-      &seq_num_allocator_, nullptr, nullptr, nullptr, nullptr,
-      &mock_rtc_event_log_, &send_packet_observer_,
-      &retransmission_rate_limiter_, nullptr, false, nullptr, false, false));
+      &seq_num_allocator_, nullptr, nullptr, nullptr, &mock_rtc_event_log_,
+      &send_packet_observer_, &retransmission_rate_limiter_, nullptr, false,
+      nullptr, false, false));
  rtp_sender_->SetSSRC(kMediaSsrc);
  rtp_sender_->SetSequenceNumber(kSeqNum);
  rtp_sender_->SetStorePacketsStatus(true, 10);
@ -1223,9 +1222,9 @@ TEST_P(RtpSenderTest, NoFlexfecForTimingFrames) {
  // Reset |rtp_sender_| to use FlexFEC.
  rtp_sender_.reset(new RTPSender(
      false, &fake_clock_, &transport_, &mock_paced_sender_, &flexfec_sender,
-      &seq_num_allocator_, nullptr, nullptr, nullptr, nullptr,
-      &mock_rtc_event_log_, &send_packet_observer_,
-      &retransmission_rate_limiter_, nullptr, false, nullptr, false, false));
+      &seq_num_allocator_, nullptr, nullptr, nullptr, &mock_rtc_event_log_,
+      &send_packet_observer_, &retransmission_rate_limiter_, nullptr, false,
+      nullptr, false, false));
  rtp_sender_->SetSSRC(kMediaSsrc);
  rtp_sender_->SetSequenceNumber(kSeqNum);
  rtp_sender_->SetStorePacketsStatus(true, 10);
@ -1321,9 +1320,9 @@ TEST_P(RtpSenderTestWithoutPacer, SendFlexfecPackets) {
  // Reset |rtp_sender_| to use FlexFEC.
  rtp_sender_.reset(new RTPSender(
      false, &fake_clock_, &transport_, nullptr, &flexfec_sender,
-      &seq_num_allocator_, nullptr, nullptr, nullptr, nullptr,
-      &mock_rtc_event_log_, &send_packet_observer_,
-      &retransmission_rate_limiter_, nullptr, false, nullptr, false, false));
+      &seq_num_allocator_, nullptr, nullptr, nullptr, &mock_rtc_event_log_,
+      &send_packet_observer_, &retransmission_rate_limiter_, nullptr, false,
+      nullptr, false, false));
  rtp_sender_->SetSSRC(kMediaSsrc);
  rtp_sender_->SetSequenceNumber(kSeqNum);

@ -1438,9 +1437,9 @@ TEST_P(RtpSenderTest, FecOverheadRate) {
  // Reset |rtp_sender_| to use FlexFEC.
  rtp_sender_.reset(new RTPSender(
      false, &fake_clock_, &transport_, &mock_paced_sender_, &flexfec_sender,
-      &seq_num_allocator_, nullptr, nullptr, nullptr, nullptr,
-      &mock_rtc_event_log_, &send_packet_observer_,
-      &retransmission_rate_limiter_, nullptr, false, nullptr, false, false));
+      &seq_num_allocator_, nullptr, nullptr, nullptr, &mock_rtc_event_log_,
+      &send_packet_observer_, &retransmission_rate_limiter_, nullptr, false,
+      nullptr, false, false));
  rtp_sender_->SetSSRC(kMediaSsrc);
  rtp_sender_->SetSequenceNumber(kSeqNum);

@ -1471,62 +1470,6 @@ TEST_P(RtpSenderTest, FecOverheadRate) {
              rtp_sender_->FecOverheadRate(), 500);
 }

-TEST_P(RtpSenderTest, FrameCountCallbacks) {
-  class TestCallback : public FrameCountObserver {
-   public:
-    TestCallback() : FrameCountObserver(), num_calls_(0), ssrc_(0) {}
-    ~TestCallback() override = default;
-
-    void FrameCountUpdated(const FrameCounts& frame_counts,
-                           uint32_t ssrc) override {
-      ++num_calls_;
-      ssrc_ = ssrc;
-      frame_counts_ = frame_counts;
-    }
-
-    uint32_t num_calls_;
-    uint32_t ssrc_;
-    FrameCounts frame_counts_;
-  } callback;
-
-  rtp_sender_.reset(new RTPSender(
-      false, &fake_clock_, &transport_, &mock_paced_sender_, nullptr, nullptr,
-      nullptr, nullptr, &callback, nullptr, nullptr, nullptr,
-      &retransmission_rate_limiter_, nullptr, false, nullptr, false, false));
-  rtp_sender_->SetSSRC(kSsrc);
-  const char payload_name[] = "GENERIC";
-  const uint8_t payload_type = 127;
-  ASSERT_EQ(0, rtp_sender_->RegisterPayload(payload_name, payload_type, 90000,
-                                            0, 1500));
-  uint8_t payload[] = {47, 11, 32, 93, 89};
-  rtp_sender_->SetStorePacketsStatus(true, 1);
-  uint32_t ssrc = rtp_sender_->SSRC();
-
-  EXPECT_CALL(mock_paced_sender_, InsertPacket(_, _, _, _, _, _))
-      .Times(::testing::AtLeast(2));
-
-  RTPVideoHeader video_header;
-  ASSERT_TRUE(rtp_sender_->SendOutgoingData(
-      kVideoFrameKey, payload_type, 1234, 4321, payload, sizeof(payload),
-      nullptr, &video_header, nullptr, kDefaultExpectedRetransmissionTimeMs));
-
-  EXPECT_EQ(1U, callback.num_calls_);
-  EXPECT_EQ(ssrc, callback.ssrc_);
-  EXPECT_EQ(1, callback.frame_counts_.key_frames);
-  EXPECT_EQ(0, callback.frame_counts_.delta_frames);
-
-  ASSERT_TRUE(rtp_sender_->SendOutgoingData(
-      kVideoFrameDelta, payload_type, 1234, 4321, payload, sizeof(payload),
-      nullptr, &video_header, nullptr, kDefaultExpectedRetransmissionTimeMs));
-
-  EXPECT_EQ(2U, callback.num_calls_);
-  EXPECT_EQ(ssrc, callback.ssrc_);
-  EXPECT_EQ(1, callback.frame_counts_.key_frames);
-  EXPECT_EQ(1, callback.frame_counts_.delta_frames);
-
-  rtp_sender_.reset();
-}
-
 TEST_P(RtpSenderTest, BitrateCallbacks) {
  class TestCallback : public BitrateStatisticsObserver {
   public:
@ -1554,8 +1497,8 @@ TEST_P(RtpSenderTest, BitrateCallbacks) {
  } callback;
  rtp_sender_.reset(new RTPSender(
      false, &fake_clock_, &transport_, nullptr, nullptr, nullptr, nullptr,
-      &callback, nullptr, nullptr, nullptr, nullptr,
-      &retransmission_rate_limiter_, nullptr, false, nullptr, false, false));
+      &callback, nullptr, nullptr, nullptr, &retransmission_rate_limiter_,
+      nullptr, false, nullptr, false, false));
  rtp_sender_->SetSSRC(kSsrc);

  // Simulate kNumPackets sent with kPacketInterval ms intervals, with the
@ -1614,8 +1557,8 @@ class RtpSenderAudioTest : public RtpSenderTest {
    payload_ = kAudioPayload;
    rtp_sender_.reset(new RTPSender(
        true, &fake_clock_, &transport_, nullptr, nullptr, nullptr, nullptr,
-        nullptr, nullptr, nullptr, nullptr, nullptr,
-        &retransmission_rate_limiter_, nullptr, false, nullptr, false, false));
+        nullptr, nullptr, nullptr, nullptr, &retransmission_rate_limiter_,
+        nullptr, false, nullptr, false, false));
    rtp_sender_->SetSSRC(kSsrc);
    rtp_sender_->SetSequenceNumber(kSeqNum);
  }
@ -2278,11 +2221,10 @@ TEST_P(RtpSenderVideoTest,

 TEST_P(RtpSenderTest, OnOverheadChanged) {
  MockOverheadObserver mock_overhead_observer;
-  rtp_sender_.reset(
-      new RTPSender(false, &fake_clock_, &transport_, nullptr, nullptr, nullptr,
-                    nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,
-                    &retransmission_rate_limiter_, &mock_overhead_observer,
-                    false, nullptr, false, false));
+  rtp_sender_.reset(new RTPSender(
+      false, &fake_clock_, &transport_, nullptr, nullptr, nullptr, nullptr,
+      nullptr, nullptr, nullptr, nullptr, &retransmission_rate_limiter_,
+      &mock_overhead_observer, false, nullptr, false, false));
  rtp_sender_->SetSSRC(kSsrc);

  // RTP overhead is 12B.
@ -2300,11 +2242,10 @@ TEST_P(RtpSenderTest, OnOverheadChanged) {

 TEST_P(RtpSenderTest, DoesNotUpdateOverheadOnEqualSize) {
  MockOverheadObserver mock_overhead_observer;
-  rtp_sender_.reset(
-      new RTPSender(false, &fake_clock_, &transport_, nullptr, nullptr, nullptr,
-                    nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,
-                    &retransmission_rate_limiter_, &mock_overhead_observer,
-                    false, nullptr, false, false));
+  rtp_sender_.reset(new RTPSender(
+      false, &fake_clock_, &transport_, nullptr, nullptr, nullptr, nullptr,
+      nullptr, nullptr, nullptr, nullptr, &retransmission_rate_limiter_,
+      &mock_overhead_observer, false, nullptr, false, false));
  rtp_sender_->SetSSRC(kSsrc);

  EXPECT_CALL(mock_overhead_observer, OnOverheadChanged(_)).Times(1);
@ -2316,7 +2257,7 @@ TEST_P(RtpSenderTest, SendsKeepAlive) {
  MockTransport transport;
  rtp_sender_.reset(new RTPSender(
      false, &fake_clock_, &transport, nullptr, nullptr, nullptr, nullptr,
-      nullptr, nullptr, nullptr, &mock_rtc_event_log_, nullptr,
+      nullptr, nullptr, &mock_rtc_event_log_, nullptr,
      &retransmission_rate_limiter_, nullptr, false, nullptr, false, false));
  rtp_sender_->SetSequenceNumber(kSeqNum);
  rtp_sender_->SetTimestampOffset(0);
--- a/video/rtp_video_stream_receiver.cc
+++ b/video/rtp_video_stream_receiver.cc
@ -70,7 +70,6 @@ std::unique_ptr<RtpRtcp> CreateRtpRtcpModule(
  configuration.transport_sequence_number_allocator =
      transport_sequence_number_allocator;
  configuration.send_bitrate_observer = nullptr;
-  configuration.send_frame_count_observer = nullptr;
  configuration.send_side_delay_observer = nullptr;
  configuration.send_packet_observer = nullptr;
  configuration.bandwidth_callback = nullptr;