Adding "adapter" ORTC objects on top of ChannelManager/BaseChannel/etc.

webrtc/ortc/ortcrtpsender_unittest.cc

Index: webrtc/ortc/ortcrtpsender_unittest.cc
diff --git a/webrtc/ortc/ortcrtpsender_unittest.cc b/webrtc/ortc/ortcrtpsender_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..f2ed8f235549970cea4dc8abb24cbd1966d2d4d0
--- /dev/null
+++ b/webrtc/ortc/ortcrtpsender_unittest.cc
@@ -0,0 +1,457 @@
+/*
+ *  Copyright 2017 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.
+ */
+
+#include <memory>
+
+#include "webrtc/base/gunit.h"
+#include "webrtc/media/base/fakemediaengine.h"
+#include "webrtc/p2p/base/fakepackettransport.h"
+#include "webrtc/ortc/ortcfactory.h"
+#include "webrtc/ortc/testrtpparameters.h"
+#include "webrtc/pc/test/fakevideotracksource.h"
+
+namespace webrtc {
+
+// This test uses an individual RtpSender using only the public interface, and
+// verify that its APIs behave as intended. Also tests that parameters are
+// applied to the audio/video engines as expected. Network and media interfaces
+// are faked to isolate what's being tested.
+//
+// This test shouldn't result any any actual media being sent. That sort of
+// test should go in ortcfactory_integrationtest.cc.
+class OrtcRtpSenderTest : public testing::Test {
+ public:
+  OrtcRtpSenderTest() {
+    fake_media_engine_ = new cricket::FakeMediaEngine();
+    // Note: This doesn't need to use fake network classes, since we already
+    // use FakePacketTransport.
+    ortc_factory_ =
+        OrtcFactory::Create(
+            nullptr, nullptr, nullptr, nullptr, nullptr,
+            std::unique_ptr<cricket::MediaEngineInterface>(fake_media_engine_))
+            .MoveValue();
+    fake_packet_transport_.reset(new rtc::FakePacketTransport("fake_packet"));
+    RtcpParameters rtcp_parameters;
+    rtcp_parameters.mux = true;
+    rtp_transport_ =
+        ortc_factory_
+            ->CreateRtpTransport(rtcp_parameters, fake_packet_transport_.get(),
+                                 nullptr, nullptr)
+            .MoveValue();
+  }
+
+ protected:
+  rtc::scoped_refptr<AudioTrackInterface> CreateAudioTrack(
+      const std::string& id) {
+    return ortc_factory_->CreateAudioTrack(id, nullptr);
+  }
+
+  rtc::scoped_refptr<VideoTrackInterface> CreateVideoTrack(
+      const std::string& id) {
+    return rtc::scoped_refptr<webrtc::VideoTrackInterface>(
+        ortc_factory_->CreateVideoTrack(id, FakeVideoTrackSource::Create()));
+  }
+
+  // Owned by |ortc_factory_|.
+  cricket::FakeMediaEngine* fake_media_engine_;
+  std::unique_ptr<OrtcFactoryInterface> ortc_factory_;
+  std::unique_ptr<PacketTransportInterface> fake_packet_transport_;
+  std::unique_ptr<RtpTransportInterface> rtp_transport_;
+};
+
+TEST_F(OrtcRtpSenderTest, GetAndSetTrack) {
+  // Test GetTrack with a sender constructed with a track.
+  auto audio_track = CreateAudioTrack("audio");
+  auto audio_sender =
+      ortc_factory_->CreateRtpSender(audio_track, rtp_transport_.get())
+          .MoveValue();
+  EXPECT_EQ(audio_track, audio_sender->GetTrack());
+
+  // Test GetTrack after SetTrack.
+  auto video_sender =
+      ortc_factory_
+          ->CreateRtpSender(cricket::MEDIA_TYPE_VIDEO, rtp_transport_.get())
+          .MoveValue();
+  auto video_track = CreateVideoTrack("video1");
+  EXPECT_TRUE(video_sender->SetTrack(video_track).ok());
+  EXPECT_EQ(video_track, video_sender->GetTrack());
+  video_track = CreateVideoTrack("video2");
+  EXPECT_TRUE(video_sender->SetTrack(video_track).ok());
+  EXPECT_EQ(video_track, video_sender->GetTrack());
+}
+
+// Test that track can be sent, even mid sending (or at least, configured for
+// sending).
+TEST_F(OrtcRtpSenderTest, SetTrackWhileSending) {
+  auto audio_sender =
+      ortc_factory_
+          ->CreateRtpSender(cricket::MEDIA_TYPE_AUDIO, rtp_transport_.get())
+          .MoveValue();
+  EXPECT_TRUE(audio_sender->Send(MakeMinimalOpusParameters()).ok());
+  EXPECT_TRUE(audio_sender->SetTrack(CreateAudioTrack("audio")).ok());
+
+  auto video_sender =
+      ortc_factory_
+          ->CreateRtpSender(cricket::MEDIA_TYPE_VIDEO, rtp_transport_.get())
+          .MoveValue();
+  EXPECT_TRUE(video_sender->Send(MakeMinimalVp8Parameters()).ok());
+  EXPECT_TRUE(video_sender->SetTrack(CreateVideoTrack("video")).ok());
+}
+
+// Test that track can be changed mid-sending.
+TEST_F(OrtcRtpSenderTest, ChangeTrackWhileSending) {
+  auto audio_sender =
+      ortc_factory_
+          ->CreateRtpSender(CreateAudioTrack("audio1"), rtp_transport_.get())
+          .MoveValue();
+  EXPECT_TRUE(audio_sender->Send(MakeMinimalOpusParameters()).ok());
+  EXPECT_TRUE(audio_sender->SetTrack(CreateAudioTrack("audio2")).ok());
+
+  auto video_sender =
+      ortc_factory_
+          ->CreateRtpSender(CreateVideoTrack("video1"), rtp_transport_.get())
+          .MoveValue();
+  EXPECT_TRUE(video_sender->Send(MakeMinimalVp8Parameters()).ok());
+  EXPECT_TRUE(video_sender->SetTrack(CreateVideoTrack("video2")).ok());
+}
+
+// Test that track can be set to null wihle sending.
+TEST_F(OrtcRtpSenderTest, UnsetTrackWhileSending) {
+  auto audio_sender =
+      ortc_factory_
+          ->CreateRtpSender(CreateAudioTrack("audio"), rtp_transport_.get())
+          .MoveValue();
+  EXPECT_TRUE(audio_sender->Send(MakeMinimalOpusParameters()).ok());
+  EXPECT_TRUE(audio_sender->SetTrack(nullptr).ok());
+
+  auto video_sender =
+      ortc_factory_
+          ->CreateRtpSender(CreateVideoTrack("video"), rtp_transport_.get())
+          .MoveValue();
+  EXPECT_TRUE(video_sender->Send(MakeMinimalVp8Parameters()).ok());
+  EXPECT_TRUE(video_sender->SetTrack(nullptr).ok());
+}
+
+// Shouldn't be able to set an audio track on a video sender or vice versa.
+TEST_F(OrtcRtpSenderTest, SetTrackOfWrongKindFails) {
+  auto audio_sender =
+      ortc_factory_
+          ->CreateRtpSender(cricket::MEDIA_TYPE_AUDIO, rtp_transport_.get())
+          .MoveValue();
+  EXPECT_EQ(RTCErrorType::INVALID_PARAMETER,
+            audio_sender->SetTrack(CreateVideoTrack("video")).error().type());
+
+  auto video_sender =
+      ortc_factory_
+          ->CreateRtpSender(cricket::MEDIA_TYPE_VIDEO, rtp_transport_.get())
+          .MoveValue();
+  EXPECT_EQ(RTCErrorType::INVALID_PARAMETER,
+            video_sender->SetTrack(CreateAudioTrack("audio")).error().type());
+}
+
+// Currently SetTransport isn't supported. When it is, replace this test with a
+// test/tests for it.
+TEST_F(OrtcRtpSenderTest, SetTransportFails) {
+  rtc::FakePacketTransport fake_packet_transport2("fake_two");
+  RtcpParameters rtcp_parameters;
+  rtcp_parameters.mux = true;
+  auto rtp_transport2 =
+      ortc_factory_
+          ->CreateRtpTransport(rtcp_parameters, &fake_packet_transport2,
+                               nullptr, nullptr)
+          .MoveValue();
+
+  auto sender =
+      ortc_factory_
+          ->CreateRtpSender(cricket::MEDIA_TYPE_AUDIO, rtp_transport_.get())
+          .MoveValue();
+  EXPECT_FALSE(RTCErrorType::INVALID_PARAMETER,
+               sender->SetTransport(rtp_transport2.get()).error().type());
+}
+
+TEST_F(OrtcRtpSenderTest, GetTransport) {
+  auto result = ortc_factory_->CreateRtpSender(cricket::MEDIA_TYPE_AUDIO,
+                                               rtp_transport_.get());
+  EXPECT_EQ(rtp_transport_.get(), result.value()->GetTransport());
+}
+
+// Test that "Send" causes the expected parameters to be applied to the media
+// engine level, for an audio sender.
+TEST_F(OrtcRtpSenderTest, SendAppliesAudioParametersToMediaEngine) {
+  auto audio_sender =
+      ortc_factory_
+          ->CreateRtpSender(cricket::MEDIA_TYPE_AUDIO, rtp_transport_.get())
+          .MoveValue();
+
+  // First, create parameters with all the bells and whistles.
+  RtpParameters parameters;
+
+  RtpCodecParameters opus_codec;
+  opus_codec.name = "opus";
+  opus_codec.kind = cricket::MEDIA_TYPE_AUDIO;
+  opus_codec.payload_type = 120;
+  opus_codec.clock_rate.emplace(48000);
+  opus_codec.num_channels.emplace(2);
+  opus_codec.parameters["minptime"] = "10";
+  opus_codec.rtcp_feedback.emplace_back(RtcpFeedbackType::TRANSPORT_CC);
+  parameters.codecs.push_back(std::move(opus_codec));
+
+  // Add two codecs, expecting the first to be used.
+  // TODO(deadbeef): Once "codec_payload_type" is supported, use it to select a
+  // codec that's not at the top of the list.
+  RtpCodecParameters isac_codec;
+  isac_codec.name = "ISAC";
+  isac_codec.kind = cricket::MEDIA_TYPE_AUDIO;
+  isac_codec.payload_type = 110;
+  isac_codec.clock_rate.emplace(16000);
+  parameters.codecs.push_back(std::move(isac_codec));
+
+  RtpEncodingParameters encoding;
+  encoding.ssrc.emplace(0xdeadbeef);
+  encoding.max_bitrate_bps.emplace(20000);
+  parameters.encodings.push_back(std::move(encoding));
+
+  parameters.header_extensions.emplace_back(
+      "urn:ietf:params:rtp-hdrext:ssrc-audio-level", 3);
+
+  EXPECT_TRUE(audio_sender->Send(parameters).ok());
+
+  // Now verify that the parameters were applied to the fake media engine layer
+  // that exists below BaseChannel.
+  cricket::FakeVoiceMediaChannel* fake_voice_channel =
+      fake_media_engine_->GetVoiceChannel(0);
+  ASSERT_NE(nullptr, fake_voice_channel);
+
+  // Verify codec parameters.
+  ASSERT_GT(fake_voice_channel->send_codecs().size(), 0u);
+  const cricket::AudioCodec& top_codec = fake_voice_channel->send_codecs()[0];
+  EXPECT_EQ("opus", top_codec.name);
+  EXPECT_EQ(120, top_codec.id);
+  EXPECT_EQ(48000, top_codec.clockrate);
+  EXPECT_EQ(2u, top_codec.channels);
+  ASSERT_NE(top_codec.params.end(), top_codec.params.find("minptime"));
+  EXPECT_EQ("10", top_codec.params.at("minptime"));
+
+  // Verify encoding parameters.
+  EXPECT_EQ(20000, fake_voice_channel->max_bps());
+  EXPECT_EQ(1u, fake_voice_channel->send_streams().size());
+  const cricket::StreamParams& send_stream =
+      fake_voice_channel->send_streams()[0];
+  EXPECT_EQ(1u, send_stream.ssrcs.size());
+  EXPECT_EQ(0xdeadbeef, send_stream.first_ssrc());
+
+  // Verify header extensions.
+  ASSERT_EQ(1u, fake_voice_channel->send_extensions().size());
+  const RtpExtension& extension = fake_voice_channel->send_extensions()[0];
+  EXPECT_EQ("urn:ietf:params:rtp-hdrext:ssrc-audio-level", extension.uri);
+  EXPECT_EQ(3, extension.id);
+}
+
+// Test that "Send" causes the expected parameters to be applied to the media
+// engine level, for a video sender.
+TEST_F(OrtcRtpSenderTest, SendAppliesVideoParametersToMediaEngine) {
+  auto video_sender =
+      ortc_factory_
+          ->CreateRtpSender(cricket::MEDIA_TYPE_VIDEO, rtp_transport_.get())
+          .MoveValue();
+
+  // First, create parameters with all the bells and whistles.
+  RtpParameters parameters;
+
+  RtpCodecParameters vp8_codec;
+  vp8_codec.name = "VP8";
+  vp8_codec.kind = cricket::MEDIA_TYPE_VIDEO;
+  vp8_codec.payload_type = 99;
+  // Try a couple types of feedback params. "Generic NACK" is a bit of a
+  // special case, so test it here.
+  vp8_codec.rtcp_feedback.emplace_back(RtcpFeedbackType::CCM,
+                                       RtcpFeedbackMessageType::FIR);
+  vp8_codec.rtcp_feedback.emplace_back(RtcpFeedbackType::NACK,
+                                       RtcpFeedbackMessageType::GENERIC_NACK);
+  parameters.codecs.push_back(std::move(vp8_codec));
+
+  RtpCodecParameters vp8_rtx_codec;
+  vp8_rtx_codec.name = "rtx";
+  vp8_rtx_codec.kind = cricket::MEDIA_TYPE_VIDEO;
+  vp8_rtx_codec.payload_type = 100;
+  vp8_rtx_codec.parameters["apt"] = "99";
+  parameters.codecs.push_back(std::move(vp8_rtx_codec));
+
+  // Add two codecs, expecting the first to be used.
+  // TODO(deadbeef): Once "codec_payload_type" is supported, use it to select a
+  // codec that's not at the top of the list.
+  RtpCodecParameters vp9_codec;
+  vp9_codec.name = "VP9";
+  vp9_codec.kind = cricket::MEDIA_TYPE_VIDEO;
+  vp9_codec.payload_type = 102;
+  parameters.codecs.push_back(std::move(vp9_codec));
+
+  RtpCodecParameters vp9_rtx_codec;
+  vp9_rtx_codec.name = "rtx";
+  vp9_rtx_codec.kind = cricket::MEDIA_TYPE_VIDEO;
+  vp9_rtx_codec.payload_type = 103;
+  vp9_rtx_codec.parameters["apt"] = "102";
+  parameters.codecs.push_back(std::move(vp9_rtx_codec));
+
+  RtpEncodingParameters encoding;
+  encoding.ssrc.emplace(0xdeadbeef);
+  encoding.rtx.emplace(0xbaadfeed);
+  encoding.max_bitrate_bps.emplace(99999);
+  parameters.encodings.push_back(std::move(encoding));
+
+  parameters.header_extensions.emplace_back("urn:3gpp:video-orientation", 4);
+  parameters.header_extensions.emplace_back(
+      "http://www.webrtc.org/experiments/rtp-hdrext/playout-delay", 6);
+
+  EXPECT_TRUE(video_sender->Send(parameters).ok());
+
+  // Now verify that the parameters were applied to the fake media engine layer
+  // that exists below BaseChannel.
+  cricket::FakeVideoMediaChannel* fake_video_channel =
+      fake_media_engine_->GetVideoChannel(0);
+  ASSERT_NE(nullptr, fake_video_channel);
+
+  // Verify codec parameters.
+  ASSERT_GE(fake_video_channel->send_codecs().size(), 2u);
+  const cricket::VideoCodec& top_codec = fake_video_channel->send_codecs()[0];
+  EXPECT_EQ("VP8", top_codec.name);
+  EXPECT_EQ(99, top_codec.id);
+  EXPECT_TRUE(
+      top_codec.feedback_params.Has(cricket::FeedbackParam("ccm", "fir")));
+  EXPECT_TRUE(top_codec.feedback_params.Has(cricket::FeedbackParam("nack")));
+
+  const cricket::VideoCodec& rtx_codec = fake_video_channel->send_codecs()[1];
+  EXPECT_EQ("rtx", rtx_codec.name);
+  EXPECT_EQ(100, rtx_codec.id);
+  ASSERT_NE(rtx_codec.params.end(), rtx_codec.params.find("apt"));
+  EXPECT_EQ("99", rtx_codec.params.at("apt"));
+
+  // Verify encoding parameters.
+  EXPECT_EQ(99999, fake_video_channel->max_bps());
+  EXPECT_EQ(1u, fake_video_channel->send_streams().size());
+  const cricket::StreamParams& send_stream =
+      fake_video_channel->send_streams()[0];
+  EXPECT_EQ(2u, send_stream.ssrcs.size());
+  EXPECT_EQ(0xdeadbeef, send_stream.first_ssrc());
+  uint32_t rtx_ssrc = 0u;
+  EXPECT_TRUE(send_stream.GetFidSsrc(send_stream.first_ssrc(), &rtx_ssrc));
+  EXPECT_EQ(0xbaadfeed, rtx_ssrc);
+
+  // Verify header extensions.
+  ASSERT_EQ(2u, fake_video_channel->send_extensions().size());
+  const RtpExtension& extension1 = fake_video_channel->send_extensions()[0];
+  EXPECT_EQ("urn:3gpp:video-orientation", extension1.uri);
+  EXPECT_EQ(4, extension1.id);
+  const RtpExtension& extension2 = fake_video_channel->send_extensions()[1];
+  EXPECT_EQ("http://www.webrtc.org/experiments/rtp-hdrext/playout-delay",
+            extension2.uri);
+  EXPECT_EQ(6, extension2.id);
+}
+
+// Test changing both the send codec and SSRC at the same time, and verify that
+// the new parameters are applied to the media engine level.
+TEST_F(OrtcRtpSenderTest, CallingSendTwiceChangesParameters) {
+  auto audio_sender =
+      ortc_factory_
+          ->CreateRtpSender(cricket::MEDIA_TYPE_AUDIO, rtp_transport_.get())
+          .MoveValue();
+  audio_sender->Send(MakeMinimalOpusParametersWithSsrc(0x11111111));
+  audio_sender->Send(MakeMinimalIsacParametersWithSsrc(0x22222222));
+
+  cricket::FakeVoiceMediaChannel* fake_voice_channel =
+      fake_media_engine_->GetVoiceChannel(0);
+  ASSERT_NE(nullptr, fake_voice_channel);
+  ASSERT_GT(fake_voice_channel->send_codecs().size(), 0u);
+  EXPECT_EQ("ISAC", fake_voice_channel->send_codecs()[0].name);
+  ASSERT_EQ(1u, fake_voice_channel->send_streams().size());
+  EXPECT_EQ(0x22222222u, fake_voice_channel->send_streams()[0].first_ssrc());
+
+  auto video_sender =
+      ortc_factory_
+          ->CreateRtpSender(cricket::MEDIA_TYPE_VIDEO, rtp_transport_.get())
+          .MoveValue();
+  video_sender->Send(MakeMinimalVp8ParametersWithSsrc(0x33333333));
+  video_sender->Send(MakeMinimalVp9ParametersWithSsrc(0x44444444));
+
+  cricket::FakeVideoMediaChannel* fake_video_channel =
+      fake_media_engine_->GetVideoChannel(0);
+  ASSERT_NE(nullptr, fake_video_channel);
+  ASSERT_GT(fake_video_channel->send_codecs().size(), 0u);
+  EXPECT_EQ("VP9", fake_video_channel->send_codecs()[0].name);
+  ASSERT_EQ(1u, fake_video_channel->send_streams().size());
+  EXPECT_EQ(0x44444444u, fake_video_channel->send_streams()[0].first_ssrc());
+}
+
+// If Send hasn't been called, GetParameters should return empty parameters.
+TEST_F(OrtcRtpSenderTest, GetDefaultParameters) {
+  auto result = ortc_factory_->CreateRtpSender(cricket::MEDIA_TYPE_AUDIO,
+                                               rtp_transport_.get());
+  EXPECT_EQ(RtpParameters(), result.value()->GetParameters());
+  result = ortc_factory_->CreateRtpSender(cricket::MEDIA_TYPE_VIDEO,
+                                          rtp_transport_.get());
+  EXPECT_EQ(RtpParameters(), result.value()->GetParameters());
+}
+
+// Test that GetParameters returns the last parameters passed into Send, along
+// with the implementation-default values filled in where they were left unset.
+TEST_F(OrtcRtpSenderTest,
+       GetParametersReturnsLastSetParametersWithDefaultsFilled) {
+  auto audio_sender =
+      ortc_factory_
+          ->CreateRtpSender(CreateAudioTrack("audio"), rtp_transport_.get())
+          .MoveValue();
+
+  RtpParameters opus_parameters = MakeMinimalOpusParameters();
+  EXPECT_TRUE(audio_sender->Send(opus_parameters).ok());
+  EXPECT_EQ(opus_parameters, audio_sender->GetParameters());
+
+  RtpParameters isac_parameters = MakeMinimalIsacParameters();
+  // Sanity check that num_channels actually is left unset.
+  ASSERT_FALSE(isac_parameters.codecs[0].num_channels);
+  EXPECT_TRUE(audio_sender->Send(isac_parameters).ok());
+  // Should be filled with a default "num channels" of 1.
+  isac_parameters.codecs[0].num_channels.emplace(1);
+  EXPECT_EQ(isac_parameters, audio_sender->GetParameters());
+
+  auto video_sender =
+      ortc_factory_
+          ->CreateRtpSender(CreateVideoTrack("video"), rtp_transport_.get())
+          .MoveValue();
+
+  RtpParameters vp8_parameters = MakeMinimalVp8Parameters();
+  // Sanity check that clock_rate actually is left unset.
+  EXPECT_TRUE(video_sender->Send(vp8_parameters).ok());
+  // Should be filled with a default clock rate of 90000.
+  vp8_parameters.codecs[0].clock_rate.emplace(90000);
+  EXPECT_EQ(vp8_parameters, video_sender->GetParameters());
+
+  RtpParameters vp9_parameters = MakeMinimalVp9Parameters();
+  // Sanity check that clock_rate actually is left unset.
+  EXPECT_TRUE(video_sender->Send(vp9_parameters).ok());
+  // Should be filled with a default clock rate of 90000.
+  vp9_parameters.codecs[0].clock_rate.emplace(90000);
+  EXPECT_EQ(vp9_parameters, video_sender->GetParameters());
+}
+
+TEST_F(OrtcRtpSenderTest, GetKind) {
+  // Construct one sender from the "kind" enum and another from a track.
+  auto audio_sender =
+      ortc_factory_
+          ->CreateRtpSender(cricket::MEDIA_TYPE_AUDIO, rtp_transport_.get())
+          .MoveValue();
+  auto video_sender =
+      ortc_factory_
+          ->CreateRtpSender(CreateVideoTrack("video"), rtp_transport_.get())
+          .MoveValue();
+  EXPECT_EQ(cricket::MEDIA_TYPE_AUDIO, audio_sender->GetKind());
+  EXPECT_EQ(cricket::MEDIA_TYPE_VIDEO, video_sender->GetKind());
+}
+
+}  // namespace webrtc