1 files changed, 21 insertions, 65 deletions

diff --git a/chromium/net/quic/congestion_control/fix_rate_sender.cc b/chromium/net/quic/congestion_control/fix_rate_sender.cc
index 8280f1eeb31..c346a63d6ff 100644
--- a/chromium/net/quic/congestion_control/fix_rate_sender.cc
+++ b/chromium/net/quic/congestion_control/fix_rate_sender.cc
@@ -9,8 +9,11 @@
 #include <algorithm>
 
 #include "base/logging.h"
+#include "net/quic/congestion_control/rtt_stats.h"
 #include "net/quic/quic_protocol.h"
 
+using std::max;
+
 namespace {
   const int kInitialBitrate = 100000;  // In bytes per second.
   const uint64 kWindowSizeUs = 10000;  // 10 ms.
@@ -18,12 +21,11 @@ namespace {
 
 namespace net {
 
-FixRateSender::FixRateSender(const QuicClock* clock)
-    : bitrate_(QuicBandwidth::FromBytesPerSecond(kInitialBitrate)),
+FixRateSender::FixRateSender(const RttStats* rtt_stats)
+    : rtt_stats_(rtt_stats),
+      bitrate_(QuicBandwidth::FromBytesPerSecond(kInitialBitrate)),
       max_segment_size_(kDefaultMaxPacketSize),
       fix_rate_leaky_bucket_(bitrate_),
-      paced_sender_(bitrate_, max_segment_size_),
-      data_in_flight_(0),
       latest_rtt_(QuicTime::Delta::Zero()) {
   DVLOG(1) << "FixRateSender";
 }
@@ -34,101 +36,55 @@ FixRateSender::~FixRateSender() {
 void FixRateSender::SetFromConfig(const QuicConfig& config, bool is_server) {
 }
 
-void FixRateSender::SetMaxPacketSize(QuicByteCount max_packet_size) {
-  max_segment_size_ = max_packet_size;
-  paced_sender_.set_max_segment_size(max_segment_size_);
-}
-
 void FixRateSender::OnIncomingQuicCongestionFeedbackFrame(
     const QuicCongestionFeedbackFrame& feedback,
-    QuicTime feedback_receive_time,
-    const SentPacketsMap& /*sent_packets*/) {
-  if (feedback.type != kFixRate) {
-    LOG(DFATAL) << "Invalid incoming CongestionFeedbackType:" << feedback.type;
-  }
+    QuicTime feedback_receive_time) {
+  LOG_IF(DFATAL, feedback.type != kFixRate) <<
+      "Invalid incoming CongestionFeedbackType:" << feedback.type;
   if (feedback.type == kFixRate) {
     bitrate_ = feedback.fix_rate.bitrate;
     fix_rate_leaky_bucket_.SetDrainingRate(feedback_receive_time, bitrate_);
-    paced_sender_.UpdateBandwidthEstimate(feedback_receive_time, bitrate_);
   }
   // Silently ignore invalid messages in release mode.
 }
 
-void FixRateSender::OnPacketAcked(
-    QuicPacketSequenceNumber /*acked_sequence_number*/,
-    QuicByteCount bytes_acked,
-    QuicTime::Delta rtt) {
-  // RTT can't be negative.
-  DCHECK_LE(0, rtt.ToMicroseconds());
-
-  data_in_flight_ -= bytes_acked;
-  if (rtt.IsInfinite()) {
-    return;
-  }
-  latest_rtt_ = rtt;
-}
-
-void FixRateSender::OnPacketLost(QuicPacketSequenceNumber /*sequence_number*/,
-                                 QuicTime /*ack_receive_time*/) {
-  // Ignore losses for fix rate sender.
+void FixRateSender::OnCongestionEvent(bool rtt_updated,
+                                      QuicByteCount bytes_in_flight,
+                                      const CongestionMap& acked_packets,
+                                      const CongestionMap& lost_packets) {
 }
 
 bool FixRateSender::OnPacketSent(
     QuicTime sent_time,
+    QuicByteCount /*bytes_in_flight*/,
     QuicPacketSequenceNumber /*sequence_number*/,
     QuicByteCount bytes,
-    TransmissionType transmission_type,
     HasRetransmittableData /*has_retransmittable_data*/) {
   fix_rate_leaky_bucket_.Add(sent_time, bytes);
-  paced_sender_.OnPacketSent(sent_time, bytes);
-  if (transmission_type == NOT_RETRANSMISSION) {
-    data_in_flight_ += bytes;
-  }
+
   return true;
 }
 
-void FixRateSender::OnRetransmissionTimeout() { }
-
-void FixRateSender::OnPacketAbandoned(
-    QuicPacketSequenceNumber /*sequence_number*/,
-    QuicByteCount /*abandoned_bytes*/) {
-}
+void FixRateSender::OnRetransmissionTimeout(bool packets_retransmitted) { }
 
 QuicTime::Delta FixRateSender::TimeUntilSend(
     QuicTime now,
-    TransmissionType /* transmission_type */,
-    HasRetransmittableData /*has_retransmittable_data*/,
-    IsHandshake /*handshake*/) {
-  if (CongestionWindow() > fix_rate_leaky_bucket_.BytesPending(now)) {
-    if (CongestionWindow() <= data_in_flight_) {
-      // We need an ack before we send more.
-      return QuicTime::Delta::Infinite();
-    }
-    return paced_sender_.TimeUntilSend(now, QuicTime::Delta::Zero());
-  }
-  QuicTime::Delta time_remaining = fix_rate_leaky_bucket_.TimeRemaining(now);
-  if (time_remaining.IsZero()) {
-    // We need an ack before we send more.
-    return QuicTime::Delta::Infinite();
-  }
-  return paced_sender_.TimeUntilSend(now, time_remaining);
+    QuicByteCount /*bytes_in_flight*/,
+    HasRetransmittableData /*has_retransmittable_data*/) const {
+  return fix_rate_leaky_bucket_.TimeRemaining(now);
 }
 
-QuicByteCount FixRateSender::CongestionWindow() {
+QuicByteCount FixRateSender::CongestionWindow() const {
   QuicByteCount window_size_bytes = bitrate_.ToBytesPerPeriod(
       QuicTime::Delta::FromMicroseconds(kWindowSizeUs));
   // Make sure window size is not less than a packet.
-  return std::max(kDefaultMaxPacketSize, window_size_bytes);
+  return max(kDefaultMaxPacketSize, window_size_bytes);
 }
 
 QuicBandwidth FixRateSender::BandwidthEstimate() const {
   return bitrate_;
 }
 
-QuicTime::Delta FixRateSender::SmoothedRtt() const {
-  // TODO(satyamshekhar): Calculate and return smoothed rtt.
-  return latest_rtt_;
-}
 
 QuicTime::Delta FixRateSender::RetransmissionDelay() const {
   // TODO(pwestin): Calculate and return retransmission delay.