deprecating gfe2_reloadable_flag_use_early_return_when_verifying_chlo

net/quic/crypto/crypto_server_test.cc

 // Copyright (c) 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 <algorithm>
 #include <cstdint>
 #include <memory>
 #include <ostream>
 #include <vector>
 
@@ skipping 38 matching lines @@
            const std::string& error_details,
            std::unique_ptr<ProofVerifyDetails>* details) override {
     // Do nothing
   }
 };
 
 const char kOldConfigId[] = "old-config-id";
 
 }  // namespace
 
-// Run tests with both parities of
-// FLAGS_use_early_return_when_verifying_chlo.
 struct TestParams {
-  TestParams(bool use_early_return_when_verifying_chlo,
-             bool enable_stateless_rejects,
+  TestParams(bool enable_stateless_rejects,
              bool use_stateless_rejects,
              QuicVersionVector supported_versions)
-      : use_early_return_when_verifying_chlo(
-            use_early_return_when_verifying_chlo),
-        enable_stateless_rejects(enable_stateless_rejects),
+      : enable_stateless_rejects(enable_stateless_rejects),
         use_stateless_rejects(use_stateless_rejects),
         supported_versions(supported_versions) {}
 
   friend ostream& operator<<(ostream& os, const TestParams& p) {
-    os << "{ use_early_return_when_verifying_chlo: "
-       << p.use_early_return_when_verifying_chlo << std::endl;
     os << "  enable_stateless_rejects: " << p.enable_stateless_rejects
        << std::endl;
     os << "  use_stateless_rejects: " << p.use_stateless_rejects << std::endl;
     os << "  versions: " << QuicVersionVectorToString(p.supported_versions)
        << " }";
     return os;
   }
 
-  bool use_early_return_when_verifying_chlo;
   // This only enables the stateless reject feature via the feature-flag.
   // It does not force the crypto server to emit stateless rejects.
   bool enable_stateless_rejects;
   // If true, this forces the server to send a stateless reject when
   // rejecting messages.  This should be a no-op if
   // enable_stateless_rejects is false.
   bool use_stateless_rejects;
   // Versions supported by client and server.
   QuicVersionVector supported_versions;
 };
 
 // Constructs various test permutations.
 vector<TestParams> GetTestParams() {
   vector<TestParams> params;
   static const bool kTrueFalse[] = {true, false};
-  for (bool use_early_return : kTrueFalse) {
-    for (bool enable_stateless_rejects : kTrueFalse) {
-      for (bool use_stateless_rejects : kTrueFalse) {
-        // Start with all versions, remove highest on each iteration.
-        QuicVersionVector supported_versions = QuicSupportedVersions();
-        while (!supported_versions.empty()) {
-          params.push_back(
-              TestParams(use_early_return, enable_stateless_rejects,
-                         use_stateless_rejects, supported_versions));
-          supported_versions.erase(supported_versions.begin());
-        }
+  for (bool enable_stateless_rejects : kTrueFalse) {
+    for (bool use_stateless_rejects : kTrueFalse) {
+      // Start with all versions, remove highest on each iteration.
+      QuicVersionVector supported_versions = QuicSupportedVersions();
+      while (!supported_versions.empty()) {
+        params.push_back(TestParams(enable_stateless_rejects,
+                                    use_stateless_rejects, supported_versions));
+        supported_versions.erase(supported_versions.begin());
       }
     }
   }
   return params;
 }
 
 class CryptoServerTest : public ::testing::TestWithParam<TestParams> {
  public:
   CryptoServerTest()
       : rand_(QuicRandom::GetInstance()),
         client_address_(Loopback4(), 1234),
         config_(QuicCryptoServerConfig::TESTING,
                 rand_,
                 CryptoTestUtils::ProofSourceForTesting()),
         compressed_certs_cache_(
             QuicCompressedCertsCache::kQuicCompressedCertsCacheSize) {
     supported_versions_ = GetParam().supported_versions;
     config_.set_enable_serving_sct(true);
 
     client_version_ = supported_versions_.front();
     client_version_string_ =
         QuicUtils::TagToString(QuicVersionToQuicTag(client_version_));
 
-    FLAGS_use_early_return_when_verifying_chlo =
-        GetParam().use_early_return_when_verifying_chlo;
     FLAGS_enable_quic_stateless_reject_support =
         GetParam().enable_stateless_rejects;
     use_stateless_rejects_ = GetParam().use_stateless_rejects;
   }
 
   void SetUp() override {
     QuicCryptoServerConfig::ConfigOptions old_config_options;
     old_config_options.id = kOldConfigId;
     delete config_.AddDefaultConfig(rand_, &clock_, old_config_options);
     clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(1000));
@@ skipping 175 matching lines @@
   void CheckRejectReasons(
       const HandshakeFailureReason* expected_handshake_failures,
       size_t expected_count) {
     const uint32_t* reject_reasons;
     size_t num_reject_reasons;
     static_assert(sizeof(QuicTag) == sizeof(uint32_t), "header out of sync");
     QuicErrorCode error_code =
         out_.GetTaglist(kRREJ, &reject_reasons, &num_reject_reasons);
     ASSERT_EQ(QUIC_NO_ERROR, error_code);
 
-    if (FLAGS_use_early_return_when_verifying_chlo) {
-      EXPECT_EQ(1u, num_reject_reasons);
-    } else {
-      EXPECT_EQ(expected_count, num_reject_reasons);
-    }
+    EXPECT_EQ(expected_count, num_reject_reasons);
     for (size_t i = 0; i < num_reject_reasons; ++i) {
       EXPECT_EQ(expected_handshake_failures[i], reject_reasons[i]);
     }
   }
 
   // If the server is rejecting statelessly, make sure it contains a
   // server-designated connection id.  Once the check is complete,
   // allow the random id-generator to move to the next value.
   void CheckForServerDesignatedConnectionId() {
     QuicConnectionId server_designated_connection_id;
@@ skipping 44 matching lines @@
   CryptoHandshakeMessage out_;
   uint8_t orbit_[kOrbitSize];
   bool use_stateless_rejects_;
 
   // These strings contain hex escaped values from the server suitable for using
   // when constructing client hello messages.
   string nonce_hex_, pub_hex_, srct_hex_, scid_hex_;
   std::unique_ptr<CryptoHandshakeMessage> server_config_;
 };
 
-// Run all CryptoServerTest with both values of
-// FLAGS_use_early_return_when_verifying_chlo.
 INSTANTIATE_TEST_CASE_P(CryptoServerTests,
                         CryptoServerTest,
                         ::testing::ValuesIn(GetTestParams()));
 
 TEST_P(CryptoServerTest, BadSNI) {
   // clang-format off
   static const char* const kBadSNIs[] = {
     "",
     "foo",
     "#00",
@@ skipping 764 matching lines @@
 
   strike_register_client_->RunPendingVerifications();
   ASSERT_TRUE(called);
   EXPECT_EQ(0, strike_register_client_->PendingVerifications());
   // The message should be rejected now.
   CheckRejectTag();
 }
 
 }  // namespace test
 }  // namespace net