Revert "Add ability to set ssrcs of RtpSender at construction time"

This reverts commit e9d6e658c307fc0241d622756703d5c0d5388d80.

Reason for revert: breaks downstream project

Original change's description:
> Add ability to set ssrcs of RtpSender at construction time
> 
> Bug: webrtc:10774
> Change-Id: I7147a75ccbcd1093dcd2e08047da8900843fdd8d
> Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/144037
> Commit-Queue: Erik Språng <sprang@webrtc.org>
> Reviewed-by: Åsa Persson <asapersson@webrtc.org>
> Cr-Commit-Position: refs/heads/master@{#28447}

TBR=asapersson@webrtc.org,sprang@webrtc.org

Change-Id: I8b0cba0836e7d86ae1718055196c2c89860b97ff
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Bug: webrtc:10774
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/144368
Reviewed-by: Amit Hilbuch <amithi@webrtc.org>
Commit-Queue: Amit Hilbuch <amithi@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#28453}

modules/rtp_rtcp/include/rtp_rtcp.h

@@ -28,6 +28,7 @@
 #include "modules/rtp_rtcp/include/rtp_packet_pacer.h"
 #include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
 #include "modules/rtp_rtcp/source/rtp_packet_to_send.h"
+#include "modules/rtp_rtcp/source/rtp_sender.h"
 #include "rtc_base/constructor_magic.h"
 #include "rtc_base/deprecation.h"
 
@@ -40,7 +41,6 @@ class RateLimiter;
 class ReceiveStatisticsProvider;
 class RemoteBitrateEstimator;
 class RtcEventLog;
-class RTPSender;
 class Transport;
 class VideoBitrateAllocationObserver;
 
@@ -52,7 +52,6 @@ class RtpRtcp : public Module, public RtcpFeedbackSenderInterface {
  public:
   struct Configuration {
     Configuration();
-    Configuration(Configuration&& rhs);
 
     // True for a audio version of the RTP/RTCP module object false will create
     // a video version.
@@ -121,11 +120,6 @@ class RtpRtcp : public Module, public RtcpFeedbackSenderInterface {
     // defaults to  webrtc::FieldTrialBasedConfig.
     const WebRtcKeyValueConfig* field_trials = nullptr;
 
-    // SSRCs for sending media and retransmission, respectively.
-    // FlexFec SSRC is fetched from |flexfec_sender|.
-    absl::optional<uint32_t> media_send_ssrc;
-    absl::optional<uint32_t> rtx_send_ssrc;
-
    private:
     RTC_DISALLOW_COPY_AND_ASSIGN(Configuration);
   };
@@ -199,7 +193,6 @@ class RtpRtcp : public Module, public RtcpFeedbackSenderInterface {
   uint32_t SSRC() const override = 0;
 
   // Sets SSRC, default is a random number.
-  // TODO(bugs.webrtc.org/10774): Remove.
   virtual void SetSSRC(uint32_t ssrc) = 0;
 
   // Sets the value for sending in the RID (and Repaired) RTP header extension.
@@ -227,7 +220,6 @@ class RtpRtcp : public Module, public RtcpFeedbackSenderInterface {
 
   // Sets the SSRC to use when sending RTX packets. This doesn't enable RTX,
   // only the SSRC is set.
-  // TODO(bugs.webrtc.org/10774): Remove.
   virtual void SetRtxSsrc(uint32_t ssrc) = 0;
 
   // Sets the payload type to use when sending RTX packets. Note that this

modules/rtp_rtcp/source/rtp_rtcp_impl.cc

@@ -40,7 +40,6 @@ constexpr int32_t kDefaultAudioReportInterval = 5000;
 }  // namespace
 
 RtpRtcp::Configuration::Configuration() = default;
-RtpRtcp::Configuration::Configuration(Configuration&& rhs) = default;
 
 std::unique_ptr<RtpRtcp> RtpRtcp::Create(const Configuration& configuration) {
   RTC_DCHECK(configuration.clock);
@@ -95,8 +94,27 @@ ModuleRtpRtcpImpl::ModuleRtpRtcpImpl(const Configuration& configuration)
       ack_observer_(configuration.ack_observer),
       rtt_stats_(configuration.rtt_stats),
       rtt_ms_(0) {
+  FieldTrialBasedConfig default_trials;
   if (!configuration.receiver_only) {
-    rtp_sender_.reset(new RTPSender(configuration));
+    rtp_sender_.reset(new RTPSender(
+        configuration.audio, configuration.clock,
+        configuration.outgoing_transport, configuration.paced_sender,
+        configuration.flexfec_sender
+            ? absl::make_optional(configuration.flexfec_sender->ssrc())
+            : absl::nullopt,
+        configuration.transport_sequence_number_allocator,
+        configuration.transport_feedback_callback,
+        configuration.send_bitrate_observer,
+        configuration.send_side_delay_observer, configuration.event_log,
+        configuration.send_packet_observer,
+        configuration.retransmission_rate_limiter,
+        configuration.overhead_observer,
+        configuration.populate_network2_timestamp,
+        configuration.frame_encryptor, configuration.require_frame_encryption,
+        configuration.extmap_allow_mixed,
+        configuration.field_trials ? *configuration.field_trials
+                                   : default_trials));
+
     // Make sure rtcp sender use same timestamp offset as rtp sender.
     rtcp_sender_.SetTimestampOffset(rtp_sender_->TimestampOffset());
   }

modules/rtp_rtcp/source/rtp_sender.cc

@@ -18,7 +18,6 @@
 #include "absl/memory/memory.h"
 #include "absl/strings/match.h"
 #include "api/array_view.h"
-#include "api/transport/field_trial_based_config.h"
 #include "logging/rtc_event_log/events/rtc_event_rtp_packet_outgoing.h"
 #include "logging/rtc_event_log/rtc_event_log.h"
 #include "modules/rtp_rtcp/include/rtp_cvo.h"
@@ -124,41 +123,42 @@ RtpPacketSender::Priority PacketTypeToPriority(RtpPacketToSend::Type type) {
   return RtpPacketSender::Priority::kLowPriority;
 }
 
-bool IsEnabled(absl::string_view name,
-               const WebRtcKeyValueConfig* field_trials) {
-  FieldTrialBasedConfig default_trials;
-  auto& trials = field_trials ? *field_trials : default_trials;
-  return trials.Lookup(name).find("Enabled") == 0;
-}
-
-bool IsDisabled(absl::string_view name,
-                const WebRtcKeyValueConfig* field_trials) {
-  FieldTrialBasedConfig default_trials;
-  auto& trials = field_trials ? *field_trials : default_trials;
-  return trials.Lookup(name).find("Disabled") == 0;
-}
-
 }  // namespace
 
-RTPSender::RTPSender(const RtpRtcp::Configuration& config)
+RTPSender::RTPSender(
-    : clock_(config.clock),
+    bool audio,
+    Clock* clock,
+    Transport* transport,
+    RtpPacketPacer* paced_sender,
+    absl::optional<uint32_t> flexfec_ssrc,
+    TransportSequenceNumberAllocator* sequence_number_allocator,
+    TransportFeedbackObserver* transport_feedback_observer,
+    BitrateStatisticsObserver* bitrate_callback,
+    SendSideDelayObserver* send_side_delay_observer,
+    RtcEventLog* event_log,
+    SendPacketObserver* send_packet_observer,
+    RateLimiter* retransmission_rate_limiter,
+    OverheadObserver* overhead_observer,
+    bool populate_network2_timestamp,
+    FrameEncryptorInterface* frame_encryptor,
+    bool require_frame_encryption,
+    bool extmap_allow_mixed,
+    const WebRtcKeyValueConfig& field_trials)
+    : clock_(clock),
       random_(clock_->TimeInMicroseconds()),
-      audio_configured_(config.audio),
+      audio_configured_(audio),
-      flexfec_ssrc_(config.flexfec_sender
+      flexfec_ssrc_(flexfec_ssrc),
-                        ? absl::make_optional(config.flexfec_sender->ssrc())
+      paced_sender_(paced_sender),
-                        : absl::nullopt),
+      transport_sequence_number_allocator_(sequence_number_allocator),
-      paced_sender_(config.paced_sender),
+      transport_feedback_observer_(transport_feedback_observer),
-      transport_sequence_number_allocator_(
+      transport_(transport),
-          config.transport_sequence_number_allocator),
-      transport_feedback_observer_(config.transport_feedback_callback),
-      transport_(config.outgoing_transport),
       sending_media_(true),  // Default to sending media.
       force_part_of_allocation_(false),
       max_packet_size_(IP_PACKET_SIZE - 28),  // Default is IP-v4/UDP.
       last_payload_type_(-1),
-      rtp_header_extension_map_(config.extmap_allow_mixed),
+      rtp_header_extension_map_(extmap_allow_mixed),
-      packet_history_(clock_),
+      packet_history_(clock),
-      flexfec_packet_history_(clock_),
+      flexfec_packet_history_(clock),
       // Statistics
       send_delays_(),
       max_delay_it_(send_delays_.end()),
@@ -168,13 +168,12 @@ RTPSender::RTPSender(const RtpRtcp::Configuration& config)
       total_bitrate_sent_(kBitrateStatisticsWindowMs,
                           RateStatistics::kBpsScale),
       nack_bitrate_sent_(kBitrateStatisticsWindowMs, RateStatistics::kBpsScale),
-      send_side_delay_observer_(config.send_side_delay_observer),
+      send_side_delay_observer_(send_side_delay_observer),
-      event_log_(config.event_log),
+      event_log_(event_log),
-      send_packet_observer_(config.send_packet_observer),
+      send_packet_observer_(send_packet_observer),
-      bitrate_callback_(config.send_bitrate_observer),
+      bitrate_callback_(bitrate_callback),
       // RTP variables
       sequence_number_forced_(false),
-      ssrc_(config.media_send_ssrc),
       last_rtp_timestamp_(0),
       capture_time_ms_(0),
       last_timestamp_time_ms_(0),
@@ -182,19 +181,19 @@ RTPSender::RTPSender(const RtpRtcp::Configuration& config)
       last_packet_marker_bit_(false),
       csrcs_(),
       rtx_(kRtxOff),
-      ssrc_rtx_(config.rtx_send_ssrc),
       rtp_overhead_bytes_per_packet_(0),
-      retransmission_rate_limiter_(config.retransmission_rate_limiter),
+      retransmission_rate_limiter_(retransmission_rate_limiter),
-      overhead_observer_(config.overhead_observer),
+      overhead_observer_(overhead_observer),
-      populate_network2_timestamp_(config.populate_network2_timestamp),
+      populate_network2_timestamp_(populate_network2_timestamp),
       send_side_bwe_with_overhead_(
-          IsEnabled("WebRTC-SendSideBwe-WithOverhead", config.field_trials)),
+          field_trials.Lookup("WebRTC-SendSideBwe-WithOverhead")
+              .find("Enabled") == 0),
       legacy_packet_history_storage_mode_(
-          IsEnabled("WebRTC-UseRtpPacketHistoryLegacyStorageMode",
+          field_trials.Lookup("WebRTC-UseRtpPacketHistoryLegacyStorageMode")
-                    config.field_trials)),
+              .find("Enabled") == 0),
       payload_padding_prefer_useful_packets_(
-          !IsDisabled("WebRTC-PayloadPadding-UseMostUsefulPacket",
+          field_trials.Lookup("WebRTC-PayloadPadding-UseMostUsefulPacket")
-                      config.field_trials)) {
+              .find("Disabled") != 0) {
   // This random initialization is not intended to be cryptographic strong.
   timestamp_offset_ = random_.Rand<uint32_t>();
   // Random start, 16 bits. Can't be 0.

modules/rtp_rtcp/source/rtp_sender.h

@@ -25,7 +25,6 @@
 #include "modules/rtp_rtcp/include/flexfec_sender.h"
 #include "modules/rtp_rtcp/include/rtp_header_extension_map.h"
 #include "modules/rtp_rtcp/include/rtp_packet_pacer.h"
-#include "modules/rtp_rtcp/include/rtp_rtcp.h"
 #include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
 #include "modules/rtp_rtcp/source/rtp_packet_history.h"
 #include "modules/rtp_rtcp/source/rtp_rtcp_config.h"
@@ -46,7 +45,24 @@ class RtpPacketToSend;
 
 class RTPSender {
  public:
-  explicit RTPSender(const RtpRtcp::Configuration& config);
+  RTPSender(bool audio,
+            Clock* clock,
+            Transport* transport,
+            RtpPacketPacer* paced_sender,
+            absl::optional<uint32_t> flexfec_ssrc,
+            TransportSequenceNumberAllocator* sequence_number_allocator,
+            TransportFeedbackObserver* transport_feedback_callback,
+            BitrateStatisticsObserver* bitrate_callback,
+            SendSideDelayObserver* send_side_delay_observer,
+            RtcEventLog* event_log,
+            SendPacketObserver* send_packet_observer,
+            RateLimiter* nack_rate_limiter,
+            OverheadObserver* overhead_observer,
+            bool populate_network2_timestamp,
+            FrameEncryptorInterface* frame_encryptor,
+            bool require_frame_encryption,
+            bool extmap_allow_mixed,
+            const WebRtcKeyValueConfig& field_trials);
 
   ~RTPSender();
 
@@ -67,7 +83,6 @@ class RTPSender {
   uint32_t TimestampOffset() const;
   void SetTimestampOffset(uint32_t timestamp);
 
-  // TODO(bugs.webrtc.org/10774): Remove.
   void SetSSRC(uint32_t ssrc);
 
   void SetRid(const std::string& rid);
@@ -114,9 +129,8 @@ class RTPSender {
   // RTX.
   void SetRtxStatus(int mode);
   int RtxStatus() const;
-  uint32_t RtxSsrc() const;
 
-  // TODO(bugs.webrtc.org/10774): Remove.
+  uint32_t RtxSsrc() const;
   void SetRtxSsrc(uint32_t ssrc);
 
   void SetRtxPayloadType(int payload_type, int associated_payload_type);

modules/rtp_rtcp/source/rtp_sender_audio_unittest.cc

@@ -64,15 +64,26 @@ class RtpSenderAudioTest : public ::testing::Test {
  public:
   RtpSenderAudioTest()
       : fake_clock_(kStartTime),
-        rtp_sender_([&] {
+        rtp_sender_(true,
-          RtpRtcp::Configuration config;
+                    &fake_clock_,
-          config.audio = true;
+                    &transport_,
-          config.clock = &fake_clock_;
+                    nullptr,
-          config.outgoing_transport = &transport_;
+                    absl::nullopt,
-          config.media_send_ssrc = kSsrc;
+                    nullptr,
-          return config;
+                    nullptr,
-        }()),
+                    nullptr,
+                    nullptr,
+                    nullptr,
+                    nullptr,
+                    nullptr,
+                    nullptr,
+                    false,
+                    nullptr,
+                    false,
+                    false,
+                    FieldTrialBasedConfig()),
         rtp_sender_audio_(&fake_clock_, &rtp_sender_) {
+    rtp_sender_.SetSSRC(kSsrc);
     rtp_sender_.SetSequenceNumber(kSeqNum);
   }
 

modules/rtp_rtcp/source/rtp_sender_unittest.cc

@@ -195,14 +195,6 @@ class RtpSenderTest : public ::testing::TestWithParam<bool> {
         mock_rtc_event_log_(),
         mock_paced_sender_(),
         retransmission_rate_limiter_(&fake_clock_, 1000),
-        flexfec_sender_(0,
-                        kFlexFecSsrc,
-                        kSsrc,
-                        "",
-                        std::vector<RtpExtension>(),
-                        std::vector<RtpExtensionSize>(),
-                        nullptr,
-                        &fake_clock_),
         rtp_sender_(),
         transport_(),
         kMarkerBit(true),
@@ -212,21 +204,16 @@ class RtpSenderTest : public ::testing::TestWithParam<bool> {
   void SetUp() override { SetUpRtpSender(true, false); }
 
   void SetUpRtpSender(bool pacer, bool populate_network2) {
-    RtpRtcp::Configuration config;
+    rtp_sender_.reset(new RTPSender(
-    config.clock = &fake_clock_;
+        false, &fake_clock_, &transport_, pacer ? &mock_paced_sender_ : nullptr,
-    config.outgoing_transport = &transport_;
+        kFlexFecSsrc, &seq_num_allocator_, nullptr, nullptr, nullptr,
-    config.media_send_ssrc = kSsrc;
+        &mock_rtc_event_log_, &send_packet_observer_,
-    config.rtx_send_ssrc = kRtxSsrc;
+        &retransmission_rate_limiter_, nullptr, populate_network2, nullptr,
-    config.flexfec_sender = &flexfec_sender_;
+        false, false, FieldTrialBasedConfig()));
-    config.transport_sequence_number_allocator = &seq_num_allocator_;
-    config.event_log = &mock_rtc_event_log_;
-    config.send_packet_observer = &send_packet_observer_;
-    config.retransmission_rate_limiter = &retransmission_rate_limiter_;
-    config.paced_sender = pacer ? &mock_paced_sender_ : nullptr;
-    config.populate_network2_timestamp = populate_network2;
-    rtp_sender_.reset(new RTPSender(config));
     rtp_sender_->SetSequenceNumber(kSeqNum);
     rtp_sender_->SetTimestampOffset(0);
+    rtp_sender_->SetSSRC(kSsrc);
+    rtp_sender_->SetRtxSsrc(kRtxSsrc);
   }
 
   SimulatedClock fake_clock_;
@@ -236,7 +223,6 @@ class RtpSenderTest : public ::testing::TestWithParam<bool> {
   StrictMock<MockSendPacketObserver> send_packet_observer_;
   StrictMock<MockTransportFeedbackObserver> feedback_observer_;
   RateLimiter retransmission_rate_limiter_;
-  FlexfecSender flexfec_sender_;
   std::unique_ptr<RTPSender> rtp_sender_;
   LoopbackTransportTest transport_;
   const bool kMarkerBit;
@@ -359,17 +345,14 @@ TEST_P(RtpSenderTestWithoutPacer, AssignSequenceNumberMayAllowPaddingOnVideo) {
 
 TEST_P(RtpSenderTest, AssignSequenceNumberAllowsPaddingOnAudio) {
   MockTransport transport;
-  RtpRtcp::Configuration config;
+  const bool kEnableAudio = true;
-  config.audio = true;
+  rtp_sender_.reset(new RTPSender(
-  config.clock = &fake_clock_;
+      kEnableAudio, &fake_clock_, &transport, &mock_paced_sender_,
-  config.outgoing_transport = &transport;
+      absl::nullopt, nullptr, nullptr, nullptr, nullptr, &mock_rtc_event_log_,
-  config.paced_sender = &mock_paced_sender_;
+      nullptr, &retransmission_rate_limiter_, nullptr, false, nullptr, false,
-  config.media_send_ssrc = kSsrc;
+      false, FieldTrialBasedConfig()));
-  config.event_log = &mock_rtc_event_log_;
-  config.retransmission_rate_limiter = &retransmission_rate_limiter_;
-  rtp_sender_ = absl::make_unique<RTPSender>(config);
-
   rtp_sender_->SetTimestampOffset(0);
+  rtp_sender_->SetSSRC(kSsrc);
 
   std::unique_ptr<RtpPacketToSend> audio_packet = rtp_sender_->AllocatePacket();
   // Padding on audio stream allowed regardless of marker in the last packet.
@@ -410,18 +393,13 @@ TEST_P(RtpSenderTestWithoutPacer,
        TransportFeedbackObserverGetsCorrectByteCount) {
   constexpr int kRtpOverheadBytesPerPacket = 12 + 8;
   NiceMock<MockOverheadObserver> mock_overhead_observer;
-
+  rtp_sender_.reset(
-  RtpRtcp::Configuration config;
+      new RTPSender(false, &fake_clock_, &transport_, nullptr, absl::nullopt,
-  config.clock = &fake_clock_;
+                    &seq_num_allocator_, &feedback_observer_, nullptr, nullptr,
-  config.outgoing_transport = &transport_;
+                    &mock_rtc_event_log_, nullptr,
-  config.media_send_ssrc = kSsrc;
+                    &retransmission_rate_limiter_, &mock_overhead_observer,
-  config.transport_sequence_number_allocator = &seq_num_allocator_;
+                    false, nullptr, false, false, FieldTrialBasedConfig()));
-  config.transport_feedback_callback = &feedback_observer_;
+  rtp_sender_->SetSSRC(kSsrc);
-  config.event_log = &mock_rtc_event_log_;
-  config.retransmission_rate_limiter = &retransmission_rate_limiter_;
-  config.overhead_observer = &mock_overhead_observer;
-  rtp_sender_ = absl::make_unique<RTPSender>(config);
-
   EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
                    kRtpExtensionTransportSequenceNumber,
                    kTransportSequenceNumberExtensionId));
@@ -449,17 +427,13 @@ TEST_P(RtpSenderTestWithoutPacer,
 }
 
 TEST_P(RtpSenderTestWithoutPacer, SendsPacketsWithTransportSequenceNumber) {
-  RtpRtcp::Configuration config;
+  rtp_sender_.reset(
-  config.clock = &fake_clock_;
+      new RTPSender(false, &fake_clock_, &transport_, nullptr, absl::nullopt,
-  config.outgoing_transport = &transport_;
+                    &seq_num_allocator_, &feedback_observer_, nullptr, nullptr,
-  config.media_send_ssrc = kSsrc;
+                    &mock_rtc_event_log_, &send_packet_observer_,
-  config.transport_sequence_number_allocator = &seq_num_allocator_;
+                    &retransmission_rate_limiter_, nullptr, false, nullptr,
-  config.transport_feedback_callback = &feedback_observer_;
+                    false, false, FieldTrialBasedConfig()));
-  config.event_log = &mock_rtc_event_log_;
+  rtp_sender_->SetSSRC(kSsrc);
-  config.send_packet_observer = &send_packet_observer_;
-  config.retransmission_rate_limiter = &retransmission_rate_limiter_;
-  rtp_sender_ = absl::make_unique<RTPSender>(config);
-
   EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
                    kRtpExtensionTransportSequenceNumber,
                    kTransportSequenceNumberExtensionId));
@@ -491,16 +465,13 @@ TEST_P(RtpSenderTestWithoutPacer, SendsPacketsWithTransportSequenceNumber) {
 }
 
 TEST_P(RtpSenderTestWithoutPacer, PacketOptionsNoRetransmission) {
-  RtpRtcp::Configuration config;
+  rtp_sender_.reset(
-  config.clock = &fake_clock_;
+      new RTPSender(false, &fake_clock_, &transport_, nullptr, absl::nullopt,
-  config.outgoing_transport = &transport_;
+                    &seq_num_allocator_, &feedback_observer_, nullptr, nullptr,
-  config.media_send_ssrc = kSsrc;
+                    &mock_rtc_event_log_, &send_packet_observer_,
-  config.transport_sequence_number_allocator = &seq_num_allocator_;
+                    &retransmission_rate_limiter_, nullptr, false, nullptr,
-  config.transport_feedback_callback = &feedback_observer_;
+                    false, false, FieldTrialBasedConfig()));
-  config.event_log = &mock_rtc_event_log_;
+  rtp_sender_->SetSSRC(kSsrc);
-  config.send_packet_observer = &send_packet_observer_;
-  config.retransmission_rate_limiter = &retransmission_rate_limiter_;
-  rtp_sender_ = absl::make_unique<RTPSender>(config);
 
   SendGenericPacket();
 
@@ -550,15 +521,12 @@ TEST_P(RtpSenderTestWithoutPacer, DoesnSetIncludedInAllocationByDefault) {
 
 TEST_P(RtpSenderTestWithoutPacer, OnSendSideDelayUpdated) {
   StrictMock<MockSendSideDelayObserver> send_side_delay_observer_;
-
+  rtp_sender_.reset(
-  RtpRtcp::Configuration config;
+      new RTPSender(false, &fake_clock_, &transport_, nullptr, absl::nullopt,
-  config.clock = &fake_clock_;
+                    nullptr, nullptr, nullptr, &send_side_delay_observer_,
-  config.outgoing_transport = &transport_;
+                    &mock_rtc_event_log_, nullptr, nullptr, nullptr, false,
-  config.media_send_ssrc = kSsrc;
+                    nullptr, false, false, FieldTrialBasedConfig()));
-  config.send_side_delay_observer = &send_side_delay_observer_;
+  rtp_sender_->SetSSRC(kSsrc);
-  config.event_log = &mock_rtc_event_log_;
-  rtp_sender_ = absl::make_unique<RTPSender>(config);
-
   PlayoutDelayOracle playout_delay_oracle;
   RTPSenderVideo rtp_sender_video(&fake_clock_, rtp_sender_.get(), nullptr,
                                   &playout_delay_oracle, nullptr, false, false,
@@ -640,19 +608,14 @@ TEST_P(RtpSenderTestWithoutPacer, OnSendPacketUpdated) {
 }
 
 TEST_P(RtpSenderTest, SendsPacketsWithTransportSequenceNumber) {
-  RtpRtcp::Configuration config;
+  rtp_sender_.reset(new RTPSender(
-  config.clock = &fake_clock_;
+      false, &fake_clock_, &transport_, &mock_paced_sender_, absl::nullopt,
-  config.outgoing_transport = &transport_;
+      &seq_num_allocator_, &feedback_observer_, nullptr, nullptr,
-  config.paced_sender = &mock_paced_sender_;
+      &mock_rtc_event_log_, &send_packet_observer_,
-  config.media_send_ssrc = kSsrc;
+      &retransmission_rate_limiter_, nullptr, false, nullptr, false, false,
-  config.transport_sequence_number_allocator = &seq_num_allocator_;
+      FieldTrialBasedConfig()));
-  config.transport_feedback_callback = &feedback_observer_;
-  config.event_log = &mock_rtc_event_log_;
-  config.send_packet_observer = &send_packet_observer_;
-  config.retransmission_rate_limiter = &retransmission_rate_limiter_;
-  rtp_sender_ = absl::make_unique<RTPSender>(config);
-
   rtp_sender_->SetSequenceNumber(kSeqNum);
+  rtp_sender_->SetSSRC(kSsrc);
   rtp_sender_->SetStorePacketsStatus(true, 10);
   EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
                    kRtpExtensionTransportSequenceNumber,
@@ -1041,16 +1004,13 @@ TEST_P(RtpSenderTest, OnSendPacketNotUpdatedForRetransmits) {
 }
 
 TEST_P(RtpSenderTest, OnSendPacketNotUpdatedWithoutSeqNumAllocator) {
-  RtpRtcp::Configuration config;
+  rtp_sender_.reset(new RTPSender(
-  config.clock = &fake_clock_;
+      false, &fake_clock_, &transport_, &mock_paced_sender_, absl::nullopt,
-  config.outgoing_transport = &transport_;
+      nullptr /* TransportSequenceNumberAllocator */, nullptr, nullptr, nullptr,
-  config.paced_sender = &mock_paced_sender_;
+      nullptr, &send_packet_observer_, &retransmission_rate_limiter_, nullptr,
-  config.media_send_ssrc = kSsrc;
+      false, nullptr, false, false, FieldTrialBasedConfig()));
-  config.send_packet_observer = &send_packet_observer_;
-  config.retransmission_rate_limiter = &retransmission_rate_limiter_;
-  rtp_sender_ = absl::make_unique<RTPSender>(config);
-
   rtp_sender_->SetSequenceNumber(kSeqNum);
+  rtp_sender_->SetSSRC(kSsrc);
   EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
                    kRtpExtensionTransportSequenceNumber,
                    kTransportSequenceNumberExtensionId));
@@ -1075,17 +1035,13 @@ TEST_P(RtpSenderTest, SendRedundantPayloads) {
   test::ScopedFieldTrials field_trials(
       "WebRTC-PayloadPadding-UseMostUsefulPacket/Disabled/");
   MockTransport transport;
-  RtpRtcp::Configuration config;
+  rtp_sender_.reset(new RTPSender(
-  config.clock = &fake_clock_;
+      false, &fake_clock_, &transport, &mock_paced_sender_, absl::nullopt,
-  config.outgoing_transport = &transport;
+      nullptr, nullptr, nullptr, nullptr, &mock_rtc_event_log_, nullptr,
-  config.paced_sender = &mock_paced_sender_;
+      &retransmission_rate_limiter_, nullptr, false, nullptr, false, false,
-  config.media_send_ssrc = kSsrc;
+      FieldTrialBasedConfig()));
-  config.rtx_send_ssrc = kRtxSsrc;
-  config.event_log = &mock_rtc_event_log_;
-  config.retransmission_rate_limiter = &retransmission_rate_limiter_;
-  rtp_sender_ = absl::make_unique<RTPSender>(config);
-
   rtp_sender_->SetSequenceNumber(kSeqNum);
+  rtp_sender_->SetSSRC(kSsrc);
   rtp_sender_->SetRtxPayloadType(kRtxPayload, kPayload);
 
   uint16_t seq_num = kSeqNum;
@@ -1098,6 +1054,7 @@ TEST_P(RtpSenderTest, SendRedundantPayloads) {
   rtp_header_len += 4;  // 4 extra bytes common to all extension headers.
 
   rtp_sender_->SetRtxStatus(kRtxRetransmitted | kRtxRedundantPayloads);
+  rtp_sender_->SetRtxSsrc(1234);
 
   const size_t kNumPayloadSizes = 10;
   const size_t kPayloadSizes[kNumPayloadSizes] = {500, 550, 600, 650, 700,
@@ -1156,17 +1113,13 @@ TEST_P(RtpSenderTest, SendRedundantPayloadsUsefulPadding) {
   test::ScopedFieldTrials field_trials(
       "WebRTC-PayloadPadding-UseMostUsefulPacket/Enabled/");
   MockTransport transport;
-  RtpRtcp::Configuration config;
+  rtp_sender_ = absl::make_unique<RTPSender>(
-  config.clock = &fake_clock_;
+      false, &fake_clock_, &transport, &mock_paced_sender_, absl::nullopt,
-  config.outgoing_transport = &transport;
+      nullptr, nullptr, nullptr, nullptr, &mock_rtc_event_log_, nullptr,
-  config.paced_sender = &mock_paced_sender_;
+      &retransmission_rate_limiter_, nullptr, false, nullptr, false, false,
-  config.media_send_ssrc = kSsrc;
+      FieldTrialBasedConfig());
-  config.rtx_send_ssrc = kRtxSsrc;
-  config.event_log = &mock_rtc_event_log_;
-  config.retransmission_rate_limiter = &retransmission_rate_limiter_;
-  rtp_sender_ = absl::make_unique<RTPSender>(config);
-
   rtp_sender_->SetSequenceNumber(kSeqNum);
+  rtp_sender_->SetSSRC(kSsrc);
   rtp_sender_->SetRtxPayloadType(kRtxPayload, kPayload);
 
   uint16_t seq_num = kSeqNum;
@@ -1179,6 +1132,7 @@ TEST_P(RtpSenderTest, SendRedundantPayloadsUsefulPadding) {
   rtp_header_len += 4;  // 4 extra bytes common to all extension headers.
 
   rtp_sender_->SetRtxStatus(kRtxRetransmitted | kRtxRedundantPayloads);
+  rtp_sender_->SetRtxSsrc(1234);
 
   const size_t kNumPayloadSizes = 10;
   const size_t kPayloadSizes[kNumPayloadSizes] = {500, 550, 600, 650, 700,
@@ -1305,25 +1259,21 @@ TEST_P(RtpSenderTest, SendFlexfecPackets) {
   constexpr uint32_t kTimestamp = 1234;
   constexpr int kMediaPayloadType = 127;
   constexpr int kFlexfecPayloadType = 118;
+  constexpr uint32_t kMediaSsrc = 1234;
+  constexpr uint32_t kFlexfecSsrc = 5678;
   const std::vector<RtpExtension> kNoRtpExtensions;
   const std::vector<RtpExtensionSize> kNoRtpExtensionSizes;
-  FlexfecSender flexfec_sender(kFlexfecPayloadType, kFlexFecSsrc, kSsrc, kNoMid,
+  FlexfecSender flexfec_sender(kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc,
-                               kNoRtpExtensions, kNoRtpExtensionSizes,
+                               kNoMid, kNoRtpExtensions, kNoRtpExtensionSizes,
                                nullptr /* rtp_state */, &fake_clock_);
 
   // Reset |rtp_sender_| to use FlexFEC.
-  RtpRtcp::Configuration config;
+  rtp_sender_.reset(new RTPSender(
-  config.clock = &fake_clock_;
+      false, &fake_clock_, &transport_, &mock_paced_sender_, kFlexfecSsrc,
-  config.outgoing_transport = &transport_;
+      &seq_num_allocator_, nullptr, nullptr, nullptr, &mock_rtc_event_log_,
-  config.paced_sender = &mock_paced_sender_;
+      &send_packet_observer_, &retransmission_rate_limiter_, nullptr, false,
-  config.media_send_ssrc = kSsrc;
+      nullptr, false, false, FieldTrialBasedConfig()));
-  config.flexfec_sender = &flexfec_sender_;
+  rtp_sender_->SetSSRC(kMediaSsrc);
-  config.transport_sequence_number_allocator = &seq_num_allocator_;
-  config.event_log = &mock_rtc_event_log_;
-  config.send_packet_observer = &send_packet_observer_;
-  config.retransmission_rate_limiter = &retransmission_rate_limiter_;
-  rtp_sender_ = absl::make_unique<RTPSender>(config);
-
   rtp_sender_->SetSequenceNumber(kSeqNum);
   rtp_sender_->SetStorePacketsStatus(true, 10);
 
@@ -1341,11 +1291,12 @@ TEST_P(RtpSenderTest, SendFlexfecPackets) {
   params.fec_mask_type = kFecMaskRandom;
   rtp_sender_video.SetFecParameters(params, params);
 
-  EXPECT_CALL(mock_paced_sender_, InsertPacket(RtpPacketSender::kLowPriority,
+  EXPECT_CALL(mock_paced_sender_,
-                                               kSsrc, kSeqNum, _, _, false));
+              InsertPacket(RtpPacketSender::kLowPriority, kMediaSsrc, kSeqNum,
+                           _, _, false));
   uint16_t flexfec_seq_num;
   EXPECT_CALL(mock_paced_sender_, InsertPacket(RtpPacketSender::kLowPriority,
-                                               kFlexFecSsrc, _, _, _, false))
+                                               kFlexfecSsrc, _, _, _, false))
       .WillOnce(SaveArg<2>(&flexfec_seq_num));
 
   RTPVideoHeader video_header;
@@ -1358,47 +1309,43 @@ TEST_P(RtpSenderTest, SendFlexfecPackets) {
               LogProxy(SameRtcEventTypeAs(RtcEvent::Type::RtpPacketOutgoing)))
       .Times(2);
   EXPECT_EQ(RtpPacketSendResult::kSuccess,
-            rtp_sender_->TimeToSendPacket(kSsrc, kSeqNum,
+            rtp_sender_->TimeToSendPacket(kMediaSsrc, kSeqNum,
                                           fake_clock_.TimeInMilliseconds(),
                                           false, PacedPacketInfo()));
   EXPECT_EQ(RtpPacketSendResult::kSuccess,
-            rtp_sender_->TimeToSendPacket(kFlexFecSsrc, flexfec_seq_num,
+            rtp_sender_->TimeToSendPacket(kFlexfecSsrc, flexfec_seq_num,
                                           fake_clock_.TimeInMilliseconds(),
                                           false, PacedPacketInfo()));
   ASSERT_EQ(2, transport_.packets_sent());
   const RtpPacketReceived& media_packet = transport_.sent_packets_[0];
   EXPECT_EQ(kMediaPayloadType, media_packet.PayloadType());
   EXPECT_EQ(kSeqNum, media_packet.SequenceNumber());
-  EXPECT_EQ(kSsrc, media_packet.Ssrc());
+  EXPECT_EQ(kMediaSsrc, media_packet.Ssrc());
   const RtpPacketReceived& flexfec_packet = transport_.sent_packets_[1];
   EXPECT_EQ(kFlexfecPayloadType, flexfec_packet.PayloadType());
   EXPECT_EQ(flexfec_seq_num, flexfec_packet.SequenceNumber());
-  EXPECT_EQ(kFlexFecSsrc, flexfec_packet.Ssrc());
+  EXPECT_EQ(kFlexfecSsrc, flexfec_packet.Ssrc());
 }
 
 TEST_P(RtpSenderTestWithoutPacer, SendFlexfecPackets) {
   constexpr uint32_t kTimestamp = 1234;
   constexpr int kMediaPayloadType = 127;
   constexpr int kFlexfecPayloadType = 118;
+  constexpr uint32_t kMediaSsrc = 1234;
   constexpr uint32_t kFlexfecSsrc = 5678;
   const std::vector<RtpExtension> kNoRtpExtensions;
   const std::vector<RtpExtensionSize> kNoRtpExtensionSizes;
-  FlexfecSender flexfec_sender(kFlexfecPayloadType, kFlexfecSsrc, kSsrc, kNoMid,
+  FlexfecSender flexfec_sender(kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc,
-                               kNoRtpExtensions, kNoRtpExtensionSizes,
+                               kNoMid, kNoRtpExtensions, kNoRtpExtensionSizes,
                                nullptr /* rtp_state */, &fake_clock_);
 
   // Reset |rtp_sender_| to use FlexFEC.
-  RtpRtcp::Configuration config;
+  rtp_sender_.reset(new RTPSender(
-  config.clock = &fake_clock_;
+      false, &fake_clock_, &transport_, nullptr, flexfec_sender.ssrc(),
-  config.outgoing_transport = &transport_;
+      &seq_num_allocator_, nullptr, nullptr, nullptr, &mock_rtc_event_log_,
-  config.media_send_ssrc = kSsrc;
+      &send_packet_observer_, &retransmission_rate_limiter_, nullptr, false,
-  config.flexfec_sender = &flexfec_sender;
+      nullptr, false, false, FieldTrialBasedConfig()));
-  config.transport_sequence_number_allocator = &seq_num_allocator_;
+  rtp_sender_->SetSSRC(kMediaSsrc);
-  config.event_log = &mock_rtc_event_log_;
-  config.send_packet_observer = &send_packet_observer_;
-  config.retransmission_rate_limiter = &retransmission_rate_limiter_;
-  rtp_sender_ = absl::make_unique<RTPSender>(config);
-
   rtp_sender_->SetSequenceNumber(kSeqNum);
 
   PlayoutDelayOracle playout_delay_oracle;
@@ -1427,7 +1374,7 @@ TEST_P(RtpSenderTestWithoutPacer, SendFlexfecPackets) {
   ASSERT_EQ(2, transport_.packets_sent());
   const RtpPacketReceived& media_packet = transport_.sent_packets_[0];
   EXPECT_EQ(kMediaPayloadType, media_packet.PayloadType());
-  EXPECT_EQ(kSsrc, media_packet.Ssrc());
+  EXPECT_EQ(kMediaSsrc, media_packet.Ssrc());
   const RtpPacketReceived& flexfec_packet = transport_.sent_packets_[1];
   EXPECT_EQ(kFlexfecPayloadType, flexfec_packet.PayloadType());
   EXPECT_EQ(kFlexfecSsrc, flexfec_packet.Ssrc());
@@ -1487,6 +1434,7 @@ TEST_P(RtpSenderTestWithoutPacer, RidIncludedOnRtxSentPackets) {
   rtp_sender_->SetSendingMediaStatus(true);
 
   rtp_sender_->SetRtxStatus(kRtxRetransmitted | kRtxRedundantPayloads);
+  rtp_sender_->SetRtxSsrc(kRtxSsrc);
   rtp_sender_->SetRtxPayloadType(kRtxPayload, kPayload);
 
   rtp_sender_->SetStorePacketsStatus(true, 10);
@@ -1513,25 +1461,22 @@ TEST_P(RtpSenderTest, FecOverheadRate) {
   constexpr uint32_t kTimestamp = 1234;
   constexpr int kMediaPayloadType = 127;
   constexpr int kFlexfecPayloadType = 118;
+  constexpr uint32_t kMediaSsrc = 1234;
+  constexpr uint32_t kFlexfecSsrc = 5678;
   const std::vector<RtpExtension> kNoRtpExtensions;
   const std::vector<RtpExtensionSize> kNoRtpExtensionSizes;
-  FlexfecSender flexfec_sender(kFlexfecPayloadType, kFlexFecSsrc, kSsrc, kNoMid,
+  FlexfecSender flexfec_sender(kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc,
-                               kNoRtpExtensions, kNoRtpExtensionSizes,
+                               kNoMid, kNoRtpExtensions, kNoRtpExtensionSizes,
                                nullptr /* rtp_state */, &fake_clock_);
 
   // Reset |rtp_sender_| to use FlexFEC.
-  RtpRtcp::Configuration config;
+  rtp_sender_.reset(new RTPSender(
-  config.clock = &fake_clock_;
+      false, &fake_clock_, &transport_, &mock_paced_sender_,
-  config.outgoing_transport = &transport_;
+      flexfec_sender.ssrc(), &seq_num_allocator_, nullptr, nullptr, nullptr,
-  config.paced_sender = &mock_paced_sender_;
+      &mock_rtc_event_log_, &send_packet_observer_,
-  config.media_send_ssrc = kSsrc;
+      &retransmission_rate_limiter_, nullptr, false, nullptr, false, false,
-  config.flexfec_sender = &flexfec_sender;
+      FieldTrialBasedConfig()));
-  config.transport_sequence_number_allocator = &seq_num_allocator_;
+  rtp_sender_->SetSSRC(kMediaSsrc);
-  config.event_log = &mock_rtc_event_log_;
-  config.send_packet_observer = &send_packet_observer_;
-  config.retransmission_rate_limiter = &retransmission_rate_limiter_;
-  rtp_sender_ = absl::make_unique<RTPSender>(config);
-
   rtp_sender_->SetSequenceNumber(kSeqNum);
 
   PlayoutDelayOracle playout_delay_oracle;
@@ -1598,14 +1543,12 @@ TEST_P(RtpSenderTest, BitrateCallbacks) {
     uint32_t total_bitrate_;
     uint32_t retransmit_bitrate_;
   } callback;
-
+  rtp_sender_.reset(
-  RtpRtcp::Configuration config;
+      new RTPSender(false, &fake_clock_, &transport_, nullptr, absl::nullopt,
-  config.clock = &fake_clock_;
+                    nullptr, nullptr, &callback, nullptr, nullptr, nullptr,
-  config.outgoing_transport = &transport_;
+                    &retransmission_rate_limiter_, nullptr, false, nullptr,
-  config.media_send_ssrc = kSsrc;
+                    false, false, FieldTrialBasedConfig()));
-  config.send_bitrate_observer = &callback;
+  rtp_sender_->SetSSRC(kSsrc);
-  config.retransmission_rate_limiter = &retransmission_rate_limiter_;
-  rtp_sender_ = absl::make_unique<RTPSender>(config);
 
   PlayoutDelayOracle playout_delay_oracle;
   RTPSenderVideo rtp_sender_video(&fake_clock_, rtp_sender_.get(), nullptr,
@@ -1769,6 +1712,8 @@ TEST_P(RtpSenderTestWithoutPacer, StreamDataCountersCallbacks) {
 TEST_P(RtpSenderTestWithoutPacer, BytesReportedCorrectly) {
   // XXX const char* kPayloadName = "GENERIC";
   const uint8_t kPayloadType = 127;
+  rtp_sender_->SetSSRC(1234);
+  rtp_sender_->SetRtxSsrc(kRtxSsrc);
   rtp_sender_->SetRtxPayloadType(kPayloadType - 1, kPayloadType);
   rtp_sender_->SetRtxStatus(kRtxRetransmitted | kRtxRedundantPayloads);
 
@@ -1838,13 +1783,12 @@ TEST_P(RtpSenderTestWithoutPacer, RespectsNackBitrateLimit) {
 
 TEST_P(RtpSenderTest, OnOverheadChanged) {
   MockOverheadObserver mock_overhead_observer;
-  RtpRtcp::Configuration config;
+  rtp_sender_.reset(
-  config.clock = &fake_clock_;
+      new RTPSender(false, &fake_clock_, &transport_, nullptr, absl::nullopt,
-  config.outgoing_transport = &transport_;
+                    nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,
-  config.media_send_ssrc = kSsrc;
+                    &retransmission_rate_limiter_, &mock_overhead_observer,
-  config.retransmission_rate_limiter = &retransmission_rate_limiter_;
+                    false, nullptr, false, false, FieldTrialBasedConfig()));
-  config.overhead_observer = &mock_overhead_observer;
+  rtp_sender_->SetSSRC(kSsrc);
-  rtp_sender_ = absl::make_unique<RTPSender>(config);
 
   // RTP overhead is 12B.
   EXPECT_CALL(mock_overhead_observer, OnOverheadChanged(12)).Times(1);
@@ -1861,13 +1805,12 @@ TEST_P(RtpSenderTest, OnOverheadChanged) {
 
 TEST_P(RtpSenderTest, DoesNotUpdateOverheadOnEqualSize) {
   MockOverheadObserver mock_overhead_observer;
-  RtpRtcp::Configuration config;
+  rtp_sender_.reset(
-  config.clock = &fake_clock_;
+      new RTPSender(false, &fake_clock_, &transport_, nullptr, absl::nullopt,
-  config.outgoing_transport = &transport_;
+                    nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,
-  config.media_send_ssrc = kSsrc;
+                    &retransmission_rate_limiter_, &mock_overhead_observer,
-  config.retransmission_rate_limiter = &retransmission_rate_limiter_;
+                    false, nullptr, false, false, FieldTrialBasedConfig()));
-  config.overhead_observer = &mock_overhead_observer;
+  rtp_sender_->SetSSRC(kSsrc);
-  rtp_sender_ = absl::make_unique<RTPSender>(config);
 
   EXPECT_CALL(mock_overhead_observer, OnOverheadChanged(_)).Times(1);
   SendGenericPacket();
@@ -2083,17 +2026,13 @@ TEST_P(RtpSenderTest, TrySendPacketUpdatesStats) {
   const size_t kPayloadSize = 1000;
 
   StrictMock<MockSendSideDelayObserver> send_side_delay_observer;
-
+  rtp_sender_.reset(new RTPSender(
-  RtpRtcp::Configuration config;
+      false, &fake_clock_, &transport_, nullptr, kFlexFecSsrc, nullptr, nullptr,
-  config.clock = &fake_clock_;
+      nullptr, &send_side_delay_observer, &mock_rtc_event_log_,
-  config.outgoing_transport = &transport_;
+      &send_packet_observer_, nullptr, nullptr, false, nullptr, false, false,
-  config.media_send_ssrc = kSsrc;
+      FieldTrialBasedConfig()));
-  config.rtx_send_ssrc = kRtxSsrc;
+  rtp_sender_->SetSSRC(kSsrc);
-  config.flexfec_sender = &flexfec_sender_;
+  rtp_sender_->SetRtxSsrc(kRtxSsrc);
-  config.send_side_delay_observer = &send_side_delay_observer;
-  config.event_log = &mock_rtc_event_log_;
-  config.send_packet_observer = &send_packet_observer_;
-  rtp_sender_ = absl::make_unique<RTPSender>(config);
   ASSERT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
                    kRtpExtensionTransportSequenceNumber,
                    kTransportSequenceNumberExtensionId));

modules/rtp_rtcp/source/rtp_sender_video_unittest.cc

@@ -140,18 +140,29 @@ class RtpSenderVideoTest : public ::testing::TestWithParam<bool> {
       : field_trials_(GetParam()),
         fake_clock_(kStartTime),
         retransmission_rate_limiter_(&fake_clock_, 1000),
-        rtp_sender_([&] {
+        // TODO(pbos): Set up to use pacer.
-          RtpRtcp::Configuration config;
+        rtp_sender_(false,
-          config.clock = &fake_clock_;
+                    &fake_clock_,
-          config.outgoing_transport = &transport_;
+                    &transport_,
-          config.retransmission_rate_limiter = &retransmission_rate_limiter_;
+                    nullptr,
-          config.field_trials = &field_trials_;
+                    absl::nullopt,
-          config.media_send_ssrc = kSsrc;
+                    nullptr,
-          return config;
+                    nullptr,
-        }()),
+                    nullptr,
+                    nullptr,
+                    nullptr,
+                    nullptr,
+                    &retransmission_rate_limiter_,
+                    nullptr,
+                    false,
+                    nullptr,
+                    false,
+                    false,
+                    field_trials_),
         rtp_sender_video_(&fake_clock_, &rtp_sender_, nullptr, field_trials_) {
     rtp_sender_.SetSequenceNumber(kSeqNum);
     rtp_sender_.SetTimestampOffset(0);
+    rtp_sender_.SetSSRC(kSsrc);
 
     rtp_sender_video_.RegisterPayloadType(kPayload, "generic",
                                           /*raw_payload=*/false);