Deprecate FLAGS_quic_disable_pre_30. Remove QUIC versions [25-29].

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 <list>
 #include <memory>
 #include <string>
@@ skipping 135 matching lines @@
 vector<TestParams> GetTestParams() {
   // Divide the versions into buckets in which the intra-frame format
   // is compatible. When clients encounter QUIC version negotiation
   // they simply retransmit all packets using the new version's
   // QUIC framing. However, they are unable to change the intra-frame
   // layout (for example to change SPDY/4 headers to SPDY/3). So
   // these tests need to ensure that clients are never attempting
   // to do 0-RTT across incompatible versions. Chromium only supports
   // a single version at a time anyway. :)
   QuicVersionVector all_supported_versions = QuicSupportedVersions();
-  QuicVersionVector version_buckets[5];
+  QuicVersionVector version_buckets[4];
 
   for (const QuicVersion version : all_supported_versions) {
-    if (version <= QUIC_VERSION_25) {
-      // Versions: 25
-      // SPDY/4
+    if (version <= QUIC_VERSION_30) {
+      // Versions: 30
+      // v26 adds a hash of the expected leaf cert in the XLCT tag.
       version_buckets[0].push_back(version);
-    } else if (version <= QUIC_VERSION_30) {
-      // Versions: 26-30
-      // v26 adds a hash of the expected leaf cert in the XLCT tag.
-      version_buckets[1].push_back(version);
     } else if (version <= QUIC_VERSION_32) {
       // Versions: 31-32
       // v31 adds a hash of the CHLO into the proof signature.
-      version_buckets[2].push_back(version);
+      version_buckets[1].push_back(version);
     } else if (version <= QUIC_VERSION_33) {
       // Versions: 33
       // v33 adds a diversification nonce into the hkdf.
-      version_buckets[3].push_back(version);
+      version_buckets[2].push_back(version);
     } else {
       // Versions: 34+
       // QUIC_VERSION_34 deprecates entropy and uses new ack and stop waiting
       // wire formats.
-      version_buckets[4].push_back(version);
+      version_buckets[3].push_back(version);
     }
   }
 
   // This must be kept in sync with the number of nested for-loops below as it
   // is used to prune the number of tests that are run.
   const int kMaxEnabledOptions = 5;
   int max_enabled_options = 0;
   vector<TestParams> params;
   for (bool server_uses_stateless_rejects_if_peer_supported : {true, false}) {
     for (bool client_supports_stateless_rejects : {true, false}) {
@@ skipping 25 matching lines @@
                 max_enabled_options = enabled_options;
               }
 
               // Run tests with no options, a single option, or all the options
               // enabled to avoid a combinatorial explosion.
               if (enabled_options > 1 && enabled_options < kMaxEnabledOptions) {
                 continue;
               }
 
               for (const QuicVersionVector& client_versions : version_buckets) {
-                if (client_versions.front() < QUIC_VERSION_30 &&
-                    FLAGS_quic_disable_pre_30) {
-                  continue;
-                }
                 CHECK(!client_versions.empty());
                 // Add an entry for server and client supporting all versions.
                 params.push_back(TestParams(
                     client_versions, all_supported_versions,
                     client_versions.front(), client_supports_stateless_rejects,
                     server_uses_stateless_rejects_if_peer_supported,
                     congestion_control_tag, auto_tune_flow_control_window,
                     disable_hpack_dynamic_table, force_hol_blocking));
 
                 // Run version negotiation tests tests with no options, or all
                 // the options enabled to avoid a combinatorial explosion.
                 if (enabled_options > 0 &&
                     enabled_options < kMaxEnabledOptions) {
                   continue;
                 }
 
                 // Test client supporting all versions and server
                 // supporting 1 version. Simulate an old server and
                 // exercise version downgrade in the client. Protocol
                 // negotiation should occur. Skip the i = 0 case
                 // because it is essentially the same as the default
                 // case.
                 for (size_t i = 1; i < client_versions.size(); ++i) {
-                  if (client_versions[i] < QUIC_VERSION_30 &&
-                      FLAGS_quic_disable_pre_30) {
-                    continue;
-                  }
                   QuicVersionVector server_supported_versions;
                   server_supported_versions.push_back(client_versions[i]);
                   params.push_back(TestParams(
                       client_versions, server_supported_versions,
                       server_supported_versions.front(),
                       client_supports_stateless_rejects,
                       server_uses_stateless_rejects_if_peer_supported,
                       congestion_control_tag, auto_tune_flow_control_window,
                       disable_hpack_dynamic_table, force_hol_blocking));
                 }
@@ skipping 951 matching lines @@
   request.AddHeader("content-length", "3");
   request.set_has_complete_message(false);
 
   // The server supports a small number of additional streams beyond the
   // negotiated limit. Open enough streams to go beyond that limit.
   for (int i = 0; i < kServerMaxStreams + 1; ++i) {
     client_->SendMessage(request);
   }
   client_->WaitForResponse();
 
-  if (negotiated_version_ <= QUIC_VERSION_27) {
-    EXPECT_FALSE(client_->connected());
-    EXPECT_EQ(QUIC_STREAM_CONNECTION_ERROR, client_->stream_error());
-    EXPECT_EQ(QUIC_TOO_MANY_OPEN_STREAMS, client_->connection_error());
-  } else {
-    EXPECT_TRUE(client_->connected());
-    EXPECT_EQ(QUIC_REFUSED_STREAM, client_->stream_error());
-    EXPECT_EQ(QUIC_NO_ERROR, client_->connection_error());
-  }
+  EXPECT_TRUE(client_->connected());
+  EXPECT_EQ(QUIC_REFUSED_STREAM, client_->stream_error());
+  EXPECT_EQ(QUIC_NO_ERROR, client_->connection_error());
 }
 
 TEST_P(EndToEndTest, MaxIncomingDynamicStreamsLimitRespected) {
   // Set a limit on maximum number of incoming dynamic streams.
   // Make sure the limit is respected.
   const uint32_t kServerMaxIncomingDynamicStreams = 1;
   server_config_.SetMaxIncomingDynamicStreamsToSend(
       kServerMaxIncomingDynamicStreams);
   ASSERT_TRUE(Initialize());
   client_->client()->WaitForCryptoHandshakeConfirmed();
@@ skipping 1158 matching lines @@
   set_server_initial_stream_flow_control_receive_window(kWindowSize);
   set_server_initial_session_flow_control_receive_window(kWindowSize);
 
   ASSERT_TRUE(Initialize());
 
   client_->client()->WaitForCryptoHandshakeConfirmed();
 
   // POST to a URL that gets an early error response, after the headers are
   // received and before the body is received.
   HTTPMessage request(HttpConstants::HTTP_1_1, HttpConstants::POST, "/garbage");
-  const uint32_t kBodySize = 2 * kWindowSize;
   // Invalid content-length so the request will receive an early 500 response.
   request.AddHeader("content-length", "-1");
   request.set_skip_message_validation(true);
   request.set_has_complete_message(false);
 
   // Tell the client to not close the stream if it receives an early response.
   client_->set_allow_bidirectional_data(true);
   // Send the headers.
   client_->SendMessage(request);
   // Receive the response and let the server close writing.
   client_->WaitForInitialResponse();
   EXPECT_EQ(500u, client_->response_headers()->parsed_response_code());
 
-  if (negotiated_version_ > QUIC_VERSION_28) {
-    // Receive the reset stream from server on early response.
-    client_->WaitForResponseForMs(100);
-    ReliableQuicStream* stream =
-        client_->client()->session()->GetOrCreateStream(kClientDataStreamId1);
-    // The stream is reset by server's reset stream.
-    EXPECT_EQ(stream, nullptr);
-    return;
-  }
-
-  // Send a body larger than the stream flow control window.
-  string body;
-  GenerateBody(&body, kBodySize);
-  client_->SendData(body, true);
-
-  // Run the client to let any buffered data be sent.
-  // (This is OK despite already waiting for a response.)
-  client_->WaitForResponse();
-  // There should be no buffered data to write in the client's stream.
+  // Receive the reset stream from server on early response.
   ReliableQuicStream* stream =
       client_->client()->session()->GetOrCreateStream(kClientDataStreamId1);
-  EXPECT_FALSE(stream != nullptr && stream->HasBufferedData());
+  // The stream is reset by server's reset stream.
+  EXPECT_EQ(stream, nullptr);
 }
 
 TEST_P(EndToEndTest, Trailers) {
   // Test sending and receiving HTTP/2 Trailers (trailing HEADERS frames).
   ASSERT_TRUE(Initialize());
   client_->client()->WaitForCryptoHandshakeConfirmed();
 
   // Set reordering to ensure that Trailers arriving before body is ok.
   SetPacketSendDelay(QuicTime::Delta::FromMilliseconds(2));
   SetReorderPercentage(30);
@@ skipping 378 matching lines @@
   client_->WaitForResponse();
   // TODO(fayang): Fix this test to work with stateless rejects.
   if (!BothSidesSupportStatelessRejects()) {
     VerifyCleanConnection(true);
   }
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net