Land Recent QUIC Changes.

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 <string>
 #include <sys/epoll.h>
 #include <vector>
 
 #include "base/basictypes.h"
@@ skipping 121 matching lines @@
                                     use_fec != 0,
                                     congestion_control_tag));
 
         // 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 < all_supported_versions.size(); ++i) {
           QuicVersionVector server_supported_versions;
           server_supported_versions.push_back(all_supported_versions[i]);
-          if (all_supported_versions[i] >= QUIC_VERSION_18) {
-            // Until flow control is globally rolled out and we remove
-            // QUIC_VERSION_16, the server MUST support at least one QUIC
-            // version that does not use flow control.
-            server_supported_versions.push_back(QUIC_VERSION_16);
-          }
           params.push_back(TestParams(all_supported_versions,
                                       server_supported_versions,
                                       server_supported_versions[0],
                                       use_pacing != 0,
                                       use_fec != 0,
                                       congestion_control_tag));
         }
       }
     }
   }
@@ skipping 528 matching lines @@
                       HttpConstants::POST, "/foo");
   request.AddBody(body, true);
 
   EXPECT_EQ(kFooResponseBody, client_->SendCustomSynchronousRequest(request));
   EXPECT_EQ(2, client_->client()->session()->GetNumSentClientHellos());
 
   client_->Disconnect();
 
   // The 0-RTT handshake should succeed.
   client_->Connect();
-  if (client_supported_versions_[0] >= QUIC_VERSION_18 &&
-      negotiated_version_ <= QUIC_VERSION_16) {
-    // If the version negotiation has resulted in a downgrade, then the client
-    // must wait for the handshake to complete before sending any data.
-    // Otherwise it may have queued frames which will trigger a
-    // DFATAL when they are serialized after the downgrade.
-    client_->client()->WaitForCryptoHandshakeConfirmed();
-  }
   client_->WaitForResponseForMs(-1);
   ASSERT_TRUE(client_->client()->connected());
   EXPECT_EQ(kFooResponseBody, client_->SendCustomSynchronousRequest(request));
   EXPECT_EQ(1, client_->client()->session()->GetNumSentClientHellos());
 
   client_->Disconnect();
 
   // Restart the server so that the 0-RTT handshake will take 1 RTT.
   StopServer();
   server_writer_ = new PacketDroppingTestWriter();
   StartServer();
 
   client_->Connect();
-  if (client_supported_versions_[0] >= QUIC_VERSION_18 &&
-      negotiated_version_ <= QUIC_VERSION_16) {
-    // If the version negotiation has resulted in a downgrade, then the client
-    // must wait for the handshake to complete before sending any data.
-    // Otherwise it may have queued frames which will trigger a
-    // DFATAL when they are serialized after the downgrade.
-    client_->client()->WaitForCryptoHandshakeConfirmed();
-  }
   ASSERT_TRUE(client_->client()->connected());
   EXPECT_EQ(kFooResponseBody, client_->SendCustomSynchronousRequest(request));
   EXPECT_EQ(2, client_->client()->session()->GetNumSentClientHellos());
   VerifyCleanConnection(false);
 }
 
 TEST_P(EndToEndTest, CorrectlyConfiguredFec) {
   ASSERT_TRUE(Initialize());
   client_->client()->WaitForCryptoHandshakeConfirmed();
   server_thread_->WaitForCryptoHandshakeConfirmed();
@@ skipping 128 matching lines @@
 
   // By default the stream protects itself from writes after terminte is set.
   // Override this to test the server handling buggy clients.
   ReliableQuicStreamPeer::SetWriteSideClosed(
       false, client_->GetOrCreateStream());
 
   EXPECT_DFATAL(client_->SendData("eep", true), "Fin already buffered");
 }
 
 TEST_P(EndToEndTest, Timeout) {
-  client_config_.set_idle_connection_state_lifetime(
+  client_config_.SetIdleConnectionStateLifetime(
       QuicTime::Delta::FromMicroseconds(500),
       QuicTime::Delta::FromMicroseconds(500));
   // Note: we do NOT ASSERT_TRUE: we may time out during initial handshake:
   // that's enough to validate timeout in this case.
   Initialize();
   while (client_->client()->connected()) {
     client_->client()->WaitForEvents();
   }
 }
 
 TEST_P(EndToEndTest, NegotiateMaxOpenStreams) {
   // Negotiate 1 max open stream.
-  client_config_.set_max_streams_per_connection(1, 1);
+  client_config_.SetMaxStreamsPerConnection(1, 1);
   ASSERT_TRUE(Initialize());
   client_->client()->WaitForCryptoHandshakeConfirmed();
 
   // Make the client misbehave after negotiation.
   QuicSessionPeer::SetMaxOpenStreams(client_->client()->session(), 10);
 
   HTTPMessage request(HttpConstants::HTTP_1_1,
                       HttpConstants::POST, "/foo");
   request.AddHeader("content-length", "3");
   request.set_has_complete_message(false);
@@ skipping 28 matching lines @@
   }
 
   EXPECT_EQ(expected_congestion_control_type,
             QuicSentPacketManagerPeer::GetCongestionControlAlgorithm(
                 *GetSentPacketManagerFromFirstServerSession())
             ->GetCongestionControlType());
 }
 
 TEST_P(EndToEndTest, LimitMaxOpenStreams) {
   // Server limits the number of max streams to 2.
-  server_config_.set_max_streams_per_connection(2, 2);
+  server_config_.SetMaxStreamsPerConnection(2, 2);
   // Client tries to negotiate for 10.
-  client_config_.set_max_streams_per_connection(10, 5);
+  client_config_.SetMaxStreamsPerConnection(10, 5);
 
   ASSERT_TRUE(Initialize());
   client_->client()->WaitForCryptoHandshakeConfirmed();
   QuicConfig* client_negotiated_config = client_->client()->session()->config();
-  EXPECT_EQ(2u, client_negotiated_config->max_streams_per_connection());
+  EXPECT_EQ(2u, client_negotiated_config->MaxStreamsPerConnection());
 }
 
 TEST_P(EndToEndTest, LimitCongestionWindowAndRTT) {
   // Client tries to request twice the server's max initial window, and the
   // server limits it to the max.
   client_config_.SetInitialCongestionWindowToSend(2 * kMaxInitialWindow);
   client_config_.SetInitialRoundTripTimeUsToSend(1000);
 
   ASSERT_TRUE(Initialize());
   client_->client()->WaitForCryptoHandshakeConfirmed();
@@ skipping 432 matching lines @@
   QuicSession* session = dispatcher->session_map().begin()->second;
   EXPECT_EQ(0u, QuicSessionPeer::GetLocallyClosedStreamsHighestOffset(
       session).size());
   server_thread_->Resume();
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace tools
 }  // namespace net