Update from https://crrev.com/311076

net/quic/quic_connection_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/quic_connection.h"
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/stl_util.h"
 #include "net/base/net_errors.h"
@@ skipping 1664 matching lines @@
   EXPECT_EQ(0u, connection_.NumQueuedPackets());
   BlockOnNextWrite();
   const string payload(payload_length, 'a');
   connection_.SendStreamDataWithStringWithFec(1, payload, 0, !kFin, nullptr);
   EXPECT_FALSE(creator->IsFecGroupOpen());
   EXPECT_FALSE(creator->IsFecProtected());
   // Expect the first data packet and the fec packet to be queued.
   EXPECT_EQ(2u, connection_.NumQueuedPackets());
 }
 
-TEST_P(QuicConnectionTest, AbandonFECFromCongestionWindow) {
+TEST_P(QuicConnectionTest, RemoveFECFromInflightOnRetransmissionTimeout) {
+  EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
   EXPECT_TRUE(QuicConnectionPeer::GetPacketCreator(
       &connection_)->IsFecEnabled());
+  QuicSentPacketManager* manager =
+      QuicConnectionPeer::GetSentPacketManager(&connection_);
+  EXPECT_EQ(0u, QuicSentPacketManagerPeer::GetBytesInFlight(manager));
 
   // 1 Data and 1 FEC packet.
   EXPECT_CALL(*send_algorithm_,
               OnPacketSent(_, _, _, _, HAS_RETRANSMITTABLE_DATA)).Times(2);
   connection_.SendStreamDataWithStringWithFec(3, "foo", 0, !kFin, nullptr);
+  size_t data_and_fec = QuicSentPacketManagerPeer::GetBytesInFlight(manager);
+  EXPECT_LT(0u, data_and_fec);
 
-  const QuicTime::Delta retransmission_time =
-      QuicTime::Delta::FromMilliseconds(5000);
-  clock_.AdvanceTime(retransmission_time);
+  clock_.AdvanceTime(DefaultRetransmissionTime());
 
-  // Abandon FEC packet and data packet.
+  // On RTO, both data and FEC packets are removed from inflight,
+  // and retransmission of the data (but not FEC) gets added into the inflight.
   EXPECT_CALL(*send_algorithm_, OnRetransmissionTimeout(true));
   EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(1);
-  EXPECT_CALL(visitor_, OnCanWrite());
-  connection_.OnRetransmissionTimeout();
+  connection_.GetRetransmissionAlarm()->Fire();
+  ;
+
+  size_t data_only = QuicSentPacketManagerPeer::GetBytesInFlight(manager);
+  EXPECT_LT(0u, data_only);
+  EXPECT_GE(data_and_fec, 2 * data_only);
+
+  // Receive ack for the retransmission. No data should be outstanding.
+  QuicAckFrame ack = InitAckFrame(3);
+  NackPacket(1, &ack);
+  NackPacket(2, &ack);
+  SequenceNumberSet lost_packets;
+  EXPECT_CALL(*loss_algorithm_, DetectLostPackets(_, _, _, _))
+      .WillOnce(Return(lost_packets));
+  EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _));
+  ProcessAckPacket(&ack);
+  EXPECT_EQ(0u, QuicSentPacketManagerPeer::GetBytesInFlight(manager));
+
+  // Ensure the alarm is not set since all packets have been acked or abandoned.
+  EXPECT_FALSE(connection_.GetRetransmissionAlarm()->IsSet());
+  EXPECT_EQ(0u, QuicSentPacketManagerPeer::GetBytesInFlight(manager));
 }
 
