Ignore the peer's receive buffer in QUIC and instead set the max CWND to 2000 packets. Protected b…

net/quic/congestion_control/tcp_cubic_sender_packets_test.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_packets.h"
 
 #include <algorithm>
 #include <memory>
 
 #include "base/logging.h"
@@ skipping 29 matching lines @@
                             QuicPacketCount max_tcp_congestion_window)
       : TcpCubicSenderPackets(clock,
                               &rtt_stats_,
                               reno,
                               kInitialCongestionWindowPackets,
                               max_tcp_congestion_window,
                               &stats_) {}
 
   QuicPacketCount congestion_window() { return congestion_window_; }
 
+  QuicPacketCount max_congestion_window() { return max_tcp_congestion_window_; }
+
   QuicPacketCount slowstart_threshold() { return slowstart_threshold_; }
 
   const HybridSlowStart& hybrid_slow_start() const {
     return hybrid_slow_start_;
   }
 
   float GetRenoBeta() const { return RenoBeta(); }
 
   RttStats rtt_stats_;
   QuicConnectionStats stats_;
@@ skipping 894 matching lines @@
   EXPECT_EQ(expected_send_window / kDefaultTCPMSS,
             sender_->slowstart_threshold());
 
   // Resets cwnd and slow start threshold on connection migrations.
   sender_->OnConnectionMigration();
   EXPECT_EQ(kDefaultWindowTCP, sender_->GetCongestionWindow());
   EXPECT_EQ(kMaxCongestionWindowPackets, sender_->slowstart_threshold());
   EXPECT_FALSE(sender_->hybrid_slow_start().started());
 }
 
+TEST_F(TcpCubicSenderPacketsTest, DefaultMaxCwnd) {
+  ValueRestore<bool> old_flag(&FLAGS_quic_ignore_srbf, true);
+  RttStats rtt_stats;
+  QuicConnectionStats stats;
+  std::unique_ptr<SendAlgorithmInterface> sender(SendAlgorithmInterface::Create(
+      &clock_, &rtt_stats, kCubic, &stats, kInitialCongestionWindow));
+
+  SendAlgorithmInterface::CongestionVector acked_packets;
+  SendAlgorithmInterface::CongestionVector missing_packets;
+  for (uint64_t i = 1; i < kDefaultMaxCongestionWindowPackets; ++i) {
+    acked_packets.clear();
+    acked_packets.push_back(std::make_pair(i, 1350));
+    sender->OnCongestionEvent(true, sender->GetCongestionWindow(),
+                              acked_packets, missing_packets);
+  }
+  EXPECT_EQ(kDefaultMaxCongestionWindowPackets,
+            sender->GetCongestionWindow() / kDefaultTCPMSS);
+}
+
 }  // namespace test
 }  // namespace net