Support N unsignaled audio streams

webrtc/media/engine/webrtcvoiceengine_unittest.cc

Index: webrtc/media/engine/webrtcvoiceengine_unittest.cc
diff --git a/webrtc/media/engine/webrtcvoiceengine_unittest.cc b/webrtc/media/engine/webrtcvoiceengine_unittest.cc
index c55389ae7361d9beaa4e8a1469a732019836e943..5045d720267dac21d883292ed2ddb2a371e4d997 100644
--- a/webrtc/media/engine/webrtcvoiceengine_unittest.cc
+++ b/webrtc/media/engine/webrtcvoiceengine_unittest.cc
@@ -47,10 +47,11 @@ const cricket::AudioCodec
 const cricket::AudioCodec
     kTelephoneEventCodec2(107, "telephone-event", 32000, 0, 1);
 
-const uint32_t kSsrc1 = 0x99;
+const uint32_t kSsrc1 = 1;
 const uint32_t kSsrc2 = 2;
 const uint32_t kSsrc3 = 3;
 const uint32_t kSsrc4 = 0x42;
+const uint32_t kSsrc9 = 0x9;
 const uint32_t kSsrcs4[] = { 1, 2, 3, 4 };
 
 constexpr int kRtpHistoryMs = 5000;
@@ -137,18 +138,18 @@ class WebRtcVoiceEngineTestFake : public testing::Test {
     if (!SetupChannel()) {
       return false;
     }
-    return AddRecvStream(kSsrc1);
+    return AddRecvStream(kSsrc9);

[Taylor Brandstetter, 2017/02/17 10:34:46]

What was the motivation for changing to kSsrc9? I think it was ok before. To me,
"kSsrc1" just means "an SSRC that's not equal to kSsrc2, kSsrc3 or kSsrc4".

[the sun, 2017/02/17 11:22:47]

kPcmuFrame has hard coded SSRC=1, so it is sometimes convenient to test
explicitly against that. I've renamed these "arbitrary" test SSRCs to kSsrcX,
kSsrcY, kSsrcZ instead, and added a constant for kSsrc0. Hopefully it makes the
tests a little easier to read.

[Taylor Brandstetter, 2017/02/17 16:10:53]

I'd suggest fixing that problem by either renaming "kPcmuFrame" to
"kPcmuFrameWithSsrc1", so it's clear that tests are depending on that behavior,
or call a "MakePcmuFrame" method instead of using kPcmuFrame directly.

   }
 
   bool SetupSendStream() {
     if (!SetupChannel()) {
       return false;
     }
-    if (!channel_->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc1))) {
+    if (!channel_->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc9))) {
       return false;
     }
     EXPECT_CALL(apm_, set_output_will_be_muted(false));
-    return channel_->SetAudioSend(kSsrc1, true, nullptr, &fake_source_);
+    return channel_->SetAudioSend(kSsrc9, true, nullptr, &fake_source_);
   }
 
   bool AddRecvStream(uint32_t ssrc) {
@@ -159,10 +160,10 @@ class WebRtcVoiceEngineTestFake : public testing::Test {
   void SetupForMultiSendStream() {
     EXPECT_TRUE(SetupSendStream());
     // Remove stream added in Setup.
-    EXPECT_TRUE(call_.GetAudioSendStream(kSsrc1));
-    EXPECT_TRUE(channel_->RemoveSendStream(kSsrc1));
+    EXPECT_TRUE(call_.GetAudioSendStream(kSsrc9));
+    EXPECT_TRUE(channel_->RemoveSendStream(kSsrc9));
     // Verify the channel does not exist.
-    EXPECT_FALSE(call_.GetAudioSendStream(kSsrc1));
+    EXPECT_FALSE(call_.GetAudioSendStream(kSsrc9));
   }
 
   void DeliverPacket(const void* data, int len) {
@@ -231,7 +232,7 @@ class WebRtcVoiceEngineTestFake : public testing::Test {
       // If this is a caller, local description will be applied and add the
       // send stream.
       EXPECT_TRUE(channel_->AddSendStream(
-          cricket::StreamParams::CreateLegacy(kSsrc1)));
+          cricket::StreamParams::CreateLegacy(kSsrc9)));
     }
 
     // Test we can only InsertDtmf when the other side supports telephone-event.
@@ -247,7 +248,7 @@ class WebRtcVoiceEngineTestFake : public testing::Test {
       // If this is callee, there's no active send channel yet.
       EXPECT_FALSE(channel_->InsertDtmf(ssrc, 2, 123));
       EXPECT_TRUE(channel_->AddSendStream(
-          cricket::StreamParams::CreateLegacy(kSsrc1)));
+          cricket::StreamParams::CreateLegacy(kSsrc9)));
     }
 
     // Check we fail if the ssrc is invalid.
@@ -255,10 +256,10 @@ class WebRtcVoiceEngineTestFake : public testing::Test {
 
     // Test send.
     cricket::FakeAudioSendStream::TelephoneEvent telephone_event =
-        GetSendStream(kSsrc1).GetLatestTelephoneEvent();
+        GetSendStream(kSsrc9).GetLatestTelephoneEvent();
     EXPECT_EQ(-1, telephone_event.payload_type);
     EXPECT_TRUE(channel_->InsertDtmf(ssrc, 2, 123));
-    telephone_event = GetSendStream(kSsrc1).GetLatestTelephoneEvent();
+    telephone_event = GetSendStream(kSsrc9).GetLatestTelephoneEvent();
     EXPECT_EQ(codec.id, telephone_event.payload_type);
     EXPECT_EQ(codec.clockrate, telephone_event.payload_frequency);
     EXPECT_EQ(2, telephone_event.event_code);
@@ -282,7 +283,7 @@ class WebRtcVoiceEngineTestFake : public testing::Test {
     } else {
       EXPECT_FALSE(channel_->SetSendParameters(parameters));
     }
-    EXPECT_EQ(expected_bitrate, GetCodecBitrate(kSsrc1));
+    EXPECT_EQ(expected_bitrate, GetCodecBitrate(kSsrc9));
   }
 
   // Sets the per-stream maximum bitrate limit for the specified SSRC.
@@ -341,22 +342,22 @@ class WebRtcVoiceEngineTestFake : public testing::Test {
                               bool expected_result,
                               int expected_codec_bitrate) {
     // Clear the bitrate limit from the previous test case.
-    EXPECT_TRUE(SetMaxBitrateForStream(kSsrc1, -1));
+    EXPECT_TRUE(SetMaxBitrateForStream(kSsrc9, -1));
 
     // Attempt to set the requested bitrate limits.
     SetGlobalMaxBitrate(codec, global_max);
-    EXPECT_EQ(expected_result, SetMaxBitrateForStream(kSsrc1, stream_max));
+    EXPECT_EQ(expected_result, SetMaxBitrateForStream(kSsrc9, stream_max));
 
     // Verify that reading back the parameters gives results
     // consistent with the Set() result.
     webrtc::RtpParameters resulting_parameters =
-        channel_->GetRtpSendParameters(kSsrc1);
+        channel_->GetRtpSendParameters(kSsrc9);
     EXPECT_EQ(1UL, resulting_parameters.encodings.size());
     EXPECT_EQ(expected_result ? stream_max : -1,
               resulting_parameters.encodings[0].max_bitrate_bps);
 
     // Verify that the codec settings have the expected bitrate.
-    EXPECT_EQ(expected_codec_bitrate, GetCodecBitrate(kSsrc1));
+    EXPECT_EQ(expected_codec_bitrate, GetCodecBitrate(kSsrc9));
   }
 
   void SetSendCodecsShouldWorkForBitrates(const char* min_bitrate_kbps,
@@ -386,31 +387,31 @@ class WebRtcVoiceEngineTestFake : public testing::Test {
     EXPECT_TRUE(SetupSendStream());
 
     // Ensure extensions are off by default.
-    EXPECT_EQ(0u, GetSendStreamConfig(kSsrc1).rtp.extensions.size());
+    EXPECT_EQ(0u, GetSendStreamConfig(kSsrc9).rtp.extensions.size());
 
     // Ensure unknown extensions won't cause an error.
     send_parameters_.extensions.push_back(
         webrtc::RtpExtension("urn:ietf:params:unknownextention", 1));
     SetSendParameters(send_parameters_);
-    EXPECT_EQ(0u, GetSendStreamConfig(kSsrc1).rtp.extensions.size());
+    EXPECT_EQ(0u, GetSendStreamConfig(kSsrc9).rtp.extensions.size());
 
     // Ensure extensions stay off with an empty list of headers.
     send_parameters_.extensions.clear();
     SetSendParameters(send_parameters_);
-    EXPECT_EQ(0u, GetSendStreamConfig(kSsrc1).rtp.extensions.size());
+    EXPECT_EQ(0u, GetSendStreamConfig(kSsrc9).rtp.extensions.size());
 
     // Ensure extension is set properly.
     const int id = 1;
     send_parameters_.extensions.push_back(webrtc::RtpExtension(ext, id));
     SetSendParameters(send_parameters_);
-    EXPECT_EQ(1u, GetSendStreamConfig(kSsrc1).rtp.extensions.size());
-    EXPECT_EQ(ext, GetSendStreamConfig(kSsrc1).rtp.extensions[0].uri);
-    EXPECT_EQ(id, GetSendStreamConfig(kSsrc1).rtp.extensions[0].id);
+    EXPECT_EQ(1u, GetSendStreamConfig(kSsrc9).rtp.extensions.size());
+    EXPECT_EQ(ext, GetSendStreamConfig(kSsrc9).rtp.extensions[0].uri);
+    EXPECT_EQ(id, GetSendStreamConfig(kSsrc9).rtp.extensions[0].id);
 
     // Ensure extension is set properly on new stream.
     EXPECT_TRUE(channel_->AddSendStream(
         cricket::StreamParams::CreateLegacy(kSsrc2)));
-    EXPECT_NE(call_.GetAudioSendStream(kSsrc1),
+    EXPECT_NE(call_.GetAudioSendStream(kSsrc9),
               call_.GetAudioSendStream(kSsrc2));
     EXPECT_EQ(1u, GetSendStreamConfig(kSsrc2).rtp.extensions.size());
     EXPECT_EQ(ext, GetSendStreamConfig(kSsrc2).rtp.extensions[0].uri);
@@ -420,7 +421,7 @@ class WebRtcVoiceEngineTestFake : public testing::Test {
     send_parameters_.codecs.push_back(kPcmuCodec);
     send_parameters_.extensions.clear();
     SetSendParameters(send_parameters_);
-    EXPECT_EQ(0u, GetSendStreamConfig(kSsrc1).rtp.extensions.size());
+    EXPECT_EQ(0u, GetSendStreamConfig(kSsrc9).rtp.extensions.size());
     EXPECT_EQ(0u, GetSendStreamConfig(kSsrc2).rtp.extensions.size());
   }
 
@@ -428,30 +429,30 @@ class WebRtcVoiceEngineTestFake : public testing::Test {
     EXPECT_TRUE(SetupRecvStream());
 
     // Ensure extensions are off by default.
-    EXPECT_EQ(0u, GetRecvStreamConfig(kSsrc1).rtp.extensions.size());
+    EXPECT_EQ(0u, GetRecvStreamConfig(kSsrc9).rtp.extensions.size());
 
     // Ensure unknown extensions won't cause an error.
     recv_parameters_.extensions.push_back(
         webrtc::RtpExtension("urn:ietf:params:unknownextention", 1));
     EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_));
-    EXPECT_EQ(0u, GetRecvStreamConfig(kSsrc1).rtp.extensions.size());
+    EXPECT_EQ(0u, GetRecvStreamConfig(kSsrc9).rtp.extensions.size());
 
     // Ensure extensions stay off with an empty list of headers.
     recv_parameters_.extensions.clear();
     EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_));
-    EXPECT_EQ(0u, GetRecvStreamConfig(kSsrc1).rtp.extensions.size());
+    EXPECT_EQ(0u, GetRecvStreamConfig(kSsrc9).rtp.extensions.size());
 
     // Ensure extension is set properly.
     const int id = 2;
     recv_parameters_.extensions.push_back(webrtc::RtpExtension(ext, id));
     EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_));
-    EXPECT_EQ(1u, GetRecvStreamConfig(kSsrc1).rtp.extensions.size());
-    EXPECT_EQ(ext, GetRecvStreamConfig(kSsrc1).rtp.extensions[0].uri);
-    EXPECT_EQ(id, GetRecvStreamConfig(kSsrc1).rtp.extensions[0].id);
+    EXPECT_EQ(1u, GetRecvStreamConfig(kSsrc9).rtp.extensions.size());
+    EXPECT_EQ(ext, GetRecvStreamConfig(kSsrc9).rtp.extensions[0].uri);
+    EXPECT_EQ(id, GetRecvStreamConfig(kSsrc9).rtp.extensions[0].id);
 
     // Ensure extension is set properly on new stream.
     EXPECT_TRUE(AddRecvStream(kSsrc2));
-    EXPECT_NE(call_.GetAudioReceiveStream(kSsrc1),
+    EXPECT_NE(call_.GetAudioReceiveStream(kSsrc9),
               call_.GetAudioReceiveStream(kSsrc2));
     EXPECT_EQ(1u, GetRecvStreamConfig(kSsrc2).rtp.extensions.size());
     EXPECT_EQ(ext, GetRecvStreamConfig(kSsrc2).rtp.extensions[0].uri);
@@ -460,7 +461,7 @@ class WebRtcVoiceEngineTestFake : public testing::Test {
     // Ensure all extensions go back off with an empty list.
     recv_parameters_.extensions.clear();
     EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_));
-    EXPECT_EQ(0u, GetRecvStreamConfig(kSsrc1).rtp.extensions.size());
+    EXPECT_EQ(0u, GetRecvStreamConfig(kSsrc9).rtp.extensions.size());
     EXPECT_EQ(0u, GetRecvStreamConfig(kSsrc2).rtp.extensions.size());
   }
 
