Landing Recent QUIC changes until Sun Sep 4 03:41:00

net/quic/core/quic_sent_packet_manager_test.cc

 // Copyright 2013 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/core/quic_sent_packet_manager.h"
 
 #include <memory>
 #include "base/memory/ptr_util.h"
 #include "base/stl_util.h"
 #include "net/quic/core/quic_flags.h"
@@ skipping 546 matching lines @@
     ExpectAck(4);
     EXPECT_CALL(*loss_algorithm, DetectLosses(_, _, _, _, _));
     manager_.OnIncomingAck(ack_frame, clock_.Now());
     RetransmitAndSendPacket(3, 5, LOSS_RETRANSMISSION);
   }
 
   // Ack 3, which causes SpuriousRetransmitDetected to be called.
   {
     QuicAckFrame ack_frame = InitAckFrame(4);
     NackPackets(2, 3, &ack_frame);
-    EXPECT_CALL(*loss_algorithm, DetectLosses(_, _, _, _, _));
-    EXPECT_CALL(*loss_algorithm, SpuriousRetransmitDetected(_, _, _, 5));
-    manager_.OnIncomingAck(ack_frame, clock_.Now());
   }
 }
 
-TEST_P(QuicSentPacketManagerTest, AckPreviousTransmissionThenTruncatedAck) {
-  FLAGS_quic_loss_recovery_use_largest_acked = false;
-  if (!GetParam().missing) {
-    return;
-  }
-  SendDataPacket(1);
-  RetransmitAndSendPacket(1, 2);
-  RetransmitAndSendPacket(2, 3);
-  RetransmitAndSendPacket(3, 4);
-  SendDataPacket(5);
-  SendDataPacket(6);
-  SendDataPacket(7);
-  SendDataPacket(8);
-  SendDataPacket(9);
-
-  // Ack previous transmission
-  {
-    QuicAckFrame ack_frame = InitAckFrame(2);
-    NackPackets(1, 2, &ack_frame);
-    ExpectAck(2);
-    manager_.OnIncomingAck(ack_frame, clock_.Now());
-    EXPECT_TRUE(QuicSentPacketManagerPeer::IsUnacked(&manager_, 4));
-  }
-
-  // Truncated ack with 4 NACKs
-  {
-    QuicAckFrame ack_frame = InitAckFrame(6);
-    NackPackets(3, 7, &ack_frame);
-    ack_frame.is_truncated = true;
-    ExpectAckAndLoss(true, 1, 3);
-    manager_.OnIncomingAck(ack_frame, clock_.Now());
-  }
-
-  // High water mark will be raised.
-  QuicPacketNumber unacked[] = {4, 5, 6, 7, 8, 9};
-  VerifyUnackedPackets(unacked, arraysize(unacked));
-  QuicPacketNumber retransmittable[] = {5, 6, 7, 8, 9};
-  VerifyRetransmittablePackets(retransmittable, arraysize(retransmittable));
-}
-
 TEST_P(QuicSentPacketManagerTest, GetLeastUnacked) {
   EXPECT_EQ(1u, manager_.GetLeastUnacked(kDefaultPathId));
 }
 
 TEST_P(QuicSentPacketManagerTest, GetLeastUnackedUnacked) {
   SendDataPacket(1);
   EXPECT_EQ(1u, manager_.GetLeastUnacked(kDefaultPathId));
 }
 
 TEST_P(QuicSentPacketManagerTest, AckAckAndUpdateRtt) {
@@ skipping 916 matching lines @@
   options.push_back(kNRTO);
   QuicSentPacketManagerPeer::SetPerspective(&manager_, Perspective::IS_CLIENT);
   client_config.SetConnectionOptionsToSend(options);
   EXPECT_CALL(*network_change_visitor_, OnCongestionChange());
   EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _));
   manager_.SetFromConfig(client_config);
   EXPECT_TRUE(QuicSentPacketManagerPeer::GetUseNewRto(&manager_));
 }
 
 TEST_P(QuicSentPacketManagerTest, NegotiateUndoFromOptionsAtServer) {
-  FLAGS_quic_loss_recovery_use_largest_acked = true;
   EXPECT_FALSE(QuicSentPacketManagerPeer::GetUndoRetransmits(&manager_));
   QuicConfig config;
   QuicTagVector options;
 
   options.push_back(kUNDO);
   QuicConfigPeer::SetReceivedConnectionOptions(&config, options);
   EXPECT_CALL(*network_change_visitor_, OnCongestionChange());
   EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _));
   manager_.SetFromConfig(config);
   EXPECT_TRUE(QuicSentPacketManagerPeer::GetUndoRetransmits(&manager_));
