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 74 matching lines @@
 protected:
 RtpTransportControllerAdapter* GetInternal() override {
   return internal();
 }
 END_PROXY_MAP()
 
 // static
 std::unique_ptr<RtpTransportControllerInterface>
 RtpTransportControllerAdapter::CreateProxied(
     const cricket::MediaConfig& config,
+    const RtpTransportParameters& parameters,
     cricket::ChannelManager* channel_manager,
     webrtc::RtcEventLog* event_log,
     rtc::Thread* signaling_thread,
     rtc::Thread* worker_thread) {
   std::unique_ptr<RtpTransportControllerAdapter> wrapped(
-      new RtpTransportControllerAdapter(config, channel_manager, event_log,
-                                        signaling_thread, worker_thread));
+      new RtpTransportControllerAdapter(config, parameters, channel_manager,
+                                        event_log, signaling_thread,
+                                        worker_thread));
   return RtpTransportControllerProxyWithInternal<
       RtpTransportControllerAdapter>::Create(signaling_thread, worker_thread,
                                              std::move(wrapped));
 }
 
 RtpTransportControllerAdapter::~RtpTransportControllerAdapter() {
   RTC_DCHECK_RUN_ON(signaling_thread_);
   if (!transport_proxies_.empty()) {
     LOG(LS_ERROR)
         << "Destroying RtpTransportControllerAdapter while RtpTransports "
@@ skipping 10 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);
+  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::SetRtpTransportAndParameters(
+    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.");

[Taylor Brandstetter, 2017/08/03 16:50:36]

nit: Someone using this API may interpret "media stream" as referring to a
MediaStream object, which isn't what this is talking about. "Stream" is a pretty
ambiguous term for us, since it has different meanings in the contexts of
WebRTC, SDP and RTP.

Can you rephrase this message in the terminology used by this API? Which I think
would be "RtpSender has started sending"?

+  }
+  RTC_DCHECK(call_->SetRtpKeepAliveConfig(parameters.keepalive));

[Taylor Brandstetter, 2017/08/03 01:18:03]

If this is in a DCHECK, it will only be executed in debug builds, right?

[sprang_webrtc, 2017/08/03 13:08:14]

Oops, right. Let's do a check instead then.

   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;
       }
     }
@@ skipping 14 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_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 202 matching lines @@
   if (!video_channel_->SetRemoteContent(&remote_video_description_,
                                         cricket::CA_ANSWER, nullptr)) {
     LOG_AND_RETURN_ERROR(RTCErrorType::INTERNAL_ERROR,
                          "Failed to apply remote parameters to media channel.");
   }
   return RTCError::OK();
 }
 
 RtpTransportControllerAdapter::RtpTransportControllerAdapter(
     const cricket::MediaConfig& config,
+    const RtpTransportParameters& params,
     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),
+      keepalive_(params.keepalive),
       channel_manager_(channel_manager),
       event_log_(event_log) {
   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);
   remote_audio_description_.AddCodec(dummy_audio);
   local_video_description_.AddCodec(dummy_video);
   remote_video_description_.AddCodec(dummy_video);
 
   worker_thread_->Invoke<void>(
       RTC_FROM_HERE,
-      rtc::Bind(&RtpTransportControllerAdapter::Init_w, this));
+      rtc::Bind(&RtpTransportControllerAdapter::Init_w, this, params));
 }
 
 // TODO(nisse): Duplicates corresponding method in PeerConnection (used
 // to be in MediaController).
-void RtpTransportControllerAdapter::Init_w() {
+void RtpTransportControllerAdapter::Init_w(
+    const RtpTransportParameters& params) {
   RTC_DCHECK(worker_thread_->IsCurrent());
   RTC_DCHECK(!call_);
 
   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_config.keepalive_config = params.keepalive;
 
   call_.reset(webrtc::Call::Create(call_config));
 }
 
 void RtpTransportControllerAdapter::Close_w() {
   call_.reset();
 }
 
 RTCError RtpTransportControllerAdapter::AttachAudioSender(
     OrtcRtpSenderAdapter* sender,
@@ skipping 11 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_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