Drop not awaited packets before decrypt them.

net/quic/quic_connection_test.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 <ostream>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
@@ skipping 43 matching lines @@
 
 namespace net {
 namespace test {
 namespace {
 
 const char data1[] = "foo";
 const char data2[] = "bar";
 
 const bool kFin = true;
 const bool kEntropyFlag = true;
+const bool kHasStopWaiting = true;
 
 const QuicPacketEntropyHash kTestEntropyHash = 76;
 
 const int kDefaultRetransmissionTimeMs = 500;
 
 const IPEndPoint kPeerAddress = IPEndPoint(Loopback6(), /*port=*/12345);
 const IPEndPoint kSelfAddress = IPEndPoint(Loopback6(), /*port=*/443);
 
 // TaggingEncrypter appends kTagSize bytes of |tag| to the end of each message.
 class TaggingEncrypter : public QuicEncrypter {
@@ skipping 730 matching lines @@
         framer_.EncryptPayload(level, number, *packet, buffer, kMaxPacketSize);
     connection_.ProcessUdpPacket(
         kSelfAddress, kPeerAddress,
         QuicEncryptedPacket(buffer, encrypted_length, false));
     return base::checked_cast<QuicPacketEntropyHash>(encrypted_length);
   }
 
   size_t ProcessDataPacket(QuicPacketNumber number,
                            QuicFecGroupNumber fec_group,
                            bool entropy_flag) {
-    return ProcessDataPacketAtLevel(number, fec_group, entropy_flag,
+    return ProcessDataPacketAtLevel(number, fec_group, entropy_flag, false,
                                     ENCRYPTION_NONE);
   }
 
   size_t ProcessDataPacketAtLevel(QuicPacketNumber number,
                                   QuicFecGroupNumber fec_group,
                                   bool entropy_flag,
+                                  bool has_stop_waiting,
                                   EncryptionLevel level) {
-    scoped_ptr<QuicPacket> packet(ConstructDataPacket(number, fec_group,
-                                                      entropy_flag));
+    scoped_ptr<QuicPacket> packet(
+        ConstructDataPacket(number, fec_group, entropy_flag, has_stop_waiting));
     char buffer[kMaxPacketSize];
     size_t encrypted_length =
         framer_.EncryptPayload(level, number, *packet, buffer, kMaxPacketSize);
     connection_.ProcessUdpPacket(
         kSelfAddress, kPeerAddress,
         QuicEncryptedPacket(buffer, encrypted_length, false));
     return encrypted_length;
   }
 
   void ProcessClosePacket(QuicPacketNumber number,
                           QuicFecGroupNumber fec_group) {
     scoped_ptr<QuicPacket> packet(ConstructClosePacket(number, fec_group));
     char buffer[kMaxPacketSize];
     size_t encrypted_length = framer_.EncryptPayload(
         ENCRYPTION_NONE, number, *packet, buffer, kMaxPacketSize);
     connection_.ProcessUdpPacket(
         kSelfAddress, kPeerAddress,
         QuicEncryptedPacket(buffer, encrypted_length, false));
   }
 
   size_t ProcessFecProtectedPacket(QuicPacketNumber number,
                                    bool expect_revival,
-                                   bool entropy_flag) {
+                                   bool entropy_flag,
+                                   bool has_stop_waiting) {
     return ProcessFecProtectedPacketAtLevel(number, 1, expect_revival,
-                                            entropy_flag, ENCRYPTION_NONE);
+                                            entropy_flag, has_stop_waiting,
+                                            ENCRYPTION_NONE);
   }
 
   size_t ProcessFecProtectedPacketAtLevel(QuicPacketNumber number,
                                           QuicFecGroupNumber fec_group,
                                           bool expect_revival,
                                           bool entropy_flag,
+                                          bool has_stop_waiting,
                                           EncryptionLevel level) {
     if (expect_revival) {
       EXPECT_CALL(visitor_, OnStreamFrame(_)).Times(1);
     }
     EXPECT_CALL(visitor_, OnStreamFrame(_)).Times(1).RetiresOnSaturation();
-    return ProcessDataPacketAtLevel(number, fec_group, entropy_flag, level);
+    return ProcessDataPacketAtLevel(number, fec_group, entropy_flag,
+                                    has_stop_waiting, level);
   }
 
   // Processes an FEC packet that covers the packets that would have been
   // received.
   size_t ProcessFecPacket(QuicPacketNumber number,
                           QuicPacketNumber min_protected_packet,
                           bool expect_revival,
                           bool entropy_flag,
                           QuicPacket* packet) {
     return ProcessFecPacketAtLevel(number, min_protected_packet, expect_revival,
@@ skipping 12 matching lines @@
       EXPECT_CALL(visitor_, OnStreamFrame(_)).Times(1);
     }
 
     // Construct the decrypted data packet so we can compute the correct
     // redundancy. If |packet| has been provided then use that, otherwise
     // construct a default data packet.
     scoped_ptr<QuicPacket> data_packet;
     if (packet) {
       data_packet.reset(packet);
     } else {
-      data_packet.reset(ConstructDataPacket(number, 1, !kEntropyFlag));
+      data_packet.reset(
+          ConstructDataPacket(number, 1, !kEntropyFlag, !kHasStopWaiting));
     }
 
     QuicPacketHeader header;
     header.public_header.connection_id = connection_id_;
     header.public_header.packet_number_length = packet_number_length_;
     header.public_header.connection_id_length = connection_id_length_;
     header.packet_number = number;
     header.entropy_flag = entropy_flag;
     header.fec_flag = true;
     header.is_in_fec_group = IN_FEC_GROUP;
@@ skipping 78 matching lines @@
   }
 
   QuicPacket* ConstructPacket(QuicPacketHeader header, QuicFrames frames) {
     QuicPacket* packet = BuildUnsizedDataPacket(&framer_, header, frames);
     EXPECT_NE(nullptr, packet);
     return packet;
   }
 
   QuicPacket* ConstructDataPacket(QuicPacketNumber number,
                                   QuicFecGroupNumber fec_group,
-                                  bool entropy_flag) {
+                                  bool entropy_flag,
+                                  bool has_stop_waiting) {
     QuicPacketHeader header;
     header.public_header.connection_id = connection_id_;
     header.public_header.packet_number_length = packet_number_length_;
     header.public_header.connection_id_length = connection_id_length_;
     header.entropy_flag = entropy_flag;
     header.packet_number = number;
     header.is_in_fec_group = fec_group == 0u ? NOT_IN_FEC_GROUP : IN_FEC_GROUP;
     header.fec_group = fec_group;
 
     QuicFrames frames;
     frames.push_back(QuicFrame(&frame1_));
+    if (has_stop_waiting) {
+      frames.push_back(QuicFrame(&stop_waiting_));
+    }
     return ConstructPacket(header, frames);
   }
 
   QuicPacket* ConstructClosePacket(QuicPacketNumber number,
                                    QuicFecGroupNumber fec_group) {
     QuicPacketHeader header;
     header.public_header.connection_id = connection_id_;
     header.packet_number = number;
     header.is_in_fec_group = fec_group == 0u ? NOT_IN_FEC_GROUP : IN_FEC_GROUP;
     header.fec_group = fec_group;
@@ skipping 2043 matching lines @@
     // Connection id length in the revived header should be the same as
     // in the original data/fec packet headers.
     EXPECT_EQ(connection_id_length_,
               fec_visitor->revived_header().public_header.connection_id_length);
   }
 }
 
 TEST_P(QuicConnectionTest, ReviveMissingPacketAfterDataPacketThenFecPacket) {
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
 
-  ProcessFecProtectedPacket(1, false, kEntropyFlag);
+  ProcessFecProtectedPacket(1, false, kEntropyFlag, !kHasStopWaiting);
   // Don't send missing packet 2.
   ProcessFecPacket(3, 1, true, !kEntropyFlag, nullptr);
   // Entropy flag should be true, so entropy should not be 0.
   EXPECT_NE(0u, QuicConnectionPeer::ReceivedEntropyHash(&connection_, 2));
 }
 
 TEST_P(QuicConnectionTest, ReviveMissingPacketAfterDataPacketsThenFecPacket) {
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
 
-  ProcessFecProtectedPacket(1, false, !kEntropyFlag);
+  ProcessFecProtectedPacket(1, false, !kEntropyFlag, !kHasStopWaiting);
   // Don't send missing packet 2.
-  ProcessFecProtectedPacket(3, false, !kEntropyFlag);
+  ProcessFecProtectedPacket(3, false, !kEntropyFlag, !kHasStopWaiting);
   ProcessFecPacket(4, 1, true, kEntropyFlag, nullptr);
   // Ensure QUIC no longer revives entropy for lost packets.
   EXPECT_EQ(0u, QuicConnectionPeer::ReceivedEntropyHash(&connection_, 2));
   EXPECT_NE(0u, QuicConnectionPeer::ReceivedEntropyHash(&connection_, 4));
 }
 
 TEST_P(QuicConnectionTest, ReviveMissingPacketAfterDataPacket) {
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
 
   // Don't send missing packet 1.
   ProcessFecPacket(3, 1, false, !kEntropyFlag, nullptr);
   // Out of order.
-  ProcessFecProtectedPacket(2, true, !kEntropyFlag);
+  ProcessFecProtectedPacket(2, true, !kEntropyFlag, !kHasStopWaiting);
   // Entropy flag should be false, so entropy should be 0.
   EXPECT_EQ(0u, QuicConnectionPeer::ReceivedEntropyHash(&connection_, 2));
 }
 
 TEST_P(QuicConnectionTest, ReviveMissingPacketAfterDataPackets) {
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
 
-  ProcessFecProtectedPacket(1, false, !kEntropyFlag);
+  ProcessFecProtectedPacket(1, false, !kEntropyFlag, !kHasStopWaiting);
   // Don't send missing packet 2.
   ProcessFecPacket(6, 1, false, kEntropyFlag, nullptr);
-  ProcessFecProtectedPacket(3, false, kEntropyFlag);
-  ProcessFecProtectedPacket(4, false, kEntropyFlag);
-  ProcessFecProtectedPacket(5, true, !kEntropyFlag);
+  ProcessFecProtectedPacket(3, false, kEntropyFlag, !kHasStopWaiting);
+  ProcessFecProtectedPacket(4, false, kEntropyFlag, !kHasStopWaiting);
+  ProcessFecProtectedPacket(5, true, !kEntropyFlag, !kHasStopWaiting);
   // Ensure entropy is not revived for the missing packet.
   EXPECT_EQ(0u, QuicConnectionPeer::ReceivedEntropyHash(&connection_, 2));
   EXPECT_NE(0u, QuicConnectionPeer::ReceivedEntropyHash(&connection_, 3));
 }
 
 TEST_P(QuicConnectionTest, TLP) {
   QuicSentPacketManagerPeer::SetMaxTailLossProbes(manager_, 1);
 
   SendStreamDataToPeer(3, "foo", 0, !kFin, nullptr);
   EXPECT_EQ(1u, stop_waiting()->least_unacked);
@@ skipping 195 matching lines @@
   QuicConfig config;
   connection_.SetFromConfig(config);
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
   use_tagging_decrypter();
 
   const uint8 tag = 0x07;
   framer_.SetEncrypter(ENCRYPTION_INITIAL, new TaggingEncrypter(tag));
 
   // Process an encrypted packet which can not yet be decrypted which should
   // result in the packet being buffered.
-  ProcessDataPacketAtLevel(1, 0, kEntropyFlag, ENCRYPTION_INITIAL);
+  ProcessDataPacketAtLevel(1, 0, kEntropyFlag, !kHasStopWaiting,
+                           ENCRYPTION_INITIAL);
 
   // Transition to the new encryption state and process another encrypted packet
   // which should result in the original packet being processed.
   connection_.SetDecrypter(ENCRYPTION_INITIAL, new StrictTaggingDecrypter(tag));
   connection_.SetDefaultEncryptionLevel(ENCRYPTION_INITIAL);
   connection_.SetEncrypter(ENCRYPTION_INITIAL, new TaggingEncrypter(tag));
   EXPECT_CALL(visitor_, OnStreamFrame(_)).Times(2);
-  ProcessDataPacketAtLevel(2, 0, kEntropyFlag, ENCRYPTION_INITIAL);
+  ProcessDataPacketAtLevel(2, 0, kEntropyFlag, !kHasStopWaiting,
+                           ENCRYPTION_INITIAL);
 
   // Finally, process a third packet and note that we do not reprocess the
   // buffered packet.
   EXPECT_CALL(visitor_, OnStreamFrame(_)).Times(1);
-  ProcessDataPacketAtLevel(3, 0, kEntropyFlag, ENCRYPTION_INITIAL);
+  ProcessDataPacketAtLevel(3, 0, kEntropyFlag, !kHasStopWaiting,
+                           ENCRYPTION_INITIAL);
 }
 
 TEST_P(QuicConnectionTest, ProcessBufferedFECGroup) {
   // SetFromConfig is always called after construction from InitializeSession.
   EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _));
   QuicConfig config;
   config.set_max_undecryptable_packets(100);
   connection_.SetFromConfig(config);
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
   use_tagging_decrypter();
 
   const uint8 tag = 0x07;
   framer_.SetEncrypter(ENCRYPTION_INITIAL, new TaggingEncrypter(tag));
 
   // Don't send packet 1 and buffer initially encrypted packets.
-  ProcessFecProtectedPacketAtLevel(2, 1, false, !kEntropyFlag,
+  ProcessFecProtectedPacketAtLevel(2, 1, false, !kEntropyFlag, !kHasStopWaiting,
                                    ENCRYPTION_INITIAL);
   ProcessFecPacketAtLevel(3, 1, false, kEntropyFlag, nullptr,
                           ENCRYPTION_INITIAL);
   // Since the packets were buffered, no FEC group should be open.
   ASSERT_EQ(0u, connection_.NumFecGroups());
 
   // Now send non-fec protected ack packet and close the group.
   QuicStopWaitingFrame frame = InitStopWaitingFrame(4);
   ProcessStopWaitingPacketAtLevel(4, &frame, ENCRYPTION_INITIAL);
 
   // Transition to the new encryption state and process another encrypted packet
   // which should result in the original packets being processed. The missing
   // packet should be revived before the STOP_WAITING packet is processed.
   connection_.SetDecrypter(ENCRYPTION_INITIAL, new StrictTaggingDecrypter(tag));
   connection_.SetDefaultEncryptionLevel(ENCRYPTION_INITIAL);
   connection_.SetEncrypter(ENCRYPTION_INITIAL, new TaggingEncrypter(tag));
 
   EXPECT_CALL(visitor_, OnStreamFrame(_)).Times(2).RetiresOnSaturation();
-  ProcessDataPacketAtLevel(5, 0, kEntropyFlag, ENCRYPTION_INITIAL);
+  ProcessDataPacketAtLevel(5, 0, kEntropyFlag, !kHasStopWaiting,
+                           ENCRYPTION_INITIAL);
   const QuicConnectionStats& stats = connection_.GetStats();
   EXPECT_EQ(1u, stats.packets_revived);
 }
 
 TEST_P(QuicConnectionTest, Buffer100NonDecryptablePackets) {
   // SetFromConfig is always called after construction from InitializeSession.
   EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _));
   QuicConfig config;
   config.set_max_undecryptable_packets(100);
   connection_.SetFromConfig(config);
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
   use_tagging_decrypter();
 
   const uint8 tag = 0x07;
   framer_.SetEncrypter(ENCRYPTION_INITIAL, new TaggingEncrypter(tag));
 
   // Process an encrypted packet which can not yet be decrypted which should
   // result in the packet being buffered.
   for (QuicPacketNumber i = 1; i <= 100; ++i) {
-    ProcessDataPacketAtLevel(i, 0, kEntropyFlag, ENCRYPTION_INITIAL);
+    ProcessDataPacketAtLevel(i, 0, kEntropyFlag, !kHasStopWaiting,
+                             ENCRYPTION_INITIAL);
   }
 
   // Transition to the new encryption state and process another encrypted packet
   // which should result in the original packets being processed.
   connection_.SetDecrypter(ENCRYPTION_INITIAL, new StrictTaggingDecrypter(tag));
   connection_.SetDefaultEncryptionLevel(ENCRYPTION_INITIAL);
   connection_.SetEncrypter(ENCRYPTION_INITIAL, new TaggingEncrypter(tag));
   EXPECT_CALL(visitor_, OnStreamFrame(_)).Times(101);
