Create the SrtpTransportInterface.

webrtc/ortc/rtptransport_unittest.cc

+/*
+ *  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/ortc/ortcfactory.h"
+#include "webrtc/ortc/testrtpparameters.h"
+#include "webrtc/p2p/base/fakepackettransport.h"
+
+namespace webrtc {
+
+static const char kTestKeyParams1[] =
+    "inline:WVNfX19zZW1jdGwgKCkgewkyMjA7fQp9CnVubGVz";
+static const char kTestKeyParams2[] =
+    "inline:PS1uQCVeeCFCanVmcjkpPywjNWhcYD0mXXtxaVBR";
+
+static const cricket::CryptoParams kTestCryptoParams1(1,
+                                                      "AES_CM_128_HMAC_SHA1_80",
+                                                      kTestKeyParams1,
+                                                      "");
+static const cricket::CryptoParams kTestCryptoParams2(1,
+                                                      "AES_CM_128_HMAC_SHA1_80",
+                                                      kTestKeyParams2,
+                                                      "");
+
+// This test uses fake packet transports and a fake media engine, in order to
+// test the RtpTransport at only an API level. Any end-to-end test should go in
+// ortcfactory_integrationtest.cc instead.
+class RtpTransportTest : public testing::Test {
+ public:
+  RtpTransportTest() {
+    fake_media_engine_ = new cricket::FakeMediaEngine();
+    // Note: This doesn't need to use fake network classes, since it uses
+    // FakePacketTransports.
+    auto result = OrtcFactory::Create(
+        nullptr, nullptr, nullptr, nullptr, nullptr,
+        std::unique_ptr<cricket::MediaEngineInterface>(fake_media_engine_));
+    ortc_factory_ = result.MoveValue();
+    rtp_transport_controller_ =
+        ortc_factory_->CreateRtpTransportController().MoveValue();
+  }
+
+ protected:
+  // Owned by |ortc_factory_|.
+  cricket::FakeMediaEngine* fake_media_engine_;
+  std::unique_ptr<OrtcFactoryInterface> ortc_factory_;
+  std::unique_ptr<RtpTransportControllerInterface> rtp_transport_controller_;
+};
+
+// Test GetRtpPacketTransport and GetRtcpPacketTransport, with and without RTCP
+// muxing.
+TEST_F(RtpTransportTest, GetPacketTransports) {
+  rtc::FakePacketTransport rtp("rtp");
+  rtc::FakePacketTransport rtcp("rtcp");
+  // With muxed RTCP.
+  RtcpParameters rtcp_parameters;
+  rtcp_parameters.mux = true;
+  auto result = ortc_factory_->CreateRtpTransport(rtcp_parameters, &rtp,
+                                                  nullptr, nullptr);
+  ASSERT_TRUE(result.ok());
+  EXPECT_EQ(&rtp, result.value()->GetRtpPacketTransport());
+  EXPECT_EQ(nullptr, result.value()->GetRtcpPacketTransport());
+  result.MoveValue().reset();
+  // With non-muxed RTCP.
+  rtcp_parameters.mux = false;
+  result =
+      ortc_factory_->CreateRtpTransport(rtcp_parameters, &rtp, &rtcp, nullptr);
+  ASSERT_TRUE(result.ok());
+  EXPECT_EQ(&rtp, result.value()->GetRtpPacketTransport());
+  EXPECT_EQ(&rtcp, result.value()->GetRtcpPacketTransport());
+}
+
+// If an RtpTransport starts out un-muxed and then starts muxing, the RTCP
+// packet transport should be forgotten and GetRtcpPacketTransport should
+// return null.
+TEST_F(RtpTransportTest, EnablingRtcpMuxingUnsetsRtcpTransport) {
+  rtc::FakePacketTransport rtp("rtp");
+  rtc::FakePacketTransport rtcp("rtcp");
+
+  // Create non-muxed.
+  RtcpParameters rtcp_parameters;
+  rtcp_parameters.mux = false;
+  auto result =
+      ortc_factory_->CreateRtpTransport(rtcp_parameters, &rtp, &rtcp, nullptr);
+  ASSERT_TRUE(result.ok());
+  auto rtp_transport = result.MoveValue();
+
+  // Enable muxing.
+  rtcp_parameters.mux = true;
+  EXPECT_TRUE(rtp_transport->SetRtcpParameters(rtcp_parameters).ok());
+  EXPECT_EQ(nullptr, rtp_transport->GetRtcpPacketTransport());
+}
+
+TEST_F(RtpTransportTest, GetAndSetRtcpParameters) {
+  rtc::FakePacketTransport rtp("rtp");
+  rtc::FakePacketTransport rtcp("rtcp");
+  // Start with non-muxed RTCP.
+  RtcpParameters rtcp_parameters;
+  rtcp_parameters.mux = false;
+  rtcp_parameters.cname = "teST";
+  rtcp_parameters.reduced_size = false;
+  auto result =
+      ortc_factory_->CreateRtpTransport(rtcp_parameters, &rtp, &rtcp, nullptr);
+  ASSERT_TRUE(result.ok());
+  auto transport = result.MoveValue();
+  EXPECT_EQ(rtcp_parameters, transport->GetRtcpParameters());
+
+  // Changing the CNAME is currently unsupported.
+  rtcp_parameters.cname = "different";
+  EXPECT_EQ(RTCErrorType::UNSUPPORTED_OPERATION,
+            transport->SetRtcpParameters(rtcp_parameters).type());
+  rtcp_parameters.cname = "teST";
+
+  // Enable RTCP muxing and reduced-size RTCP.
+  rtcp_parameters.mux = true;
+  rtcp_parameters.reduced_size = true;
+  EXPECT_TRUE(transport->SetRtcpParameters(rtcp_parameters).ok());
+  EXPECT_EQ(rtcp_parameters, transport->GetRtcpParameters());
+
+  // Empty CNAME should result in the existing CNAME being used.
+  rtcp_parameters.cname.clear();
+  EXPECT_TRUE(transport->SetRtcpParameters(rtcp_parameters).ok());
+  EXPECT_EQ("teST", transport->GetRtcpParameters().cname);
+
+  // Disabling RTCP muxing after enabling shouldn't be allowed, since enabling
+  // muxing should have made the RTP transport forget about the RTCP packet
+  // transport initially passed into it.
+  rtcp_parameters.mux = false;
+  EXPECT_EQ(RTCErrorType::INVALID_STATE,
+            transport->SetRtcpParameters(rtcp_parameters).type());
+}
+
+// When Send or Receive is called on a sender or receiver, the RTCP parameters
+// from the RtpTransport underneath the sender should be applied to the created
+// media stream. The only relevant parameters (currently) are |cname| and
+// |reduced_size|.
+TEST_F(RtpTransportTest, SendAndReceiveApplyRtcpParametersToMediaEngine) {
+  // First, create video transport with reduced-size RTCP.
+  rtc::FakePacketTransport fake_packet_transport1("1");
+  RtcpParameters rtcp_parameters;
+  rtcp_parameters.mux = true;
+  rtcp_parameters.reduced_size = true;
+  rtcp_parameters.cname = "foo";
+  auto rtp_transport_result = ortc_factory_->CreateRtpTransport(
+      rtcp_parameters, &fake_packet_transport1, nullptr, nullptr);
+  auto video_transport = rtp_transport_result.MoveValue();
+
+  // Create video sender and call Send, expecting parameters to be applied.
+  auto sender_result = ortc_factory_->CreateRtpSender(cricket::MEDIA_TYPE_VIDEO,
+                                                      video_transport.get());
+  auto video_sender = sender_result.MoveValue();
+  EXPECT_TRUE(video_sender->Send(MakeMinimalVp8Parameters()).ok());
+  cricket::FakeVideoMediaChannel* fake_video_channel =
+      fake_media_engine_->GetVideoChannel(0);
+  ASSERT_NE(nullptr, fake_video_channel);
+  EXPECT_TRUE(fake_video_channel->send_rtcp_parameters().reduced_size);
+  ASSERT_EQ(1u, fake_video_channel->send_streams().size());
+  const cricket::StreamParams& video_send_stream =
+      fake_video_channel->send_streams()[0];
+  EXPECT_EQ("foo", video_send_stream.cname);
+
+  // Create video receiver and call Receive, expecting parameters to be applied
+  // (minus |cname|, since that's the sent cname, not received).
+  auto receiver_result = ortc_factory_->CreateRtpReceiver(
+      cricket::MEDIA_TYPE_VIDEO, video_transport.get());
+  auto video_receiver = receiver_result.MoveValue();
+  EXPECT_TRUE(
+      video_receiver->Receive(MakeMinimalVp8ParametersWithSsrc(0xdeadbeef))
+          .ok());
+  EXPECT_TRUE(fake_video_channel->recv_rtcp_parameters().reduced_size);
+
+  // Create audio transport with non-reduced size RTCP.
+  rtc::FakePacketTransport fake_packet_transport2("2");
+  rtcp_parameters.reduced_size = false;
+  rtcp_parameters.cname = "bar";
+  rtp_transport_result = ortc_factory_->CreateRtpTransport(
+      rtcp_parameters, &fake_packet_transport2, nullptr, nullptr);
+  auto audio_transport = rtp_transport_result.MoveValue();
+
+  // Create audio sender and call Send, expecting parameters to be applied.
+  sender_result = ortc_factory_->CreateRtpSender(cricket::MEDIA_TYPE_AUDIO,
+                                                 audio_transport.get());
+  auto audio_sender = sender_result.MoveValue();
+  EXPECT_TRUE(audio_sender->Send(MakeMinimalIsacParameters()).ok());
+
+  cricket::FakeVoiceMediaChannel* fake_voice_channel =
+      fake_media_engine_->GetVoiceChannel(0);
+  ASSERT_NE(nullptr, fake_voice_channel);
+  EXPECT_FALSE(fake_voice_channel->send_rtcp_parameters().reduced_size);
+  ASSERT_EQ(1u, fake_voice_channel->send_streams().size());
+  const cricket::StreamParams& audio_send_stream =
+      fake_voice_channel->send_streams()[0];
+  EXPECT_EQ("bar", audio_send_stream.cname);
+
+  // Create audio receiver and call Receive, expecting parameters to be applied
+  // (minus |cname|, since that's the sent cname, not received).
+  receiver_result = ortc_factory_->CreateRtpReceiver(cricket::MEDIA_TYPE_AUDIO,
+                                                     audio_transport.get());
+  auto audio_receiver = receiver_result.MoveValue();
+  EXPECT_TRUE(
+      audio_receiver->Receive(MakeMinimalOpusParametersWithSsrc(0xbaadf00d))
+          .ok());
+  EXPECT_FALSE(fake_voice_channel->recv_rtcp_parameters().reduced_size);
+}
+
+// When SetRtcpParameters is called, the modified parameters should be applied
+// to the media engine.
+// TODO(deadbeef): Once the implementation supports changing the CNAME,
+// test that here.
+TEST_F(RtpTransportTest, SetRtcpParametersAppliesParametersToMediaEngine) {
+  rtc::FakePacketTransport fake_packet_transport("fake");
+  RtcpParameters rtcp_parameters;
+  rtcp_parameters.mux = true;
+  rtcp_parameters.reduced_size = false;
+  auto rtp_transport_result = ortc_factory_->CreateRtpTransport(
+      rtcp_parameters, &fake_packet_transport, nullptr, nullptr);
+  auto rtp_transport = rtp_transport_result.MoveValue();
+
+  // Create video sender and call Send, applying an initial set of parameters.
+  auto sender_result = ortc_factory_->CreateRtpSender(cricket::MEDIA_TYPE_VIDEO,
+                                                      rtp_transport.get());
+  auto sender = sender_result.MoveValue();
+  EXPECT_TRUE(sender->Send(MakeMinimalVp8Parameters()).ok());
+
+  // Modify parameters and expect them to be changed at the media engine level.
+  rtcp_parameters.reduced_size = true;
+  EXPECT_TRUE(rtp_transport->SetRtcpParameters(rtcp_parameters).ok());
+
+  cricket::FakeVideoMediaChannel* fake_video_channel =
+      fake_media_engine_->GetVideoChannel(0);
+  ASSERT_NE(nullptr, fake_video_channel);
+  EXPECT_TRUE(fake_video_channel->send_rtcp_parameters().reduced_size);
+}
+
+// Tests that re-setting the SRTP send/receive key is not supported.
+TEST_F(RtpTransportTest, SetSrtpSendAndReceiveKey) {
+  rtc::FakePacketTransport fake_packet_transport("fake");
+  RtcpParameters rtcp_parameters;
+  auto srtp_transport_result = ortc_factory_->CreateSrtpTransport(
+      rtcp_parameters, &fake_packet_transport, nullptr,
+      rtp_transport_controller_.get());
+  auto srtp_transport = srtp_transport_result.MoveValue();
+  auto sender_result = ortc_factory_->CreateRtpSender(cricket::MEDIA_TYPE_VIDEO,
+                                                      srtp_transport.get());
+  EXPECT_TRUE(srtp_transport->SetSrtpSendKey(kTestCryptoParams1).ok());
+  EXPECT_FALSE(srtp_transport->SetSrtpSendKey(kTestCryptoParams2).ok());
+  EXPECT_TRUE(srtp_transport->SetSrtpReceiveKey(kTestCryptoParams1).ok());
+  EXPECT_FALSE(srtp_transport->SetSrtpReceiveKey(kTestCryptoParams2).ok());
+}
+
+// Tests that the senders cannot send before setting the keys.
+TEST_F(RtpTransportTest, SendBeforeSettingKeys) {
+  rtc::FakePacketTransport fake_packet_transport("fake");
+  RtcpParameters rtcp_parameters;
+  auto srtp_transport_result = ortc_factory_->CreateSrtpTransport(
+      rtcp_parameters, &fake_packet_transport, nullptr,
+      rtp_transport_controller_.get());
+  auto srtp_transport = srtp_transport_result.MoveValue();
+  auto sender_result = ortc_factory_->CreateRtpSender(cricket::MEDIA_TYPE_VIDEO,
+                                                      srtp_transport.get());
+  auto sender = sender_result.MoveValue();
+  EXPECT_FALSE(sender->Send(MakeMinimalVp8Parameters()).ok());
+  EXPECT_TRUE(srtp_transport->SetSrtpSendKey(kTestCryptoParams1).ok());
+  EXPECT_FALSE(sender->Send(MakeMinimalVp8Parameters()).ok());
+  EXPECT_TRUE(srtp_transport->SetSrtpReceiveKey(kTestCryptoParams1).ok());
+  EXPECT_TRUE(sender->Send(MakeMinimalVp8Parameters()).ok());
+}
+
+// Tests that the Receivers cannot receive before setting the keys.
+TEST_F(RtpTransportTest, ReceiveBeforeSettingKeys) {
+  rtc::FakePacketTransport fake_packet_transport("fake");
+  RtcpParameters rtcp_parameters;
+  auto srtp_transport_result = ortc_factory_->CreateSrtpTransport(
+      rtcp_parameters, &fake_packet_transport, nullptr,
+      rtp_transport_controller_.get());
+  auto srtp_transport = srtp_transport_result.MoveValue();
+  auto receiver_result = ortc_factory_->CreateRtpReceiver(
+      cricket::MEDIA_TYPE_VIDEO, srtp_transport.get());
+  auto receiver = receiver_result.MoveValue();
+  EXPECT_FALSE(receiver->Receive(MakeMinimalVp8Parameters()).ok());
+  EXPECT_TRUE(srtp_transport->SetSrtpSendKey(kTestCryptoParams1).ok());
+  EXPECT_FALSE(receiver->Receive(MakeMinimalVp8Parameters()).ok());
+  EXPECT_TRUE(srtp_transport->SetSrtpReceiveKey(kTestCryptoParams1).ok());
+  EXPECT_TRUE(receiver->Receive(MakeMinimalVp8Parameters()).ok());
+}
+
+}  // namespace webrtc