@@ -628,9 +629,9 @@ TEST_F(WebRtcVoiceEngineTestFake, CreateChannel) {
 TEST_F(WebRtcVoiceEngineTestFake, CreateSendStream) {
   EXPECT_TRUE(SetupChannel());
   EXPECT_TRUE(
-      channel_->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc1)));
-  const webrtc::AudioSendStream::Config& config = GetSendStreamConfig(kSsrc1);
-  EXPECT_EQ(kSsrc1, config.rtp.ssrc);
+      channel_->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc9)));
+  const webrtc::AudioSendStream::Config& config = GetSendStreamConfig(kSsrc9);
+  EXPECT_EQ(kSsrc9, config.rtp.ssrc);
   EXPECT_EQ("", config.rtp.c_name);
   EXPECT_EQ(0u, config.rtp.extensions.size());
   EXPECT_EQ(static_cast<cricket::WebRtcVoiceMediaChannel*>(channel_),
@@ -640,10 +641,10 @@ TEST_F(WebRtcVoiceEngineTestFake, CreateSendStream) {
 // Test that we can add a receive stream and that it has the correct defaults.
 TEST_F(WebRtcVoiceEngineTestFake, CreateRecvStream) {
   EXPECT_TRUE(SetupChannel());
-  EXPECT_TRUE(AddRecvStream(kSsrc1));
+  EXPECT_TRUE(AddRecvStream(kSsrc9));
   const webrtc::AudioReceiveStream::Config& config =
-      GetRecvStreamConfig(kSsrc1);
-  EXPECT_EQ(kSsrc1, config.rtp.remote_ssrc);
+      GetRecvStreamConfig(kSsrc9);
+  EXPECT_EQ(kSsrc9, config.rtp.remote_ssrc);
   EXPECT_EQ(0xFA17FA17, config.rtp.local_ssrc);
   EXPECT_FALSE(config.rtp.transport_cc);
   EXPECT_EQ(0u, config.rtp.extensions.size());
@@ -728,7 +729,7 @@ TEST_F(WebRtcVoiceEngineTestFake, SetRecvCodecs) {
   parameters.codecs[0].id = 106;  // collide with existing CN 32k
   parameters.codecs[2].id = 126;
   EXPECT_TRUE(channel_->SetRecvParameters(parameters));
-  EXPECT_TRUE(AddRecvStream(kSsrc1));
+  EXPECT_TRUE(AddRecvStream(kSsrc9));
   int channel_num = voe_.GetLastChannel();
 
   webrtc::CodecInst gcodec;
@@ -778,7 +779,7 @@ TEST_F(WebRtcVoiceEngineTestFake, SetRecvCodecsWithOpusNoStereo) {
   parameters.codecs.push_back(kPcmuCodec);
   parameters.codecs.push_back(kOpusCodec);
   EXPECT_TRUE(channel_->SetRecvParameters(parameters));
-  EXPECT_TRUE(AddRecvStream(kSsrc1));
+  EXPECT_TRUE(AddRecvStream(kSsrc9));
   int channel_num = voe_.GetLastChannel();
   webrtc::CodecInst opus;
   cricket::WebRtcVoiceEngine::ToCodecInst(kOpusCodec, &opus);
@@ -800,7 +801,7 @@ TEST_F(WebRtcVoiceEngineTestFake, SetRecvCodecsWithOpus0Stereo) {
   parameters.codecs.push_back(kOpusCodec);
   parameters.codecs[2].params["stereo"] = "0";
   EXPECT_TRUE(channel_->SetRecvParameters(parameters));
-  EXPECT_TRUE(AddRecvStream(kSsrc1));
+  EXPECT_TRUE(AddRecvStream(kSsrc9));
   int channel_num2 = voe_.GetLastChannel();
   webrtc::CodecInst opus;
   cricket::WebRtcVoiceEngine::ToCodecInst(kOpusCodec, &opus);
@@ -822,7 +823,7 @@ TEST_F(WebRtcVoiceEngineTestFake, SetRecvCodecsWithOpus1Stereo) {
   parameters.codecs.push_back(kOpusCodec);
   parameters.codecs[2].params["stereo"] = "1";
   EXPECT_TRUE(channel_->SetRecvParameters(parameters));
-  EXPECT_TRUE(AddRecvStream(kSsrc1));
+  EXPECT_TRUE(AddRecvStream(kSsrc9));
   int channel_num2 = voe_.GetLastChannel();
   webrtc::CodecInst opus;
   cricket::WebRtcVoiceEngine::ToCodecInst(kOpusCodec, &opus);
@@ -845,7 +846,7 @@ TEST_F(WebRtcVoiceEngineTestFake, SetRecvCodecsWithMultipleStreams) {
   parameters.codecs[0].id = 106;  // collide with existing CN 32k
   parameters.codecs[2].id = 126;
   EXPECT_TRUE(channel_->SetRecvParameters(parameters));
-  EXPECT_TRUE(AddRecvStream(kSsrc1));
+  EXPECT_TRUE(AddRecvStream(kSsrc9));
   int channel_num2 = voe_.GetLastChannel();
 
   webrtc::CodecInst gcodec;
@@ -876,7 +877,7 @@ TEST_F(WebRtcVoiceEngineTestFake, SetRecvCodecsAfterAddingStreams) {
   parameters.codecs[0].id = 106;  // collide with existing CN 32k
   EXPECT_TRUE(channel_->SetRecvParameters(parameters));
 
-  const auto& dm = GetRecvStreamConfig(kSsrc1).decoder_map;
+  const auto& dm = GetRecvStreamConfig(kSsrc9).decoder_map;
   ASSERT_EQ(1, dm.count(106));
   EXPECT_EQ(webrtc::SdpAudioFormat("isac", 16000, 1), dm.at(106));
 }
@@ -894,7 +895,7 @@ TEST_F(WebRtcVoiceEngineTestFake, SetRecvCodecsWhilePlaying) {
   // Changing the payload type of a codec should fail.
   parameters.codecs[0].id = 127;
   EXPECT_FALSE(channel_->SetRecvParameters(parameters));
-  EXPECT_TRUE(GetRecvStream(kSsrc1).started());
+  EXPECT_TRUE(GetRecvStream(kSsrc9).started());
 }
 
 // Test that we can add a codec while playing.
@@ -908,7 +909,7 @@ TEST_F(WebRtcVoiceEngineTestFake, AddRecvCodecsWhilePlaying) {
 
   parameters.codecs.push_back(kOpusCodec);
   EXPECT_TRUE(channel_->SetRecvParameters(parameters));
-  EXPECT_TRUE(GetRecvStream(kSsrc1).started());
+  EXPECT_TRUE(GetRecvStream(kSsrc9).started());
   webrtc::CodecInst gcodec;
   EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst(kOpusCodec, &gcodec));
   EXPECT_EQ(kOpusCodec.id, gcodec.pltype);
@@ -974,9 +975,9 @@ TEST_F(WebRtcVoiceEngineTestFake, SetMaxSendBandwidthMultiRateAsCallee) {
   SetSendParameters(parameters);
 
   EXPECT_TRUE(channel_->AddSendStream(
-      cricket::StreamParams::CreateLegacy(kSsrc1)));
+      cricket::StreamParams::CreateLegacy(kSsrc9)));
 
-  EXPECT_EQ(kDesiredBitrate, GetCodecBitrate(kSsrc1));
+  EXPECT_EQ(kDesiredBitrate, GetCodecBitrate(kSsrc9));
 }
 
 // Test that bitrate cannot be set for CBR codecs.
@@ -987,15 +988,15 @@ TEST_F(WebRtcVoiceEngineTestFake, SetMaxSendBandwidthCbr) {
 
   // PCMU, default bitrate == 64000.
   SetSendParameters(send_parameters_);
-  EXPECT_EQ(64000, GetCodecBitrate(kSsrc1));
+  EXPECT_EQ(64000, GetCodecBitrate(kSsrc9));
 
   send_parameters_.max_bandwidth_bps = 128000;
   SetSendParameters(send_parameters_);
-  EXPECT_EQ(64000, GetCodecBitrate(kSsrc1));
+  EXPECT_EQ(64000, GetCodecBitrate(kSsrc9));
 
   send_parameters_.max_bandwidth_bps = 128;
   EXPECT_FALSE(channel_->SetSendParameters(send_parameters_));
-  EXPECT_EQ(64000, GetCodecBitrate(kSsrc1));
+  EXPECT_EQ(64000, GetCodecBitrate(kSsrc9));
 }
 
 // Test that the per-stream bitrate limit and the global
@@ -1025,11 +1026,11 @@ TEST_F(WebRtcVoiceEngineTestFake, SetMaxBitratePerStream) {
 TEST_F(WebRtcVoiceEngineTestFake, CannotSetMaxBitrateForNonexistentStream) {
   EXPECT_TRUE(SetupChannel());
   webrtc::RtpParameters nonexistent_parameters =
-      channel_->GetRtpSendParameters(kSsrc1);
+      channel_->GetRtpSendParameters(kSsrc9);
   EXPECT_EQ(0, nonexistent_parameters.encodings.size());
 
   nonexistent_parameters.encodings.push_back(webrtc::RtpEncodingParameters());
-  EXPECT_FALSE(channel_->SetRtpSendParameters(kSsrc1, nonexistent_parameters));
+  EXPECT_FALSE(channel_->SetRtpSendParameters(kSsrc9, nonexistent_parameters));
 }
 
 TEST_F(WebRtcVoiceEngineTestFake,
@@ -1040,21 +1041,21 @@ TEST_F(WebRtcVoiceEngineTestFake,
   // for each encoding individually.
 
   EXPECT_TRUE(SetupSendStream());
-  webrtc::RtpParameters parameters = channel_->GetRtpSendParameters(kSsrc1);
+  webrtc::RtpParameters parameters = channel_->GetRtpSendParameters(kSsrc9);
   // Two or more encodings should result in failure.
   parameters.encodings.push_back(webrtc::RtpEncodingParameters());
-  EXPECT_FALSE(channel_->SetRtpSendParameters(kSsrc1, parameters));
+  EXPECT_FALSE(channel_->SetRtpSendParameters(kSsrc9, parameters));
   // Zero encodings should also fail.
   parameters.encodings.clear();
-  EXPECT_FALSE(channel_->SetRtpSendParameters(kSsrc1, parameters));
+  EXPECT_FALSE(channel_->SetRtpSendParameters(kSsrc9, parameters));
 }
 
 // Changing the SSRC through RtpParameters is not allowed.
 TEST_F(WebRtcVoiceEngineTestFake, CannotSetSsrcInRtpSendParameters) {
   EXPECT_TRUE(SetupSendStream());
-  webrtc::RtpParameters parameters = channel_->GetRtpSendParameters(kSsrc1);
+  webrtc::RtpParameters parameters = channel_->GetRtpSendParameters(kSsrc9);
   parameters.encodings[0].ssrc = rtc::Optional<uint32_t>(0xdeadbeef);
-  EXPECT_FALSE(channel_->SetRtpSendParameters(kSsrc1, parameters));
+  EXPECT_FALSE(channel_->SetRtpSendParameters(kSsrc9, parameters));
 }
 
 // Test that a stream will not be sending if its encoding is made
@@ -1062,19 +1063,19 @@ TEST_F(WebRtcVoiceEngineTestFake, CannotSetSsrcInRtpSendParameters) {
 TEST_F(WebRtcVoiceEngineTestFake, SetRtpParametersEncodingsActive) {
   EXPECT_TRUE(SetupSendStream());
   SetSend(true);
-  EXPECT_TRUE(GetSendStream(kSsrc1).IsSending());
+  EXPECT_TRUE(GetSendStream(kSsrc9).IsSending());
   // Get current parameters and change "active" to false.
-  webrtc::RtpParameters parameters = channel_->GetRtpSendParameters(kSsrc1);
+  webrtc::RtpParameters parameters = channel_->GetRtpSendParameters(kSsrc9);
   ASSERT_EQ(1u, parameters.encodings.size());
   ASSERT_TRUE(parameters.encodings[0].active);
   parameters.encodings[0].active = false;
-  EXPECT_TRUE(channel_->SetRtpSendParameters(kSsrc1, parameters));
-  EXPECT_FALSE(GetSendStream(kSsrc1).IsSending());
+  EXPECT_TRUE(channel_->SetRtpSendParameters(kSsrc9, parameters));
+  EXPECT_FALSE(GetSendStream(kSsrc9).IsSending());
 
   // Now change it back to active and verify we resume sending.
   parameters.encodings[0].active = true;
-  EXPECT_TRUE(channel_->SetRtpSendParameters(kSsrc1, parameters));
-  EXPECT_TRUE(GetSendStream(kSsrc1).IsSending());
+  EXPECT_TRUE(channel_->SetRtpSendParameters(kSsrc9, parameters));
+  EXPECT_TRUE(GetSendStream(kSsrc9).IsSending());
 }
 
 // Test that SetRtpSendParameters configures the correct encoding channel for
@@ -1114,7 +1115,7 @@ TEST_F(WebRtcVoiceEngineTestFake, GetRtpSendParametersCodecs) {
   parameters.codecs.push_back(kPcmuCodec);
   SetSendParameters(parameters);
 
-  webrtc::RtpParameters rtp_parameters = channel_->GetRtpSendParameters(kSsrc1);
+  webrtc::RtpParameters rtp_parameters = channel_->GetRtpSendParameters(kSsrc9);
   ASSERT_EQ(2u, rtp_parameters.codecs.size());
   EXPECT_EQ(kIsacCodec.ToCodecParameters(), rtp_parameters.codecs[0]);
   EXPECT_EQ(kPcmuCodec.ToCodecParameters(), rtp_parameters.codecs[1]);
@@ -1123,9 +1124,9 @@ TEST_F(WebRtcVoiceEngineTestFake, GetRtpSendParametersCodecs) {
 // Test that GetRtpSendParameters returns an SSRC.
 TEST_F(WebRtcVoiceEngineTestFake, GetRtpSendParametersSsrc) {
   EXPECT_TRUE(SetupSendStream());
-  webrtc::RtpParameters rtp_parameters = channel_->GetRtpSendParameters(kSsrc1);
+  webrtc::RtpParameters rtp_parameters = channel_->GetRtpSendParameters(kSsrc9);
   ASSERT_EQ(1u, rtp_parameters.encodings.size());
-  EXPECT_EQ(kSsrc1, rtp_parameters.encodings[0].ssrc);
+  EXPECT_EQ(kSsrc9, rtp_parameters.encodings[0].ssrc);
 }
 
 // Test that if we set/get parameters multiple times, we get the same results.
@@ -1136,14 +1137,14 @@ TEST_F(WebRtcVoiceEngineTestFake, SetAndGetRtpSendParameters) {
   parameters.codecs.push_back(kPcmuCodec);
   SetSendParameters(parameters);
 
-  webrtc::RtpParameters initial_params = channel_->GetRtpSendParameters(kSsrc1);
+  webrtc::RtpParameters initial_params = channel_->GetRtpSendParameters(kSsrc9);
 
   // We should be able to set the params we just got.
-  EXPECT_TRUE(channel_->SetRtpSendParameters(kSsrc1, initial_params));
+  EXPECT_TRUE(channel_->SetRtpSendParameters(kSsrc9, initial_params));
 
   // ... And this shouldn't change the params returned by GetRtpSendParameters.
-  webrtc::RtpParameters new_params = channel_->GetRtpSendParameters(kSsrc1);
-  EXPECT_EQ(initial_params, channel_->GetRtpSendParameters(kSsrc1));
+  webrtc::RtpParameters new_params = channel_->GetRtpSendParameters(kSsrc9);
+  EXPECT_EQ(initial_params, channel_->GetRtpSendParameters(kSsrc9));
 }
 
 // Test that GetRtpReceiveParameters returns the currently configured codecs.
@@ -1155,7 +1156,7 @@ TEST_F(WebRtcVoiceEngineTestFake, GetRtpReceiveParametersCodecs) {
   EXPECT_TRUE(channel_->SetRecvParameters(parameters));
 
   webrtc::RtpParameters rtp_parameters =
-      channel_->GetRtpReceiveParameters(kSsrc1);
+      channel_->GetRtpReceiveParameters(kSsrc9);
   ASSERT_EQ(2u, rtp_parameters.codecs.size());
   EXPECT_EQ(kIsacCodec.ToCodecParameters(), rtp_parameters.codecs[0]);
   EXPECT_EQ(kPcmuCodec.ToCodecParameters(), rtp_parameters.codecs[1]);
@@ -1165,9 +1166,9 @@ TEST_F(WebRtcVoiceEngineTestFake, GetRtpReceiveParametersCodecs) {
 TEST_F(WebRtcVoiceEngineTestFake, GetRtpReceiveParametersSsrc) {
   EXPECT_TRUE(SetupRecvStream());
   webrtc::RtpParameters rtp_parameters =
-      channel_->GetRtpReceiveParameters(kSsrc1);
+      channel_->GetRtpReceiveParameters(kSsrc9);
   ASSERT_EQ(1u, rtp_parameters.encodings.size());
-  EXPECT_EQ(kSsrc1, rtp_parameters.encodings[0].ssrc);
+  EXPECT_EQ(kSsrc9, rtp_parameters.encodings[0].ssrc);
 }
 
 // Test that if we set/get parameters multiple times, we get the same results.
@@ -1179,15 +1180,15 @@ TEST_F(WebRtcVoiceEngineTestFake, SetAndGetRtpReceiveParameters) {
   EXPECT_TRUE(channel_->SetRecvParameters(parameters));
 
   webrtc::RtpParameters initial_params =
-      channel_->GetRtpReceiveParameters(kSsrc1);
+      channel_->GetRtpReceiveParameters(kSsrc9);
 
   // We should be able to set the params we just got.
-  EXPECT_TRUE(channel_->SetRtpReceiveParameters(kSsrc1, initial_params));
+  EXPECT_TRUE(channel_->SetRtpReceiveParameters(kSsrc9, initial_params));
 
   // ... And this shouldn't change the params returned by
   // GetRtpReceiveParameters.
-  webrtc::RtpParameters new_params = channel_->GetRtpReceiveParameters(kSsrc1);
-  EXPECT_EQ(initial_params, channel_->GetRtpReceiveParameters(kSsrc1));
+  webrtc::RtpParameters new_params = channel_->GetRtpReceiveParameters(kSsrc9);
+  EXPECT_EQ(initial_params, channel_->GetRtpReceiveParameters(kSsrc9));
 }
 
 // Test that we apply codecs properly.
@@ -1202,7 +1203,7 @@ TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecs) {
   const int initial_num = call_.GetNumCreatedSendStreams();
   SetSendParameters(parameters);
   EXPECT_EQ(initial_num + 1, call_.GetNumCreatedSendStreams());
-  const auto& send_codec_spec = GetSendStreamConfig(kSsrc1).send_codec_spec;
+  const auto& send_codec_spec = GetSendStreamConfig(kSsrc9).send_codec_spec;
   EXPECT_EQ(96, send_codec_spec.codec_inst.pltype);
   EXPECT_EQ(48000, send_codec_spec.codec_inst.rate);
   EXPECT_STREQ("ISAC", send_codec_spec.codec_inst.plname);
@@ -1237,7 +1238,7 @@ TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecG722) {
   cricket::AudioSendParameters parameters;
   parameters.codecs.push_back(kG722CodecSdp);
   SetSendParameters(parameters);
-  const auto& gcodec = GetSendStreamConfig(kSsrc1).send_codec_spec.codec_inst;
+  const auto& gcodec = GetSendStreamConfig(kSsrc9).send_codec_spec.codec_inst;
   EXPECT_STREQ("G722", gcodec.plname);
   EXPECT_EQ(1, gcodec.channels);
   EXPECT_EQ(16000, gcodec.plfreq);
@@ -1314,7 +1315,7 @@ TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGood0BitrateNoStereo) {
   parameters.codecs.push_back(kOpusCodec);
   parameters.codecs[0].bitrate = 0;
   SetSendParameters(parameters);
-  CheckSendCodec(kSsrc1, "opus", 1, 32000);
+  CheckSendCodec(kSsrc9, "opus", 1, 32000);
 }
 
 // Test that with bitrate=0 and stereo=0,
@@ -1326,7 +1327,7 @@ TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGood0Bitrate0Stereo) {
   parameters.codecs[0].bitrate = 0;
   parameters.codecs[0].params["stereo"] = "0";
   SetSendParameters(parameters);
-  CheckSendCodec(kSsrc1, "opus", 1, 32000);
+  CheckSendCodec(kSsrc9, "opus", 1, 32000);
 }
 
 // Test that with bitrate=invalid and stereo=0,
@@ -1339,11 +1340,11 @@ TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodXBitrate0Stereo) {
   // bitrate that's out of the range between 6000 and 510000 will be clamped.
   parameters.codecs[0].bitrate = 5999;
   SetSendParameters(parameters);
-  CheckSendCodec(kSsrc1, "opus", 1, 6000);
+  CheckSendCodec(kSsrc9, "opus", 1, 6000);
 
   parameters.codecs[0].bitrate = 510001;
   SetSendParameters(parameters);
-  CheckSendCodec(kSsrc1, "opus", 1, 510000);
+  CheckSendCodec(kSsrc9, "opus", 1, 510000);
 }
 
 // Test that with bitrate=0 and stereo=1,
@@ -1355,7 +1356,7 @@ TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGood0Bitrate1Stereo) {
   parameters.codecs[0].bitrate = 0;
   parameters.codecs[0].params["stereo"] = "1";
   SetSendParameters(parameters);
-  CheckSendCodec(kSsrc1, "opus", 2, 64000);
+  CheckSendCodec(kSsrc9, "opus", 2, 64000);
 }
 
 // Test that with bitrate=invalid and stereo=1,
@@ -1368,11 +1369,11 @@ TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodXBitrate1Stereo) {
   // bitrate that's out of the range between 6000 and 510000 will be clamped.
   parameters.codecs[0].bitrate = 5999;
   SetSendParameters(parameters);
-  CheckSendCodec(kSsrc1, "opus", 2, 6000);
+  CheckSendCodec(kSsrc9, "opus", 2, 6000);
 
   parameters.codecs[0].bitrate = 510001;
   SetSendParameters(parameters);
-  CheckSendCodec(kSsrc1, "opus", 2, 510000);
+  CheckSendCodec(kSsrc9, "opus", 2, 510000);
 }
 
 // Test that with bitrate=N and stereo unset,
@@ -1383,7 +1384,7 @@ TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrateNoStereo) {
   parameters.codecs.push_back(kOpusCodec);
   parameters.codecs[0].bitrate = 96000;
   SetSendParameters(parameters);
-  const auto& gcodec = GetSendStreamConfig(kSsrc1).send_codec_spec.codec_inst;
+  const auto& gcodec = GetSendStreamConfig(kSsrc9).send_codec_spec.codec_inst;
   EXPECT_EQ(111, gcodec.pltype);
   EXPECT_EQ(96000, gcodec.rate);
   EXPECT_STREQ("opus", gcodec.plname);
@@ -1400,7 +1401,7 @@ TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrate0Stereo) {
   parameters.codecs[0].bitrate = 30000;
   parameters.codecs[0].params["stereo"] = "0";
   SetSendParameters(parameters);
-  CheckSendCodec(kSsrc1, "opus", 1, 30000);
+  CheckSendCodec(kSsrc9, "opus", 1, 30000);
 }
 
 // Test that with bitrate=N and without any parameters,
@@ -1411,7 +1412,7 @@ TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrateNoParameters) {
   parameters.codecs.push_back(kOpusCodec);
   parameters.codecs[0].bitrate = 30000;
   SetSendParameters(parameters);
-  CheckSendCodec(kSsrc1, "opus", 1, 30000);
+  CheckSendCodec(kSsrc9, "opus", 1, 30000);
 }
 
 // Test that with bitrate=N and stereo=1,
@@ -1423,7 +1424,7 @@ TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrate1Stereo) {
   parameters.codecs[0].bitrate = 30000;
   parameters.codecs[0].params["stereo"] = "1";
   SetSendParameters(parameters);
-  CheckSendCodec(kSsrc1, "opus", 2, 30000);
+  CheckSendCodec(kSsrc9, "opus", 2, 30000);
 }
 
 // Test that bitrate will be overridden by the "maxaveragebitrate" parameter.
@@ -1437,16 +1438,16 @@ TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusMaxAverageBitrate) {
   // Ignore if less than 6000.
   parameters.codecs[0].params["maxaveragebitrate"] = "5999";
   SetSendParameters(parameters);
-  EXPECT_EQ(6000, GetCodecBitrate(kSsrc1));
+  EXPECT_EQ(6000, GetCodecBitrate(kSsrc9));
 
   // Ignore if larger than 510000.
   parameters.codecs[0].params["maxaveragebitrate"] = "510001";
   SetSendParameters(parameters);
-  EXPECT_EQ(510000, GetCodecBitrate(kSsrc1));
+  EXPECT_EQ(510000, GetCodecBitrate(kSsrc9));
 
   parameters.codecs[0].params["maxaveragebitrate"] = "200000";
   SetSendParameters(parameters);
-  EXPECT_EQ(200000, GetCodecBitrate(kSsrc1));
+  EXPECT_EQ(200000, GetCodecBitrate(kSsrc9));
 }
 
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsWithBitrates) {
@@ -1488,9 +1489,9 @@ TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecEnableNackAsCaller) {
   parameters.codecs[0].AddFeedbackParam(
       cricket::FeedbackParam(cricket::kRtcpFbParamNack,
                              cricket::kParamValueEmpty));
-  EXPECT_EQ(0, GetSendStreamConfig(kSsrc1).rtp.nack.rtp_history_ms);
+  EXPECT_EQ(0, GetSendStreamConfig(kSsrc9).rtp.nack.rtp_history_ms);
   SetSendParameters(parameters);
-  EXPECT_EQ(kRtpHistoryMs, GetSendStreamConfig(kSsrc1).rtp.nack.rtp_history_ms);
+  EXPECT_EQ(kRtpHistoryMs, GetSendStreamConfig(kSsrc9).rtp.nack.rtp_history_ms);
 }
 
 // Test that we can enable NACK with opus as callee.
@@ -1501,14 +1502,14 @@ TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecEnableNackAsCallee) {
   parameters.codecs[0].AddFeedbackParam(
       cricket::FeedbackParam(cricket::kRtcpFbParamNack,
                              cricket::kParamValueEmpty));
-  EXPECT_EQ(0, GetRecvStreamConfig(kSsrc1).rtp.nack.rtp_history_ms);
+  EXPECT_EQ(0, GetRecvStreamConfig(kSsrc9).rtp.nack.rtp_history_ms);
   SetSendParameters(parameters);
   // NACK should be enabled even with no send stream.
-  EXPECT_EQ(kRtpHistoryMs, GetRecvStreamConfig(kSsrc1).rtp.nack.rtp_history_ms);
+  EXPECT_EQ(kRtpHistoryMs, GetRecvStreamConfig(kSsrc9).rtp.nack.rtp_history_ms);
 
   EXPECT_TRUE(channel_->AddSendStream(
-      cricket::StreamParams::CreateLegacy(kSsrc1)));
-  EXPECT_EQ(kRtpHistoryMs, GetSendStreamConfig(kSsrc1).rtp.nack.rtp_history_ms);
+      cricket::StreamParams::CreateLegacy(kSsrc9)));
+  EXPECT_EQ(kRtpHistoryMs, GetSendStreamConfig(kSsrc9).rtp.nack.rtp_history_ms);
 }
 
 // Test that we can enable NACK on receive streams.
