Switch voice transport to use Call and Stream instead of VoENetwork.

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 2584 matching lines @@
 
   EXPECT_TRUE(call_.GetAudioSendStream(1234));
   EXPECT_EQ(1234U, voe_.GetLocalSSRC(receive_channel_num));
 }
 
 // Test that we can properly receive packets.
 TEST_F(WebRtcVoiceEngineTestFake, Recv) {
   EXPECT_TRUE(SetupChannel());
   EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(1)));
   DeliverPacket(kPcmuFrame, sizeof(kPcmuFrame));
-  int channel_num = voe_.GetLastChannel();
-  EXPECT_TRUE(voe_.CheckPacket(channel_num, kPcmuFrame, sizeof(kPcmuFrame)));
+
+  const cricket::FakeAudioReceiveStream* stream =
+      call_.GetAudioReceiveStreams().front();

[the sun, 2016/04/22 12:40:32]

Use GetRecvStream(1) instead

[mflodman, 2016/04/27 13:42:17]

Done.

+  EXPECT_TRUE(stream->VerifyLastPacket(kPcmuFrame, sizeof(kPcmuFrame)));
 }
 
 // Test that we can properly receive packets on multiple streams.
 TEST_F(WebRtcVoiceEngineTestFake, RecvWithMultipleStreams) {
   EXPECT_TRUE(SetupChannel());
-  EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(1)));
-  int channel_num1 = voe_.GetLastChannel();
-  EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(2)));
-  int channel_num2 = voe_.GetLastChannel();
-  EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(3)));
-  int channel_num3 = voe_.GetLastChannel();
+  const uint32_t ssrc1 = 1;
+  const uint32_t ssrc2 = 2;
+  const uint32_t ssrc3 = 3;
+  EXPECT_TRUE(channel_->AddRecvStream(
+      cricket::StreamParams::CreateLegacy(ssrc1)));
+  EXPECT_TRUE(channel_->AddRecvStream(
+      cricket::StreamParams::CreateLegacy(ssrc2)));
+  EXPECT_TRUE(channel_->AddRecvStream(
+      cricket::StreamParams::CreateLegacy(ssrc3)));
   // Create packets with the right SSRCs.
   char packets[4][sizeof(kPcmuFrame)];
   for (size_t i = 0; i < arraysize(packets); ++i) {
     memcpy(packets[i], kPcmuFrame, sizeof(kPcmuFrame));
     rtc::SetBE32(packets[i] + 8, static_cast<uint32_t>(i));
   }
-  EXPECT_TRUE(voe_.CheckNoPacket(channel_num1));
-  EXPECT_TRUE(voe_.CheckNoPacket(channel_num2));
-  EXPECT_TRUE(voe_.CheckNoPacket(channel_num3));
+
+  const cricket::FakeAudioReceiveStream* s1 =
+      call_.GetAudioReceiveStream(ssrc1);

[the sun, 2016/04/22 12:40:31]

Use GetRecvStream(..)

[mflodman, 2016/04/27 13:42:17]

Done.

+  const cricket::FakeAudioReceiveStream* s2 =
+      call_.GetAudioReceiveStream(ssrc2);
+  const cricket::FakeAudioReceiveStream* s3 =
+      call_.GetAudioReceiveStream(ssrc3);
+
+  EXPECT_EQ(s1->received_packets(), 0);
+  EXPECT_EQ(s2->received_packets(), 0);
+  EXPECT_EQ(s3->received_packets(), 0);
 
   DeliverPacket(packets[0], sizeof(packets[0]));
-  EXPECT_TRUE(voe_.CheckNoPacket(channel_num1));
-  EXPECT_TRUE(voe_.CheckNoPacket(channel_num2));
-  EXPECT_TRUE(voe_.CheckNoPacket(channel_num3));
+  EXPECT_EQ(s1->received_packets(), 0);
+  EXPECT_EQ(s2->received_packets(), 0);
+  EXPECT_EQ(s3->received_packets(), 0);
 
   DeliverPacket(packets[1], sizeof(packets[1]));
