Move receive_window_ from BbrTcpSender and TcpCubicSender to

net/quic/congestion_control/tcp_cubic_sender.cc

 // Copyright (c) 2012 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 "net/quic/congestion_control/tcp_cubic_sender.h"
 
 #include <algorithm>
 
 #include "base/metrics/histogram.h"
 #include "net/quic/congestion_control/rtt_stats.h"
@@ skipping 20 matching lines @@
     bool reno,
     QuicPacketCount max_tcp_congestion_window,
     QuicConnectionStats* stats)
     : hybrid_slow_start_(clock),
       cubic_(clock, stats),
       rtt_stats_(rtt_stats),
       stats_(stats),
       reno_(reno),
       num_connections_(2),
       congestion_window_count_(0),
-      receive_window_(kDefaultSocketReceiveBuffer),
       prr_out_(0),
       prr_delivered_(0),
       ack_count_since_loss_(0),
       bytes_in_flight_before_loss_(0),
       largest_sent_sequence_number_(0),
       largest_acked_sequence_number_(0),
       largest_sent_at_last_cutback_(0),
       congestion_window_(kInitialCongestionWindow),
       previous_congestion_window_(0),
       slowstart_threshold_(max_tcp_congestion_window),
@@ skipping 13 matching lines @@
       // Initial window experiment.  Ignore the initial congestion
       // window suggested by the client and use the default ICWND of
       // 10 instead.
       congestion_window_ = kInitialCongestionWindow;
     } else if (config.HasReceivedInitialCongestionWindow()) {
       // Set the initial window size.
       congestion_window_ = min(kMaxInitialWindow,
                                config.ReceivedInitialCongestionWindow());
     }
   }
-  if (config.HasReceivedSocketReceiveBuffer()) {
-    // Set the initial socket receive buffer size in bytes.
-    receive_window_ = config.ReceivedSocketReceiveBuffer();
-  }
 }
 
 void TcpCubicSender::SetNumEmulatedConnections(int num_connections) {
   num_connections_ = max(1, num_connections);
   cubic_.SetNumConnections(num_connections_);
 }
 
-void TcpCubicSender::OnIncomingQuicCongestionFeedbackFrame(
-    const QuicCongestionFeedbackFrame& feedback,
-    QuicTime feedback_receive_time) {
-  if (feedback.type == kTCP) {
-    receive_window_ = feedback.tcp.receive_window;
-  }
-}
-
 void TcpCubicSender::OnCongestionEvent(
     bool rtt_updated,
     QuicByteCount bytes_in_flight,
     const CongestionVector& acked_packets,
     const CongestionVector& lost_packets) {
   if (rtt_updated && InSlowStart() &&
       hybrid_slow_start_.ShouldExitSlowStart(rtt_stats_->latest_rtt(),
                                              rtt_stats_->MinRtt(),
                                              congestion_window_)) {
     slowstart_threshold_ = congestion_window_;
@@ skipping 82 matching lines @@
     QuicTime /* now */,
     QuicByteCount bytes_in_flight,
     HasRetransmittableData has_retransmittable_data) const {
   if (has_retransmittable_data == NO_RETRANSMITTABLE_DATA) {
     // For TCP we can always send an ACK immediately.
     return QuicTime::Delta::Zero();
   }
   if (InRecovery()) {
     return PrrTimeUntilSend(bytes_in_flight);
   }
-  if (SendWindow() > bytes_in_flight) {
+  if (GetCongestionWindow() > bytes_in_flight) {
     return QuicTime::Delta::Zero();
   }
   return QuicTime::Delta::Infinite();
 }
 
-QuicByteCount TcpCubicSender::SendWindow() const {
-  // What's the current send window in bytes.
-  return min(receive_window_, GetCongestionWindow());
-}
-
 QuicBandwidth TcpCubicSender::PacingRate() const {
   // We pace at twice the rate of the underlying sender's bandwidth estimate
   // during slow start and 1.25x during congestion avoidance to ensure pacing
   // doesn't prevent us from filling the window.
   return BandwidthEstimate().Scale(InSlowStart() ? 2 : 1.25);
 }
 
 QuicBandwidth TcpCubicSender::BandwidthEstimate() const {
   if (rtt_stats_->SmoothedRtt().IsZero()) {
     LOG(DFATAL) << "In BandwidthEstimate(), smoothed RTT is zero!";
@@ skipping 128 matching lines @@
   ++ack_count_since_loss_;
 }
 
 QuicTime::Delta TcpCubicSender::PrrTimeUntilSend(
     QuicByteCount bytes_in_flight) const {
   DCHECK(InRecovery());
   // Return QuicTime::Zero In order to ensure limited transmit always works.
   if (prr_out_ == 0 || bytes_in_flight < kMaxSegmentSize) {
     return QuicTime::Delta::Zero();
   }
-  if (SendWindow() > bytes_in_flight) {
+  if (GetCongestionWindow() > bytes_in_flight) {
     // During PRR-SSRB, limit outgoing packets to 1 extra MSS per ack, instead
     // of sending the entire available window. This prevents burst retransmits
     // when more packets are lost than the CWND reduction.
     //   limit = MAX(prr_delivered - prr_out, DeliveredData) + MSS
     if (prr_delivered_ + ack_count_since_loss_ * kMaxSegmentSize <= prr_out_) {
       return QuicTime::Delta::Infinite();
     }
     return QuicTime::Delta::Zero();
   }
   // Implement Proportional Rate Reduction (RFC6937)
   // Checks a simplified version of the PRR formula that doesn't use division:
   // AvailableSendWindow =
   //   CEIL(prr_delivered * ssthresh / BytesInFlightAtLoss) - prr_sent
   if (prr_delivered_ * slowstart_threshold_ * kMaxSegmentSize >
           prr_out_ * bytes_in_flight_before_loss_) {
     return QuicTime::Delta::Zero();
   }
   return QuicTime::Delta::Infinite();
 }
 
 CongestionControlType TcpCubicSender::GetCongestionControlType() const {
   return reno_ ? kReno : kCubic;
 }
 
 }  // namespace net