Make QUIC stateless rejects work in the face of packet loss by storing the SREJ packet(s) in the Qu…

net/tools/quic/quic_time_wait_list_manager_test.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/tools/quic/quic_time_wait_list_manager.h"
 
 #include <errno.h>
 
 #include "net/quic/crypto/crypto_protocol.h"
 #include "net/quic/crypto/null_encrypter.h"
@@ skipping 98 matching lines @@
     EXPECT_CALL(writer_, IsWriteBlockedDataBuffered())
         .WillRepeatedly(Return(false));
   }
 
   void AddConnectionId(QuicConnectionId connection_id) {
     AddConnectionId(connection_id, QuicVersionMax(),
                     /*connection_rejected_statelessly=*/false, nullptr);
   }
 
   void AddStatelessConnectionId(QuicConnectionId connection_id) {
+    std::vector<QuicEncryptedPacket*> termination_packets;
+    termination_packets.push_back(new QuicEncryptedPacket(nullptr, 0, false));
     time_wait_list_manager_.AddConnectionIdToTimeWait(
         connection_id, QuicVersionMax(),
-        /*connection_rejected_statelessly=*/true, nullptr);
+        /*connection_rejected_statelessly=*/true, &termination_packets);
   }
 
   void AddConnectionId(QuicConnectionId connection_id,
                        QuicVersion version,
                        bool connection_rejected_statelessly,
-                       QuicEncryptedPacket* packet) {
+                       std::vector<QuicEncryptedPacket*>* packets) {
     time_wait_list_manager_.AddConnectionIdToTimeWait(
-        connection_id, version, connection_rejected_statelessly, packet);
+        connection_id, version, connection_rejected_statelessly, packets);
   }
 
   bool IsConnectionIdInTimeWait(QuicConnectionId connection_id) {
     return time_wait_list_manager_.IsConnectionIdInTimeWait(connection_id);
   }
 
   void ProcessPacket(QuicConnectionId connection_id,
                      QuicPacketNumber packet_number) {
     QuicEncryptedPacket packet(nullptr, 0);
     time_wait_list_manager_.ProcessPacket(server_address_, client_address_,
@@ skipping 72 matching lines @@
   EXPECT_FALSE(IsConnectionIdInTimeWait(connection_id_));
   EXPECT_CALL(visitor_, OnConnectionAddedToTimeWaitList(connection_id_));
   AddStatelessConnectionId(connection_id_);
   EXPECT_EQ(1u, time_wait_list_manager_.num_connections());
   EXPECT_TRUE(IsConnectionIdInTimeWait(connection_id_));
 }
 
 TEST_F(QuicTimeWaitListManagerTest, SendConnectionClose) {
   const size_t kConnectionCloseLength = 100;
   EXPECT_CALL(visitor_, OnConnectionAddedToTimeWaitList(connection_id_));
+  std::vector<QuicEncryptedPacket*> termination_packets;
+  termination_packets.push_back(
+      new QuicEncryptedPacket(new char[kConnectionCloseLength],
+                              kConnectionCloseLength, true));
   AddConnectionId(connection_id_, QuicVersionMax(),
                   /*connection_rejected_statelessly=*/false,
-                  new QuicEncryptedPacket(new char[kConnectionCloseLength],
-                                          kConnectionCloseLength, true));
+                  &termination_packets);
   const int kRandomSequenceNumber = 1;
   EXPECT_CALL(writer_, WritePacket(_, kConnectionCloseLength,
                                    server_address_.address(),
                                    client_address_))
       .WillOnce(Return(WriteResult(WRITE_STATUS_OK, 1)));
 
   ProcessPacket(connection_id_, kRandomSequenceNumber);
 }
 
