Wire up RTP keep-alive in ortc api.

webrtc/ortc/rtptransportcontrolleradapter.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 111 matching lines @@
     DestroyVideoChannel();
   }
   // Call must be destroyed on the worker thread.
   worker_thread_->Invoke<void>(
       RTC_FROM_HERE,
       rtc::Bind(&RtpTransportControllerAdapter::Close_w, this));
 }
 
 RTCErrorOr<std::unique_ptr<RtpTransportInterface>>
 RtpTransportControllerAdapter::CreateProxiedRtpTransport(
-    const RtcpParameters& rtcp_parameters,
+    const RtpTransportParameters& parameters,
     PacketTransportInterface* rtp,
     PacketTransportInterface* rtcp) {
-  auto result =
-      RtpTransportAdapter::CreateProxied(rtcp_parameters, rtp, rtcp, this);
+  if (!transport_proxies_.empty() && (parameters.keepalive != keepalive_)) {
+    LOG_AND_RETURN_ERROR(RTCErrorType::INVALID_MODIFICATION,
+                         "Cannot create RtpTransport with different keep-alive "
+                         "from the RtpTransports already associated with this "
+                         "transport controller.");
+  }
+  auto result = RtpTransportAdapter::CreateProxied(parameters, rtp, rtcp, this);
   if (result.ok()) {
     transport_proxies_.push_back(result.value().get());
     transport_proxies_.back()->GetInternal()->SignalDestroyed.connect(
         this, &RtpTransportControllerAdapter::OnRtpTransportDestroyed);
   }
   return result;
 }
 
 RTCErrorOr<std::unique_ptr<SrtpTransportInterface>>
 RtpTransportControllerAdapter::CreateProxiedSrtpTransport(
-    const RtcpParameters& rtcp_parameters,
+    const RtpTransportParameters& parameters,
     PacketTransportInterface* rtp,
     PacketTransportInterface* rtcp) {
   auto result =
-      RtpTransportAdapter::CreateSrtpProxied(rtcp_parameters, rtp, rtcp, this);
+      RtpTransportAdapter::CreateSrtpProxied(parameters, rtp, rtcp, this);
   if (result.ok()) {
     transport_proxies_.push_back(result.value().get());
     transport_proxies_.back()->GetInternal()->SignalDestroyed.connect(
         this, &RtpTransportControllerAdapter::OnRtpTransportDestroyed);
   }
   return result;
 }
 
 RTCErrorOr<std::unique_ptr<OrtcRtpSenderInterface>>
 RtpTransportControllerAdapter::CreateProxiedRtpSender(
@@ skipping 50 matching lines @@
 
   return OrtcRtpReceiverAdapter::CreateProxy(std::move(new_receiver));
 }
 
 std::vector<RtpTransportInterface*>
 RtpTransportControllerAdapter::GetTransports() const {
   RTC_DCHECK_RUN_ON(signaling_thread_);
   return transport_proxies_;
 }
 