-  ProcessDataPacketAtLevel(101, 0, kEntropyFlag, ENCRYPTION_INITIAL);
+  ProcessDataPacketAtLevel(101, 0, kEntropyFlag, !kHasStopWaiting,
+                           ENCRYPTION_INITIAL);
 
   // Finally, process a third packet and note that we do not reprocess the
   // buffered packet.
   EXPECT_CALL(visitor_, OnStreamFrame(_)).Times(1);
-  ProcessDataPacketAtLevel(102, 0, kEntropyFlag, ENCRYPTION_INITIAL);
+  ProcessDataPacketAtLevel(102, 0, kEntropyFlag, !kHasStopWaiting,
+                           ENCRYPTION_INITIAL);
 }
 
 TEST_P(QuicConnectionTest, TestRetransmitOrder) {
   QuicByteCount first_packet_size;
   EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).WillOnce(
       DoAll(SaveArg<3>(&first_packet_size), Return(true)));
 
   connection_.SendStreamDataWithString(3, "first_packet", 0, !kFin, nullptr);
   QuicByteCount second_packet_size;
   EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).WillOnce(
@@ skipping 83 matching lines @@
   // Unblock the writes and actually send.
   writer_->SetWritable();
   connection_.OnCanWrite();
   EXPECT_EQ(0u, connection_.NumQueuedPackets());
 }
 
 TEST_P(QuicConnectionTest, CloseFecGroup) {
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
   // Don't send missing packet 1.
   // Don't send missing packet 2.
-  ProcessFecProtectedPacket(3, false, !kEntropyFlag);
+  ProcessFecProtectedPacket(3, false, !kEntropyFlag, !kHasStopWaiting);
   // Don't send missing FEC packet 3.
   ASSERT_EQ(1u, connection_.NumFecGroups());
 
   // Now send non-fec protected ack packet and close the group.
   QuicPacketCreatorPeer::SetPacketNumber(&peer_creator_, 4);
   QuicStopWaitingFrame frame = InitStopWaitingFrame(5);
   ProcessStopWaitingPacket(&frame);
   ASSERT_EQ(0u, connection_.NumFecGroups());
 }
 