@@ -1520,10 +1521,10 @@ TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecEnableNackRecvStreams) {
   parameters.codecs[0].AddFeedbackParam(
       cricket::FeedbackParam(cricket::kRtcpFbParamNack,
                              cricket::kParamValueEmpty));
-  EXPECT_EQ(0, GetSendStreamConfig(kSsrc1).rtp.nack.rtp_history_ms);
+  EXPECT_EQ(0, GetSendStreamConfig(kSsrc9).rtp.nack.rtp_history_ms);
   EXPECT_EQ(0, GetRecvStreamConfig(kSsrc2).rtp.nack.rtp_history_ms);
   SetSendParameters(parameters);
-  EXPECT_EQ(kRtpHistoryMs, GetSendStreamConfig(kSsrc1).rtp.nack.rtp_history_ms);
+  EXPECT_EQ(kRtpHistoryMs, GetSendStreamConfig(kSsrc9).rtp.nack.rtp_history_ms);
   EXPECT_EQ(kRtpHistoryMs, GetRecvStreamConfig(kSsrc2).rtp.nack.rtp_history_ms);
 }
 
@@ -1536,12 +1537,12 @@ TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecDisableNack) {
       cricket::FeedbackParam(cricket::kRtcpFbParamNack,
                              cricket::kParamValueEmpty));
   SetSendParameters(parameters);