-RTCError RtpTransportControllerAdapter::SetRtcpParameters(
-    const RtcpParameters& parameters,
+RTCError RtpTransportControllerAdapter::SetRtpTransportParameters(
+    const RtpTransportParameters& parameters,
     RtpTransportInterface* inner_transport) {
+  if ((video_channel_ != nullptr || voice_channel_ != nullptr) &&
+      (parameters.keepalive != keepalive_)) {
+    LOG_AND_RETURN_ERROR(RTCErrorType::INVALID_MODIFICATION,
+                         "Cannot change keep-alive settings after creating "
+                         "media streams or additional transports for the same "
+                         "transport controller.");
+  }
+  // Call must be configured on the worker thread.
+  worker_thread_->Invoke<void>(
+      RTC_FROM_HERE,
+      rtc::Bind(&RtpTransportControllerAdapter::SetRtpTransportParameters_w,
+                this, parameters));
+
   do {
     if (inner_transport == inner_audio_transport_) {
-      CopyRtcpParametersToDescriptions(parameters, &local_audio_description_,
+      CopyRtcpParametersToDescriptions(parameters.rtcp,
+                                       &local_audio_description_,
                                        &remote_audio_description_);
       if (!voice_channel_->SetLocalContent(&local_audio_description_,
                                            cricket::CA_OFFER, nullptr)) {
         break;
       }
       if (!voice_channel_->SetRemoteContent(&remote_audio_description_,
                                             cricket::CA_ANSWER, nullptr)) {
         break;
       }
     } else if (inner_transport == inner_video_transport_) {
-      CopyRtcpParametersToDescriptions(parameters, &local_video_description_,
+      CopyRtcpParametersToDescriptions(parameters.rtcp,
+                                       &local_video_description_,
                                        &remote_video_description_);
       if (!video_channel_->SetLocalContent(&local_video_description_,
                                            cricket::CA_OFFER, nullptr)) {
         break;
       }
       if (!video_channel_->SetRemoteContent(&remote_video_description_,
                                             cricket::CA_ANSWER, nullptr)) {
         break;
       }
     }
     return RTCError::OK();
   } while (false);
   LOG_AND_RETURN_ERROR(RTCErrorType::INTERNAL_ERROR,
                        "Failed to apply new RTCP parameters.");
 }
 
+void RtpTransportControllerAdapter::SetRtpTransportParameters_w(
+    const RtpTransportParameters& parameters) {
+  call_send_rtp_transport_controller_->SetKeepAliveConfig(parameters.keepalive);
+}
+
 RTCError RtpTransportControllerAdapter::ValidateAndApplyAudioSenderParameters(
     const RtpParameters& parameters,
     uint32_t* primary_ssrc) {
   RTC_DCHECK(voice_channel_);
   RTC_DCHECK(have_audio_sender_);
 
   auto codecs_result = ToCricketCodecs<cricket::AudioCodec>(parameters.codecs);
   if (!codecs_result.ok()) {
     return codecs_result.MoveError();
   }
 
   auto extensions_result =
       ToCricketRtpHeaderExtensions(parameters.header_extensions);
   if (!extensions_result.ok()) {
     return extensions_result.MoveError();
   }
 
   auto stream_params_result = MakeSendStreamParamsVec(
-      parameters.encodings, inner_audio_transport_->GetRtcpParameters().cname,
+      parameters.encodings, inner_audio_transport_->GetParameters().rtcp.cname,
       local_audio_description_);
   if (!stream_params_result.ok()) {
     return stream_params_result.MoveError();
   }
 
   // Check that audio/video sender aren't using the same IDs to refer to
   // different things, if they share the same transport.
   if (inner_audio_transport_ == inner_video_transport_) {
     RTCError err = CheckForIdConflicts(
         codecs_result.value(), extensions_result.value(),
@@ skipping 68 matching lines @@
     return codecs_result.MoveError();
   }
 
   auto extensions_result =
       ToCricketRtpHeaderExtensions(parameters.header_extensions);
   if (!extensions_result.ok()) {
     return extensions_result.MoveError();
   }
 
   auto stream_params_result = MakeSendStreamParamsVec(
-      parameters.encodings, inner_video_transport_->GetRtcpParameters().cname,
+      parameters.encodings, inner_video_transport_->GetParameters().rtcp.cname,
       local_video_description_);
   if (!stream_params_result.ok()) {
     return stream_params_result.MoveError();
   }
 
   // Check that audio/video sender aren't using the same IDs to refer to
   // different things, if they share the same transport.
   if (inner_audio_transport_ == inner_video_transport_) {
     RTCError err = CheckForIdConflicts(
         codecs_result.value(), extensions_result.value(),
@@ skipping 210 matching lines @@
 RtpTransportControllerAdapter::RtpTransportControllerAdapter(
     const cricket::MediaConfig& config,
     cricket::ChannelManager* channel_manager,
     webrtc::RtcEventLog* event_log,
     rtc::Thread* signaling_thread,
     rtc::Thread* worker_thread)
     : signaling_thread_(signaling_thread),
       worker_thread_(worker_thread),
       media_config_(config),
       channel_manager_(channel_manager),
-      event_log_(event_log) {
+      event_log_(event_log),
+      call_send_rtp_transport_controller_(nullptr) {
   RTC_DCHECK_RUN_ON(signaling_thread_);
   RTC_DCHECK(channel_manager_);
   // Add "dummy" codecs to the descriptions, because the media engines
   // currently reject empty lists of codecs. Note that these codecs will never
   // actually be used, because when parameters are set, the dummy codecs will
   // be replaced by actual codecs before any send/receive streams are created.
   static const cricket::AudioCodec dummy_audio(0, cricket::kPcmuCodecName, 8000,
                                                0, 1);
   static const cricket::VideoCodec dummy_video(96, cricket::kVp8CodecName);
   local_audio_description_.AddCodec(dummy_audio);
@@ skipping 15 matching lines @@
   const int kMinBandwidthBps = 30000;
   const int kStartBandwidthBps = 300000;
   const int kMaxBandwidthBps = 2000000;
 
   webrtc::Call::Config call_config(event_log_);
   call_config.audio_state = channel_manager_->media_engine()->GetAudioState();
   call_config.bitrate_config.min_bitrate_bps = kMinBandwidthBps;
   call_config.bitrate_config.start_bitrate_bps = kStartBandwidthBps;
   call_config.bitrate_config.max_bitrate_bps = kMaxBandwidthBps;
 
-  call_.reset(webrtc::Call::Create(call_config));
+  call_send_rtp_transport_controller_ =
+      new RtpTransportControllerSend(Clock::GetRealTimeClock(), event_log_);
+  call_.reset(webrtc::Call::Create(
+      call_config, std::unique_ptr<RtpTransportControllerSendInterface>(
+                       call_send_rtp_transport_controller_)));
 }
 
 void RtpTransportControllerAdapter::Close_w() {
   call_.reset();
+  call_send_rtp_transport_controller_ = nullptr;
 }
 
 RTCError RtpTransportControllerAdapter::AttachAudioSender(
     OrtcRtpSenderAdapter* sender,
     RtpTransportInterface* inner_transport) {
   if (have_audio_sender_) {
     LOG_AND_RETURN_ERROR(RTCErrorType::UNSUPPORTED_OPERATION,
                          "Using two audio RtpSenders with the same "
                          "RtpTransportControllerAdapter is not currently "
                          "supported.");
   }
   if (inner_audio_transport_ && inner_audio_transport_ != inner_transport) {
     LOG_AND_RETURN_ERROR(RTCErrorType::UNSUPPORTED_OPERATION,
                          "Using different transports for the audio "
                          "RtpSender and RtpReceiver is not currently "
                          "supported.");
   }
   RTCError err = MaybeSetCryptos(inner_transport, &local_audio_description_,
                                  &remote_audio_description_);
   if (!err.ok()) {
     return err;
   }
   // If setting new transport, extract its RTCP parameters and create voice
   // channel.
   if (!inner_audio_transport_) {
-    CopyRtcpParametersToDescriptions(inner_transport->GetRtcpParameters(),
+    CopyRtcpParametersToDescriptions(inner_transport->GetParameters().rtcp,
                                      &local_audio_description_,
                                      &remote_audio_description_);
     inner_audio_transport_ = inner_transport;
     CreateVoiceChannel();
   }
   have_audio_sender_ = true;
   sender->SignalDestroyed.connect(
       this, &RtpTransportControllerAdapter::OnAudioSenderDestroyed);
   return RTCError::OK();
 }
@@ skipping 14 matching lines @@
                          "supported.");
   }
   RTCError err = MaybeSetCryptos(inner_transport, &local_video_description_,
                                  &remote_video_description_);
   if (!err.ok()) {
     return err;
   }
   // If setting new transport, extract its RTCP parameters and create video
   // channel.
   if (!inner_video_transport_) {
-    CopyRtcpParametersToDescriptions(inner_transport->GetRtcpParameters(),
+    CopyRtcpParametersToDescriptions(inner_transport->GetParameters().rtcp,
                                      &local_video_description_,
                                      &remote_video_description_);
     inner_video_transport_ = inner_transport;
     CreateVideoChannel();
   }
   have_video_sender_ = true;
   sender->SignalDestroyed.connect(
       this, &RtpTransportControllerAdapter::OnVideoSenderDestroyed);
   return RTCError::OK();
 }
@@ skipping 14 matching lines @@
                          "supported.");
   }
   RTCError err = MaybeSetCryptos(inner_transport, &local_audio_description_,
                                  &remote_audio_description_);
   if (!err.ok()) {
     return err;
   }
   // If setting new transport, extract its RTCP parameters and create voice
   // channel.
   if (!inner_audio_transport_) {
-    CopyRtcpParametersToDescriptions(inner_transport->GetRtcpParameters(),
+    CopyRtcpParametersToDescriptions(inner_transport->GetParameters().rtcp,
                                      &local_audio_description_,
                                      &remote_audio_description_);
     inner_audio_transport_ = inner_transport;
     CreateVoiceChannel();
   }
   have_audio_receiver_ = true;
   receiver->SignalDestroyed.connect(
       this, &RtpTransportControllerAdapter::OnAudioReceiverDestroyed);
   return RTCError::OK();
 }
@@ skipping 14 matching lines @@
                          "supported.");
   }
   RTCError err = MaybeSetCryptos(inner_transport, &local_video_description_,
                                  &remote_video_description_);
   if (!err.ok()) {
     return err;
   }
   // If setting new transport, extract its RTCP parameters and create video
   // channel.
   if (!inner_video_transport_) {
-    CopyRtcpParametersToDescriptions(inner_transport->GetRtcpParameters(),
+    CopyRtcpParametersToDescriptions(inner_transport->GetParameters().rtcp,
                                      &local_video_description_,
                                      &remote_video_description_);
     inner_video_transport_ = inner_transport;
     CreateVideoChannel();
   }
   have_video_receiver_ = true;
   receiver->SignalDestroyed.connect(
       this, &RtpTransportControllerAdapter::OnVideoReceiverDestroyed);
   return RTCError::OK();
 }
@@ skipping 199 matching lines @@
     local_description->set_cryptos(cryptos);
 
     cryptos.clear();
     cryptos.push_back(*(rtp_transport->GetInternal()->send_key()));
     remote_description->set_cryptos(cryptos);
   }
   return RTCError::OK();
 }
 
 }  // namespace webrtc