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

net/tools/quic/end_to_end_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 <stddef.h>
 #include <string>
 #include <sys/epoll.h>
 #include <vector>
 
 #include "base/basictypes.h"
@@ skipping 456 matching lines @@
   // Calls server_thread_ Pause() and Resume(), which may only be called once
   // per test.
   void VerifyCleanConnection(bool /*had_packet_loss*/) {
     QuicConnectionStats client_stats =
         client_->client()->session()->connection()->GetStats();
     // TODO(ianswett): Re-enable this check once b/19572432 is fixed.
     // if (!had_packet_loss) {
     //   EXPECT_EQ(0u, client_stats.packets_lost);
     // }
     EXPECT_EQ(0u, client_stats.packets_discarded);
-    EXPECT_EQ(0u, client_stats.packets_dropped);
+    // When doing 0-RTT with stateless rejects, the encrypted requests cause
+    // a retranmission of the SREJ packets which are dropped by the client.
+    if (!BothSidesSupportStatelessRejects()) {
+      EXPECT_EQ(0u, client_stats.packets_dropped);
+    }
     EXPECT_EQ(client_stats.packets_received, client_stats.packets_processed);
 
     const int num_expected_stateless_rejects =
         (BothSidesSupportStatelessRejects() &&
          client_->client()->session()->GetNumSentClientHellos() > 0)
             ? 1
             : 0;
     EXPECT_EQ(num_expected_stateless_rejects,
               client_->client()->num_stateless_rejects_received());
 
@@ skipping 431 matching lines @@
   EXPECT_EQ(expected_num_hellos_latest_session,
             client_->client()->session()->GetNumSentClientHellos());
   EXPECT_EQ(2, client_->client()->GetNumSentClientHellos());
 
   VerifyCleanConnection(false);
 }
 
 TEST_P(EndToEndTest, StatelessRejectWithPacketLoss) {
   // In this test, we intentionally drop the first packet from the
   // server, which corresponds with the initial REJ/SREJ response from
-  // the server.  The REJ case will succeed, due to redundancy in the
-  // stateful handshake.  The SREJ will fail, because there is
-  // (currently) no way to recover from a loss of the first SREJ, and
-  // all remaining state for the first handshake is black-holed on the
-  // time-wait list.
-  // TODO(jokulik): Once redundant SREJ support is added, this test
-  // should succeed.
+  // the server.
   server_writer_->set_fake_drop_first_n_packets(1);
-  // If this test will involve version negotiation then the version
-  // negotiation packet will be dropped, not the SREJ, and since the
-  // version negotiation packet will be retransmitted the test will
-  // succeed.
-  const bool will_succeed =
-      !BothSidesSupportStatelessRejects() ||
-      negotiated_version_ != client_supported_versions_.front();
-  ASSERT_EQ(will_succeed, Initialize());
+  ASSERT_TRUE(Initialize());
 }
 
 TEST_P(EndToEndTest, SetInitialReceivedConnectionOptions) {
   QuicTagVector initial_received_options;
   initial_received_options.push_back(kTBBR);
   initial_received_options.push_back(kIW10);
   initial_received_options.push_back(kPRST);
   EXPECT_TRUE(server_config_.SetInitialReceivedConnectionOptions(
       initial_received_options));
 
@@ skipping 1155 matching lines @@
     // There will be buffered data to write in the client's stream.
     ReliableQuicStream* stream = client_->client()->session()->GetStream(5);
     EXPECT_TRUE(stream != nullptr && stream->HasBufferedData());
   }
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace tools
 }  // namespace net