-  EXPECT_EQ(kRtpHistoryMs, GetSendStreamConfig(kSsrc1).rtp.nack.rtp_history_ms);
+  EXPECT_EQ(kRtpHistoryMs, GetSendStreamConfig(kSsrc9).rtp.nack.rtp_history_ms);
 
   parameters.codecs.clear();
   parameters.codecs.push_back(kOpusCodec);
   SetSendParameters(parameters);
-  EXPECT_EQ(0, GetSendStreamConfig(kSsrc1).rtp.nack.rtp_history_ms);
+  EXPECT_EQ(0, GetSendStreamConfig(kSsrc9).rtp.nack.rtp_history_ms);
 }
 
 // Test that we can disable NACK on receive streams.
@@ -1554,13 +1555,13 @@ TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecDisableNackRecvStreams) {
       cricket::FeedbackParam(cricket::kRtcpFbParamNack,
                              cricket::kParamValueEmpty));
   SetSendParameters(parameters);
-  EXPECT_EQ(kRtpHistoryMs, GetSendStreamConfig(kSsrc1).rtp.nack.rtp_history_ms);
+  EXPECT_EQ(kRtpHistoryMs, GetSendStreamConfig(kSsrc9).rtp.nack.rtp_history_ms);
   EXPECT_EQ(kRtpHistoryMs, GetRecvStreamConfig(kSsrc2).rtp.nack.rtp_history_ms);
 
   parameters.codecs.clear();
   parameters.codecs.push_back(kOpusCodec);
   SetSendParameters(parameters);
-  EXPECT_EQ(0, GetSendStreamConfig(kSsrc1).rtp.nack.rtp_history_ms);
+  EXPECT_EQ(0, GetSendStreamConfig(kSsrc9).rtp.nack.rtp_history_ms);
   EXPECT_EQ(0, GetRecvStreamConfig(kSsrc2).rtp.nack.rtp_history_ms);
 }
 
@@ -1574,7 +1575,7 @@ TEST_F(WebRtcVoiceEngineTestFake, AddRecvStreamEnableNack) {
       cricket::FeedbackParam(cricket::kRtcpFbParamNack,
                              cricket::kParamValueEmpty));
   SetSendParameters(parameters);
-  EXPECT_EQ(kRtpHistoryMs, GetSendStreamConfig(kSsrc1).rtp.nack.rtp_history_ms);
+  EXPECT_EQ(kRtpHistoryMs, GetSendStreamConfig(kSsrc9).rtp.nack.rtp_history_ms);
 
   EXPECT_TRUE(AddRecvStream(kSsrc2));
   EXPECT_EQ(kRtpHistoryMs, GetRecvStreamConfig(kSsrc2).rtp.nack.rtp_history_ms);
@@ -1588,7 +1589,7 @@ TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecNoOpusFec) {
   cricket::AudioSendParameters parameters;
   parameters.codecs.push_back(kOpusCodec);
   SetSendParameters(parameters);
-  EXPECT_FALSE(GetCodecFec(kSsrc1));
+  EXPECT_FALSE(GetCodecFec(kSsrc9));
 }
 
 // Test that with useinbandfec=0, Opus FEC is off.
@@ -1599,7 +1600,7 @@ TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusDisableFec) {
   parameters.codecs[0].bitrate = 0;
   parameters.codecs[0].params["useinbandfec"] = "0";
   SetSendParameters(parameters);
-  CheckSendCodec(kSsrc1, "opus", 1, 32000);
+  CheckSendCodec(kSsrc9, "opus", 1, 32000);
 }
 
 // Test that with useinbandfec=1, Opus FEC is on.
@@ -1610,8 +1611,8 @@ TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusEnableFec) {
   parameters.codecs[0].bitrate = 0;
   parameters.codecs[0].params["useinbandfec"] = "1";
   SetSendParameters(parameters);
-  EXPECT_TRUE(GetCodecFec(kSsrc1));
-  CheckSendCodec(kSsrc1, "opus", 1, 32000);
+  EXPECT_TRUE(GetCodecFec(kSsrc9));
+  CheckSendCodec(kSsrc9, "opus", 1, 32000);
 }
 
 // Test that with useinbandfec=1, stereo=1, Opus FEC is on.
@@ -1623,8 +1624,8 @@ TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusEnableFecStereo) {
   parameters.codecs[0].params["stereo"] = "1";
   parameters.codecs[0].params["useinbandfec"] = "1";
   SetSendParameters(parameters);
-  EXPECT_TRUE(GetCodecFec(kSsrc1));
-  CheckSendCodec(kSsrc1, "opus", 2, 64000);
+  EXPECT_TRUE(GetCodecFec(kSsrc9));
+  CheckSendCodec(kSsrc9, "opus", 2, 64000);
 }
 
 // Test that with non-Opus, codec FEC is off.
@@ -1633,7 +1634,7 @@ TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecIsacNoFec) {
   cricket::AudioSendParameters parameters;
   parameters.codecs.push_back(kIsacCodec);
   SetSendParameters(parameters);
-  EXPECT_FALSE(GetCodecFec(kSsrc1));
+  EXPECT_FALSE(GetCodecFec(kSsrc9));
 }
 
 // Test the with non-Opus, even if useinbandfec=1, FEC is off.
@@ -1643,7 +1644,7 @@ TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecIsacWithParamNoFec) {
   parameters.codecs.push_back(kIsacCodec);
   parameters.codecs[0].params["useinbandfec"] = "1";
   SetSendParameters(parameters);
-  EXPECT_FALSE(GetCodecFec(kSsrc1));
+  EXPECT_FALSE(GetCodecFec(kSsrc9));
 }
 
 // Test that Opus FEC status can be changed.
@@ -1652,11 +1653,11 @@ TEST_F(WebRtcVoiceEngineTestFake, ChangeOpusFecStatus) {
   cricket::AudioSendParameters parameters;
   parameters.codecs.push_back(kOpusCodec);
   SetSendParameters(parameters);
-  EXPECT_FALSE(GetCodecFec(kSsrc1));
+  EXPECT_FALSE(GetCodecFec(kSsrc9));
 
   parameters.codecs[0].params["useinbandfec"] = "1";
   SetSendParameters(parameters);
-  EXPECT_TRUE(GetCodecFec(kSsrc1));
+  EXPECT_TRUE(GetCodecFec(kSsrc9));
 }
 
 TEST_F(WebRtcVoiceEngineTestFake, TransportCcCanBeEnabledAndDisabled) {
@@ -1669,16 +1670,16 @@ TEST_F(WebRtcVoiceEngineTestFake, TransportCcCanBeEnabledAndDisabled) {
   cricket::AudioRecvParameters recv_parameters;
   recv_parameters.codecs.push_back(kIsacCodec);
   EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters));
-  EXPECT_TRUE(AddRecvStream(kSsrc1));
-  ASSERT_TRUE(call_.GetAudioReceiveStream(kSsrc1) != nullptr);
+  EXPECT_TRUE(AddRecvStream(kSsrc9));
+  ASSERT_TRUE(call_.GetAudioReceiveStream(kSsrc9) != nullptr);
   EXPECT_FALSE(
-      call_.GetAudioReceiveStream(kSsrc1)->GetConfig().rtp.transport_cc);
+      call_.GetAudioReceiveStream(kSsrc9)->GetConfig().rtp.transport_cc);
 
   send_parameters.codecs = engine_->send_codecs();
   SetSendParameters(send_parameters);
-  ASSERT_TRUE(call_.GetAudioReceiveStream(kSsrc1) != nullptr);
+  ASSERT_TRUE(call_.GetAudioReceiveStream(kSsrc9) != nullptr);
   EXPECT_TRUE(
-      call_.GetAudioReceiveStream(kSsrc1)->GetConfig().rtp.transport_cc);
+      call_.GetAudioReceiveStream(kSsrc9)->GetConfig().rtp.transport_cc);
 }
 
 // Test maxplaybackrate <= 8000 triggers Opus narrow band mode.
@@ -1689,12 +1690,12 @@ TEST_F(WebRtcVoiceEngineTestFake, SetOpusMaxPlaybackRateNb) {
   parameters.codecs[0].bitrate = 0;
   parameters.codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 8000);
   SetSendParameters(parameters);
-  EXPECT_EQ(8000, GetOpusMaxPlaybackRate(kSsrc1));
-  EXPECT_EQ(12000, GetCodecBitrate(kSsrc1));
+  EXPECT_EQ(8000, GetOpusMaxPlaybackRate(kSsrc9));
+  EXPECT_EQ(12000, GetCodecBitrate(kSsrc9));
 
   parameters.codecs[0].SetParam(cricket::kCodecParamStereo, "1");
   SetSendParameters(parameters);
-  EXPECT_EQ(24000, GetCodecBitrate(kSsrc1));
+  EXPECT_EQ(24000, GetCodecBitrate(kSsrc9));
 }
 
 // Test 8000 < maxplaybackrate <= 12000 triggers Opus medium band mode.
@@ -1705,12 +1706,12 @@ TEST_F(WebRtcVoiceEngineTestFake, SetOpusMaxPlaybackRateMb) {
   parameters.codecs[0].bitrate = 0;
   parameters.codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 8001);
   SetSendParameters(parameters);
-  EXPECT_EQ(8001, GetOpusMaxPlaybackRate(kSsrc1));
-  EXPECT_EQ(20000, GetCodecBitrate(kSsrc1));
+  EXPECT_EQ(8001, GetOpusMaxPlaybackRate(kSsrc9));
+  EXPECT_EQ(20000, GetCodecBitrate(kSsrc9));
 
   parameters.codecs[0].SetParam(cricket::kCodecParamStereo, "1");
   SetSendParameters(parameters);
-  EXPECT_EQ(40000, GetCodecBitrate(kSsrc1));
+  EXPECT_EQ(40000, GetCodecBitrate(kSsrc9));
 }
 
 // Test 12000 < maxplaybackrate <= 16000 triggers Opus wide band mode.
@@ -1721,12 +1722,12 @@ TEST_F(WebRtcVoiceEngineTestFake, SetOpusMaxPlaybackRateWb) {
   parameters.codecs[0].bitrate = 0;
   parameters.codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 12001);
   SetSendParameters(parameters);
-  EXPECT_EQ(12001, GetOpusMaxPlaybackRate(kSsrc1));
-  EXPECT_EQ(20000, GetCodecBitrate(kSsrc1));
+  EXPECT_EQ(12001, GetOpusMaxPlaybackRate(kSsrc9));
+  EXPECT_EQ(20000, GetCodecBitrate(kSsrc9));
 
   parameters.codecs[0].SetParam(cricket::kCodecParamStereo, "1");
   SetSendParameters(parameters);
-  EXPECT_EQ(40000, GetCodecBitrate(kSsrc1));
+  EXPECT_EQ(40000, GetCodecBitrate(kSsrc9));
 }
 
 // Test 16000 < maxplaybackrate <= 24000 triggers Opus super wide band mode.
@@ -1737,12 +1738,12 @@ TEST_F(WebRtcVoiceEngineTestFake, SetOpusMaxPlaybackRateSwb) {
   parameters.codecs[0].bitrate = 0;
   parameters.codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 16001);
   SetSendParameters(parameters);
-  EXPECT_EQ(16001, GetOpusMaxPlaybackRate(kSsrc1));
-  EXPECT_EQ(32000, GetCodecBitrate(kSsrc1));
+  EXPECT_EQ(16001, GetOpusMaxPlaybackRate(kSsrc9));
+  EXPECT_EQ(32000, GetCodecBitrate(kSsrc9));
 
   parameters.codecs[0].SetParam(cricket::kCodecParamStereo, "1");
   SetSendParameters(parameters);
-  EXPECT_EQ(64000, GetCodecBitrate(kSsrc1));
+  EXPECT_EQ(64000, GetCodecBitrate(kSsrc9));
 }
 
 // Test 24000 < maxplaybackrate triggers Opus full band mode.
@@ -1753,12 +1754,12 @@ TEST_F(WebRtcVoiceEngineTestFake, SetOpusMaxPlaybackRateFb) {
   parameters.codecs[0].bitrate = 0;
   parameters.codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 24001);
   SetSendParameters(parameters);
-  EXPECT_EQ(24001, GetOpusMaxPlaybackRate(kSsrc1));
-  EXPECT_EQ(32000, GetCodecBitrate(kSsrc1));
+  EXPECT_EQ(24001, GetOpusMaxPlaybackRate(kSsrc9));
+  EXPECT_EQ(32000, GetCodecBitrate(kSsrc9));
 
   parameters.codecs[0].SetParam(cricket::kCodecParamStereo, "1");
   SetSendParameters(parameters);
-  EXPECT_EQ(64000, GetCodecBitrate(kSsrc1));
+  EXPECT_EQ(64000, GetCodecBitrate(kSsrc9));
 }
 
 // Test Opus that without maxplaybackrate, default playback rate is used.
