Wire up RTP keep-alive in ortc api.

webrtc/ortc/ortcfactory_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.
  */
 
@@ skipping 48 matching lines @@
   EXPECT_TRUE(controller_result1.ok());
   auto controller_result2 = ortc_factory_->CreateRtpTransportController();
   EXPECT_TRUE(controller_result1.ok());
 }
 
 // Simple test for the successful cases of CreateRtpTransport.
 TEST_F(OrtcFactoryTest, CreateRtpTransportWithAndWithoutMux) {
   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);
+  RtpTransportParameters parameters = MakeRtcpMuxParameters();
+  auto result =
+      ortc_factory_->CreateRtpTransport(parameters, &rtp, nullptr, nullptr);
   EXPECT_TRUE(result.ok());
   result.MoveValue().reset();
   // With non-muxed RTCP.
-  rtcp_parameters.mux = false;
-  result =
-      ortc_factory_->CreateRtpTransport(rtcp_parameters, &rtp, &rtcp, nullptr);
+  parameters.rtcp.mux = false;
+  result = ortc_factory_->CreateRtpTransport(parameters, &rtp, &rtcp, nullptr);
   EXPECT_TRUE(result.ok());
 }
 
 // Simple test for the successful cases of CreateSrtpTransport.
 TEST_F(OrtcFactoryTest, CreateSrtpTransport) {
   rtc::FakePacketTransport rtp("rtp");
   rtc::FakePacketTransport rtcp("rtcp");
   // With muxed RTCP.
-  RtcpParameters rtcp_parameters;
-  rtcp_parameters.mux = true;
-  auto result = ortc_factory_->CreateSrtpTransport(rtcp_parameters, &rtp,
-                                                   nullptr, nullptr);
+  RtpTransportParameters parameters = MakeRtcpMuxParameters();
+  auto result =
+      ortc_factory_->CreateSrtpTransport(parameters, &rtp, nullptr, nullptr);
   EXPECT_TRUE(result.ok());
   result.MoveValue().reset();
   // With non-muxed RTCP.
-  rtcp_parameters.mux = false;
-  result =
-      ortc_factory_->CreateSrtpTransport(rtcp_parameters, &rtp, &rtcp, nullptr);
+  parameters.rtcp.mux = false;
+  result = ortc_factory_->CreateSrtpTransport(parameters, &rtp, &rtcp, nullptr);
   EXPECT_TRUE(result.ok());
 }
 
 // If no CNAME is provided, one should be generated and returned by
 // GetRtpParameters.
 TEST_F(OrtcFactoryTest, CreateRtpTransportGeneratesCname) {
   rtc::FakePacketTransport rtp("rtp");
-  RtcpParameters rtcp_parameters;
-  rtcp_parameters.mux = true;
-  auto result = ortc_factory_->CreateRtpTransport(rtcp_parameters, &rtp,
+  auto result = ortc_factory_->CreateRtpTransport(MakeRtcpMuxParameters(), &rtp,
                                                   nullptr, nullptr);
   ASSERT_TRUE(result.ok());
-  EXPECT_FALSE(result.value()->GetRtcpParameters().cname.empty());
+  EXPECT_FALSE(result.value()->GetParameters().rtcp.cname.empty());
 }
 
 // Extension of the above test; multiple transports created by the same factory
 // should use the same generated CNAME.
 TEST_F(OrtcFactoryTest, MultipleRtpTransportsUseSameGeneratedCname) {
   rtc::FakePacketTransport packet_transport1("1");
   rtc::FakePacketTransport packet_transport2("2");
-  RtcpParameters rtcp_parameters;
-  rtcp_parameters.mux = true;
+  RtpTransportParameters parameters = MakeRtcpMuxParameters();
   // Sanity check.
-  ASSERT_TRUE(rtcp_parameters.cname.empty());
+  ASSERT_TRUE(parameters.rtcp.cname.empty());
   auto result = ortc_factory_->CreateRtpTransport(
-      rtcp_parameters, &packet_transport1, nullptr, nullptr);
+      parameters, &packet_transport1, nullptr, nullptr);
   ASSERT_TRUE(result.ok());
   auto rtp_transport1 = result.MoveValue();
-  result = ortc_factory_->CreateRtpTransport(
-      rtcp_parameters, &packet_transport2, nullptr, nullptr);
+  result = ortc_factory_->CreateRtpTransport(parameters, &packet_transport2,
+                                             nullptr, nullptr);
   ASSERT_TRUE(result.ok());
   auto rtp_transport2 = result.MoveValue();
-  RtcpParameters params1 = rtp_transport1->GetRtcpParameters();
-  RtcpParameters params2 = rtp_transport2->GetRtcpParameters();
+  RtcpParameters params1 = rtp_transport1->GetParameters().rtcp;
+  RtcpParameters params2 = rtp_transport2->GetParameters().rtcp;
   EXPECT_FALSE(params1.cname.empty());
   EXPECT_EQ(params1.cname, params2.cname);
 }
 
 TEST_F(OrtcFactoryTest, CreateRtpTransportWithNoPacketTransport) {
   auto result = ortc_factory_->CreateRtpTransport(MakeRtcpMuxParameters(),
                                                   nullptr, nullptr, nullptr);
   EXPECT_EQ(RTCErrorType::INVALID_PARAMETER, result.error().type());
 }
 
 // If the |mux| member of the RtcpParameters is false, both an RTP and RTCP
 // packet transport are needed.
 TEST_F(OrtcFactoryTest, CreateRtpTransportWithMissingRtcpTransport) {
   rtc::FakePacketTransport rtp("rtp");
-  RtcpParameters rtcp_parameters;
-  rtcp_parameters.mux = false;
-  auto result = ortc_factory_->CreateRtpTransport(rtcp_parameters, &rtp,
-                                                  nullptr, nullptr);
+  RtpTransportParameters parameters;
+  parameters.rtcp.mux = false;
+  auto result =
+      ortc_factory_->CreateRtpTransport(parameters, &rtp, nullptr, nullptr);
   EXPECT_EQ(RTCErrorType::INVALID_PARAMETER, result.error().type());
 }
 
 // If the |mux| member of the RtcpParameters is true, only an RTP packet
 // transport is necessary. So, passing in an RTCP transport is most likely
 // an accident, and thus should be treated as an error.
 TEST_F(OrtcFactoryTest, CreateRtpTransportWithExtraneousRtcpTransport) {
   rtc::FakePacketTransport rtp("rtp");
   rtc::FakePacketTransport rtcp("rtcp");
-  RtcpParameters rtcp_parameters;
-  rtcp_parameters.mux = true;
-  auto result =
-      ortc_factory_->CreateRtpTransport(rtcp_parameters, &rtp, &rtcp, nullptr);
+  auto result = ortc_factory_->CreateRtpTransport(MakeRtcpMuxParameters(), &rtp,
+                                                  &rtcp, nullptr);
   EXPECT_EQ(RTCErrorType::INVALID_PARAMETER, result.error().type());
 }
 
 // Basic test that CreateUdpTransport works with AF_INET and AF_INET6.
 TEST_F(OrtcFactoryTest, CreateUdpTransport) {
   auto result = ortc_factory_->CreateUdpTransport(AF_INET);
   EXPECT_TRUE(result.ok());
   result = ortc_factory_->CreateUdpTransport(AF_INET6);
   EXPECT_TRUE(result.ok());
 }
@@ skipping 74 matching lines @@
 TEST_F(OrtcFactoryTest, CreateSendersOrReceieversWithNullTransport) {
   auto sender_result =
       ortc_factory_->CreateRtpSender(cricket::MEDIA_TYPE_AUDIO, nullptr);
   EXPECT_EQ(RTCErrorType::INVALID_PARAMETER, sender_result.error().type());
   auto receiver_result =
       ortc_factory_->CreateRtpReceiver(cricket::MEDIA_TYPE_AUDIO, nullptr);
   EXPECT_EQ(RTCErrorType::INVALID_PARAMETER, receiver_result.error().type());
 }
 
 }  // namespace webrtc