Remove strike-register code from QuicCryptoServerConfig

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 <sys/epoll.h>
 
 #include <cstdint>
 #include <list>
 #include <memory>
@@ skipping 259 matching lines @@
 
 class EndToEndTest : public ::testing::TestWithParam<TestParams> {
  protected:
   EndToEndTest()
       : initialized_(false),
         server_address_(IPEndPoint(Loopback4(), 0)),
         server_hostname_("test.example.com"),
         client_writer_(nullptr),
         server_writer_(nullptr),
         server_started_(false),
-        strike_register_no_startup_period_(false),
         chlo_multiplier_(0),
         stream_factory_(nullptr),
         support_server_push_(false) {
     client_supported_versions_ = GetParam().client_supported_versions;
     server_supported_versions_ = GetParam().server_supported_versions;
     negotiated_version_ = GetParam().negotiated_version;
 
     VLOG(1) << "Using Configuration: " << GetParam();
 
     // Use different flow control windows for client/server.
@@ skipping 135 matching lines @@
     StopServer();
   }
 
   void StartServer() {
     FLAGS_quic_use_cheap_stateless_rejects =
         GetParam().use_cheap_stateless_reject;
 
     auto test_server =
         new QuicTestServer(CryptoTestUtils::ProofSourceForTesting(),
                            server_config_, server_supported_versions_);
-    server_thread_.reset(new ServerThread(test_server, server_address_,
-                                          strike_register_no_startup_period_));
+    server_thread_.reset(new ServerThread(test_server, server_address_));
     if (chlo_multiplier_ != 0) {
       server_thread_->server()->SetChloMultiplier(chlo_multiplier_);
     }
     server_thread_->Initialize();
     server_address_ =
         IPEndPoint(server_address_.address(), server_thread_->GetPort());
     QuicDispatcher* dispatcher =
         QuicServerPeer::GetDispatcher(server_thread_->server());
     QuicDispatcherPeer::UseWriter(dispatcher, server_writer_);
 
@@ skipping 116 matching lines @@
   std::unique_ptr<ServerThread> server_thread_;
   std::unique_ptr<QuicTestClient> client_;
   PacketDroppingTestWriter* client_writer_;
   PacketDroppingTestWriter* server_writer_;
   bool server_started_;
   QuicConfig client_config_;
   QuicConfig server_config_;
   QuicVersionVector client_supported_versions_;
   QuicVersionVector server_supported_versions_;
   QuicVersion negotiated_version_;
-  bool strike_register_no_startup_period_;
   size_t chlo_multiplier_;
   QuicTestServer::StreamFactory* stream_factory_;
   bool support_server_push_;
   bool force_hol_blocking_;
 };
 
 // Run all end to end tests with all supported versions.
 INSTANTIATE_TEST_CASE_P(EndToEndTests,
                         EndToEndTest,
                         ::testing::ValuesIn(GetTestParams()));
@@ skipping 258 matching lines @@
   headers[":method"] = "POST";
   headers[":path"] = "/foo";
   headers[":scheme"] = "https";
   headers[":authority"] = server_hostname_;
 
   EXPECT_EQ(kFooResponseBody,
             client_->SendCustomSynchronousRequest(headers, body));
 }
 
 TEST_P(EndToEndTest, LargePostZeroRTTFailure) {
-  // Have the server accept 0-RTT without waiting a startup period.
-  strike_register_no_startup_period_ = true;
-
   // Send a request and then disconnect. This prepares the client to attempt
   // a 0-RTT handshake for the next request.
   ASSERT_TRUE(Initialize());
 
   string body;
   GenerateBody(&body, 20480);
   SpdyHeaderBlock headers;
   headers[":method"] = "POST";
   headers[":path"] = "/foo";
   headers[":scheme"] = "https";
@@ skipping 41 matching lines @@
   // torn down after the reject.  The number of hellos sent on the
   // latest session is 1.
   EXPECT_EQ(expected_num_hellos_latest_session,
             client_->client()->session()->GetNumSentClientHellos());
   EXPECT_EQ(2, client_->client()->GetNumSentClientHellos());
 
   VerifyCleanConnection(false);
 }
 
 TEST_P(EndToEndTest, SynchronousRequestZeroRTTFailure) {
-  // Have the server accept 0-RTT without waiting a startup period.
-  strike_register_no_startup_period_ = true;
-
   // Send a request and then disconnect. This prepares the client to attempt
   // a 0-RTT handshake for the next request.
   ASSERT_TRUE(Initialize());
 
   EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo"));
   // In the non-stateless case, the same session is used for both
   // hellos, so the number of hellos sent on that session is 2.  In
   // the stateless case, the first client session will be completely
   // torn down after the reject.  The number of hellos on that second
   // latest session is 1.
@@ skipping 30 matching lines @@
   // torn down after the reject.  The number of hellos sent on the
   // latest session is 1.
   EXPECT_EQ(expected_num_hellos_latest_session,
             client_->client()->session()->GetNumSentClientHellos());
   EXPECT_EQ(2, client_->client()->GetNumSentClientHellos());
 
   VerifyCleanConnection(false);
 }
 
 TEST_P(EndToEndTest, LargePostSynchronousRequest) {
-  // Have the server accept 0-RTT without waiting a startup period.
-  strike_register_no_startup_period_ = true;
-
   // Send a request and then disconnect. This prepares the client to attempt
   // a 0-RTT handshake for the next request.
   ASSERT_TRUE(Initialize());
 
   string body;
   GenerateBody(&body, 20480);
   SpdyHeaderBlock headers;
   headers[":method"] = "POST";
   headers[":path"] = "/foo";
   headers[":scheme"] = "https";
@@ skipping 1976 matching lines @@
   client_->WaitForResponse();
   EXPECT_EQ(kBarResponseBody, client_->response_body());
   QuicConnectionStats client_stats =
       client_->client()->session()->connection()->GetStats();
   EXPECT_EQ(0u, client_stats.packets_lost);
   EXPECT_EQ(1, client_->client()->GetNumSentClientHellos());
 }
 }  // namespace
 }  // namespace test
 }  // namespace net