Deprecate FLAGS_quic_drop_non_awaited_packets.

net/quic/quic_connection.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 <string.h>
 #include <sys/types.h>
 
 #include <algorithm>
@@ skipping 626 matching lines @@
     LOG(DFATAL) << "Received a packet with multipath flag on when multipath is "
                    "not enabled.";
     SendConnectionCloseWithDetails(QUIC_BAD_MULTIPATH_FLAG,
                                    "receive a packet with multipath flag on "
                                    "when multipath is not enabled.");
     return false;
   }
 
   // If this packet has already been seen, or the sender has told us that it
   // will not be retransmitted, then stop processing the packet.
-  if (FLAGS_quic_drop_non_awaited_packets &&
-      !received_packet_manager_.IsAwaitingPacket(header.packet_number)) {
+  if (!received_packet_manager_.IsAwaitingPacket(header.packet_number)) {
     DVLOG(1) << ENDPOINT << "Packet " << header.packet_number
              << " no longer being waited for.  Discarding.";
     if (debug_visitor_ != nullptr) {
       debug_visitor_->OnDuplicatePacket(header.packet_number);
     }
     ++stats_.packets_dropped;
     return false;
   }
 
   return true;
@@ skipping 746 matching lines @@
   }
 
   if (!Near(header.packet_number, last_header_.packet_number)) {
     DVLOG(1) << ENDPOINT << "Packet " << header.packet_number
              << " out of bounds.  Discarding";
     SendConnectionCloseWithDetails(QUIC_INVALID_PACKET_HEADER,
                                    "packet number out of bounds");
     return false;
   }
 
-  // If this packet has already been seen, or the sender has told us that it
-  // will not be retransmitted, then stop processing the packet.
-  if (!FLAGS_quic_drop_non_awaited_packets &&
-      !received_packet_manager_.IsAwaitingPacket(header.packet_number)) {
-    DVLOG(1) << ENDPOINT << "Packet " << header.packet_number
-             << " no longer being waited for.  Discarding.";
-    if (debug_visitor_ != nullptr) {
-      debug_visitor_->OnDuplicatePacket(header.packet_number);
-    }
-    return false;
-  }
-
   if (version_negotiation_state_ != NEGOTIATED_VERSION) {
     if (perspective_ == Perspective::IS_SERVER) {
       if (!header.public_header.version_flag) {
         // Packets should have the version flag till version negotiation is
         // done.
         string error_details =
             StringPrintf("%s Packet %" PRIu64
                          " without version flag before version negotiated.",
                          ENDPOINT, header.packet_number);
         DLOG(WARNING) << error_details;
@@ skipping 581 matching lines @@
   }
 
   ++stats_.packets_revived;
   framer_.ProcessRevivedPacket(&revived_header,
                                StringPiece(revived_payload, len));
 }
 
 QuicFecGroup* QuicConnection::GetFecGroup() {
   QuicFecGroupNumber fec_group_num = last_header_.fec_group;
   if (fec_group_num == 0 ||
-      (FLAGS_quic_drop_non_awaited_packets &&
-       fec_group_num <
+      (fec_group_num <
            received_packet_manager_.peer_least_packet_awaiting_ack() &&
        !ContainsKey(group_map_, fec_group_num))) {
     // If the group number is below peer_least_packet_awaiting_ack and this
     // group does not exist, which means this group has missing packets below
     // |peer_least_packet_awaiting_ack| which we would never receive, so return
     // nullptr.
     return nullptr;
   }
   if (!ContainsKey(group_map_, fec_group_num)) {
     if (group_map_.size() >= kMaxFecGroups) {  // Too many groups
@@ skipping 82 matching lines @@
   // Opportunistically bundle an ack with this outgoing packet.
   ScopedPacketBundler ack_bundler(this, BUNDLE_PENDING_ACK);
   packet_generator_.AddControlFrame(
       QuicFrame(new QuicGoAwayFrame(error, last_good_stream_id, reason)));
 }
 
 void QuicConnection::CloseFecGroupsBefore(QuicPacketNumber packet_number) {
   FecGroupMap::iterator it = group_map_.begin();
   while (it != group_map_.end()) {
     // If the group doesn't protect this packet we can ignore it.
-    if ((!FLAGS_quic_drop_non_awaited_packets &&
-         last_header_.fec_group == it->first) ||
-        !it->second->IsWaitingForPacketBefore(packet_number)) {
+    if (!it->second->IsWaitingForPacketBefore(packet_number)) {
       ++it;
       continue;
     }
     QuicFecGroup* fec_group = it->second;
     DCHECK(!fec_group->CanRevive());
     FecGroupMap::iterator next = it;
     ++next;
     group_map_.erase(it);
     delete fec_group;
     it = next;
@@ skipping 366 matching lines @@
 void QuicConnection::OnPathClosed(QuicPathId path_id) {
   // Stop receiving packets on this path.
   framer_.OnPathClosed(path_id);
 }
 
 bool QuicConnection::ack_frame_updated() const {
   return received_packet_manager_.ack_frame_updated();
 }
 
 }  // namespace net