Fix the video buffer size should take rtt into consideration

webrtc/video/video_receive_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.
  */
 
@@ skipping 249 matching lines @@
 void VideoReceiveStream::Start() {
   RTC_DCHECK_RUN_ON(&worker_thread_checker_);
   if (decode_thread_.IsRunning())
     return;
 
   bool protected_by_fec = config_.rtp.protected_by_flexfec ||
                           rtp_video_stream_receiver_.IsUlpfecEnabled();
 
   frame_buffer_->Start();
   call_stats_->RegisterStatsObserver(&rtp_video_stream_receiver_);
+  call_stats_->RegisterStatsObserver(this);
 
   if (rtp_video_stream_receiver_.IsRetransmissionsEnabled() &&
       protected_by_fec) {
     frame_buffer_->SetProtectionMode(kProtectionNackFEC);
   }
 
   transport_adapter_.Enable();
   rtc::VideoSinkInterface<VideoFrame>* renderer = nullptr;
   if (config_.renderer) {
     if (config_.disable_prerenderer_smoothing) {
@@ skipping 29 matching lines @@
   // Start the decode thread
   decode_thread_.Start();
   rtp_video_stream_receiver_.StartReceive();
 }
 
 void VideoReceiveStream::Stop() {
   RTC_DCHECK_RUN_ON(&worker_thread_checker_);
   rtp_video_stream_receiver_.StopReceive();
 
   frame_buffer_->Stop();
+  call_stats_->DeregisterStatsObserver(this);
   call_stats_->DeregisterStatsObserver(&rtp_video_stream_receiver_);
   process_thread_->DeRegisterModule(&video_receiver_);
 
   if (decode_thread_.IsRunning()) {
     // TriggerDecoderShutdown will release any waiting decoder thread and make
     // it stop immediately, instead of waiting for a timeout. Needs to be called
     // before joining the decoder thread.
     video_receiver_.TriggerDecoderShutdown();
 
     decode_thread_.Stop();
@@ skipping 98 matching lines @@
   rtp_video_stream_receiver_.RequestKeyFrame();
 }
 
 void VideoReceiveStream::OnCompleteFrame(
     std::unique_ptr<video_coding::FrameObject> frame) {
   int last_continuous_pid = frame_buffer_->InsertFrame(std::move(frame));
   if (last_continuous_pid != -1)
     rtp_video_stream_receiver_.FrameContinuous(last_continuous_pid);
 }
 
+void VideoReceiveStream::OnRttUpdate(int64_t avg_rtt_ms, int64_t max_rtt_ms) {
+  frame_buffer_->UpdateRtt(max_rtt_ms);
+}
+
 int VideoReceiveStream::id() const {
   RTC_DCHECK_RUN_ON(&worker_thread_checker_);
   return config_.rtp.remote_ssrc;
 }
 
 rtc::Optional<Syncable::Info> VideoReceiveStream::GetInfo() const {
   RTC_DCHECK_RUN_ON(&module_process_thread_checker_);
   Syncable::Info info;
 
   RtpReceiver* rtp_receiver = rtp_video_stream_receiver_.GetRtpReceiver();
@@ skipping 70 matching lines @@
     if (stream_is_active && !receiving_keyframe) {
       LOG(LS_WARNING) << "No decodable frame in " << kMaxWaitForFrameMs
                       << " ms, requesting keyframe.";
       RequestKeyFrame();
     }
   }
   return true;
 }
 }  // namespace internal
 }  // namespace webrtc