[Cast] Track audio queued in encoder; account for it in ShouldDropNextFrame().

media/cast/sender/frame_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/frame_sender.h"
 
 #include "base/debug/trace_event.h"
 
 namespace media {
 namespace cast {
@@ skipping 11 matching lines @@
                          int rtp_timebase,
                          uint32 ssrc,
                          double max_frame_rate,
                          base::TimeDelta playout_delay,
                          CongestionControl* congestion_control)
     : cast_environment_(cast_environment),
       transport_sender_(transport_sender),
       ssrc_(ssrc),
       rtcp_interval_(rtcp_interval),
       max_frame_rate_(max_frame_rate),
-      frames_in_encoder_(0),
       num_aggressive_rtcp_reports_sent_(0),
       last_sent_frame_id_(0),
       latest_acked_frame_id_(0),
       duplicate_ack_counter_(0),
       rtp_timebase_(rtp_timebase),
       congestion_control_(congestion_control),
       is_audio_(is_audio),
       weak_factory_(this) {
   DCHECK(transport_sender_);
   DCHECK_GT(rtp_timebase_, 0);
@@ skipping 113 matching lines @@
 }
 
 base::TimeTicks FrameSender::GetRecordedReferenceTime(uint32 frame_id) const {
   return frame_reference_times_[frame_id % arraysize(frame_reference_times_)];
 }
 
 RtpTimestamp FrameSender::GetRecordedRtpTimestamp(uint32 frame_id) const {
   return frame_rtp_timestamps_[frame_id % arraysize(frame_rtp_timestamps_)];
 }
 
-
 void FrameSender::SendEncodedFrame(
     int requested_bitrate_before_encode,
     scoped_ptr<EncodedFrame> encoded_frame) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
 
-  DCHECK_GT(frames_in_encoder_, 0) << " is_audio: " << is_audio_;
-  frames_in_encoder_--;
-
   const uint32 frame_id = encoded_frame->frame_id;
 
   const bool is_first_frame_to_be_sent = last_send_time_.is_null();
   last_send_time_ = cast_environment_->Clock()->NowTicks();
   last_sent_frame_id_ = frame_id;
   // If this is the first frame about to be sent, fake the value of
   // |latest_acked_frame_id_| to indicate the receiver starts out all caught up.
   // Also, schedule the periodic frame re-send checks.
   if (is_first_frame_to_be_sent) {
     latest_acked_frame_id_ = frame_id - 1;
@@ skipping 123 matching lines @@
   base::TimeDelta duration_in_flight;
   if (!last_send_time_.is_null()) {
     frames_in_flight =
         static_cast<int32>(last_sent_frame_id_ - latest_acked_frame_id_);
     if (frames_in_flight > 0) {
       const uint32 oldest_unacked_frame_id = latest_acked_frame_id_ + 1;
       duration_in_flight =
           capture_time - GetRecordedReferenceTime(oldest_unacked_frame_id);
     }
   }
-  frames_in_flight += frames_in_encoder_;
+  frames_in_flight += GetNumberOfFramesInEncoder();
   VLOG(2) << frames_in_flight
           << " frames in flight; last sent: " << last_sent_frame_id_
           << "; latest acked: " << latest_acked_frame_id_
-          << "; frames in encoder: " << frames_in_encoder_
+          << "; frames in encoder: " << GetNumberOfFramesInEncoder()
           << "; duration in flight: "
           << 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