+TEST_F(QuicTimeWaitListManagerTest, SendTwoConnectionCloses) {
+  const size_t kConnectionCloseLength = 100;
+  EXPECT_CALL(visitor_, OnConnectionAddedToTimeWaitList(connection_id_));
+  std::vector<QuicEncryptedPacket*> termination_packets;
+  termination_packets.push_back(
+      new QuicEncryptedPacket(new char[kConnectionCloseLength],
+                              kConnectionCloseLength, true));
+  termination_packets.push_back(
+      new QuicEncryptedPacket(new char[kConnectionCloseLength],
+                              kConnectionCloseLength, true));
+  AddConnectionId(connection_id_, QuicVersionMax(),
+                  /*connection_rejected_statelessly=*/false,
+                  &termination_packets);
+  const int kRandomSequenceNumber = 1;
+  EXPECT_CALL(writer_, WritePacket(_, kConnectionCloseLength,
+                                   server_address_.address(),
+                                   client_address_)).Times(2)
+      .WillRepeatedly(Return(WriteResult(WRITE_STATUS_OK, 1)));
+
+  ProcessPacket(connection_id_, kRandomSequenceNumber);
+}
+
 TEST_F(QuicTimeWaitListManagerTest, SendPublicReset) {
   EXPECT_CALL(visitor_, OnConnectionAddedToTimeWaitList(connection_id_));
   AddConnectionId(connection_id_);
   const int kRandomSequenceNumber = 1;
   EXPECT_CALL(writer_, WritePacket(_, _,
                                    server_address_.address(),
                                    client_address_))
       .With(Args<0, 1>(PublicResetPacketEq(connection_id_,
                                            kRandomSequenceNumber)))
       .WillOnce(Return(WriteResult(WRITE_STATUS_OK, 0)));
@@ skipping 19 matching lines @@
       EXPECT_FALSE(QuicTimeWaitListManagerPeer::ShouldSendResponse(
           &time_wait_list_manager_, packet_number));
     }
   }
 }
 
 TEST_F(QuicTimeWaitListManagerTest, NoPublicResetForStatelessConnections) {
   EXPECT_CALL(visitor_, OnConnectionAddedToTimeWaitList(connection_id_));
   AddStatelessConnectionId(connection_id_);
   const int kRandomSequenceNumber = 1;
+
+  EXPECT_CALL(writer_, WritePacket(_, _,
+                                   server_address_.address(),
+                                   client_address_))
+      .WillOnce(Return(WriteResult(WRITE_STATUS_OK, 1)));
+
   ProcessPacket(connection_id_, kRandomSequenceNumber);
 }
 
 TEST_F(QuicTimeWaitListManagerTest, CleanUpOldConnectionIds) {
   const size_t kConnectionIdCount = 100;
   const size_t kOldConnectionIdCount = 31;
 
   // Add connection_ids such that their expiry time is time_wait_period_.
   epoll_server_.set_now_in_usec(0);
   for (size_t connection_id = 1; connection_id <= kOldConnectionIdCount;
@@ skipping 121 matching lines @@
                 &time_wait_list_manager_, kConnectionId3));
 }
 
 TEST_F(QuicTimeWaitListManagerTest, AddConnectionIdTwice) {
   // Add connection_ids such that their expiry time is time_wait_period_.
   epoll_server_.set_now_in_usec(0);
   EXPECT_CALL(visitor_, OnConnectionAddedToTimeWaitList(connection_id_));
   AddConnectionId(connection_id_);
   EXPECT_TRUE(IsConnectionIdInTimeWait(connection_id_));
   const size_t kConnectionCloseLength = 100;
+  std::vector<QuicEncryptedPacket*> termination_packets;
+  termination_packets.push_back(
+      new QuicEncryptedPacket(new char[kConnectionCloseLength],
+                              kConnectionCloseLength, true));
   AddConnectionId(connection_id_, QuicVersionMax(),
                   /*connection_rejected_statelessly=*/false,
-                  new QuicEncryptedPacket(new char[kConnectionCloseLength],
-                                          kConnectionCloseLength, true));
-  EXPECT_TRUE(IsConnectionIdInTimeWait(connection_id_));
+                  &termination_packets);
+      EXPECT_TRUE(IsConnectionIdInTimeWait(connection_id_));
   EXPECT_EQ(1u, time_wait_list_manager_.num_connections());
 
   EXPECT_CALL(writer_, WritePacket(_,
                                    kConnectionCloseLength,
                                    server_address_.address(),
                                    client_address_))
       .WillOnce(Return(WriteResult(WRITE_STATUS_OK, 1)));
 
   const int kRandomSequenceNumber = 1;
   ProcessPacket(connection_id_, kRandomSequenceNumber);
@@ skipping 80 matching lines @@
               time_wait_list_manager_.num_connections());
     EXPECT_FALSE(IsConnectionIdInTimeWait(id_to_evict));
     EXPECT_TRUE(IsConnectionIdInTimeWait(current_connection_id));
   }
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace tools
 }  // namespace net