| /* | |
| * 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/media/base/fakemediaengine.h" | |
| #include "webrtc/ortc/ortcfactory.h" | |
| #include "webrtc/ortc/testrtpparameters.h" | |
| #include "webrtc/p2p/base/fakepackettransport.h" | |
| #include "webrtc/rtc_base/gunit.h" | |
| namespace webrtc { | |
| // 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(); | |
| } | |
| protected: | |
| // Owned by |ortc_factory_|. | |
| cricket::FakeMediaEngine* fake_media_engine_; | |
| std::unique_ptr<OrtcFactoryInterface> ortc_factory_; | |
| }; | |
| // Test GetRtpPacketTransport and GetRtcpPacketTransport, with and without RTCP | |
| // muxing. | |
| TEST_F(RtpTransportTest, GetPacketTransports) { | |
| rtc::FakePacketTransport rtp("rtp"); | |
| rtc::FakePacketTransport rtcp("rtcp"); | |
| // With muxed RTCP. | |
| RtpTransportParameters parameters; | |
| parameters.rtcp.mux = true; | |
| auto result = | |
| ortc_factory_->CreateRtpTransport(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. | |
| parameters.rtcp.mux = false; | |
| result = ortc_factory_->CreateRtpTransport(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. | |
| RtpTransportParameters parameters; | |
| parameters.rtcp.mux = false; | |
| auto result = | |
| ortc_factory_->CreateRtpTransport(parameters, &rtp, &rtcp, nullptr); | |
| ASSERT_TRUE(result.ok()); | |
| auto rtp_transport = result.MoveValue(); | |
| // Enable muxing. | |
| parameters.rtcp.mux = true; | |
| EXPECT_TRUE(rtp_transport->SetParameters(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. | |
| RtpTransportParameters parameters; | |
| parameters.rtcp.mux = false; | |
| parameters.rtcp.cname = "teST"; | |
| parameters.rtcp.reduced_size = false; | |
| auto result = | |
| ortc_factory_->CreateRtpTransport(parameters, &rtp, &rtcp, nullptr); | |
| ASSERT_TRUE(result.ok()); | |
| auto transport = result.MoveValue(); | |
| EXPECT_EQ(parameters, transport->GetParameters()); | |
| // Changing the CNAME is currently unsupported. | |
| parameters.rtcp.cname = "different"; | |
| EXPECT_EQ(RTCErrorType::UNSUPPORTED_OPERATION, | |
| transport->SetParameters(parameters).type()); | |
| parameters.rtcp.cname = "teST"; | |
| // Enable RTCP muxing and reduced-size RTCP. | |
| parameters.rtcp.mux = true; | |
| parameters.rtcp.reduced_size = true; | |
| EXPECT_TRUE(transport->SetParameters(parameters).ok()); | |
| EXPECT_EQ(parameters, transport->GetParameters()); | |
| // Empty CNAME should result in the existing CNAME being used. | |
| parameters.rtcp.cname.clear(); | |
| EXPECT_TRUE(transport->SetParameters(parameters).ok()); | |
| EXPECT_EQ("teST", transport->GetParameters().rtcp.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. | |
| parameters.rtcp.mux = false; | |
| EXPECT_EQ(RTCErrorType::INVALID_STATE, | |
| transport->SetParameters(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"); | |
| RtpTransportParameters parameters; | |
| parameters.rtcp.mux = true; | |
| parameters.rtcp.reduced_size = true; | |
| parameters.rtcp.cname = "foo"; | |
| auto rtp_transport_result = ortc_factory_->CreateRtpTransport( | |
| 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"); | |
| parameters.rtcp.reduced_size = false; | |
| parameters.rtcp.cname = "bar"; | |
| rtp_transport_result = ortc_factory_->CreateRtpTransport( | |
| 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 SetParameters 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"); | |
| RtpTransportParameters parameters; | |
| parameters.rtcp.mux = true; | |
| parameters.rtcp.reduced_size = false; | |
| auto rtp_transport_result = ortc_factory_->CreateRtpTransport( | |
| 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. | |
| parameters.rtcp.reduced_size = true; | |
| EXPECT_TRUE(rtp_transport->SetParameters(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); | |
| } | |
| // SetParameters should set keepalive for all RTP transports. | |
| // It is impossible to modify keepalive parameters if any streams are created. | |
| // Note: This is an implementation detail for current way of configuring the | |
| // keep-alive. It may change in the future. | |
| TEST_F(RtpTransportTest, CantChangeKeepAliveAfterCreatedSendStreams) { | |
| rtc::FakePacketTransport fake_packet_transport("fake"); | |
| RtpTransportParameters parameters; | |
| parameters.keepalive.timeout_interval_ms = 100; | |
| auto rtp_transport_result = ortc_factory_->CreateRtpTransport( | |
| parameters, &fake_packet_transport, nullptr, nullptr); | |
| ASSERT_TRUE(rtp_transport_result.ok()); | |
| std::unique_ptr<RtpTransportInterface> rtp_transport = | |
| rtp_transport_result.MoveValue(); | |
| // Updating keepalive parameters is ok, since no rtp sender created. | |
| parameters.keepalive.timeout_interval_ms = 200; | |
| EXPECT_TRUE(rtp_transport->SetParameters(parameters).ok()); | |
| // Create video sender. Note: |sender_result| scope must extend past the | |
| // SetParameters() call below. | |
| auto sender_result = ortc_factory_->CreateRtpSender(cricket::MEDIA_TYPE_VIDEO, | |
| rtp_transport.get()); | |
| EXPECT_TRUE(sender_result.ok()); | |
| // Modify parameters second time after video send stream created. | |
| parameters.keepalive.timeout_interval_ms = 10; | |
| EXPECT_EQ(RTCErrorType::INVALID_MODIFICATION, | |
| rtp_transport->SetParameters(parameters).type()); | |
| } | |
| // Note: This is an implementation detail for current way of configuring the | |
| // keep-alive. It may change in the future. | |
| TEST_F(RtpTransportTest, KeepAliveMustBeSameAcrossTransportController) { | |
| rtc::FakePacketTransport fake_packet_transport("fake"); | |
| RtpTransportParameters parameters; | |
| parameters.keepalive.timeout_interval_ms = 100; | |
| // Manually create a controller, that can be shared by multiple transports. | |
| auto controller_result = ortc_factory_->CreateRtpTransportController(); | |
| ASSERT_TRUE(controller_result.ok()); | |
| std::unique_ptr<RtpTransportControllerInterface> controller = | |
| controller_result.MoveValue(); | |
| // Create a first transport. | |
| auto first_transport_result = ortc_factory_->CreateRtpTransport( | |
| parameters, &fake_packet_transport, nullptr, controller.get()); | |
| ASSERT_TRUE(first_transport_result.ok()); | |
| // Update the parameters, and create another transport for the same | |
| // controller. | |
| parameters.keepalive.timeout_interval_ms = 10; | |
| auto seconds_transport_result = ortc_factory_->CreateRtpTransport( | |
| parameters, &fake_packet_transport, nullptr, controller.get()); | |
| EXPECT_EQ(RTCErrorType::INVALID_MODIFICATION, | |
| seconds_transport_result.error().type()); | |
| } | |
| } // namespace webrtc |