-  EXPECT_TRUE(voe_.CheckPacket(channel_num1, packets[1], sizeof(packets[1])));
-  EXPECT_TRUE(voe_.CheckNoPacket(channel_num2));
-  EXPECT_TRUE(voe_.CheckNoPacket(channel_num3));
+  EXPECT_EQ(s1->received_packets(), 1);
+  EXPECT_TRUE(s1->VerifyLastPacket(packets[1], sizeof(packets[1])));
+  EXPECT_EQ(s2->received_packets(), 0);
+  EXPECT_EQ(s3->received_packets(), 0);
 
   DeliverPacket(packets[2], sizeof(packets[2]));
-  EXPECT_TRUE(voe_.CheckNoPacket(channel_num1));
-  EXPECT_TRUE(voe_.CheckPacket(channel_num2, packets[2], sizeof(packets[2])));
-  EXPECT_TRUE(voe_.CheckNoPacket(channel_num3));
+  EXPECT_EQ(s1->received_packets(), 1);
+  EXPECT_EQ(s2->received_packets(), 1);
+  EXPECT_TRUE(s2->VerifyLastPacket(packets[2], sizeof(packets[2])));
+  EXPECT_EQ(s3->received_packets(), 0);
 
   DeliverPacket(packets[3], sizeof(packets[3]));
-  EXPECT_TRUE(voe_.CheckNoPacket(channel_num1));
-  EXPECT_TRUE(voe_.CheckNoPacket(channel_num2));
-  EXPECT_TRUE(voe_.CheckPacket(channel_num3, packets[3], sizeof(packets[3])));
+  EXPECT_EQ(s1->received_packets(), 1);
+  EXPECT_EQ(s2->received_packets(), 1);
+  EXPECT_EQ(s3->received_packets(), 1);
+  EXPECT_TRUE(s3->VerifyLastPacket(packets[3], sizeof(packets[3])));
 
