client-only - Change QUIC clients to use the initial RTT estimate that

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 925 matching lines @@
   server_config_.set_max_streams_per_connection(2, 2);
   // Client tries to negotiate for 10.
   client_config_.set_max_streams_per_connection(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());
 }
 
-// TODO(rtenneti): DISABLED_LimitCongestionWindowAndRTT seems to be flaky.
-// http://crbug.com/321870.
-TEST_P(EndToEndTest, DISABLED_LimitCongestionWindowAndRTT) {
+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(1);
+  client_config_.SetInitialRoundTripTimeUsToSend(1000);
 
   ASSERT_TRUE(Initialize());
   client_->client()->WaitForCryptoHandshakeConfirmed();
   server_thread_->WaitForCryptoHandshakeConfirmed();
 
   // Pause the server so we can access the server's internals without races.
   server_thread_->Pause();
   QuicDispatcher* dispatcher =
       QuicServerPeer::GetDispatcher(server_thread_->server());
   ASSERT_EQ(1u, dispatcher->session_map().size());
   const QuicSentPacketManager& client_sent_packet_manager =
       client_->client()->session()->connection()->sent_packet_manager();
   const QuicSentPacketManager& server_sent_packet_manager =
       *GetSentPacketManagerFromFirstServerSession();
 
   // The client shouldn't set it's initial window based on the negotiated value.
   EXPECT_EQ(kDefaultInitialWindow * kDefaultTCPMSS,
             client_sent_packet_manager.GetCongestionWindow());
   EXPECT_EQ(kMaxInitialWindow * kDefaultTCPMSS,
             server_sent_packet_manager.GetCongestionWindow());
 
   EXPECT_EQ(GetParam().use_pacing, server_sent_packet_manager.using_pacing());
   EXPECT_EQ(GetParam().use_pacing, client_sent_packet_manager.using_pacing());
 
-  EXPECT_EQ(100000u,
-            client_sent_packet_manager.GetRttStats()->initial_rtt_us());
-  EXPECT_EQ(1u, server_sent_packet_manager.GetRttStats()->initial_rtt_us());
+  // The client *should* set the intitial RTT.
+  EXPECT_EQ(1000u, client_sent_packet_manager.GetRttStats()->initial_rtt_us());
+  EXPECT_EQ(1000u, server_sent_packet_manager.GetRttStats()->initial_rtt_us());
 
   // Now use the negotiated limits with packet loss.
   SetPacketLossPercentage(30);
 
   // 10 KB body.
   string body;
   GenerateBody(&body, 1024 * 10);
 
   HTTPMessage request(HttpConstants::HTTP_1_1,
                       HttpConstants::POST, "/foo");
@@ skipping 398 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