Wire up RTP keep-alive in ortc api.

webrtc/video/video_send_stream.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.
  */
 #include "webrtc/video/video_send_stream.h"
@@ skipping 329 matching lines @@
                       rtc::TaskQueue* worker_queue,
                       CallStats* call_stats,
                       RtpTransportControllerSendInterface* transport,
                       BitrateAllocator* bitrate_allocator,
                       SendDelayStats* send_delay_stats,
                       VideoStreamEncoder* video_stream_encoder,
                       RtcEventLog* event_log,
                       const VideoSendStream::Config* config,
                       int initial_encoder_max_bitrate,
                       std::map<uint32_t, RtpState> suspended_ssrcs,
-                      VideoEncoderConfig::ContentType content_type,
-                      const RtpKeepAliveConfig& keepalive_config);
+                      VideoEncoderConfig::ContentType content_type);
   ~VideoSendStreamImpl() override;
 
   // RegisterProcessThread register |module_process_thread| with those objects
   // that use it. Registration has to happen on the thread were
   // |module_process_thread| was created (libjingle's worker thread).
   // TODO(perkj): Replace the use of |module_process_thread| with a TaskQueue,
   // maybe |worker_queue|.
   void RegisterProcessThread(ProcessThread* module_process_thread);
   void DeRegisterProcessThread();
 
@@ skipping 110 matching lines @@
                    VideoStreamEncoder* video_stream_encoder,
                    ProcessThread* module_process_thread,
                    CallStats* call_stats,
                    RtpTransportControllerSendInterface* transport,
                    BitrateAllocator* bitrate_allocator,
                    SendDelayStats* send_delay_stats,
                    RtcEventLog* event_log,
                    const VideoSendStream::Config* config,
                    int initial_encoder_max_bitrate,
                    const std::map<uint32_t, RtpState>& suspended_ssrcs,
-                   VideoEncoderConfig::ContentType content_type,
-                   const RtpKeepAliveConfig& keepalive_config)
+                   VideoEncoderConfig::ContentType content_type)
       : send_stream_(send_stream),
         done_event_(done_event),
         stats_proxy_(stats_proxy),
         video_stream_encoder_(video_stream_encoder),
         call_stats_(call_stats),
         transport_(transport),
         bitrate_allocator_(bitrate_allocator),
         send_delay_stats_(send_delay_stats),
         event_log_(event_log),
         config_(config),
         initial_encoder_max_bitrate_(initial_encoder_max_bitrate),
         suspended_ssrcs_(suspended_ssrcs),
-        content_type_(content_type),
-        keepalive_config_(keepalive_config) {}
+        content_type_(content_type) {}
 
   ~ConstructionTask() override { done_event_->Set(); }
 
  private:
   bool Run() override {
     send_stream_->reset(new VideoSendStreamImpl(
         stats_proxy_, rtc::TaskQueue::Current(), call_stats_, transport_,
         bitrate_allocator_, send_delay_stats_, video_stream_encoder_,
         event_log_, config_, initial_encoder_max_bitrate_,
-        std::move(suspended_ssrcs_), content_type_, keepalive_config_));
+        std::move(suspended_ssrcs_), content_type_));
     return true;
   }
 
   std::unique_ptr<VideoSendStreamImpl>* const send_stream_;
   rtc::Event* const done_event_;
   SendStatisticsProxy* const stats_proxy_;
   VideoStreamEncoder* const video_stream_encoder_;
   CallStats* const call_stats_;
   RtpTransportControllerSendInterface* const transport_;
   BitrateAllocator* const bitrate_allocator_;
   SendDelayStats* const send_delay_stats_;
   RtcEventLog* const event_log_;
   const VideoSendStream::Config* config_;
   int initial_encoder_max_bitrate_;
   std::map<uint32_t, RtpState> suspended_ssrcs_;
   const VideoEncoderConfig::ContentType content_type_;