@@ skipping 31 matching lines @@
   // Ack 1 and ensure the retransmissions are cancelled and put back in flight.
   EXPECT_CALL(*loss_algorithm, DetectLosses(_, _, _, _, _));
   ack_frame = InitAckFrame(5);
   NackPackets(2, kNumSentPackets, &ack_frame);
   manager_.OnIncomingAck(ack_frame, clock_.Now());
   EXPECT_FALSE(manager_.HasPendingRetransmissions());
   EXPECT_EQ(3u * kDefaultLength, BytesInFlight());
 }
 
 TEST_P(QuicSentPacketManagerTest, NegotiateUndoFromOptionsAtClient) {
-  FLAGS_quic_loss_recovery_use_largest_acked = true;
   EXPECT_FALSE(QuicSentPacketManagerPeer::GetUndoRetransmits(&manager_));
   QuicConfig client_config;
   QuicTagVector options;
 
   options.push_back(kUNDO);
   QuicSentPacketManagerPeer::SetPerspective(&manager_, Perspective::IS_CLIENT);
   client_config.SetConnectionOptionsToSend(options);
   EXPECT_CALL(*network_change_visitor_, OnCongestionChange());
   EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _));
   manager_.SetFromConfig(client_config);
@@ skipping 33 matching lines @@
   int64_t default_init_rtt = rtt_stats->initial_rtt_us();
   rtt_stats->set_initial_rtt_us(default_init_rtt * 2);
   EXPECT_EQ(2 * default_init_rtt, rtt_stats->initial_rtt_us());
 
   QuicSentPacketManagerPeer::SetConsecutiveRtoCount(&manager_, 1);
   EXPECT_EQ(1u, manager_.GetConsecutiveRtoCount());
   QuicSentPacketManagerPeer::SetConsecutiveTlpCount(&manager_, 2);
   EXPECT_EQ(2u, manager_.GetConsecutiveTlpCount());
 
   EXPECT_CALL(*send_algorithm_, OnConnectionMigration());
-  manager_.OnConnectionMigration(kDefaultPathId, UNSPECIFIED_CHANGE);
+  manager_.OnConnectionMigration(kDefaultPathId, IPV4_TO_IPV4_CHANGE);
 
   EXPECT_EQ(default_init_rtt, rtt_stats->initial_rtt_us());
   EXPECT_EQ(0u, manager_.GetConsecutiveRtoCount());
   EXPECT_EQ(0u, manager_.GetConsecutiveTlpCount());
 }
 
 TEST_P(QuicSentPacketManagerTest, ConnectionMigrationIPSubnetChange) {
   RttStats* rtt_stats = const_cast<RttStats*>(manager_.GetRttStats());
   int64_t default_init_rtt = rtt_stats->initial_rtt_us();
   rtt_stats->set_initial_rtt_us(default_init_rtt * 2);
@@ skipping 42 matching lines @@
   ExpectAck(1);
   EXPECT_CALL(*network_change_visitor_,
               OnPathMtuIncreased(kDefaultLength + 100));
   QuicAckFrame ack_frame = InitAckFrame(1);
   manager_.OnIncomingAck(ack_frame, clock_.Now());
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net