-TEST_P(QuicConnectionTest, DontAbandonAckedFEC) {
+TEST_P(QuicConnectionTest, RemoveFECFromInflightOnLossRetransmission) {
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
   EXPECT_TRUE(QuicConnectionPeer::GetPacketCreator(
       &connection_)->IsFecEnabled());
+  QuicSentPacketManager* manager =
+      QuicConnectionPeer::GetSentPacketManager(&connection_);
 
-  // 3 Data and 3 FEC packets.
+  // 1 Data packet and 1 FEC packet, followed by more data to trigger NACKs.
   EXPECT_CALL(*send_algorithm_,
               OnPacketSent(_, _, _, _, HAS_RETRANSMITTABLE_DATA)).Times(6);
   connection_.SendStreamDataWithStringWithFec(3, "foo", 0, !kFin, nullptr);
-  // Send some more data afterwards to ensure early retransmit doesn't trigger.
-  connection_.SendStreamDataWithStringWithFec(3, "foo", 3, !kFin, nullptr);
-  connection_.SendStreamDataWithStringWithFec(3, "foo", 6, !kFin, nullptr);
+  connection_.SendStreamDataWithString(3, "foo", 3, !kFin, nullptr);
+  connection_.SendStreamDataWithString(3, "foo", 6, !kFin, nullptr);
+  connection_.SendStreamDataWithString(3, "foo", 9, !kFin, nullptr);
+  connection_.SendStreamDataWithString(3, "foo", 12, !kFin, nullptr);
+  size_t multiple_data_and_fec =
+      QuicSentPacketManagerPeer::GetBytesInFlight(manager);
+  EXPECT_LT(0u, multiple_data_and_fec);
 
-  QuicAckFrame ack_fec = InitAckFrame(2);
-  // Data packet missing.
-  // TODO(ianswett): Note that this is not a sensible ack, since if the FEC was
-  // received, it would cause the covered packet to be acked as well.
-  NackPacket(1, &ack_fec);
+  // Ack data packets, and NACK 1 data packet and FEC packet. Triggers
+  // NACK-based loss detection of data and FEC packet, but only data is
+  // retransmitted and considered oustanding.
+  QuicAckFrame ack = InitAckFrame(6);
+  NackPacket(2, &ack);
+  NackPacket(3, &ack);
+  SequenceNumberSet lost_packets;
+  lost_packets.insert(2);
+  lost_packets.insert(3);
+  EXPECT_CALL(*loss_algorithm_, DetectLostPackets(_, _, _, _))
+      .WillOnce(Return(lost_packets));
   EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _));
-  ProcessAckPacket(&ack_fec);
-  clock_.AdvanceTime(DefaultRetransmissionTime());
+  EXPECT_CALL(*send_algorithm_,
+              OnPacketSent(_, _, _, _, HAS_RETRANSMITTABLE_DATA)).Times(1);
+  ProcessAckPacket(&ack);
+  size_t data_only = QuicSentPacketManagerPeer::GetBytesInFlight(manager);
+  EXPECT_GT(multiple_data_and_fec, data_only);
+  EXPECT_LT(0u, data_only);
 
-  // Don't abandon the acked FEC packet, but it will abandon 2 the subsequent
-  // FEC packets.
-  EXPECT_CALL(*send_algorithm_, OnRetransmissionTimeout(true));
-  EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(3);
-  connection_.GetRetransmissionAlarm()->Fire();
+  // Receive ack for the retransmission. No data should be outstanding.
+  QuicAckFrame ack2 = InitAckFrame(7);
+  NackPacket(2, &ack2);
+  NackPacket(3, &ack2);
+  SequenceNumberSet lost_packets2;
+  EXPECT_CALL(*loss_algorithm_, DetectLostPackets(_, _, _, _))
+      .WillOnce(Return(lost_packets2));
+  EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _));
+  ProcessAckPacket(&ack2);
+  EXPECT_EQ(0u, QuicSentPacketManagerPeer::GetBytesInFlight(manager));
 }
 
-TEST_P(QuicConnectionTest, AbandonAllFEC) {
+TEST_P(QuicConnectionTest, NoTLPForFECPacket) {
+  // Turn on TLP for this test.
+  QuicSentPacketManagerPeer::SetMaxTailLossProbes(
+      QuicConnectionPeer::GetSentPacketManager(&connection_), 1);
+
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
   EXPECT_TRUE(QuicConnectionPeer::GetPacketCreator(
       &connection_)->IsFecEnabled());
+  QuicSentPacketManager* manager =
+      QuicConnectionPeer::GetSentPacketManager(&connection_);
 
-  // 3 Data and 3 FEC packet.
+  // 1 Data packet and 1 FEC packet.
   EXPECT_CALL(*send_algorithm_,
-              OnPacketSent(_, _, _, _, HAS_RETRANSMITTABLE_DATA)).Times(6);
+              OnPacketSent(_, _, _, _, HAS_RETRANSMITTABLE_DATA)).Times(2);
   connection_.SendStreamDataWithStringWithFec(3, "foo", 0, !kFin, nullptr);
-  // Send some more data afterwards to ensure early retransmit doesn't trigger.
-  connection_.SendStreamDataWithStringWithFec(3, "foo", 3, !kFin, nullptr);
-  // Advance the time so not all the FEC packets are abandoned.
-  clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(1));
-  connection_.SendStreamDataWithStringWithFec(3, "foo", 6, !kFin, nullptr);
 
