Deprecate FLAGS_quic_track_single_retransmission.

net/quic/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/quic_sent_packet_manager.h"
 
 #include "base/stl_util.h"
 #include "net/quic/quic_flags.h"
 #include "net/quic/test_tools/quic_config_peer.h"
 #include "net/quic/test_tools/quic_sent_packet_manager_peer.h"
@@ skipping 941 matching lines @@
   EXPECT_EQ(7u, manager_.NextPendingRetransmission().packet_number);
   RetransmitNextPacket(9);
 
   EXPECT_TRUE(manager_.HasPendingRetransmissions());
   // Send 3 more data packets and ensure the least unacked is raised.
   RetransmitNextPacket(10);
   RetransmitNextPacket(11);
   RetransmitNextPacket(12);
   EXPECT_FALSE(manager_.HasPendingRetransmissions());
 
-  if (!FLAGS_quic_track_single_retransmission) {
-    EXPECT_EQ(8u, manager_.GetLeastUnacked());
-    return;
-  }
   EXPECT_EQ(1u, manager_.GetLeastUnacked());
   // Least unacked isn't raised until an ack is received, so ack the
   // crypto packets.
   QuicPacketNumber acked[] = {8, 9};
   ExpectAcksAndLosses(true, acked, arraysize(acked), nullptr, 0);
   QuicAckFrame ack_frame;
   ack_frame.largest_observed = 9;
   for (QuicPacketNumber i = 1; i < 8; ++i) {
     ack_frame.missing_packets.Add(i);
   }
@@ skipping 424 matching lines @@
   QuicSentPacketManagerPeer::SetLossAlgorithm(&manager_, loss_algorithm);
 
   EXPECT_CALL(*loss_algorithm, GetLossTimeout())
       .WillRepeatedly(Return(QuicTime::Zero()));
   SendDataPacket(1);
   SendDataPacket(2);
 
   // Handle an ack which causes the loss algorithm to be evaluated and
   // set the loss timeout.
   ExpectAck(2);
-  if (FLAGS_quic_general_loss_algorithm) {
-    EXPECT_CALL(*loss_algorithm, DetectLosses(_, _, _, _));
-  } else {
-    EXPECT_CALL(*loss_algorithm, DetectLostPackets(_, _, _, _))
-        .WillOnce(Return(PacketNumberSet()));
-  }
+  EXPECT_CALL(*loss_algorithm, DetectLosses(_, _, _, _));
   QuicAckFrame ack_frame;
   ack_frame.largest_observed = 2;
   ack_frame.missing_packets.Add(1);
   manager_.OnIncomingAck(ack_frame, clock_.Now());
 
   QuicTime timeout(clock_.Now().Add(QuicTime::Delta::FromMilliseconds(10)));
   EXPECT_CALL(*loss_algorithm, GetLossTimeout())
       .WillRepeatedly(Return(timeout));
   EXPECT_EQ(timeout, manager_.GetRetransmissionTime());
 
   // Fire the retransmission timeout and ensure the loss detection algorithm
   // is invoked.
-  if (FLAGS_quic_general_loss_algorithm) {
-    EXPECT_CALL(*loss_algorithm, DetectLosses(_, _, _, _));
-  } else {
-    EXPECT_CALL(*loss_algorithm, DetectLostPackets(_, _, _, _))
-        .WillOnce(Return(PacketNumberSet()));
-  }
+  EXPECT_CALL(*loss_algorithm, DetectLosses(_, _, _, _));
   manager_.OnRetransmissionTimeout();
 }
 
 TEST_F(QuicSentPacketManagerTest, NegotiateTimeLossDetectionFromOptions) {
   EXPECT_EQ(kNack, QuicSentPacketManagerPeer::GetLossAlgorithm(&manager_)
                        ->GetLossDetectionType());
 
   QuicConfig config;
   QuicTagVector options;
   options.push_back(kTIME);
@@ skipping 266 matching lines @@
 
   EXPECT_CALL(*send_algorithm_, ResumeConnectionState(_, false));
   manager_.ResumeConnectionState(cached_network_params, false);
   EXPECT_EQ(kRttMs * kNumMicrosPerMilli,
             static_cast<uint64_t>(manager_.GetRttStats()->initial_rtt_us()));
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net