Simplify QUIC stateless rejects by latching the value of FLAGS_enable_quic_stateless_reject_support…

net/tools/quic/quic_dispatcher_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/tools/quic/quic_dispatcher.h"
 
 #include <ostream>
 #include <string>
 
 #include "base/strings/string_piece.h"
@@ skipping 310 matching lines @@
   void set_handshake_confirmed_for_testing(bool handshake_confirmed) {
     handshake_confirmed_ = handshake_confirmed;
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockQuicCryptoServerStream);
 };
 
 struct StatelessRejectTestParams {
   StatelessRejectTestParams(bool enable_stateless_rejects_via_flag,
-                            bool use_stateless_rejects_if_peer_supported,
                             bool client_supports_statelesss_rejects,
                             bool crypto_handshake_successful)
       : enable_stateless_rejects_via_flag(enable_stateless_rejects_via_flag),
-        use_stateless_rejects_if_peer_supported(
-            use_stateless_rejects_if_peer_supported),
         client_supports_statelesss_rejects(client_supports_statelesss_rejects),
         crypto_handshake_successful(crypto_handshake_successful) {}
 
   friend std::ostream& operator<<(std::ostream& os,
                                   const StatelessRejectTestParams& p) {
     os << "  enable_stateless_rejects_via_flag: "
        << p.enable_stateless_rejects_via_flag << std::endl;
-    os << "{ use_stateless_rejects_if_peer_supported: "
-       << p.use_stateless_rejects_if_peer_supported << std::endl;
     os << "{ client_supports_statelesss_rejects: "
        << p.client_supports_statelesss_rejects << std::endl;
     os << "  crypto_handshake_successful: " << p.crypto_handshake_successful
        << " }";
     return os;
   }
 
   // This only enables the stateless reject feature via the feature-flag.
-  // It does not force the crypto server to emit stateless rejects.
+  // This should be a no-op if the peer does not support them.
   bool enable_stateless_rejects_via_flag;
-  // If true, this forces the server to send a stateless reject when rejecting
-  // messages.  This should be a no-op if enable_stateless_rejects_via_flag is
-  // false or the peer does not support them.
-  bool use_stateless_rejects_if_peer_supported;
   // Whether or not the client supports stateless rejects.
   bool client_supports_statelesss_rejects;
   // Should the initial crypto handshake succeed or not.
   bool crypto_handshake_successful;
 };
 
 // Constructs various test permutations for stateless rejects.
 vector<StatelessRejectTestParams> GetStatelessRejectTestParams() {
   vector<StatelessRejectTestParams> params;
   for (bool enable_stateless_rejects_via_flag : {true, false}) {
-    for (bool use_stateless_rejects_if_peer_supported : {true, false}) {
-      for (bool client_supports_statelesss_rejects : {true, false}) {
-        for (bool crypto_handshake_successful : {true, false}) {
-          params.push_back(StatelessRejectTestParams(
-              enable_stateless_rejects_via_flag,
-              use_stateless_rejects_if_peer_supported,
-              client_supports_statelesss_rejects, crypto_handshake_successful));
-        }
+    for (bool client_supports_statelesss_rejects : {true, false}) {
+      for (bool crypto_handshake_successful : {true, false}) {
+        params.push_back(StatelessRejectTestParams(
+            enable_stateless_rejects_via_flag,
+            client_supports_statelesss_rejects, crypto_handshake_successful));
       }
     }
   }
   return params;
 }
 
 class QuicDispatcherStatelessRejectTest
     : public QuicDispatcherTest,
       public ::testing::WithParamInterface<StatelessRejectTestParams> {
  public:
   QuicDispatcherStatelessRejectTest() : crypto_stream1_(nullptr) {}
 
   ~QuicDispatcherStatelessRejectTest() override {
     if (crypto_stream1_) {
       delete crypto_stream1_;
     }
   }
 
   // This test setup assumes that all testing will be done using
   // crypto_stream1_.
   void SetUp() override {
     FLAGS_enable_quic_stateless_reject_support =
         GetParam().enable_stateless_rejects_via_flag;
   }
 
   // Returns true or false, depending on whether the server will emit
   // a stateless reject, depending upon the parameters of the test.
   bool ExpectStatelessReject() {
     return GetParam().enable_stateless_rejects_via_flag &&
-           GetParam().use_stateless_rejects_if_peer_supported &&
            !GetParam().crypto_handshake_successful &&
            GetParam().client_supports_statelesss_rejects;
   }
 
   // Sets up dispatcher_, sesession1_, and crypto_stream1_ based on
   // the test parameters.
   QuicServerSession* CreateSessionBasedOnTestParams(
       QuicConnectionId connection_id,
       const IPEndPoint& client_address) {
     CreateSession(&dispatcher_, config_, connection_id, client_address,
                   &mock_helper_, &crypto_config_, &session1_);
 
     crypto_stream1_ = new MockQuicCryptoServerStream(crypto_config_, session1_);
     session1_->SetCryptoStream(crypto_stream1_);
-    crypto_stream1_->set_use_stateless_rejects_if_peer_supported(
-        GetParam().use_stateless_rejects_if_peer_supported);
     crypto_stream1_->set_handshake_confirmed_for_testing(
         GetParam().crypto_handshake_successful);
     crypto_stream1_->set_peer_supports_stateless_rejects(
         GetParam().client_supports_statelesss_rejects);
     return session1_;
   }
 
   MockQuicCryptoServerStream* crypto_stream1_;
 };
 
@@ skipping 322 matching lines @@
   // And we'll resume where we left off when we get another call.
   EXPECT_CALL(*connection2(), OnCanWrite());
   dispatcher_.OnCanWrite();
   EXPECT_FALSE(dispatcher_.HasPendingWrites());
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace tools
 }  // namespace net