Deprecate FLAGS_quic_always_write_queued_retransmissions.

net/quic/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/quic_sent_packet_manager.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/stl_util.h"
@@ skipping 304 matching lines @@
     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) {
       largest_newly_acked_ = packet_number;
     }
     MarkPacketHandled(packet_number, &(*it), ack_delay_time);
   }
 }
 
-bool QuicSentPacketManager::HasRetransmittableFrames(
-    QuicPathId,
-    QuicPacketNumber packet_number) const {
-  return unacked_packets_.HasRetransmittableFrames(packet_number);
-}
-
 void QuicSentPacketManager::RetransmitUnackedPackets(
     TransmissionType retransmission_type) {
   DCHECK(retransmission_type == ALL_UNACKED_RETRANSMISSION ||
          retransmission_type == ALL_INITIAL_RETRANSMISSION);
   QuicPacketNumber packet_number = unacked_packets_.GetLeastUnacked();
   for (QuicUnackedPacketMap::const_iterator it = unacked_packets_.begin();
        it != unacked_packets_.end(); ++it, ++packet_number) {
     if (!it->retransmittable_frames.empty() &&
         (retransmission_type == ALL_UNACKED_RETRANSMISSION ||
          it->encryption_level == ENCRYPTION_INITIAL)) {
@@ skipping 187 matching lines @@
     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;
   }
 }
 
-bool QuicSentPacketManager::IsUnacked(QuicPathId,
-                                      QuicPacketNumber packet_number) const {
-  return unacked_packets_.IsUnacked(packet_number);
-}
-
 bool QuicSentPacketManager::HasUnackedPackets() const {
   return unacked_packets_.HasUnackedPackets();
 }
 
 QuicPacketNumber QuicSentPacketManager::GetLeastUnacked(QuicPathId) const {
   return unacked_packets_.GetLeastUnacked();
 }
 
 bool QuicSentPacketManager::OnPacketSent(
     SerializedPacket* serialized_packet,
     QuicPathId /*original_path_id*/,
     QuicPacketNumber original_packet_number,
     QuicTime sent_time,
     TransmissionType transmission_type,
     HasRetransmittableData has_retransmittable_data) {
   QuicPacketNumber packet_number = serialized_packet->packet_number;
   DCHECK_LT(0u, packet_number);
   DCHECK(!unacked_packets_.IsUnacked(packet_number));
   QUIC_BUG_IF(serialized_packet->encrypted_length == 0)
       << "Cannot send empty packets.";
 
   if (delegate_ == nullptr && original_packet_number != 0) {
-    if (!pending_retransmissions_.erase(original_packet_number) &&
-        !FLAGS_quic_always_write_queued_retransmissions) {
-      QUIC_BUG << "Expected packet number to be in "
-               << "pending_retransmissions_.  packet_number: "
-               << original_packet_number;
-    }
+    pending_retransmissions_.erase(original_packet_number);
   }
 
   if (pending_timer_transmission_count_ > 0) {
     --pending_timer_transmission_count_;
   }
 
   // TODO(ianswett): Remove sent_time, because it's unused.
   const bool in_flight = send_algorithm_->OnPacketSent(
       sent_time, unacked_packets_.bytes_in_flight(), packet_number,
       serialized_packet->encrypted_length, has_retransmittable_data);
@@ skipping 339 matching lines @@
 }
 
 void QuicSentPacketManager::CancelRetransmissionsForStream(
     QuicStreamId stream_id) {
   unacked_packets_.CancelRetransmissionsForStream(stream_id);
   if (delegate_ != nullptr) {
     return;
   }
   PendingRetransmissionMap::iterator it = pending_retransmissions_.begin();
   while (it != pending_retransmissions_.end()) {
-    if (HasRetransmittableFrames(path_id_, it->first)) {
+    if (unacked_packets_.HasRetransmittableFrames(it->first)) {
       ++it;
       continue;
     }
     it = pending_retransmissions_.erase(it);
   }
 }
 
 void QuicSentPacketManager::EnablePacing() {
   // TODO(ianswett): Replace with a method which wraps the send algorithm in a
   // pacer every time a new algorithm is set.
@@ skipping 65 matching lines @@
 TransmissionInfo* QuicSentPacketManager::GetMutableTransmissionInfo(
     QuicPacketNumber packet_number) {
   return unacked_packets_.GetMutableTransmissionInfo(packet_number);
 }
 
 void QuicSentPacketManager::RemoveObsoletePackets() {
   unacked_packets_.RemoveObsoletePackets();
 }
 
 }  // namespace net