Deprecate FLAGS_quic_loss_recovery_use_largest_acked.

net/quic/core/quic_sent_packet_manager.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 <algorithm>
 #include <string>
 
 #include "base/logging.h"
@@ skipping 130 matching lines @@
     use_new_rto_ = true;
   }
   if (config.HasReceivedConnectionOptions() &&
       ContainsQuicTag(config.ReceivedConnectionOptions(), kTIME)) {
     general_loss_algorithm_.SetLossDetectionType(kTime);
   }
   if (config.HasReceivedConnectionOptions() &&
       ContainsQuicTag(config.ReceivedConnectionOptions(), kATIM)) {
     general_loss_algorithm_.SetLossDetectionType(kAdaptiveTime);
   }
-  if (FLAGS_quic_loss_recovery_use_largest_acked &&
-      config.HasClientSentConnectionOption(kUNDO, perspective_)) {
+  if (config.HasClientSentConnectionOption(kUNDO, perspective_)) {
     undo_pending_retransmits_ = true;
   }
   send_algorithm_->SetFromConfig(config, perspective_);
 
   if (network_change_visitor_ != nullptr) {
     network_change_visitor_->OnCongestionChange();
   }
 }
 
 void QuicSentPacketManager::ResumeConnectionState(
@@ skipping 135 matching lines @@
         (!ack_frame.missing && !ack_frame.packets.Contains(packet_number))) {
       // Packet is still missing.
       continue;
     }
     // Packet was acked, so remove it from our unacked packet list.
     DVLOG(1) << ENDPOINT << "Got an ack for packet " << packet_number;
     // If data is associated with the most recent transmission of this
     // packet, then inform the caller.
     if (it->in_flight) {
       packets_acked_.push_back(std::make_pair(packet_number, it->bytes_sent));
-    } else if (FLAGS_quic_loss_recovery_use_largest_acked &&
-               !it->is_unackable) {
+    } else if (!it->is_unackable) {
+      // Packets are marked unackable after they've been acked once.
       largest_newly_acked_ = packet_number;
     }
     MarkPacketHandled(packet_number, &(*it), ack_delay_time);
   }
 }
 
 void QuicSentPacketManager::RetransmitUnackedPackets(
     TransmissionType retransmission_type) {
   DCHECK(retransmission_type == ALL_UNACKED_RETRANSMISSION ||
          retransmission_type == ALL_INITIAL_RETRANSMISSION);
@@ skipping 187 matching lines @@
     }
   }
 
   if (network_change_visitor_ != nullptr &&
       info->bytes_sent > largest_mtu_acked_) {
     largest_mtu_acked_ = info->bytes_sent;
     network_change_visitor_->OnPathMtuIncreased(largest_mtu_acked_);
   }
   unacked_packets_.RemoveFromInFlight(info);
   unacked_packets_.RemoveRetransmittability(info);
-  if (FLAGS_quic_loss_recovery_use_largest_acked) {
-    info->is_unackable = true;
-  }
+  info->is_unackable = true;
 }
 
 bool QuicSentPacketManager::HasUnackedPackets() const {
   return unacked_packets_.HasUnackedPackets();
 }
 
 QuicPacketNumber QuicSentPacketManager::GetLeastUnacked(QuicPathId) const {
   return unacked_packets_.GetLeastUnacked();
 }
 
@@ skipping 162 matching lines @@
   }
   if (consecutive_tlp_count_ < max_tail_loss_probes_) {
     if (unacked_packets_.HasUnackedRetransmittableFrames()) {
       return TLP_MODE;
     }
   }
   return RTO_MODE;
 }
 
 void QuicSentPacketManager::InvokeLossDetection(QuicTime time) {
-  if (FLAGS_quic_loss_recovery_use_largest_acked && !packets_acked_.empty()) {
+  if (!packets_acked_.empty()) {
     DCHECK_LE(packets_acked_.front().first, packets_acked_.back().first);
     largest_newly_acked_ = packets_acked_.back().first;
   }
   loss_algorithm_->DetectLosses(unacked_packets_, time, rtt_stats_,
                                 largest_newly_acked_, &packets_lost_);
   for (const auto& pair : packets_lost_) {
     ++stats_->packets_lost;
     if (debug_delegate_ != nullptr) {
       debug_delegate_->OnPacketLoss(pair.first, LOSS_RETRANSMISSION, time);
     }
@@ skipping 284 matching lines @@
 
 void QuicSentPacketManager::RemoveObsoletePackets() {
   unacked_packets_.RemoveObsoletePackets();
 }
 
 void QuicSentPacketManager::OnApplicationLimited() {
   send_algorithm_->OnApplicationLimited(unacked_packets_.bytes_in_flight());
 }
 
 }  // namespace net