Default socket receive buffer to 256K bytes and remove unnecessary

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"
 #include "net/quic/crypto/crypto_protocol.h"
 
 using std::max;
 using std::min;
 
 namespace net {
 
 namespace {
 // Constants based on TCP defaults.
 // The minimum cwnd based on RFC 3782 (TCP NewReno) for cwnd reductions on a
 // fast retransmission.  The cwnd after a timeout is still 1.
 const QuicTcpCongestionWindow kMinimumCongestionWindow = 2;
 const QuicByteCount kMaxSegmentSize = kDefaultTCPMSS;
-const QuicByteCount kDefaultReceiveWindow = 64000;
 const int64 kInitialCongestionWindow = 10;
 const int kMaxBurstLength = 3;
 };  // namespace
 
 TcpCubicSender::TcpCubicSender(
     const QuicClock* clock,
     const RttStats* rtt_stats,
     bool reno,
     QuicTcpCongestionWindow max_tcp_congestion_window,
     QuicConnectionStats* stats)
     : hybrid_slow_start_(clock),
       cubic_(clock, stats),
       rtt_stats_(rtt_stats),
       stats_(stats),
       reno_(reno),
       congestion_window_count_(0),
-      receive_window_(kDefaultReceiveWindow),
+      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::OnIncomingQuicCongestionFeedbackFrame(
     const QuicCongestionFeedbackFrame& feedback,
     QuicTime feedback_receive_time) {
   if (feedback.type == kTCP) {
     receive_window_ = feedback.tcp.receive_window;
   }
 }
 
@@ skipping 269 matching lines @@
     return QuicTime::Delta::Zero();
   }
   return QuicTime::Delta::Infinite();
 }
 
 CongestionControlType TcpCubicSender::GetCongestionControlType() const {
   return reno_ ? kReno : kCubic;
 }
 
 }  // namespace net