@@ -1767,7 +1768,7 @@ TEST_F(WebRtcVoiceEngineTestFake, DefaultOpusMaxPlaybackRate) {
   cricket::AudioSendParameters parameters;
   parameters.codecs.push_back(kOpusCodec);
   SetSendParameters(parameters);
-  EXPECT_EQ(48000, GetOpusMaxPlaybackRate(kSsrc1));
+  EXPECT_EQ(48000, GetOpusMaxPlaybackRate(kSsrc9));
 }
 
 // Test the with non-Opus, maxplaybackrate has no effect.
@@ -1777,7 +1778,7 @@ TEST_F(WebRtcVoiceEngineTestFake, SetNonOpusMaxPlaybackRate) {
   parameters.codecs.push_back(kIsacCodec);
   parameters.codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 32000);
   SetSendParameters(parameters);
-  EXPECT_EQ(0, GetOpusMaxPlaybackRate(kSsrc1));
+  EXPECT_EQ(0, GetOpusMaxPlaybackRate(kSsrc9));
 }
 
 // Test maxplaybackrate can be set on two streams.
@@ -1786,11 +1787,11 @@ TEST_F(WebRtcVoiceEngineTestFake, SetOpusMaxPlaybackRateOnTwoStreams) {
   cricket::AudioSendParameters parameters;
   parameters.codecs.push_back(kOpusCodec);
   SetSendParameters(parameters);
-  EXPECT_EQ(48000, GetOpusMaxPlaybackRate(kSsrc1));
+  EXPECT_EQ(48000, GetOpusMaxPlaybackRate(kSsrc9));
 
   parameters.codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 8000);
   SetSendParameters(parameters);
-  EXPECT_EQ(8000, GetOpusMaxPlaybackRate(kSsrc1));
+  EXPECT_EQ(8000, GetOpusMaxPlaybackRate(kSsrc9));
 
   channel_->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc2));
   EXPECT_EQ(8000, GetOpusMaxPlaybackRate(kSsrc2));
@@ -1803,7 +1804,7 @@ TEST_F(WebRtcVoiceEngineTestFake, DisableOpusDtxOnOpus) {
   parameters.codecs.push_back(kOpusCodec);
   parameters.codecs[0].params["usedtx"] = "0";
   SetSendParameters(parameters);
-  EXPECT_FALSE(GetOpusDtx(kSsrc1));
+  EXPECT_FALSE(GetOpusDtx(kSsrc9));
 }
 
 // Test that with usedtx=1, Opus DTX is on.
@@ -1813,7 +1814,7 @@ TEST_F(WebRtcVoiceEngineTestFake, EnableOpusDtxOnOpus) {
   parameters.codecs.push_back(kOpusCodec);
   parameters.codecs[0].params["usedtx"] = "1";
   SetSendParameters(parameters);
-  EXPECT_TRUE(GetOpusDtx(kSsrc1));
+  EXPECT_TRUE(GetOpusDtx(kSsrc9));
 }
 
 // Test that usedtx=1 works with stereo Opus.
@@ -1824,7 +1825,7 @@ TEST_F(WebRtcVoiceEngineTestFake, EnableOpusDtxOnOpusStereo) {
   parameters.codecs[0].params["usedtx"] = "1";
   parameters.codecs[0].params["stereo"] = "1";
   SetSendParameters(parameters);
-  EXPECT_TRUE(GetOpusDtx(kSsrc1));
+  EXPECT_TRUE(GetOpusDtx(kSsrc9));
 }
 
 // Test that usedtx=1 does not work with non Opus.
@@ -1834,7 +1835,7 @@ TEST_F(WebRtcVoiceEngineTestFake, CannotEnableOpusDtxOnNonOpus) {
   parameters.codecs.push_back(kIsacCodec);
   parameters.codecs[0].params["usedtx"] = "1";
   SetSendParameters(parameters);
-  EXPECT_FALSE(GetOpusDtx(kSsrc1));
+  EXPECT_FALSE(GetOpusDtx(kSsrc9));
 }
 
 // Test that we can switch back and forth between Opus and ISAC with CN.
@@ -1845,7 +1846,7 @@ TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsIsacOpusSwitching) {
   opus_parameters.codecs.push_back(kOpusCodec);
   SetSendParameters(opus_parameters);
   {
-    const auto& gcodec = GetSendStreamConfig(kSsrc1).send_codec_spec.codec_inst;
+    const auto& gcodec = GetSendStreamConfig(kSsrc9).send_codec_spec.codec_inst;
     EXPECT_EQ(111, gcodec.pltype);
     EXPECT_STREQ("opus", gcodec.plname);
   }
@@ -1856,14 +1857,14 @@ TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsIsacOpusSwitching) {
   isac_parameters.codecs.push_back(kOpusCodec);
   SetSendParameters(isac_parameters);
   {
-    const auto& gcodec = GetSendStreamConfig(kSsrc1).send_codec_spec.codec_inst;
+    const auto& gcodec = GetSendStreamConfig(kSsrc9).send_codec_spec.codec_inst;
     EXPECT_EQ(103, gcodec.pltype);
     EXPECT_STREQ("ISAC", gcodec.plname);
   }
 
   SetSendParameters(opus_parameters);
   {
-    const auto& gcodec = GetSendStreamConfig(kSsrc1).send_codec_spec.codec_inst;
+    const auto& gcodec = GetSendStreamConfig(kSsrc9).send_codec_spec.codec_inst;
     EXPECT_EQ(111, gcodec.pltype);
     EXPECT_STREQ("opus", gcodec.plname);
   }
@@ -1876,7 +1877,7 @@ TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsBitrate) {
   parameters.codecs.push_back(kIsacCodec);  // bitrate == 32000
   SetSendParameters(parameters);
   {
-    const auto& gcodec = GetSendStreamConfig(kSsrc1).send_codec_spec.codec_inst;
+    const auto& gcodec = GetSendStreamConfig(kSsrc9).send_codec_spec.codec_inst;
     EXPECT_EQ(103, gcodec.pltype);
     EXPECT_STREQ("ISAC", gcodec.plname);
     EXPECT_EQ(32000, gcodec.rate);
@@ -1885,7 +1886,7 @@ TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsBitrate) {
   parameters.codecs[0].bitrate = 0;         // bitrate == default
   SetSendParameters(parameters);
   {
-    const auto& gcodec = GetSendStreamConfig(kSsrc1).send_codec_spec.codec_inst;
+    const auto& gcodec = GetSendStreamConfig(kSsrc9).send_codec_spec.codec_inst;
     EXPECT_EQ(103, gcodec.pltype);
     EXPECT_STREQ("ISAC", gcodec.plname);
     EXPECT_EQ(32000, gcodec.rate);
@@ -1893,7 +1894,7 @@ TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsBitrate) {
   parameters.codecs[0].bitrate = 28000;     // bitrate == 28000
   SetSendParameters(parameters);
   {
-    const auto& gcodec = GetSendStreamConfig(kSsrc1).send_codec_spec.codec_inst;
+    const auto& gcodec = GetSendStreamConfig(kSsrc9).send_codec_spec.codec_inst;
     EXPECT_EQ(103, gcodec.pltype);
     EXPECT_STREQ("ISAC", gcodec.plname);
     EXPECT_EQ(28000, gcodec.rate);
@@ -1902,7 +1903,7 @@ TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsBitrate) {
   parameters.codecs[0] = kPcmuCodec;        // bitrate == 64000
   SetSendParameters(parameters);
   {
-    const auto& gcodec = GetSendStreamConfig(kSsrc1).send_codec_spec.codec_inst;
+    const auto& gcodec = GetSendStreamConfig(kSsrc9).send_codec_spec.codec_inst;
     EXPECT_EQ(0, gcodec.pltype);
     EXPECT_STREQ("PCMU", gcodec.plname);
     EXPECT_EQ(64000, gcodec.rate);
@@ -1911,7 +1912,7 @@ TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsBitrate) {
   parameters.codecs[0].bitrate = 0;         // bitrate == default
   SetSendParameters(parameters);
   {
-    const auto& gcodec = GetSendStreamConfig(kSsrc1).send_codec_spec.codec_inst;
+    const auto& gcodec = GetSendStreamConfig(kSsrc9).send_codec_spec.codec_inst;
     EXPECT_EQ(0, gcodec.pltype);
     EXPECT_STREQ("PCMU", gcodec.plname);
     EXPECT_EQ(64000, gcodec.rate);
@@ -1921,7 +1922,7 @@ TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsBitrate) {
   parameters.codecs[0].bitrate = 0;         // bitrate == default
   SetSendParameters(parameters);
   {
-    const auto& gcodec = GetSendStreamConfig(kSsrc1).send_codec_spec.codec_inst;
+    const auto& gcodec = GetSendStreamConfig(kSsrc9).send_codec_spec.codec_inst;
     EXPECT_EQ(111, gcodec.pltype);
     EXPECT_STREQ("opus", gcodec.plname);
     EXPECT_EQ(32000, gcodec.rate);
@@ -1935,27 +1936,27 @@ TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsPTimeAsPacketSize) {
   parameters.codecs.push_back(kOpusCodec);
   parameters.codecs[0].SetParam(cricket::kCodecParamPTime, 40); // Within range.
   SetSendParameters(parameters);
-  EXPECT_EQ(1920, GetCodecPacSize(kSsrc1));  // Opus gets 40ms.
+  EXPECT_EQ(1920, GetCodecPacSize(kSsrc9));  // Opus gets 40ms.
 
   parameters.codecs[0].SetParam(cricket::kCodecParamPTime, 5); // Below range.
   SetSendParameters(parameters);
-  EXPECT_EQ(480, GetCodecPacSize(kSsrc1));  // Opus gets 10ms.
+  EXPECT_EQ(480, GetCodecPacSize(kSsrc9));  // Opus gets 10ms.
 
   parameters.codecs[0].SetParam(cricket::kCodecParamPTime, 80); // Beyond range.
   SetSendParameters(parameters);
-  EXPECT_EQ(2880, GetCodecPacSize(kSsrc1));  // Opus gets 60ms.
+  EXPECT_EQ(2880, GetCodecPacSize(kSsrc9));  // Opus gets 60ms.
 
   parameters.codecs[0] = kIsacCodec;  // Also try Isac, with unsupported size.
   parameters.codecs[0].SetParam(cricket::kCodecParamPTime, 40); // Within range.
   SetSendParameters(parameters);
   EXPECT_EQ(480, GetCodecPacSize(
-                     kSsrc1));  // Isac gets 30ms as the next smallest value.
+                     kSsrc9));  // Isac gets 30ms as the next smallest value.
 
   parameters.codecs[0] = kG722CodecSdp;  // Try G722 @8kHz as negotiated in SDP.
   parameters.codecs[0].SetParam(cricket::kCodecParamPTime, 40);
   SetSendParameters(parameters);
   EXPECT_EQ(640, GetCodecPacSize(
-                     kSsrc1));  // G722 gets 40ms @16kHz as defined in VoE.
+                     kSsrc9));  // G722 gets 40ms @16kHz as defined in VoE.
 }
 
 // Test that we fail if no codecs are specified.
@@ -1976,7 +1977,7 @@ TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsDTMFOnTop) {
   parameters.codecs[0].id = 98;  // DTMF
   parameters.codecs[1].id = 96;
   SetSendParameters(parameters);
-  const auto& gcodec = GetSendStreamConfig(kSsrc1).send_codec_spec.codec_inst;
+  const auto& gcodec = GetSendStreamConfig(kSsrc9).send_codec_spec.codec_inst;
   EXPECT_EQ(96, gcodec.pltype);
   EXPECT_STREQ("ISAC", gcodec.plname);
   EXPECT_TRUE(channel_->CanInsertDtmf());
@@ -2014,7 +2015,7 @@ TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNOnTop) {
   parameters.codecs[0].id = 98;  // wideband CN
   parameters.codecs[1].id = 96;
   SetSendParameters(parameters);
-  const auto& send_codec_spec = GetSendStreamConfig(kSsrc1).send_codec_spec;
+  const auto& send_codec_spec = GetSendStreamConfig(kSsrc9).send_codec_spec;
   EXPECT_EQ(96, send_codec_spec.codec_inst.pltype);
   EXPECT_STREQ("ISAC", send_codec_spec.codec_inst.plname);
   EXPECT_EQ(98, send_codec_spec.cng_payload_type);
@@ -2035,7 +2036,7 @@ TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNandDTMFAsCaller) {
   parameters.codecs[2].id = 97;  // wideband CN
   parameters.codecs[4].id = 98;  // DTMF
   SetSendParameters(parameters);
-  const auto& send_codec_spec = GetSendStreamConfig(kSsrc1).send_codec_spec;
+  const auto& send_codec_spec = GetSendStreamConfig(kSsrc9).send_codec_spec;
   EXPECT_EQ(96, send_codec_spec.codec_inst.pltype);
   EXPECT_STREQ("ISAC", send_codec_spec.codec_inst.plname);
   EXPECT_EQ(1, send_codec_spec.codec_inst.channels);
@@ -2060,9 +2061,9 @@ TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNandDTMFAsCallee) {
   parameters.codecs[4].id = 98;  // DTMF
   SetSendParameters(parameters);
   EXPECT_TRUE(channel_->AddSendStream(
-      cricket::StreamParams::CreateLegacy(kSsrc1)));
+      cricket::StreamParams::CreateLegacy(kSsrc9)));
 
-  const auto& send_codec_spec = GetSendStreamConfig(kSsrc1).send_codec_spec;
+  const auto& send_codec_spec = GetSendStreamConfig(kSsrc9).send_codec_spec;
   EXPECT_EQ(96, send_codec_spec.codec_inst.pltype);
   EXPECT_STREQ("ISAC", send_codec_spec.codec_inst.plname);
   EXPECT_EQ(1, send_codec_spec.codec_inst.channels);