-  EXPECT_TRUE(channel_->RemoveRecvStream(3));
-  EXPECT_TRUE(channel_->RemoveRecvStream(2));
-  EXPECT_TRUE(channel_->RemoveRecvStream(1));
+  EXPECT_TRUE(channel_->RemoveRecvStream(ssrc3));
+  EXPECT_TRUE(channel_->RemoveRecvStream(ssrc2));
+  EXPECT_TRUE(channel_->RemoveRecvStream(ssrc1));
 }
 
 // Test that receiving on an unsignalled stream works (default channel will be
 // created).
 TEST_F(WebRtcVoiceEngineTestFake, RecvUnsignalled) {
   EXPECT_TRUE(SetupChannel());
+  EXPECT_EQ(0, call_.GetAudioReceiveStreams().size());
+
   DeliverPacket(kPcmuFrame, sizeof(kPcmuFrame));
-  int channel_num = voe_.GetLastChannel();
-  EXPECT_TRUE(voe_.CheckPacket(channel_num, kPcmuFrame, sizeof(kPcmuFrame)));
+
+  EXPECT_EQ(1, call_.GetAudioReceiveStreams().size());
+  const cricket::FakeAudioReceiveStream* s =

[the sun, 2016/04/22 12:40:32]

Use GetRecvStream(1) instead

[mflodman, 2016/04/27 13:42:17]

Done.

+      call_.GetAudioReceiveStreams().front();
+  EXPECT_TRUE(s->VerifyLastPacket(kPcmuFrame, 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) {
+// TODO(mflodman): This is according to the old test, but it's not supported
+// by webrtc::Call. Shall this be fixed or dropped?

[the sun, 2016/04/22 12:40:32]

I believe we must support the behavior. :(
See: https://bugs.chromium.org/p/webrtc/issues/detail?id=5208

[mflodman, 2016/04/27 13:42:17]

Changed and supported now. A potential previously created default stream will be
deleted though, to not have more than one at the time and to not add _a lot_ of
code complexity to support changing ssrc for an existing default receive stream

+TEST_F(WebRtcVoiceEngineTestFake, DISABLED_RecvUnsignalledWithSsrcSwitch) {
   EXPECT_TRUE(SetupChannel());
   char packet[sizeof(kPcmuFrame)];
   memcpy(packet, kPcmuFrame, sizeof(kPcmuFrame));
 
   // Note that the first unknown SSRC cannot be 0, because we only support
   // creating receive streams for SSRC!=0.
   DeliverPacket(packet, sizeof(packet));
-  int channel_num = voe_.GetLastChannel();
-  EXPECT_TRUE(voe_.CheckPacket(channel_num, packet, sizeof(packet)));
+
+  EXPECT_EQ(1, call_.GetAudioReceiveStreams().size());
+  const cricket::FakeAudioReceiveStream* s =
+      call_.GetAudioReceiveStreams().front();
+  EXPECT_TRUE(s->VerifyLastPacket(packet, sizeof(packet)));
+
   // Once we have the default channel, SSRC==0 will be ok.
   for (uint32_t ssrc = 0; ssrc < 10; ++ssrc) {
     rtc::SetBE32(&packet[8], ssrc);
     DeliverPacket(packet, sizeof(packet));
-    EXPECT_TRUE(voe_.CheckPacket(channel_num, packet, sizeof(packet)));
+    EXPECT_TRUE(s->VerifyLastPacket(packet, sizeof(packet)));
   }
 }
 
 // Test that a default channel is created even after a signalled stream has been
 // added, and that this stream will get any packets for unknown SSRCs.
 TEST_F(WebRtcVoiceEngineTestFake, RecvUnsignalledAfterSignalled) {
   EXPECT_TRUE(SetupChannel());
   char packet[sizeof(kPcmuFrame)];
   memcpy(packet, kPcmuFrame, sizeof(kPcmuFrame));
 
   // Add a known stream, send packet and verify we got it.
-  EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(1)));
-  int signalled_channel_num = voe_.GetLastChannel();
+  const uint32_t signaled_ssrc = 1;
+  EXPECT_TRUE(channel_->AddRecvStream(
+      cricket::StreamParams::CreateLegacy(signaled_ssrc)));
   DeliverPacket(packet, sizeof(packet));
-  EXPECT_TRUE(voe_.CheckPacket(signalled_channel_num, packet, sizeof(packet)));
+  EXPECT_TRUE(call_.GetAudioReceiveStream(signaled_ssrc)->VerifyLastPacket(
+      packet, sizeof(packet)));
 
   // Note that the first unknown SSRC cannot be 0, because we only support
   // creating receive streams for SSRC!=0.
-  rtc::SetBE32(&packet[8], 7011);
+  const uint32_t unsignaled_ssrc = 7011;
+  rtc::SetBE32(&packet[8], unsignaled_ssrc);
   DeliverPacket(packet, sizeof(packet));
-  int channel_num = voe_.GetLastChannel();
-  EXPECT_NE(channel_num, signalled_channel_num);
-  EXPECT_TRUE(voe_.CheckPacket(channel_num, packet, sizeof(packet)));
-  // Once we have the default channel, SSRC==0 will be ok.
-  for (uint32_t ssrc = 0; ssrc < 20; ssrc += 2) {
-    rtc::SetBE32(&packet[8], ssrc);
-    DeliverPacket(packet, sizeof(packet));
-    EXPECT_TRUE(voe_.CheckPacket(channel_num, packet, sizeof(packet)));
-  }
+  EXPECT_TRUE(call_.GetAudioReceiveStream(unsignaled_ssrc)->VerifyLastPacket(
+      packet, sizeof(packet)));
 }
 
 // Test that we properly handle failures to add a receive stream.
 TEST_F(WebRtcVoiceEngineTestFake, AddRecvStreamFail) {
   EXPECT_TRUE(SetupChannel());
   voe_.set_fail_create_channel(true);
   EXPECT_FALSE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(2)));
 }
 
 // Test that we properly handle failures to add a send stream.
@@ skipping 845 matching lines @@
 TEST(WebRtcVoiceEngineTest, SetRecvCodecs) {
   cricket::WebRtcVoiceEngine engine(nullptr);
   std::unique_ptr<webrtc::Call> call(
       webrtc::Call::Create(webrtc::Call::Config()));
   cricket::WebRtcVoiceMediaChannel channel(&engine, cricket::MediaConfig(),
                                            cricket::AudioOptions(), call.get());
   cricket::AudioRecvParameters parameters;
   parameters.codecs = engine.codecs();
   EXPECT_TRUE(channel.SetRecvParameters(parameters));
 }