Wire up RTP keep-alive in ortc api.

webrtc/call/call.cc

 /*
  *  Copyright (c) 2013 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 194 matching lines @@
   void SignalChannelNetworkState(MediaType media, NetworkState state) override;
 
   void OnTransportOverheadChanged(MediaType media,
                                   int transport_overhead_per_packet) override;
 
   void OnNetworkRouteChanged(const std::string& transport_name,
                              const rtc::NetworkRoute& network_route) override;
 
   void OnSentPacket(const rtc::SentPacket& sent_packet) override;
 
+  bool SetRtpKeepAliveConfig(const RtpKeepAliveConfig& config) override;
 
   // Implements BitrateObserver.
   void OnNetworkChanged(uint32_t bitrate_bps,
                         uint8_t fraction_loss,
                         int64_t rtt_ms,
                         int64_t probing_interval_ms) override;
 
   // Implements BitrateAllocator::LimitObserver.
   void OnAllocationLimitsChanged(uint32_t min_send_bitrate_bps,
                                  uint32_t max_padding_bitrate_bps) override;
@@ skipping 911 matching lines @@
 
   transport_send_->send_side_cc()->SignalNetworkState(aggregate_state);
 }
 
 void Call::OnSentPacket(const rtc::SentPacket& sent_packet) {
   video_send_delay_stats_->OnSentPacket(sent_packet.packet_id,
                                         clock_->TimeInMilliseconds());
   transport_send_->send_side_cc()->OnSentPacket(sent_packet);
 }
 
+bool Call::SetRtpKeepAliveConfig(const RtpKeepAliveConfig& config) {
+  // Can be called by RtpTransportController not on the configuration thread.

[stefan-webrtc, 2017/08/08 08:13:06]

This comment will become confusing. Call currently has an
RtpTransportControllerSend object, which is what I'd expect that this refers to.
Should this method be added to that class instead? That way the send streams can
ask the RtpTransportControllerSend whether or not to enable keepalive. Later on,
the RtpTransportController will be responsible for RTP and also keepalive.

[sprang_webrtc, 2017/08/08 08:53:30]

OK, so this badly phrased comment referred to the RtpTransportControllerAdapter
in the ortc api, which is not quite the same.

I've updated that class to actually configure this on the configuration thread
as well. So removed comment and added back thread check.

+
+  ReadLockScoped lock(*send_crit_);
+  if (config != config_.keepalive_config &&
+      (!video_send_streams_.empty() || !audio_send_ssrcs_.empty())) {
+    LOG(LS_WARNING) << "RTP keep-alive settings cannot be altered after "
+                       "creating send streams.";
+    return false;
+  }
+  config_.keepalive_config = config;
+  return true;
+}
+
 void Call::OnNetworkChanged(uint32_t target_bitrate_bps,
                             uint8_t fraction_loss,
                             int64_t rtt_ms,
                             int64_t probing_interval_ms) {
   // TODO(perkj): Consider making sure CongestionController operates on
   // |worker_queue_|.
   if (!worker_queue_.IsCurrent()) {
     worker_queue_.PostTask(
         [this, target_bitrate_bps, fraction_loss, rtt_ms, probing_interval_ms] {
           OnNetworkChanged(target_bitrate_bps, fraction_loss, rtt_ms,
@@ skipping 261 matching lines @@
       (use_send_side_bwe && header.extension.hasTransportSequenceNumber)) {
     receive_side_cc_.OnReceivedPacket(
         packet.arrival_time_ms(), packet.payload_size() + packet.padding_size(),
         header);
   }
 }
 
 }  // namespace internal
 
 }  // namespace webrtc