Revert to allowing only 1 unsignaled receive stream for audio.

webrtc/media/engine/webrtcvoiceengine_unittest.cc

 /*
  *  Copyright (c) 2008 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 18 matching lines @@
 #include "webrtc/pc/channel.h"
 #include "webrtc/test/field_trial.h"
 #include "webrtc/test/gtest.h"
 #include "webrtc/voice_engine/transmit_mixer.h"
 
 using testing::Return;
 using testing::StrictMock;
 
 namespace {
 
+constexpr uint32_t kMaxUnsignaledRecvStreams = 1;
+
 const cricket::AudioCodec kPcmuCodec(0, "PCMU", 8000, 64000, 1);
 const cricket::AudioCodec kIsacCodec(103, "ISAC", 16000, 32000, 1);
 const cricket::AudioCodec kOpusCodec(111, "opus", 48000, 64000, 2);
 const cricket::AudioCodec kG722CodecVoE(9, "G722", 16000, 64000, 1);
 const cricket::AudioCodec kG722CodecSdp(9, "G722", 8000, 64000, 1);
 const cricket::AudioCodec kCn8000Codec(13, "CN", 8000, 0, 1);
 const cricket::AudioCodec kCn16000Codec(105, "CN", 16000, 0, 1);
 const cricket::AudioCodec
     kTelephoneEventCodec1(106, "telephone-event", 8000, 0, 1);
 const cricket::AudioCodec
@@ skipping 2728 matching lines @@
                                                      sizeof(kPcmuFrame)));
 }
 
 // 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));
 
-  constexpr uint32_t kMaxUnsignaledCount = 50;
-
   // Note that SSRC = 0 is not supported.
-  for (uint32_t ssrc = 1; ssrc < (1 + kMaxUnsignaledCount); ++ssrc) {
+  for (uint32_t ssrc = 1; ssrc < (1 + kMaxUnsignaledRecvStreams); ++ssrc) {
     rtc::SetBE32(&packet[8], ssrc);
     DeliverPacket(packet, sizeof(packet));
 
     // 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 on the same SSRCs again should not create new streams.
-  for (uint32_t ssrc = 1; ssrc < (1 + kMaxUnsignaledCount); ++ssrc) {
+  for (uint32_t ssrc = 1; ssrc < (1 + kMaxUnsignaledRecvStreams); ++ssrc) {
     rtc::SetBE32(&packet[8], ssrc);
     DeliverPacket(packet, sizeof(packet));
 
-    EXPECT_EQ(kMaxUnsignaledCount, call_.GetAudioReceiveStreams().size());
+    EXPECT_EQ(kMaxUnsignaledRecvStreams, 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));
 
   const auto& streams = call_.GetAudioReceiveStreams();
-  EXPECT_EQ(kMaxUnsignaledCount, streams.size());
+  EXPECT_EQ(kMaxUnsignaledRecvStreams, streams.size());
   size_t i = 0;
-  for (uint32_t ssrc = 2; ssrc < (1 + kMaxUnsignaledCount); ++ssrc, ++i) {
+  for (uint32_t ssrc = 2; ssrc < (1 + kMaxUnsignaledRecvStreams); ++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));
+  EXPECT_EQ(kMaxUnsignaledRecvStreams, (i + 1));
 }
 
 // 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, RecvUnsignaledAfterSignaled) {
   EXPECT_TRUE(SetupChannel());
   unsigned char packet[sizeof(kPcmuFrame)];
   memcpy(packet, kPcmuFrame, sizeof(kPcmuFrame));
 
   // Add a known stream, send packet and verify we got it.
@@ skipping 459 matching lines @@
 
   // 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], kSsrcX);
   DeliverPacket(pcmuFrame2, sizeof(pcmuFrame2));
   EXPECT_DOUBLE_EQ(2, GetRecvStream(kSsrcX).gain());
 
   // Setting gain with SSRC=0 should affect all unsignaled streams.
   EXPECT_TRUE(channel_->SetOutputVolume(kSsrc0, 3));
-  EXPECT_DOUBLE_EQ(3, GetRecvStream(kSsrc1).gain());
+  if (kMaxUnsignaledRecvStreams > 1) {
+    EXPECT_DOUBLE_EQ(3, GetRecvStream(kSsrc1).gain());
+  }
   EXPECT_DOUBLE_EQ(3, GetRecvStream(kSsrcX).gain());
 
   // Setting gain on an individual stream affects only that.
   EXPECT_TRUE(channel_->SetOutputVolume(kSsrcX, 4));
-  EXPECT_DOUBLE_EQ(3, GetRecvStream(kSsrc1).gain());
+  if (kMaxUnsignaledRecvStreams > 1) {
+    EXPECT_DOUBLE_EQ(3, GetRecvStream(kSsrc1).gain());
+  }
   EXPECT_DOUBLE_EQ(4, GetRecvStream(kSsrcX).gain());
 }
 
 TEST_F(WebRtcVoiceEngineTestFake, SetsSyncGroupFromSyncLabel) {
   const uint32_t kAudioSsrc = 123;
   const std::string kSyncLabel = "AvSyncLabel";
 
   EXPECT_TRUE(SetupSendStream());
   cricket::StreamParams sp = cricket::StreamParams::CreateLegacy(kAudioSsrc);
   sp.sync_label = kSyncLabel;
@@ skipping 166 matching lines @@
   EXPECT_TRUE(channel_->RemoveRecvStream(kSsrc1));
   DeliverPacket(kPcmuFrame, sizeof(kPcmuFrame));
   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], kSsrcX);
   DeliverPacket(pcmuFrame2, sizeof(pcmuFrame2));
-  EXPECT_EQ(nullptr, GetRecvStream(kSsrc1).sink());
+  if (kMaxUnsignaledRecvStreams > 1) {
+    EXPECT_EQ(nullptr, GetRecvStream(kSsrc1).sink());
+  }
   EXPECT_NE(nullptr, GetRecvStream(kSsrcX).sink());
 
   // Reset the default sink - the second unsignaled stream should lose it.
   channel_->SetRawAudioSink(kSsrc0, nullptr);
-  EXPECT_EQ(nullptr, GetRecvStream(kSsrc1).sink());
+  if (kMaxUnsignaledRecvStreams > 1) {
+    EXPECT_EQ(nullptr, GetRecvStream(kSsrc1).sink());
+  }
   EXPECT_EQ(nullptr, GetRecvStream(kSsrcX).sink());
 
   // Try setting the default sink while two streams exists.
   channel_->SetRawAudioSink(kSsrc0, std::move(fake_sink_3));
-  EXPECT_EQ(nullptr, GetRecvStream(kSsrc1).sink());
+  if (kMaxUnsignaledRecvStreams > 1) {
+    EXPECT_EQ(nullptr, GetRecvStream(kSsrc1).sink());
+  }
   EXPECT_NE(nullptr, GetRecvStream(kSsrcX).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());
+  if (kMaxUnsignaledRecvStreams > 1) {
+    EXPECT_NE(nullptr, GetRecvStream(kSsrc1).sink());
+  }
   EXPECT_NE(nullptr, GetRecvStream(kSsrcX).sink());
-  EXPECT_NE(GetRecvStream(kSsrc1).sink(), GetRecvStream(kSsrcX).sink());
+  if (kMaxUnsignaledRecvStreams > 1) {
+    EXPECT_NE(GetRecvStream(kSsrc1).sink(), GetRecvStream(kSsrcX).sink());
+  }
 }
 
 // Test that, just like the video channel, the voice channel communicates the
 // network state to the call.
 TEST_F(WebRtcVoiceEngineTestFake, OnReadyToSendSignalsNetworkState) {
   EXPECT_TRUE(SetupChannel());
 
   EXPECT_EQ(webrtc::kNetworkUp,
             call_.GetNetworkState(webrtc::MediaType::AUDIO));
   EXPECT_EQ(webrtc::kNetworkUp,
@@ skipping 270 matching lines @@
   // Without this cast, the comparison turned unsigned and, thus, failed for -1.
   const int num_specs = static_cast<int>(specs.size());
   EXPECT_GE(find_codec({"cn", 8000, 1}), num_specs);
   EXPECT_GE(find_codec({"cn", 16000, 1}), num_specs);
   EXPECT_EQ(find_codec({"cn", 32000, 1}), -1);
   EXPECT_GE(find_codec({"telephone-event", 8000, 1}), num_specs);
   EXPECT_GE(find_codec({"telephone-event", 16000, 1}), num_specs);
   EXPECT_GE(find_codec({"telephone-event", 32000, 1}), num_specs);
   EXPECT_GE(find_codec({"telephone-event", 48000, 1}), num_specs);
 }