+TEST_P(QuicConnectionTest, FailedToCloseFecGroupWithFecProtectedStopWaiting) {
+  EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
+  ValueRestore<bool> old_flag(&FLAGS_quic_drop_non_awaited_packets, false);
+  // Don't send missing packet 1.
+  ProcessFecProtectedPacket(2, false, !kEntropyFlag, !kHasStopWaiting);
+  EXPECT_EQ(1u, connection_.NumFecGroups());
+  stop_waiting_ = InitStopWaitingFrame(3);
+  ProcessFecProtectedPacket(3, false, !kEntropyFlag, kHasStopWaiting);
+  // This Fec group would be closed but created again.
+  EXPECT_EQ(1u, connection_.NumFecGroups());
+}
+
+TEST_P(QuicConnectionTest,
+       CloseFecGroupUnderStopWaitingAndWaitingForPacketsBelowStopWaiting) {
+  EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
+  ValueRestore<bool> old_flag(&FLAGS_quic_drop_non_awaited_packets, true);
+  // Don't send missing packet 1.
+  ProcessFecProtectedPacket(2, false, !kEntropyFlag, !kHasStopWaiting);
+  EXPECT_EQ(1u, connection_.NumFecGroups());
+  stop_waiting_ = InitStopWaitingFrame(2);
+  ProcessFecProtectedPacket(3, false, !kEntropyFlag, kHasStopWaiting);
+  // This Fec group would be closed.
+  EXPECT_EQ(0u, connection_.NumFecGroups());
+}
+
+TEST_P(QuicConnectionTest,
+       DoNotCloseFecGroupUnderStopWaitingButNotWaitingForPacketsBelow) {
+  EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
+  ValueRestore<bool> old_flag(&FLAGS_quic_drop_non_awaited_packets, true);
+  ProcessFecProtectedPacket(1, false, !kEntropyFlag, !kHasStopWaiting);
+  ProcessFecProtectedPacket(2, false, !kEntropyFlag, !kHasStopWaiting);
+  // Don't send missing packet 3.
+  EXPECT_EQ(1u, connection_.NumFecGroups());
+  stop_waiting_ = InitStopWaitingFrame(2);
+  ProcessFecProtectedPacket(3, false, !kEntropyFlag, kHasStopWaiting);
+  // This group will not be closed because this group is not waiting for packets
+  // below stop waiting.
+  EXPECT_EQ(1u, connection_.NumFecGroups());
+}
+
 TEST_P(QuicConnectionTest, InitialTimeout) {
   EXPECT_TRUE(connection_.connected());
   EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(AnyNumber());
   EXPECT_FALSE(connection_.GetTimeoutAlarm()->IsSet());
 
   // SetFromConfig sets the initial timeouts before negotiation.
   EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _));
   QuicConfig config;
   connection_.SetFromConfig(config);
   // Subtract a second from the idle timeout on the client side.
