Wire up RTP keep-alive in ortc api.

webrtc/ortc/ortcfactory.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 58 matching lines @@
 
 namespace webrtc {
 
 // Note that this proxy class uses the network thread as the "worker" thread.
 BEGIN_OWNED_PROXY_MAP(OrtcFactory)
 PROXY_SIGNALING_THREAD_DESTRUCTOR()
 PROXY_METHOD0(RTCErrorOr<std::unique_ptr<RtpTransportControllerInterface>>,
               CreateRtpTransportController)
 PROXY_METHOD4(RTCErrorOr<std::unique_ptr<RtpTransportInterface>>,
               CreateRtpTransport,
-              const RtcpParameters&,
+              const RtpTransportParameters&,
               PacketTransportInterface*,
               PacketTransportInterface*,
               RtpTransportControllerInterface*)
 
 PROXY_METHOD4(RTCErrorOr<std::unique_ptr<SrtpTransportInterface>>,
               CreateSrtpTransport,
-              const RtcpParameters&,
+              const RtpTransportParameters&,
               PacketTransportInterface*,
               PacketTransportInterface*,
               RtpTransportControllerInterface*)
 
 PROXY_CONSTMETHOD1(RtpCapabilities,
                    GetRtpSenderCapabilities,
                    cricket::MediaType)
 PROXY_METHOD2(RTCErrorOr<std::unique_ptr<OrtcRtpSenderInterface>>,
               CreateRtpSender,
               rtc::scoped_refptr<MediaStreamTrackInterface>,
@@ skipping 114 matching lines @@
 
 OrtcFactory::~OrtcFactory() {
   RTC_DCHECK_RUN_ON(signaling_thread_);
   if (wraps_signaling_thread_) {
     rtc::ThreadManager::Instance()->UnwrapCurrentThread();
   }
 }
 
 RTCErrorOr<std::unique_ptr<RtpTransportControllerInterface>>
 OrtcFactory::CreateRtpTransportController() {
+  return CreateRtpTransportController(RtpTransportParameters());
+}
+
+RTCErrorOr<std::unique_ptr<RtpTransportControllerInterface>>
+OrtcFactory::CreateRtpTransportController(
+    const RtpTransportParameters& parameters) {
   RTC_DCHECK_RUN_ON(signaling_thread_);
   return RtpTransportControllerAdapter::CreateProxied(
-      cricket::MediaConfig(), channel_manager_.get(), null_event_log_.get(),
-      signaling_thread_, worker_thread_.get());
+      cricket::MediaConfig(), parameters, channel_manager_.get(),
+      null_event_log_.get(), signaling_thread_, worker_thread_.get());
 }
 
 RTCErrorOr<std::unique_ptr<RtpTransportInterface>>
 OrtcFactory::CreateRtpTransport(
-    const RtcpParameters& rtcp_parameters,
+    const RtpTransportParameters& parameters,
     PacketTransportInterface* rtp,
     PacketTransportInterface* rtcp,
     RtpTransportControllerInterface* transport_controller) {
   RTC_DCHECK_RUN_ON(signaling_thread_);
-  RtcpParameters copied_parameters = rtcp_parameters;
-  if (copied_parameters.cname.empty()) {
-    copied_parameters.cname = default_cname_;
+  RtpTransportParameters copied_parameters = parameters;
+  if (copied_parameters.rtcp.cname.empty()) {
+    copied_parameters.rtcp.cname = default_cname_;
   }
   if (transport_controller) {
     return transport_controller->GetInternal()->CreateProxiedRtpTransport(
         copied_parameters, rtp, rtcp);
   } else {
     // If |transport_controller| is null, create one automatically, which the
     // returned RtpTransport will own.
     auto controller_result = CreateRtpTransportController();
     if (!controller_result.ok()) {
       return controller_result.MoveError();
     }
     auto controller = controller_result.MoveValue();
     auto transport_result =
         controller->GetInternal()->CreateProxiedRtpTransport(copied_parameters,
                                                              rtp, rtcp);
     // If RtpTransport was successfully created, transfer ownership of
     // |rtp_transport_controller|. Otherwise it will go out of scope and be
     // deleted automatically.
     if (transport_result.ok()) {
       transport_result.value()
           ->GetInternal()
           ->TakeOwnershipOfRtpTransportController(std::move(controller));
     }
     return transport_result;
   }
 }
 
 RTCErrorOr<std::unique_ptr<SrtpTransportInterface>>
 OrtcFactory::CreateSrtpTransport(
-    const RtcpParameters& rtcp_parameters,
+    const RtpTransportParameters& parameters,
     PacketTransportInterface* rtp,
     PacketTransportInterface* rtcp,
     RtpTransportControllerInterface* transport_controller) {
   RTC_DCHECK_RUN_ON(signaling_thread_);
-  RtcpParameters copied_parameters = rtcp_parameters;
-  if (copied_parameters.cname.empty()) {
-    copied_parameters.cname = default_cname_;
+  RtpTransportParameters copied_parameters = parameters;
+  if (copied_parameters.rtcp.cname.empty()) {
+    copied_parameters.rtcp.cname = default_cname_;
   }
   if (transport_controller) {
     return transport_controller->GetInternal()->CreateProxiedSrtpTransport(
         copied_parameters, rtp, rtcp);
   } else {
     // If |transport_controller| is null, create one automatically, which the
     // returned SrtpTransport will own.
     auto controller_result = CreateRtpTransportController();
     if (!controller_result.ok()) {
       return controller_result.MoveError();
@@ skipping 260 matching lines @@
   //
   // Note that |adm_| may be null, in which case the platform-specific default
   // AudioDeviceModule will be used.
   return std::unique_ptr<cricket::MediaEngineInterface>(
       cricket::WebRtcMediaEngineFactory::Create(
           adm_, audio_encoder_factory_, audio_decoder_factory_, nullptr,
           nullptr, nullptr, webrtc::AudioProcessing::Create()));
 }
 
 }  // namespace webrtc