@@ -2083,7 +2084,7 @@ TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNNoMatch) {
   parameters.codecs[1].id = 97;
   SetSendParameters(parameters);
   {
-    const auto& send_codec_spec = GetSendStreamConfig(kSsrc1).send_codec_spec;
+    const auto& send_codec_spec = GetSendStreamConfig(kSsrc9).send_codec_spec;
     EXPECT_STREQ("ISAC", send_codec_spec.codec_inst.plname);
     EXPECT_EQ(1, send_codec_spec.codec_inst.channels);
     EXPECT_EQ(send_codec_spec.codec_inst.plfreq, send_codec_spec.cng_plfreq);
@@ -2094,7 +2095,7 @@ TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNNoMatch) {
   parameters.codecs[0] = kPcmuCodec;
   SetSendParameters(parameters);
   {
-    const auto& send_codec_spec = GetSendStreamConfig(kSsrc1).send_codec_spec;
+    const auto& send_codec_spec = GetSendStreamConfig(kSsrc9).send_codec_spec;
     EXPECT_STREQ("PCMU", send_codec_spec.codec_inst.plname);
     EXPECT_NE(send_codec_spec.codec_inst.plfreq, send_codec_spec.cng_plfreq);
   }
@@ -2102,7 +2103,7 @@ TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNNoMatch) {
   parameters.codecs[1] = kCn8000Codec;
   SetSendParameters(parameters);
   {
-    const auto& send_codec_spec = GetSendStreamConfig(kSsrc1).send_codec_spec;
+    const auto& send_codec_spec = GetSendStreamConfig(kSsrc9).send_codec_spec;
     EXPECT_STREQ("PCMU", send_codec_spec.codec_inst.plname);
     EXPECT_EQ(1, send_codec_spec.codec_inst.channels);
     EXPECT_EQ(send_codec_spec.codec_inst.plfreq, send_codec_spec.cng_plfreq);
@@ -2113,7 +2114,7 @@ TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNNoMatch) {
   parameters.codecs[0] = kIsacCodec;
   SetSendParameters(parameters);
   {
-    const auto& send_codec_spec = GetSendStreamConfig(kSsrc1).send_codec_spec;
+    const auto& send_codec_spec = GetSendStreamConfig(kSsrc9).send_codec_spec;
     EXPECT_STREQ("ISAC", send_codec_spec.codec_inst.plname);
     EXPECT_NE(send_codec_spec.codec_inst.plfreq, send_codec_spec.cng_plfreq);
   }
@@ -2133,7 +2134,7 @@ TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCaseInsensitive) {
   parameters.codecs[2].id = 97;  // wideband CN
   parameters.codecs[4].id = 98;  // DTMF
   SetSendParameters(parameters);
-  const auto& send_codec_spec = GetSendStreamConfig(kSsrc1).send_codec_spec;
+  const auto& send_codec_spec = GetSendStreamConfig(kSsrc9).send_codec_spec;
   EXPECT_EQ(96, send_codec_spec.codec_inst.pltype);
   EXPECT_STREQ("ISAC", send_codec_spec.codec_inst.plname);
   EXPECT_EQ(1, send_codec_spec.codec_inst.channels);
@@ -2186,9 +2187,9 @@ TEST_F(WebRtcVoiceEngineTestFake, Send) {
   EXPECT_TRUE(SetupSendStream());
   SetSendParameters(send_parameters_);
   SetSend(true);
-  EXPECT_TRUE(GetSendStream(kSsrc1).IsSending());
+  EXPECT_TRUE(GetSendStream(kSsrc9).IsSending());
   SetSend(false);
-  EXPECT_FALSE(GetSendStream(kSsrc1).IsSending());
+  EXPECT_FALSE(GetSendStream(kSsrc9).IsSending());
 }
 
 // Test that a channel will send if and only if it has a source and is enabled
@@ -2196,49 +2197,49 @@ TEST_F(WebRtcVoiceEngineTestFake, Send) {
 TEST_F(WebRtcVoiceEngineTestFake, SendStateWithAndWithoutSource) {
   EXPECT_TRUE(SetupSendStream());
   SetSendParameters(send_parameters_);
-  SetAudioSend(kSsrc1, true, nullptr);
+  SetAudioSend(kSsrc9, true, nullptr);
   SetSend(true);
-  EXPECT_FALSE(GetSendStream(kSsrc1).IsSending());
-  SetAudioSend(kSsrc1, true, &fake_source_);
-  EXPECT_TRUE(GetSendStream(kSsrc1).IsSending());
-  SetAudioSend(kSsrc1, true, nullptr);
-  EXPECT_FALSE(GetSendStream(kSsrc1).IsSending());
+  EXPECT_FALSE(GetSendStream(kSsrc9).IsSending());
+  SetAudioSend(kSsrc9, true, &fake_source_);
+  EXPECT_TRUE(GetSendStream(kSsrc9).IsSending());
+  SetAudioSend(kSsrc9, true, nullptr);
+  EXPECT_FALSE(GetSendStream(kSsrc9).IsSending());
 }
 
 // Test that a channel is muted/unmuted.
 TEST_F(WebRtcVoiceEngineTestFake, SendStateMuteUnmute) {
   EXPECT_TRUE(SetupSendStream());
   SetSendParameters(send_parameters_);
-  EXPECT_FALSE(GetSendStream(kSsrc1).muted());
-  SetAudioSend(kSsrc1, true, nullptr);
-  EXPECT_FALSE(GetSendStream(kSsrc1).muted());
-  SetAudioSend(kSsrc1, false, nullptr);
-  EXPECT_TRUE(GetSendStream(kSsrc1).muted());
+  EXPECT_FALSE(GetSendStream(kSsrc9).muted());
+  SetAudioSend(kSsrc9, true, nullptr);
+  EXPECT_FALSE(GetSendStream(kSsrc9).muted());
+  SetAudioSend(kSsrc9, false, nullptr);
+  EXPECT_TRUE(GetSendStream(kSsrc9).muted());
 }
 
 // Test that SetSendParameters() does not alter a stream's send state.
 TEST_F(WebRtcVoiceEngineTestFake, SendStateWhenStreamsAreRecreated) {
   EXPECT_TRUE(SetupSendStream());
-  EXPECT_FALSE(GetSendStream(kSsrc1).IsSending());
+  EXPECT_FALSE(GetSendStream(kSsrc9).IsSending());
 
   // Turn on sending.
   SetSend(true);
-  EXPECT_TRUE(GetSendStream(kSsrc1).IsSending());
+  EXPECT_TRUE(GetSendStream(kSsrc9).IsSending());
 
   // Changing RTP header extensions will recreate the AudioSendStream.
   send_parameters_.extensions.push_back(
       webrtc::RtpExtension(webrtc::RtpExtension::kAudioLevelUri, 12));
   SetSendParameters(send_parameters_);
-  EXPECT_TRUE(GetSendStream(kSsrc1).IsSending());
+  EXPECT_TRUE(GetSendStream(kSsrc9).IsSending());
 
   // Turn off sending.
   SetSend(false);
-  EXPECT_FALSE(GetSendStream(kSsrc1).IsSending());
+  EXPECT_FALSE(GetSendStream(kSsrc9).IsSending());
 
   // Changing RTP header extensions will recreate the AudioSendStream.
   send_parameters_.extensions.clear();
   SetSendParameters(send_parameters_);
-  EXPECT_FALSE(GetSendStream(kSsrc1).IsSending());
+  EXPECT_FALSE(GetSendStream(kSsrc9).IsSending());
 }
 
 // Test that we can create a channel and start playing out on it.
@@ -2246,9 +2247,9 @@ TEST_F(WebRtcVoiceEngineTestFake, Playout) {
   EXPECT_TRUE(SetupRecvStream());
   EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_));
   channel_->SetPlayout(true);
-  EXPECT_TRUE(GetRecvStream(kSsrc1).started());
+  EXPECT_TRUE(GetRecvStream(kSsrc9).started());
   channel_->SetPlayout(false);
-  EXPECT_FALSE(GetRecvStream(kSsrc1).started());
+  EXPECT_FALSE(GetRecvStream(kSsrc9).started());
 }
 
 // Test that we can add and remove send streams.
@@ -2417,7 +2418,7 @@ TEST_F(WebRtcVoiceEngineTestFake, PlayoutWithMultipleStreams) {
   // Adding another stream should enable playout on the new stream only.
   EXPECT_TRUE(AddRecvStream(kSsrc2));
   SetSend(true);
-  EXPECT_TRUE(GetSendStream(kSsrc1).IsSending());
+  EXPECT_TRUE(GetSendStream(kSsrc9).IsSending());
 
   // Make sure only the new stream is played out.
   EXPECT_TRUE(GetRecvStream(kSsrc2).started());
@@ -2429,7 +2430,7 @@ TEST_F(WebRtcVoiceEngineTestFake, PlayoutWithMultipleStreams) {
 
   // Stop sending.
   SetSend(false);
-  EXPECT_FALSE(GetSendStream(kSsrc1).IsSending());
+  EXPECT_FALSE(GetSendStream(kSsrc9).IsSending());
 
   // Stop playout.
   channel_->SetPlayout(false);
@@ -2458,11 +2459,11 @@ TEST_F(WebRtcVoiceEngineTestFake, CodianSend) {
   send_parameters_.options = options_adjust_agc;
   SetSendParameters(send_parameters_);
   SetSend(true);
-  EXPECT_TRUE(GetSendStream(kSsrc1).IsSending());
+  EXPECT_TRUE(GetSendStream(kSsrc9).IsSending());
   EXPECT_EQ(0, voe_.GetAgcConfig(agc_config));
   EXPECT_EQ(agc_config.targetLeveldBOv, 10);  // level was attenuated
   SetSend(false);
-  EXPECT_FALSE(GetSendStream(kSsrc1).IsSending());
+  EXPECT_FALSE(GetSendStream(kSsrc9).IsSending());
   EXPECT_EQ(0, voe_.GetAgcConfig(agc_config));
 }
 
@@ -2509,7 +2510,7 @@ TEST_F(WebRtcVoiceEngineTestFake, SetAudioNetworkAdaptorViaOptions) {
       rtc::Optional<std::string>("1234");
   SetSendParameters(send_parameters_);
   EXPECT_EQ(send_parameters_.options.audio_network_adaptor_config,
-            GetAudioNetworkAdaptorConfig(kSsrc1));
+            GetAudioNetworkAdaptorConfig(kSsrc9));
 }
 
 TEST_F(WebRtcVoiceEngineTestFake, AudioSendResetAudioNetworkAdaptor) {
@@ -2519,14 +2520,14 @@ TEST_F(WebRtcVoiceEngineTestFake, AudioSendResetAudioNetworkAdaptor) {
       rtc::Optional<std::string>("1234");
   SetSendParameters(send_parameters_);
   EXPECT_EQ(send_parameters_.options.audio_network_adaptor_config,
-            GetAudioNetworkAdaptorConfig(kSsrc1));
+            GetAudioNetworkAdaptorConfig(kSsrc9));
   const int initial_num = call_.GetNumCreatedSendStreams();
   cricket::AudioOptions options;
   options.audio_network_adaptor = rtc::Optional<bool>(false);
-  SetAudioSend(kSsrc1, true, nullptr, &options);
+  SetAudioSend(kSsrc9, true, nullptr, &options);
   // AudioSendStream expected to be recreated.
   EXPECT_EQ(initial_num + 1, call_.GetNumCreatedSendStreams());
-  EXPECT_EQ(rtc::Optional<std::string>(), GetAudioNetworkAdaptorConfig(kSsrc1));
+  EXPECT_EQ(rtc::Optional<std::string>(), GetAudioNetworkAdaptorConfig(kSsrc9));
 }
 
 TEST_F(WebRtcVoiceEngineTestFake, AudioNetworkAdaptorNotGetOverridden) {
@@ -2536,17 +2537,17 @@ TEST_F(WebRtcVoiceEngineTestFake, AudioNetworkAdaptorNotGetOverridden) {
       rtc::Optional<std::string>("1234");
   SetSendParameters(send_parameters_);
   EXPECT_EQ(send_parameters_.options.audio_network_adaptor_config,
-            GetAudioNetworkAdaptorConfig(kSsrc1));
+            GetAudioNetworkAdaptorConfig(kSsrc9));
   const int initial_num = call_.GetNumCreatedSendStreams();
   cricket::AudioOptions options;
   options.audio_network_adaptor = rtc::Optional<bool>();
   // Unvalued |options.audio_network_adaptor|.should not reset audio network
   // adaptor.
-  SetAudioSend(kSsrc1, true, nullptr, &options);
+  SetAudioSend(kSsrc9, true, nullptr, &options);
   // AudioSendStream not expected to be recreated.
   EXPECT_EQ(initial_num, call_.GetNumCreatedSendStreams());
   EXPECT_EQ(send_parameters_.options.audio_network_adaptor_config,
-            GetAudioNetworkAdaptorConfig(kSsrc1));
+            GetAudioNetworkAdaptorConfig(kSsrc9));
 }
 
 class WebRtcVoiceEngineWithSendSideBweWithOverheadTest
@@ -2575,10 +2576,10 @@ TEST_F(WebRtcVoiceEngineWithSendSideBweWithOverheadTest, MinAndMaxBitrate) {
 
   constexpr int kOpusMinBitrateBps = 6000;
   EXPECT_EQ(kOpusMinBitrateBps + kMinOverheadBps,
-            GetSendStreamConfig(kSsrc1).min_bitrate_bps);
+            GetSendStreamConfig(kSsrc9).min_bitrate_bps);
   constexpr int kOpusBitrateFbBps = 32000;
   EXPECT_EQ(kOpusBitrateFbBps + kMaxOverheadBps,
-            GetSendStreamConfig(kSsrc1).max_bitrate_bps);
+            GetSendStreamConfig(kSsrc9).max_bitrate_bps);
 
   parameters.options.audio_network_adaptor = rtc::Optional<bool>(true);
   parameters.options.audio_network_adaptor_config =
@@ -2590,23 +2591,23 @@ TEST_F(WebRtcVoiceEngineWithSendSideBweWithOverheadTest, MinAndMaxBitrate) {
   constexpr int kMaxOverheadWithAnaBps = kOverheadPerPacket * 8 * 1000 / 20;
 
   EXPECT_EQ(kOpusMinBitrateBps + kMinOverheadWithAnaBps,
-            GetSendStreamConfig(kSsrc1).min_bitrate_bps);
+            GetSendStreamConfig(kSsrc9).min_bitrate_bps);
 
   EXPECT_EQ(kOpusBitrateFbBps + kMaxOverheadWithAnaBps,
-            GetSendStreamConfig(kSsrc1).max_bitrate_bps);
+            GetSendStreamConfig(kSsrc9).max_bitrate_bps);
 }
 
 // Test that we can set the outgoing SSRC properly.
 // SSRC is set in SetupSendStream() by calling AddSendStream.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendSsrc) {
   EXPECT_TRUE(SetupSendStream());
