Drop not awaited packets before decrypt them.

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 605 matching lines @@
     debug_visitor_->OnUnauthenticatedHeader(header);
   }
 
   // Check that any public reset packet with a different connection ID that was
   // routed to this QuicConnection has been redirected before control reaches
   // here.
   DCHECK_EQ(connection_id_, header.public_header.connection_id);
 
   // 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 (!received_packet_manager_.IsAwaitingPacket(header.packet_number)) {
+  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);
     }
     ++stats_.packets_dropped;
     return false;
   }
 
   return true;
@@ skipping 1339 matching lines @@
                                     StringPiece(revived_payload, len));
   }
 
   ++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) {
+  if (fec_group_num == 0 ||
+      (FLAGS_quic_drop_non_awaited_packets &&
+       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
       if (fec_group_num < group_map_.begin()->first) {
         // The group being requested is a group we've seen before and deleted.
         // Don't recreate it.
         return nullptr;
       }
       // Clear the lowest group number.
@@ skipping 74 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 this is the current group or the group doesn't protect this packet
-    // we can ignore it.
-    if (last_header_.fec_group == it->first ||
+    // 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)) {
       ++it;
       continue;
     }
     QuicFecGroup* fec_group = it->second;
     DCHECK(!fec_group->CanRevive());
     FecGroupMap::iterator next = it;
     ++next;
     group_map_.erase(it);
     delete fec_group;
@@ skipping 310 matching lines @@
   SendMtuDiscoveryPacket(mtu_discovery_target_);
 
   DCHECK(!mtu_discovery_alarm_->IsSet());
 }
 
 bool QuicConnection::ack_frame_updated() const {
   return received_packet_manager_.ack_frame_updated();
 }
 
 }  // namespace net