deprecate -FLAGS_quic_reloadable_flag_quic_disable_version_34 and remove support for QUIC v34.

net/quic/core/quic_server_session_base_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/quic/core/quic_server_session_base.h"
 
 #include <cstdint>
 #include <memory>
 
 #include "base/macros.h"
@@ skipping 175 matching lines @@
                         QuicServerSessionBaseTest,
                         ::testing::ValuesIn(AllSupportedVersions()));
 TEST_P(QuicServerSessionBaseTest, ServerPushDisabledByDefault) {
   FLAGS_quic_reloadable_flag_quic_enable_server_push_by_default = true;
   // Without the client explicitly sending kSPSH, server push will be disabled
   // at the server, until version 35 when it is enabled by default.
   EXPECT_FALSE(
       session_->config()->HasReceivedConnectionOptions() &&
       ContainsQuicTag(session_->config()->ReceivedConnectionOptions(), kSPSH));
   session_->OnConfigNegotiated();
-  if (GetParam() <= QUIC_VERSION_34) {
-    EXPECT_FALSE(session_->server_push_enabled());
-  } else {
-    EXPECT_TRUE(session_->server_push_enabled());
-  }
+  EXPECT_TRUE(session_->server_push_enabled());
 }
 
 TEST_P(QuicServerSessionBaseTest, CloseStreamDueToReset) {
   // Open a stream, then reset it.
   // Send two bytes of payload to open it.
   QuicStreamFrame data1(kClientDataStreamId1, false, 0, QuicStringPiece("HT"));
   session_->OnStreamFrame(data1);
   EXPECT_EQ(1u, session_->GetNumOpenIncomingStreams());
 
   // Send a reset (and expect the peer to send a RST in response).
@@ skipping 59 matching lines @@
   // The stream should never be opened, now that the reset is received.
   EXPECT_EQ(1u, session_->GetNumOpenIncomingStreams());
   EXPECT_TRUE(connection_->connected());
 }
 
 TEST_P(QuicServerSessionBaseTest, MaxOpenStreams) {
   // Test that the server refuses if a client attempts to open too many data
   // streams.  The server accepts slightly more than the negotiated stream limit
   // to deal with rare cases where a client FIN/RST is lost.
 
-  if (GetParam() <= QUIC_VERSION_34) {
-    EXPECT_EQ(kMaxStreamsForTest, session_->max_open_incoming_streams());
-  }
-
   // The slightly increased stream limit is set during config negotiation.  It
   // is either an increase of 10 over negotiated limit, or a fixed percentage
   // scaling, whichever is larger. Test both before continuing.
   session_->OnConfigNegotiated();
   EXPECT_LT(kMaxStreamsMultiplier * kMaxStreamsForTest,
             kMaxStreamsForTest + kMaxStreamsMinimumIncrement);
   EXPECT_EQ(kMaxStreamsForTest + kMaxStreamsMinimumIncrement,
             session_->max_open_incoming_streams());
   EXPECT_EQ(0u, session_->GetNumOpenIncomingStreams());
   QuicStreamId stream_id = kClientDataStreamId1;
@@ skipping 18 matching lines @@
   // Even if the connection remains open, the stream creation should fail.
   EXPECT_FALSE(QuicServerSessionBasePeer::GetOrCreateDynamicStream(
       session_.get(), stream_id));
 }
 
 TEST_P(QuicServerSessionBaseTest, MaxAvailableStreams) {
   // Test that the server closes the connection if a client makes too many data
   // streams available.  The server accepts slightly more than the negotiated
   // stream limit to deal with rare cases where a client FIN/RST is lost.
 
-  if (GetParam() <= QUIC_VERSION_34) {
-    // The slightly increased stream limit is set during config negotiation.
-    EXPECT_EQ(kMaxStreamsForTest, session_->max_open_incoming_streams());
-  }
   session_->OnConfigNegotiated();
   const size_t kAvailableStreamLimit = session_->MaxAvailableStreams();
   EXPECT_EQ(
       session_->max_open_incoming_streams() * kMaxAvailableStreamsMultiplier,
       session_->MaxAvailableStreams());
   // The protocol specification requires that there can be at least 10 times
   // as many available streams as the connection's maximum open streams.
   EXPECT_LE(10 * kMaxStreamsForTest, kAvailableStreamLimit);
 
   EXPECT_EQ(0u, session_->GetNumOpenIncomingStreams());
@@ skipping 309 matching lines @@
 
   // Allow the async ProofSource::GetProof call to complete.  Verify (under
   // asan) that this does not result in accesses to any freed memory from the
   // session or its subobjects.
   GetFakeProofSource()->InvokePendingCallback(0);
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net