-  EXPECT_TRUE(call_.GetAudioSendStream(kSsrc1));
+  EXPECT_TRUE(call_.GetAudioSendStream(kSsrc9));
 }
 
 TEST_F(WebRtcVoiceEngineTestFake, GetStats) {
   // Setup. We need send codec to be set to get all stats.
   EXPECT_TRUE(SetupSendStream());
-  // SetupSendStream adds a send stream with kSsrc1, so the receive
+  // SetupSendStream adds a send stream with kSsrc9, so the receive
   // stream has to use a different SSRC.
   EXPECT_TRUE(AddRecvStream(kSsrc2));
   SetSendParameters(send_parameters_);
@@ -2662,9 +2663,9 @@ TEST_F(WebRtcVoiceEngineTestFake, GetStats) {
 // SSRC is set in SetupSendStream() by calling AddSendStream.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendSsrcWithMultipleStreams) {
   EXPECT_TRUE(SetupSendStream());
-  EXPECT_TRUE(call_.GetAudioSendStream(kSsrc1));
+  EXPECT_TRUE(call_.GetAudioSendStream(kSsrc9));
   EXPECT_TRUE(AddRecvStream(kSsrc2));
-  EXPECT_EQ(kSsrc1, GetRecvStreamConfig(kSsrc2).rtp.local_ssrc);
+  EXPECT_EQ(kSsrc9, GetRecvStreamConfig(kSsrc2).rtp.local_ssrc);
 }
 
 // Test that the local SSRC is the same on sending and receiving channels if the
@@ -2673,9 +2674,9 @@ TEST_F(WebRtcVoiceEngineTestFake, SetSendSsrcAfterCreatingReceiveChannel) {
   EXPECT_TRUE(SetupChannel());
   EXPECT_TRUE(AddRecvStream(kSsrc2));
   EXPECT_TRUE(channel_->AddSendStream(
-      cricket::StreamParams::CreateLegacy(kSsrc1)));
-  EXPECT_TRUE(call_.GetAudioSendStream(kSsrc1));
-  EXPECT_EQ(kSsrc1, GetRecvStreamConfig(kSsrc2).rtp.local_ssrc);
+      cricket::StreamParams::CreateLegacy(kSsrc9)));
+  EXPECT_TRUE(call_.GetAudioSendStream(kSsrc9));
+  EXPECT_EQ(kSsrc9, GetRecvStreamConfig(kSsrc2).rtp.local_ssrc);
 }
 
 // Test that we can properly receive packets.