-  QuicAckFrame ack_fec = InitAckFrame(5);
-  // Ack all data packets, but no fec packets.
-  NackPacket(2, &ack_fec);
-  NackPacket(4, &ack_fec);
+  // Ack data packet, but not FEC packet.
+  QuicAckFrame ack = InitAckFrame(1);
+  EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _));
+  ProcessAckPacket(&ack);
 
-  // Lose the first FEC packet and ack the three data packets.
-  SequenceNumberSet lost_packets;
-  lost_packets.insert(2);
-  EXPECT_CALL(*loss_algorithm_, DetectLostPackets(_, _, _, _))
-      .WillOnce(Return(lost_packets));
-  EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _));
-  ProcessAckPacket(&ack_fec);
+  // No TLP alarm for FEC, so when retransmission alarm fires, it is an RTO.
+  EXPECT_TRUE(connection_.GetRetransmissionAlarm()->IsSet());
+  EXPECT_LT(0u, QuicSentPacketManagerPeer::GetBytesInFlight(manager));
+  QuicTime rto_time = connection_.GetRetransmissionAlarm()->deadline();
+  EXPECT_NE(QuicTime::Zero(), rto_time);
 
-  clock_.AdvanceTime(DefaultRetransmissionTime().Subtract(
-      QuicTime::Delta::FromMilliseconds(1)));
-
-  // Abandon all packets
+  // Simulate the retransmission alarm firing. FEC packet is no longer
+  // outstanding.
   EXPECT_CALL(*send_algorithm_, OnRetransmissionTimeout(false));
+  clock_.AdvanceTime(rto_time.Subtract(clock_.Now()));
   connection_.GetRetransmissionAlarm()->Fire();
-
-  // Ensure the alarm is not set since all packets have been abandoned.
   EXPECT_FALSE(connection_.GetRetransmissionAlarm()->IsSet());
+  EXPECT_EQ(0u, QuicSentPacketManagerPeer::GetBytesInFlight(manager));
 }
 
 TEST_P(QuicConnectionTest, FramePacking) {
   CongestionBlockWrites();
 
   // Send an ack and two stream frames in 1 packet by queueing them.
   connection_.SendAck();
   EXPECT_CALL(visitor_, OnCanWrite()).WillOnce(DoAll(
       IgnoreResult(InvokeWithoutArgs(&connection_,
                                      &TestConnection::SendStreamData3)),
@@ skipping 1238 matching lines @@
   // causing no connection close packet to be sent.
   ValueRestore<bool> old_flag(&FLAGS_quic_allow_silent_close, true);
   EXPECT_TRUE(connection_.connected());
   EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _, _));
   QuicConfig config;
 
   // Create a handshake message that also enables silent close.
   CryptoHandshakeMessage msg;
   string error_details;
   QuicConfig client_config;
-  client_config.SetInitialFlowControlWindowToSend(
-      kInitialSessionFlowControlWindowForTest);
   client_config.SetInitialStreamFlowControlWindowToSend(
       kInitialStreamFlowControlWindowForTest);
   client_config.SetInitialSessionFlowControlWindowToSend(
       kInitialSessionFlowControlWindowForTest);
   client_config.SetIdleConnectionStateLifetime(
       QuicTime::Delta::FromSeconds(kDefaultIdleTimeoutSecs),
       QuicTime::Delta::FromSeconds(kDefaultIdleTimeoutSecs));
   client_config.ToHandshakeMessage(&msg);
   const QuicErrorCode error =
       config.ProcessPeerHello(msg, CLIENT, &error_details);
@@ skipping 1257 matching lines @@
   // Regression test for b/18594622
   scoped_refptr<MockAckNotifierDelegate> delegate(new MockAckNotifierDelegate);
   EXPECT_DFATAL(
       connection_.SendStreamDataWithString(3, "", 0, !kFin, delegate.get()),
       "Attempt to send empty stream frame");
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net