-  const RtpKeepAliveConfig& keepalive_config_;
 };
 
 class VideoSendStream::DestructAndGetRtpStateTask : public rtc::QueuedTask {
  public:
   DestructAndGetRtpStateTask(VideoSendStream::RtpStateMap* state_map,
                              std::unique_ptr<VideoSendStreamImpl> send_stream,
                              rtc::Event* done_event)
       : state_map_(state_map),
         send_stream_(std::move(send_stream)),
         done_event_(done_event) {}
@@ skipping 92 matching lines @@
     int num_cpu_cores,
     ProcessThread* module_process_thread,
     rtc::TaskQueue* worker_queue,
     CallStats* call_stats,
     RtpTransportControllerSendInterface* transport,
     BitrateAllocator* bitrate_allocator,
     SendDelayStats* send_delay_stats,
     RtcEventLog* event_log,
     VideoSendStream::Config config,
     VideoEncoderConfig encoder_config,
-    const std::map<uint32_t, RtpState>& suspended_ssrcs,
-    const RtpKeepAliveConfig& keepalive_config)
+    const std::map<uint32_t, RtpState>& suspended_ssrcs)
     : worker_queue_(worker_queue),
       thread_sync_event_(false /* manual_reset */, false),
       stats_proxy_(Clock::GetRealTimeClock(),
                    config,
                    encoder_config.content_type),
       config_(std::move(config)),
       content_type_(encoder_config.content_type) {
   video_stream_encoder_.reset(
       new VideoStreamEncoder(num_cpu_cores, &stats_proxy_,
                              config_.encoder_settings,
                              config_.pre_encode_callback,
                              config_.post_encode_callback,
                              std::unique_ptr<OveruseFrameDetector>()));
   worker_queue_->PostTask(std::unique_ptr<rtc::QueuedTask>(new ConstructionTask(
       &send_stream_, &thread_sync_event_, &stats_proxy_,
       video_stream_encoder_.get(), module_process_thread, call_stats, transport,
       bitrate_allocator, send_delay_stats, event_log, &config_,
       encoder_config.max_bitrate_bps, suspended_ssrcs,
-      encoder_config.content_type, keepalive_config)));
+      encoder_config.content_type)));
 
   // Wait for ConstructionTask to complete so that |send_stream_| can be used.
   // |module_process_thread| must be registered and deregistered on the thread
   // it was created on.
   thread_sync_event_.Wait(rtc::Event::kForever);
   send_stream_->RegisterProcessThread(module_process_thread);
   // TODO(sprang): Enable this also for regular video calls if it works well.
   if (encoder_config.content_type == VideoEncoderConfig::ContentType::kScreen) {
     // Only signal target bitrate for screenshare streams, for now.
     video_stream_encoder_->SetBitrateObserver(send_stream_.get());
@@ skipping 99 matching lines @@
     rtc::TaskQueue* worker_queue,
     CallStats* call_stats,
     RtpTransportControllerSendInterface* transport,
     BitrateAllocator* bitrate_allocator,
     SendDelayStats* send_delay_stats,
     VideoStreamEncoder* video_stream_encoder,
     RtcEventLog* event_log,
     const VideoSendStream::Config* config,
     int initial_encoder_max_bitrate,
     std::map<uint32_t, RtpState> suspended_ssrcs,
-    VideoEncoderConfig::ContentType content_type,
-    const RtpKeepAliveConfig& keepalive_config)
+    VideoEncoderConfig::ContentType content_type)
     : send_side_bwe_with_overhead_(
           webrtc::field_trial::IsEnabled("WebRTC-SendSideBwe-WithOverhead")),
       stats_proxy_(stats_proxy),
       config_(config),
       suspended_ssrcs_(std::move(suspended_ssrcs)),
       module_process_thread_(nullptr),
       worker_queue_(worker_queue),
       check_encoder_activity_task_(nullptr),
       call_stats_(call_stats),
       transport_(transport),
@@ skipping 17 matching lines @@
           bandwidth_observer_.get(),
           transport,
           call_stats_->rtcp_rtt_stats(),
           flexfec_sender_.get(),
           stats_proxy_,
           send_delay_stats,
           event_log,
           transport->send_side_cc()->GetRetransmissionRateLimiter(),
           this,
           config_->rtp.ssrcs.size(),
-          keepalive_config)),
+          transport->keepalive_config())),
       payload_router_(rtp_rtcp_modules_,
                       config_->encoder_settings.payload_type),
       weak_ptr_factory_(this),
       overhead_bytes_per_packet_(0),
       transport_overhead_bytes_per_packet_(0) {
   RTC_DCHECK_RUN_ON(worker_queue_);
   LOG(LS_INFO) << "VideoSendStreamInternal: " << config_->ToString();
   weak_ptr_ = weak_ptr_factory_.GetWeakPtr();
   module_process_thread_checker_.DetachFromThread();
 
@@ skipping 549 matching lines @@
       std::min(config_->rtp.max_packet_size,
                kPathMTU - transport_overhead_bytes_per_packet_);
 
   for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) {
     rtp_rtcp->SetMaxRtpPacketSize(rtp_packet_size);
   }
 }
 
 }  // namespace internal
 }  // namespace webrtc