[Cast] RTT clean-up to the max!

media/cast/sender/video_sender.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "media/cast/sender/video_sender.h"
 
 #include <algorithm>
 #include <cstring>
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "media/cast/cast_defines.h"
 #include "media/cast/net/cast_transport_config.h"
 #include "media/cast/sender/external_video_encoder.h"
 #include "media/cast/sender/video_encoder_impl.h"
 
 namespace media {
 namespace cast {
 
+namespace {
+
 const int kNumAggressiveReportsSentAtStart = 100;
 
-namespace {
-
 // Returns a fixed bitrate value when external video encoder is used.
 // Some hardware encoder shows bad behavior if we set the bitrate too
 // frequently, e.g. quality drop, not abiding by target bitrate, etc.
 // See details: crbug.com/392086.
 size_t GetFixedBitrate(const VideoSenderConfig& video_config) {
   if (!video_config.use_external_encoder)
     return 0;
   return (video_config.min_bitrate + video_config.max_bitrate) / 2;
 }
 
@@ skipping 43 matching lines @@
   transport_config.feedback_ssrc = video_config.incoming_feedback_ssrc;
   transport_config.rtp_payload_type = video_config.rtp_payload_type;
   transport_config.stored_frames = max_unacked_frames_;
   transport_config.aes_key = video_config.aes_key;
   transport_config.aes_iv_mask = video_config.aes_iv_mask;
 
   transport_sender->InitializeVideo(
       transport_config,
       base::Bind(&VideoSender::OnReceivedCastFeedback,
                  weak_factory_.GetWeakPtr()),
-      base::Bind(&VideoSender::OnReceivedRtt, weak_factory_.GetWeakPtr()));
+      base::Bind(&VideoSender::OnMeasuredRoundTripTime,
+                 weak_factory_.GetWeakPtr()));
 }
 
 VideoSender::~VideoSender() {
 }
 
 void VideoSender::InsertRawVideoFrame(
     const scoped_refptr<media::VideoFrame>& video_frame,
     const base::TimeTicks& capture_time) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   if (cast_initialization_status_ != STATUS_VIDEO_INITIALIZED) {
@@ skipping 110 matching lines @@
   if (send_target_playout_delay_) {
     encoded_frame->new_playout_delay_ms =
         target_playout_delay_.InMilliseconds();
   }
   transport_sender_->InsertCodedVideoFrame(*encoded_frame);
 }
 
 void VideoSender::OnReceivedCastFeedback(const RtcpCastMessage& cast_feedback) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
 
-  base::TimeDelta rtt;
-  base::TimeDelta avg_rtt;
-  base::TimeDelta min_rtt;
-  base::TimeDelta max_rtt;
   if (is_rtt_available()) {
-    rtt = rtt_;
-    avg_rtt = avg_rtt_;
-    min_rtt = min_rtt_;
-    max_rtt = max_rtt_;
+    congestion_control_.UpdateRtt(current_round_trip_time());
 
-    congestion_control_.UpdateRtt(rtt);
-
-    // Don't use a RTT lower than our average.
-    rtt = std::max(rtt, avg_rtt);
-
-    // Having the RTT values implies the receiver sent back a receiver report
+    // Having the RTT value implies the receiver sent back a receiver report
     // based on it having received a report from here.  Therefore, ensure this
     // sender stops aggressively sending reports.
     if (num_aggressive_rtcp_reports_sent_ < kNumAggressiveReportsSentAtStart) {
       VLOG(1) << "No longer a need to send reports aggressively (sent "
               << num_aggressive_rtcp_reports_sent_ << ").";
       num_aggressive_rtcp_reports_sent_ = kNumAggressiveReportsSentAtStart;
       ScheduleNextRtcpReport();
     }
-  } else {
-    // We have no measured value use default.
-    rtt = base::TimeDelta::FromMilliseconds(kStartRttMs);
   }
 
   if (last_send_time_.is_null())
     return;  // Cannot get an ACK without having first sent a frame.
 
   if (cast_feedback.missing_frames_and_packets.empty()) {
     video_encoder_->LatestFrameIdToReference(cast_feedback.ack_frame_id);
 
     // We only count duplicate ACKs when we have sent newer frames.
     if (latest_acked_frame_id_ == cast_feedback.ack_frame_id &&
@@ skipping 62 matching lines @@
           << duration_in_flight.InMicroseconds() << " usec ("
           << (target_playout_delay_ > base::TimeDelta() ?
                   100 * duration_in_flight / target_playout_delay_ :
                   kint64max) << "%)";
   return frames_in_flight >= max_unacked_frames_ ||
       duration_in_flight >= target_playout_delay_;
 }
 
 }  // namespace cast
 }  // namespace media