@@ skipping 644 matching lines @@
                                          nullptr);
     connection_.GetTimeoutAlarm()->Fire();
     clock_.AdvanceTime(QuicTime::Delta::FromSeconds(1));
   }
   EXPECT_FALSE(connection_.connected());
   EXPECT_FALSE(connection_.GetTimeoutAlarm()->IsSet());
 }
 
 TEST_P(QuicConnectionTest, SendScheduler) {
   // Test that if we send a packet without delay, it is not queued.
-  QuicPacket* packet = ConstructDataPacket(1, 0, !kEntropyFlag);
+  QuicPacket* packet =
+      ConstructDataPacket(1, 0, !kEntropyFlag, !kHasStopWaiting);
   EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _));
   connection_.SendPacket(ENCRYPTION_NONE, 1, packet, kTestEntropyHash,
                          HAS_RETRANSMITTABLE_DATA, false, false);
   EXPECT_EQ(0u, connection_.NumQueuedPackets());
 }
 
 TEST_P(QuicConnectionTest, FailToSendFirstPacket) {
   // Test that the connection does not crash when it fails to send the first
   // packet at which point self_address_ might be uninitialized.
   EXPECT_CALL(visitor_, OnConnectionClosed(_, _)).Times(1);
-  QuicPacket* packet = ConstructDataPacket(1, 0, !kEntropyFlag);
+  QuicPacket* packet =
+      ConstructDataPacket(1, 0, !kEntropyFlag, !kHasStopWaiting);
   writer_->SetShouldWriteFail();
   connection_.SendPacket(ENCRYPTION_NONE, 1, packet, kTestEntropyHash,
                          HAS_RETRANSMITTABLE_DATA, false, false);
 }
 
 TEST_P(QuicConnectionTest, SendSchedulerEAGAIN) {
-  QuicPacket* packet = ConstructDataPacket(1, 0, !kEntropyFlag);
+  QuicPacket* packet =
+      ConstructDataPacket(1, 0, !kEntropyFlag, !kHasStopWaiting);
   BlockOnNextWrite();
   EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, 1, _, _)).Times(0);
   connection_.SendPacket(ENCRYPTION_NONE, 1, packet, kTestEntropyHash,
                          HAS_RETRANSMITTABLE_DATA, false, false);
   EXPECT_EQ(1u, connection_.NumQueuedPackets());
 }
 
 TEST_P(QuicConnectionTest, TestQueueLimitsOnSendStreamData) {
   // All packets carry version info till version is negotiated.
   size_t payload_length;
@@ skipping 90 matching lines @@
   EXPECT_FALSE(connection_.GetAckAlarm()->IsSet());
   const uint8 tag = 0x07;
   connection_.SetDecrypter(ENCRYPTION_INITIAL, new StrictTaggingDecrypter(tag));
   framer_.SetEncrypter(ENCRYPTION_INITIAL, new TaggingEncrypter(tag));
   // Process a packet from the non-crypto stream.
   frame1_.stream_id = 3;
 
   // The same as ProcessPacket(1) except that ENCRYPTION_INITIAL is used
   // instead of ENCRYPTION_NONE.
   EXPECT_CALL(visitor_, OnStreamFrame(_)).Times(1);
-  ProcessDataPacketAtLevel(1, 0, !kEntropyFlag, ENCRYPTION_INITIAL);
+  ProcessDataPacketAtLevel(1, 0, !kEntropyFlag, !kHasStopWaiting,
+                           ENCRYPTION_INITIAL);
 
   // Check if delayed ack timer is running for the expected interval.
   EXPECT_TRUE(connection_.GetAckAlarm()->IsSet());
   EXPECT_EQ(ack_time, connection_.GetAckAlarm()->deadline());
   // Simulate delayed ack alarm firing.
   connection_.GetAckAlarm()->Fire();
   // Check that ack is sent and that delayed ack alarm is reset.
   EXPECT_EQ(2u, writer_->frame_count());
   EXPECT_FALSE(writer_->stop_waiting_frames().empty());
   EXPECT_FALSE(writer_->ack_frames().empty());
@@ skipping 16 matching lines @@
   const uint8 tag = 0x07;
   connection_.SetDecrypter(ENCRYPTION_INITIAL, new StrictTaggingDecrypter(tag));
   framer_.SetEncrypter(ENCRYPTION_INITIAL, new TaggingEncrypter(tag));
   // Process a packet from the non-crypto stream.
   frame1_.stream_id = 3;
 
   // Process all the initial packets in order so there aren't missing packets.
   QuicPacketNumber kFirstDecimatedPacket = 101;
   for (unsigned int i = 0; i < kFirstDecimatedPacket - 1; ++i) {
     EXPECT_CALL(visitor_, OnStreamFrame(_)).Times(1);
-    ProcessDataPacketAtLevel(1 + i, 0, !kEntropyFlag, ENCRYPTION_INITIAL);
+    ProcessDataPacketAtLevel(1 + i, 0, !kEntropyFlag, !kHasStopWaiting,
+                             ENCRYPTION_INITIAL);
   }
   EXPECT_FALSE(connection_.GetAckAlarm()->IsSet());
   // The same as ProcessPacket(1) except that ENCRYPTION_INITIAL is used
   // instead of ENCRYPTION_NONE.
   EXPECT_CALL(visitor_, OnStreamFrame(_)).Times(1);
   ProcessDataPacketAtLevel(kFirstDecimatedPacket, 0, !kEntropyFlag,
-                           ENCRYPTION_INITIAL);
+                           !kHasStopWaiting, ENCRYPTION_INITIAL);
 
   // Check if delayed ack timer is running for the expected interval.
   EXPECT_TRUE(connection_.GetAckAlarm()->IsSet());
   EXPECT_EQ(ack_time, connection_.GetAckAlarm()->deadline());
 
   // The 10th received packet causes an ack to be sent.
   for (int i = 0; i < 9; ++i) {
     EXPECT_TRUE(connection_.GetAckAlarm()->IsSet());
     EXPECT_CALL(visitor_, OnStreamFrame(_)).Times(1);
     ProcessDataPacketAtLevel(kFirstDecimatedPacket + 1 + i, 0, !kEntropyFlag,
-                             ENCRYPTION_INITIAL);
+                             !kHasStopWaiting, ENCRYPTION_INITIAL);
   }
   // Check that ack is sent and that delayed ack alarm is reset.
   EXPECT_EQ(2u, writer_->frame_count());
   EXPECT_FALSE(writer_->stop_waiting_frames().empty());
   EXPECT_FALSE(writer_->ack_frames().empty());
   EXPECT_FALSE(connection_.GetAckAlarm()->IsSet());
 }
 
 TEST_P(QuicConnectionTest, SendDelayedAckOnHandshakeConfirmed) {
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
@@ skipping 185 matching lines @@
   EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(0);
   ProcessClosePacket(2, 0);
 }
 
 TEST_P(QuicConnectionTest, SendWhenDisconnected) {
   EXPECT_TRUE(connection_.connected());
   EXPECT_CALL(visitor_, OnConnectionClosed(QUIC_PEER_GOING_AWAY, false));
   connection_.CloseConnection(QUIC_PEER_GOING_AWAY, false);
   EXPECT_FALSE(connection_.connected());
   EXPECT_FALSE(connection_.CanWriteStreamData());
-  QuicPacket* packet = ConstructDataPacket(1, 0, !kEntropyFlag);
+  QuicPacket* packet =
+      ConstructDataPacket(1, 0, !kEntropyFlag, !kHasStopWaiting);
   EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, 1, _, _)).Times(0);
   connection_.SendPacket(ENCRYPTION_NONE, 1, packet, kTestEntropyHash,
                          HAS_RETRANSMITTABLE_DATA, false, false);
 }
 
 TEST_P(QuicConnectionTest, PublicReset) {
   QuicPublicResetPacket header;
   header.public_header.connection_id = connection_id_;
   header.public_header.reset_flag = true;
   header.public_header.version_flag = false;
@@ skipping 337 matching lines @@
             stats.bytes_retransmitted);
   EXPECT_EQ(3u, stats.packets_retransmitted);
   EXPECT_EQ(1u, stats.rto_count);
   EXPECT_EQ(kDefaultMaxPacketSize, stats.max_packet_size);
 }
 
 TEST_P(QuicConnectionTest, CheckReceiveStats) {
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
 
   size_t received_bytes = 0;
-  received_bytes += ProcessFecProtectedPacket(1, false, !kEntropyFlag);
-  received_bytes += ProcessFecProtectedPacket(3, false, !kEntropyFlag);
+  received_bytes +=
+      ProcessFecProtectedPacket(1, false, !kEntropyFlag, !kHasStopWaiting);
+  received_bytes +=
+      ProcessFecProtectedPacket(3, false, !kEntropyFlag, !kHasStopWaiting);
   // Should be counted against dropped packets.
   received_bytes += ProcessDataPacket(3, 1, !kEntropyFlag);
   received_bytes += ProcessFecPacket(4, 1, true, !kEntropyFlag, nullptr);
 
   EXPECT_CALL(*send_algorithm_, BandwidthEstimate()).WillOnce(
       Return(QuicBandwidth::Zero()));
 
   const QuicConnectionStats& stats = connection_.GetStats();
   EXPECT_EQ(received_bytes, stats.bytes_received);
   EXPECT_EQ(4u, stats.packets_received);
@@ skipping 410 matching lines @@
             QuicPacketCreatorPeer::GetFecTimeout(creator_));
 }
 
 TEST_P(QuicConnectionTest, OnPacketHeaderDebugVisitor) {
   QuicPacketHeader header;
 
   scoped_ptr<MockQuicConnectionDebugVisitor> debug_visitor(
       new MockQuicConnectionDebugVisitor());
   connection_.set_debug_visitor(debug_visitor.get());
   EXPECT_CALL(*debug_visitor, OnPacketHeader(Ref(header))).Times(1);
-  EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_)).Times(1);
-  EXPECT_CALL(*debug_visitor, OnSuccessfulVersionNegotiation(_)).Times(1);
+  if (FLAGS_quic_drop_non_awaited_packets) {
+    EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_)).Times(1);
+    EXPECT_CALL(*debug_visitor, OnSuccessfulVersionNegotiation(_)).Times(1);
+  }
   connection_.OnPacketHeader(header);
 }
 
 TEST_P(QuicConnectionTest, Pacing) {
   TestConnection server(connection_id_, kSelfAddress, helper_.get(), factory_,
                         Perspective::IS_SERVER, version());
   TestConnection client(connection_id_, kPeerAddress, helper_.get(), factory_,
                         Perspective::IS_CLIENT, version());
   EXPECT_FALSE(client.sent_packet_manager().using_pacing());
   EXPECT_FALSE(server.sent_packet_manager().using_pacing());
@@ skipping 129 matching lines @@
   EXPECT_CALL(visitor_,
               OnConnectionClosed(QUIC_UNENCRYPTED_STREAM_DATA, false));
   EXPECT_DFATAL(connection_.SendStreamDataWithString(3, "", 0, kFin, nullptr),
                 "Cannot send stream data without encryption.");
   EXPECT_FALSE(connection_.connected());
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net