@@ -2691,12 +2692,9 @@ TEST_F(WebRtcVoiceEngineTestFake, Recv) {
 // Test that we can properly receive packets on multiple streams.
 TEST_F(WebRtcVoiceEngineTestFake, RecvWithMultipleStreams) {
   EXPECT_TRUE(SetupChannel());
-  const uint32_t ssrc1 = 1;
-  const uint32_t ssrc2 = 2;
-  const uint32_t ssrc3 = 3;
-  EXPECT_TRUE(AddRecvStream(ssrc1));
-  EXPECT_TRUE(AddRecvStream(ssrc2));
-  EXPECT_TRUE(AddRecvStream(ssrc3));
+  EXPECT_TRUE(AddRecvStream(kSsrc1));
+  EXPECT_TRUE(AddRecvStream(kSsrc2));
+  EXPECT_TRUE(AddRecvStream(kSsrc3));
   // Create packets with the right SSRCs.
   unsigned char packets[4][sizeof(kPcmuFrame)];
   for (size_t i = 0; i < arraysize(packets); ++i) {
@@ -2704,9 +2702,9 @@ TEST_F(WebRtcVoiceEngineTestFake, RecvWithMultipleStreams) {
     rtc::SetBE32(packets[i] + 8, static_cast<uint32_t>(i));

[Taylor Brandstetter, 2017/02/17 10:34:46]

This test puts the literal values 1, 2 and 3 in the packets, so it shouldn't be
relying on constants defined outside of the test (kSsrc1/kSsrc2/kSsrc3). Or, it
should be using kSsrc1/kSsrc2/kSsrc3 in rtc::SetBE32.

[the sun, 2017/02/17 11:22:47]

Oh, well spotted. Reverted. Thanks!

   }
 
-  const cricket::FakeAudioReceiveStream& s1 = GetRecvStream(ssrc1);
-  const cricket::FakeAudioReceiveStream& s2 = GetRecvStream(ssrc2);
-  const cricket::FakeAudioReceiveStream& s3 = GetRecvStream(ssrc3);
+  const cricket::FakeAudioReceiveStream& s1 = GetRecvStream(kSsrc1);
+  const cricket::FakeAudioReceiveStream& s2 = GetRecvStream(kSsrc2);
+  const cricket::FakeAudioReceiveStream& s3 = GetRecvStream(kSsrc3);
 
   EXPECT_EQ(s1.received_packets(), 0);
   EXPECT_EQ(s2.received_packets(), 0);
@@ -2735,14 +2733,13 @@ TEST_F(WebRtcVoiceEngineTestFake, RecvWithMultipleStreams) {
   EXPECT_EQ(s3.received_packets(), 1);
   EXPECT_TRUE(s3.VerifyLastPacket(packets[3], sizeof(packets[3])));
 
-  EXPECT_TRUE(channel_->RemoveRecvStream(ssrc3));
-  EXPECT_TRUE(channel_->RemoveRecvStream(ssrc2));
-  EXPECT_TRUE(channel_->RemoveRecvStream(ssrc1));
+  EXPECT_TRUE(channel_->RemoveRecvStream(kSsrc3));
+  EXPECT_TRUE(channel_->RemoveRecvStream(kSsrc2));
+  EXPECT_TRUE(channel_->RemoveRecvStream(kSsrc1));
 }
 
-// Test that receiving on an unsignalled stream works (default channel will be
-// created).
-TEST_F(WebRtcVoiceEngineTestFake, RecvUnsignalled) {
+// Test that receiving on an unsignaled stream works (a stream is created).
+TEST_F(WebRtcVoiceEngineTestFake, RecvUnsignaled) {
   EXPECT_TRUE(SetupChannel());
   EXPECT_EQ(0, call_.GetAudioReceiveStreams().size());
 
@@ -2753,37 +2750,57 @@ TEST_F(WebRtcVoiceEngineTestFake, RecvUnsignalled) {
                                                 sizeof(kPcmuFrame)));
 }
 
-// Test that receiving on an unsignalled stream works (default channel will be
-// created), and that packets will be forwarded to the default channel
-// regardless of their SSRCs.
-TEST_F(WebRtcVoiceEngineTestFake, RecvUnsignalledWithSsrcSwitch) {
+// Test that receiving N unsignaled stream works (streams will be created), and
+// that packets are forwarded to them all.
+TEST_F(WebRtcVoiceEngineTestFake, RecvMultipleUnsignaled) {
   EXPECT_TRUE(SetupChannel());
   unsigned char packet[sizeof(kPcmuFrame)];
   memcpy(packet, kPcmuFrame, sizeof(kPcmuFrame));
 
-  // Note that ssrc = 0 is not supported.
-  uint32_t ssrc = 1;
-  for (; ssrc < 10; ++ssrc) {
+  constexpr uint32_t kMaxUnsignaledCount = 50;
+
+  // Note that SSRC = 0 is not supported.
+  for (uint32_t ssrc = 1; ssrc < (1 + kMaxUnsignaledCount); ++ssrc) {
     rtc::SetBE32(&packet[8], ssrc);
     DeliverPacket(packet, sizeof(packet));
 
-    // Verify we only have one default stream.
-    EXPECT_EQ(1, call_.GetAudioReceiveStreams().size());
+    // Verify we have one new stream for each loop iteration.
+    EXPECT_EQ(ssrc, call_.GetAudioReceiveStreams().size());
     EXPECT_EQ(1, GetRecvStream(ssrc).received_packets());
     EXPECT_TRUE(GetRecvStream(ssrc).VerifyLastPacket(packet, sizeof(packet)));
   }
 
-  // Sending the same ssrc again should not create a new stream.
-  --ssrc;
+  // Sending on the same SSRCs again should not create new streams.
+  for (uint32_t ssrc = 1; ssrc < (1 + kMaxUnsignaledCount); ++ssrc) {
+    rtc::SetBE32(&packet[8], ssrc);
+    DeliverPacket(packet, sizeof(packet));
+
+    EXPECT_EQ(kMaxUnsignaledCount, call_.GetAudioReceiveStreams().size());
+    EXPECT_EQ(2, GetRecvStream(ssrc).received_packets());
+    EXPECT_TRUE(GetRecvStream(ssrc).VerifyLastPacket(packet, sizeof(packet)));
+  }
+
+  // Send on another SSRC, the oldest unsignaled stream (SSRC=1) is replaced.
+  constexpr uint32_t kAnotherSsrc = 667;
+  rtc::SetBE32(&packet[8], kAnotherSsrc);
   DeliverPacket(packet, sizeof(packet));
-  EXPECT_EQ(1, call_.GetAudioReceiveStreams().size());
-  EXPECT_EQ(2, GetRecvStream(ssrc).received_packets());
-  EXPECT_TRUE(GetRecvStream(ssrc).VerifyLastPacket(packet, sizeof(packet)));
+
+  const auto& streams = call_.GetAudioReceiveStreams();
+  EXPECT_EQ(kMaxUnsignaledCount, streams.size());
+  size_t i = 0;
+  for (uint32_t ssrc = 2; ssrc < (1 + kMaxUnsignaledCount); ++ssrc, ++i) {
+    EXPECT_EQ(ssrc, streams[i]->GetConfig().rtp.remote_ssrc);
+    EXPECT_EQ(2, streams[i]->received_packets());
+  }
+  EXPECT_EQ(kAnotherSsrc, streams[i]->GetConfig().rtp.remote_ssrc);
+  EXPECT_EQ(1, streams[i]->received_packets());
+  // Sanity check that we've checked all streams.
+  EXPECT_EQ(kMaxUnsignaledCount, (i + 1));
 }
 
-// Test that a default channel is created even after a signalled stream has been
+// Test that a default channel is created even after a signaled stream has been
 // added, and that this stream will get any packets for unknown SSRCs.
-TEST_F(WebRtcVoiceEngineTestFake, RecvUnsignalledAfterSignalled) {
+TEST_F(WebRtcVoiceEngineTestFake, RecvUnsignaledAfterSignaled) {
   EXPECT_TRUE(SetupChannel());
   unsigned char packet[sizeof(kPcmuFrame)];
   memcpy(packet, kPcmuFrame, sizeof(kPcmuFrame));
@@ -2795,6 +2812,7 @@ TEST_F(WebRtcVoiceEngineTestFake, RecvUnsignalledAfterSignalled) {
   DeliverPacket(packet, sizeof(packet));
   EXPECT_TRUE(GetRecvStream(signaled_ssrc).VerifyLastPacket(
       packet, sizeof(packet)));
+  EXPECT_EQ(1, call_.GetAudioReceiveStreams().size());
 
   // Note that the first unknown SSRC cannot be 0, because we only support
   // creating receive streams for SSRC!=0.
@@ -2844,7 +2862,7 @@ TEST_F(WebRtcVoiceEngineTestFake, AddRecvStreamUnsupportedCodec) {
   parameters.codecs.push_back(kIsacCodec);
   parameters.codecs.push_back(kPcmuCodec);
   EXPECT_TRUE(channel_->SetRecvParameters(parameters));
-  EXPECT_TRUE(AddRecvStream(kSsrc1));
+  EXPECT_TRUE(AddRecvStream(kSsrc9));
   int channel_num2 = voe_.GetLastChannel();
   webrtc::CodecInst gcodec;
   rtc::strcpyn(gcodec.plname, arraysize(gcodec.plname), "opus");
@@ -2897,12 +2915,12 @@ TEST_F(WebRtcVoiceEngineTestFake, InsertDtmfOnDefaultSendStreamAsCallee) {
 
 // Test the InsertDtmf on specified send stream as caller.
 TEST_F(WebRtcVoiceEngineTestFake, InsertDtmfOnSendStreamAsCaller) {
-  TestInsertDtmf(kSsrc1, true, kTelephoneEventCodec2);
+  TestInsertDtmf(kSsrc9, true, kTelephoneEventCodec2);
 }
 
 // Test the InsertDtmf on specified send stream as callee.
 TEST_F(WebRtcVoiceEngineTestFake, InsertDtmfOnSendStreamAsCallee) {
-  TestInsertDtmf(kSsrc1, false, kTelephoneEventCodec1);
+  TestInsertDtmf(kSsrc9, false, kTelephoneEventCodec1);
 }
 
 TEST_F(WebRtcVoiceEngineTestFake, SetAudioOptions) {
@@ -3255,9 +3273,9 @@ TEST_F(WebRtcVoiceEngineTestFake, TestGetReceiveChannelId) {
   cricket::WebRtcVoiceMediaChannel* media_channel =
         static_cast<cricket::WebRtcVoiceMediaChannel*>(channel_);
   EXPECT_EQ(-1, media_channel->GetReceiveChannelId(0));
-  EXPECT_TRUE(AddRecvStream(kSsrc1));
+  EXPECT_TRUE(AddRecvStream(kSsrc9));
   int channel_id = voe_.GetLastChannel();
-  EXPECT_EQ(channel_id, media_channel->GetReceiveChannelId(kSsrc1));
+  EXPECT_EQ(channel_id, media_channel->GetReceiveChannelId(kSsrc9));
   EXPECT_EQ(-1, media_channel->GetReceiveChannelId(kSsrc2));
   EXPECT_TRUE(AddRecvStream(kSsrc2));
   int channel_id2 = voe_.GetLastChannel();
@@ -3270,9 +3288,9 @@ TEST_F(WebRtcVoiceEngineTestFake, TestGetSendChannelId) {
         static_cast<cricket::WebRtcVoiceMediaChannel*>(channel_);
   EXPECT_EQ(-1, media_channel->GetSendChannelId(0));
   EXPECT_TRUE(channel_->AddSendStream(
-      cricket::StreamParams::CreateLegacy(kSsrc1)));
+      cricket::StreamParams::CreateLegacy(kSsrc9)));
   int channel_id = voe_.GetLastChannel();
-  EXPECT_EQ(channel_id, media_channel->GetSendChannelId(kSsrc1));
+  EXPECT_EQ(channel_id, media_channel->GetSendChannelId(kSsrc9));
   EXPECT_EQ(-1, media_channel->GetSendChannelId(kSsrc2));
   EXPECT_TRUE(channel_->AddSendStream(
       cricket::StreamParams::CreateLegacy(kSsrc2)));
@@ -3291,15 +3309,34 @@ TEST_F(WebRtcVoiceEngineTestFake, SetOutputVolume) {
   EXPECT_DOUBLE_EQ(3, GetRecvStream(kSsrc2).gain());
 }
 
-TEST_F(WebRtcVoiceEngineTestFake, SetOutputVolumeDefaultRecvStream) {
+TEST_F(WebRtcVoiceEngineTestFake, SetOutputVolumeUnsignaledRecvStream) {
   EXPECT_TRUE(SetupChannel());
-  EXPECT_TRUE(channel_->SetOutputVolume(0, 2));
+
+  // Spawn an unsignaled stream by sending a packet - gain should be 1.
   DeliverPacket(kPcmuFrame, sizeof(kPcmuFrame));
-  EXPECT_DOUBLE_EQ(2, GetRecvStream(1).gain());
+  EXPECT_DOUBLE_EQ(1, GetRecvStream(kSsrc1).gain());
+
+  // Should remember the volume "2" which will be set on new unsignaled streams,
+  // and also set the gain to 2 on existing unsignaled streams.
+  EXPECT_TRUE(channel_->SetOutputVolume(0, 2));
+  EXPECT_DOUBLE_EQ(2, GetRecvStream(kSsrc1).gain());
+
+  // Spawn an unsignaled stream by sending a packet - gain should be 2.
+  unsigned char pcmuFrame2[sizeof(kPcmuFrame)];
+  memcpy(pcmuFrame2, kPcmuFrame, sizeof(kPcmuFrame));
+  rtc::SetBE32(&pcmuFrame2[8], kSsrc4);
+  DeliverPacket(pcmuFrame2, sizeof(pcmuFrame2));
+  EXPECT_DOUBLE_EQ(2, GetRecvStream(kSsrc4).gain());
+
+  // Setting gain with SSRC=0 should affect all unsignaled streams.
   EXPECT_TRUE(channel_->SetOutputVolume(0, 3));
-  EXPECT_DOUBLE_EQ(3, GetRecvStream(1).gain());
-  EXPECT_TRUE(channel_->SetOutputVolume(1, 4));
-  EXPECT_DOUBLE_EQ(4, GetRecvStream(1).gain());
+  EXPECT_DOUBLE_EQ(3, GetRecvStream(kSsrc1).gain());
+  EXPECT_DOUBLE_EQ(3, GetRecvStream(kSsrc4).gain());
+
+  // Setting gain on an individual stream affects only that.
+  EXPECT_TRUE(channel_->SetOutputVolume(kSsrc4, 4));
+  EXPECT_DOUBLE_EQ(3, GetRecvStream(kSsrc1).gain());
+  EXPECT_DOUBLE_EQ(4, GetRecvStream(kSsrc4).gain());
 }
 
 TEST_F(WebRtcVoiceEngineTestFake, SetsSyncGroupFromSyncLabel) {
@@ -3410,25 +3447,25 @@ TEST_F(WebRtcVoiceEngineTestFake, DeliverAudioPacket_Call) {
 TEST_F(WebRtcVoiceEngineTestFake, AssociateFirstSendChannel_SendCreatedFirst) {
   EXPECT_TRUE(SetupSendStream());
   EXPECT_TRUE(AddRecvStream(kSsrc2));
-  EXPECT_EQ(kSsrc1, GetRecvStreamConfig(kSsrc2).rtp.local_ssrc);
+  EXPECT_EQ(kSsrc9, GetRecvStreamConfig(kSsrc2).rtp.local_ssrc);
   EXPECT_TRUE(channel_->AddSendStream(
       cricket::StreamParams::CreateLegacy(kSsrc3)));
-  EXPECT_EQ(kSsrc1, GetRecvStreamConfig(kSsrc2).rtp.local_ssrc);
+  EXPECT_EQ(kSsrc9, GetRecvStreamConfig(kSsrc2).rtp.local_ssrc);
   EXPECT_TRUE(AddRecvStream(kSsrc4));
-  EXPECT_EQ(kSsrc1, GetRecvStreamConfig(kSsrc4).rtp.local_ssrc);
+  EXPECT_EQ(kSsrc9, GetRecvStreamConfig(kSsrc4).rtp.local_ssrc);
 }
 
 TEST_F(WebRtcVoiceEngineTestFake, AssociateFirstSendChannel_RecvCreatedFirst) {
   EXPECT_TRUE(SetupRecvStream());
-  EXPECT_EQ(0xFA17FA17u, GetRecvStreamConfig(kSsrc1).rtp.local_ssrc);
+  EXPECT_EQ(0xFA17FA17u, GetRecvStreamConfig(kSsrc9).rtp.local_ssrc);
   EXPECT_TRUE(channel_->AddSendStream(
       cricket::StreamParams::CreateLegacy(kSsrc2)));
-  EXPECT_EQ(kSsrc2, GetRecvStreamConfig(kSsrc1).rtp.local_ssrc);
+  EXPECT_EQ(kSsrc2, GetRecvStreamConfig(kSsrc9).rtp.local_ssrc);
   EXPECT_TRUE(AddRecvStream(kSsrc3));
   EXPECT_EQ(kSsrc2, GetRecvStreamConfig(kSsrc3).rtp.local_ssrc);
   EXPECT_TRUE(channel_->AddSendStream(
       cricket::StreamParams::CreateLegacy(kSsrc4)));
-  EXPECT_EQ(kSsrc2, GetRecvStreamConfig(kSsrc1).rtp.local_ssrc);
+  EXPECT_EQ(kSsrc2, GetRecvStreamConfig(kSsrc9).rtp.local_ssrc);
   EXPECT_EQ(kSsrc2, GetRecvStreamConfig(kSsrc3).rtp.local_ssrc);
 }
 
@@ -3438,43 +3475,71 @@ TEST_F(WebRtcVoiceEngineTestFake, SetRawAudioSink) {
   std::unique_ptr<FakeAudioSink> fake_sink_2(new FakeAudioSink());
 
   // Setting the sink before a recv stream exists should do nothing.
-  channel_->SetRawAudioSink(kSsrc1, std::move(fake_sink_1));
-  EXPECT_TRUE(AddRecvStream(kSsrc1));
-  EXPECT_EQ(nullptr, GetRecvStream(kSsrc1).sink());
+  channel_->SetRawAudioSink(kSsrc9, std::move(fake_sink_1));
+  EXPECT_TRUE(AddRecvStream(kSsrc9));
+  EXPECT_EQ(nullptr, GetRecvStream(kSsrc9).sink());
 
   // Now try actually setting the sink.
-  channel_->SetRawAudioSink(kSsrc1, std::move(fake_sink_2));
-  EXPECT_NE(nullptr, GetRecvStream(kSsrc1).sink());
+  channel_->SetRawAudioSink(kSsrc9, std::move(fake_sink_2));
+  EXPECT_NE(nullptr, GetRecvStream(kSsrc9).sink());
 
   // Now try resetting it.
-  channel_->SetRawAudioSink(kSsrc1, nullptr);
-  EXPECT_EQ(nullptr, GetRecvStream(kSsrc1).sink());
+  channel_->SetRawAudioSink(kSsrc9, nullptr);
+  EXPECT_EQ(nullptr, GetRecvStream(kSsrc9).sink());
 }
 
-TEST_F(WebRtcVoiceEngineTestFake, SetRawAudioSinkDefaultRecvStream) {
+TEST_F(WebRtcVoiceEngineTestFake, SetRawAudioSinkUnsignaledRecvStream) {
   EXPECT_TRUE(SetupChannel());
   std::unique_ptr<FakeAudioSink> fake_sink_1(new FakeAudioSink());
   std::unique_ptr<FakeAudioSink> fake_sink_2(new FakeAudioSink());
+  std::unique_ptr<FakeAudioSink> fake_sink_3(new FakeAudioSink());
+  std::unique_ptr<FakeAudioSink> fake_sink_4(new FakeAudioSink());
 
   // Should be able to set a default sink even when no stream exists.
   channel_->SetRawAudioSink(0, std::move(fake_sink_1));
 
-  // Create default channel and ensure it's assigned the default sink.
+  // Spawn an unsignaled stream by sending a packet - it should be assigned the
+  // default sink.
   DeliverPacket(kPcmuFrame, sizeof(kPcmuFrame));
-  EXPECT_NE(nullptr, GetRecvStream(0x01).sink());
+  EXPECT_NE(nullptr, GetRecvStream(kSsrc1).sink());
 
   // Try resetting the default sink.
   channel_->SetRawAudioSink(0, nullptr);
-  EXPECT_EQ(nullptr, GetRecvStream(0x01).sink());
+  EXPECT_EQ(nullptr, GetRecvStream(kSsrc1).sink());
 
   // Try setting the default sink while the default stream exists.
   channel_->SetRawAudioSink(0, std::move(fake_sink_2));
-  EXPECT_NE(nullptr, GetRecvStream(0x01).sink());
+  EXPECT_NE(nullptr, GetRecvStream(kSsrc1).sink());
 
   // If we remove and add a default stream, it should get the same sink.
-  EXPECT_TRUE(channel_->RemoveRecvStream(0x01));
+  EXPECT_TRUE(channel_->RemoveRecvStream(kSsrc1));
   DeliverPacket(kPcmuFrame, sizeof(kPcmuFrame));
-  EXPECT_NE(nullptr, GetRecvStream(0x01).sink());
+  EXPECT_NE(nullptr, GetRecvStream(kSsrc1).sink());
+
+  // Spawn another unsignaled stream - it should be assigned the default sink
+  // and the previous unsignaled stream should lose it.
+  unsigned char pcmuFrame2[sizeof(kPcmuFrame)];
+  memcpy(pcmuFrame2, kPcmuFrame, sizeof(kPcmuFrame));
+  rtc::SetBE32(&pcmuFrame2[8], kSsrc4);
+  DeliverPacket(pcmuFrame2, sizeof(pcmuFrame2));
+  EXPECT_EQ(nullptr, GetRecvStream(kSsrc1).sink());
+  EXPECT_NE(nullptr, GetRecvStream(kSsrc4).sink());
+
+  // Reset the default sink - the second unsignaled stream should lose it.
+  channel_->SetRawAudioSink(0, nullptr);
+  EXPECT_EQ(nullptr, GetRecvStream(kSsrc1).sink());
+  EXPECT_EQ(nullptr, GetRecvStream(kSsrc4).sink());
+
+  // Try setting the default sink while two streams exists.
+  channel_->SetRawAudioSink(0, std::move(fake_sink_3));
+  EXPECT_EQ(nullptr, GetRecvStream(kSsrc1).sink());
+  EXPECT_NE(nullptr, GetRecvStream(kSsrc4).sink());
+
+  // Try setting the sink for the first unsignaled stream using its known SSRC.
+  channel_->SetRawAudioSink(kSsrc1, std::move(fake_sink_4));
+  EXPECT_NE(nullptr, GetRecvStream(kSsrc1).sink());
+  EXPECT_NE(nullptr, GetRecvStream(kSsrc4).sink());
+  EXPECT_NE(GetRecvStream(kSsrc1).sink(), GetRecvStream(kSsrc4).sink());
 }
 
 // Test that, just like the video channel, the voice channel communicates the
@@ -3504,7 +3569,7 @@ TEST_F(WebRtcVoiceEngineTestFake, OnReadyToSendSignalsNetworkState) {
 TEST_F(WebRtcVoiceEngineTestFake, PreservePlayoutWhenRecreateRecvStream) {
   SetupRecvStream();
   channel_->SetPlayout(true);
-  EXPECT_TRUE(GetRecvStream(kSsrc1).started());
+  EXPECT_TRUE(GetRecvStream(kSsrc9).started());
 
   // Changing RTP header extensions will recreate the AudioReceiveStream.
   cricket::AudioRecvParameters parameters;
@@ -3512,7 +3577,7 @@ TEST_F(WebRtcVoiceEngineTestFake, PreservePlayoutWhenRecreateRecvStream) {
       webrtc::RtpExtension(webrtc::RtpExtension::kAudioLevelUri, 12));
   channel_->SetRecvParameters(parameters);
 
-  EXPECT_TRUE(GetRecvStream(kSsrc1).started());
+  EXPECT_TRUE(GetRecvStream(kSsrc9).started());
 }
 
 // Tests that the library initializes and shuts down properly.