Land Recent QUIC Changes.

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),
       previous_slowstart_threshold_(0),
       last_cutback_exited_slowstart_(false),
       max_tcp_congestion_window_(max_tcp_congestion_window) {
 }
 
 TcpCubicSender::~TcpCubicSender() {
   UMA_HISTOGRAM_COUNTS("Net.QuicSession.FinalTcpCwnd", congestion_window_);
 }
 
 void TcpCubicSender::SetFromConfig(const QuicConfig& config, bool is_server) {
-  if (is_server && config.HasReceivedInitialCongestionWindow()) {
-    // Set the initial window size.
-    congestion_window_ = min(kMaxInitialWindow,
-                             config.ReceivedInitialCongestionWindow());
+  if (is_server) {
+    if (config.HasReceivedConnectionOptions() &&
+        ContainsQuicTag(config.ReceivedConnectionOptions(), kIW10)) {
+      // 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) {
-  receive_window_ = feedback.tcp.receive_window;
+  if (feedback.type == kTCP) {
+    receive_window_ = feedback.tcp.receive_window;
+  }
 }
 
 void TcpCubicSender::OnCongestionEvent(
     bool rtt_updated,
     QuicByteCount bytes_in_flight,
     const CongestionMap& acked_packets,
     const CongestionMap& lost_packets) {
   if (rtt_updated && InSlowStart() &&
       hybrid_slow_start_.ShouldExitSlowStart(rtt_stats_->latest_rtt(),
                                              rtt_stats_->min_rtt(),
@@ skipping 261 matching lines @@
     return QuicTime::Delta::Zero();
   }
   return QuicTime::Delta::Infinite();
 }
 
 CongestionControlType TcpCubicSender::GetCongestionControlType() const {
   return reno_ ? kReno : kCubic;
 }
 
 }  // namespace net