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 "base/memory/scoped_ptr.h"
 #include "base/memory/singleton.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 43 matching lines @@
   body->reserve(length);
   for (int i = 0; i < length; ++i) {
     body->append(1, static_cast<char>(32 + i % (126 - 32)));
   }
 }
 
 
 // Simple wrapper class to run server in a thread.
 class ServerThread : public base::SimpleThread {
  public:
-  explicit ServerThread(IPEndPoint address, const QuicConfig& config)
+  ServerThread(IPEndPoint address,
+               const QuicConfig& config,
+               bool strike_register_no_startup_period)
       : SimpleThread("server_thread"),
         listening_(true, false),
         quit_(true, false),
         server_(config),
         address_(address),
         port_(0) {
+    if (strike_register_no_startup_period) {
+      server_.SetStrikeRegisterNoStartupPeriod();
+    }
   }
   virtual ~ServerThread() {
   }
 
   virtual void Run() OVERRIDE {
     server_.Listen(address_);
 
     port_lock_.Acquire();
     port_ = server_.port();
     port_lock_.Release();
@@ skipping 28 matching lines @@
 
 class EndToEndTest : public ::testing::TestWithParam<QuicVersion> {
  public:
   static void SetUpTestCase() {
     QuicInMemoryCache::GetInstance()->ResetForTests();
   }
 
  protected:
   EndToEndTest()
       : server_hostname_("example.com"),
-        server_started_(false) {
+        server_started_(false),
+        strike_register_no_startup_period_(false) {
     net::IPAddressNumber ip;
     CHECK(net::ParseIPLiteralToNumber("127.0.0.1", &ip));
     server_address_ = IPEndPoint(ip, 0);
     client_config_.SetDefaults();
     server_config_.SetDefaults();
 
     AddToCache("GET", kLargeRequest, "HTTP/1.1", "200", "OK", kFooResponseBody);
     AddToCache("GET", "https://www.google.com/foo",
                "HTTP/1.1", "200", "OK", kFooResponseBody);
     AddToCache("GET", "https://www.google.com/bar",
@@ skipping 17 matching lines @@
     StartServer();
     client_.reset(CreateQuicClient());
     return client_->client()->connected();
   }
 
   virtual void TearDown() {
     StopServer();
   }
 
   void StartServer() {
-    server_thread_.reset(new ServerThread(server_address_, server_config_));
+    server_thread_.reset(new ServerThread(server_address_, server_config_,
+                                          strike_register_no_startup_period_));
     server_thread_->Start();
     server_thread_->listening()->Wait();
     server_address_ = IPEndPoint(server_address_.address(),
                                  server_thread_->GetPort());
     server_started_ = true;
   }
 
   void StopServer() {
     if (!server_started_)
       return;
@@ skipping 35 matching lines @@
   }
 
   IPEndPoint server_address_;
   string server_hostname_;
   scoped_ptr<ServerThread> server_thread_;
   scoped_ptr<QuicTestClient> client_;
   bool server_started_;
   QuicConfig client_config_;
   QuicConfig server_config_;
   QuicVersion version_;
+  bool strike_register_no_startup_period_;
 };
 
 // Run all end to end tests with all supported versions.
 INSTANTIATE_TEST_CASE_P(EndToEndTests,
                         EndToEndTest,
                         ::testing::ValuesIn(kSupportedQuicVersions));
 
 TEST_P(EndToEndTest, SimpleRequestResponse) {
   // TODO(rtenneti): Delete this when NSS is supported.
   if (!Aes128Gcm12Encrypter::IsSupported()) {
@@ skipping 212 matching lines @@
   GenerateBody(&body, 10240);
 
   HTTPMessage request(HttpConstants::HTTP_1_1,
                       HttpConstants::POST, "/foo");
   request.AddBody(body, true);
 
   EXPECT_EQ(kFooResponseBody, client_->SendCustomSynchronousRequest(request));
 }
 
 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);
 
   HTTPMessage request(HttpConstants::HTTP_1_1,
                       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.
-  // TODO(wtc): figure out why this 0-RTT handshake takes 1 RTT.
   client_->Connect();
   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();
   StartServer();
 
   client_->Connect();
   ASSERT_TRUE(client_->client()->connected());
   EXPECT_EQ(kFooResponseBody, client_->SendCustomSynchronousRequest(request));
+  EXPECT_EQ(2, client_->client()->session()->GetNumSentClientHellos());
 }
 
 // TODO(ianswett): Enable once b/9295090 is fixed.
 TEST_P(EndToEndTest, DISABLED_LargePostFEC) {
   // FLAGS_fake_packet_loss_percentage = 30;
   ASSERT_TRUE(Initialize());
   client_->options()->max_packets_per_fec_group = 6;
 
   // TODO(rtenneti): Delete this when NSS is supported.
   if (!Aes128Gcm12Encrypter::IsSupported()) {
@@ skipping 212 matching lines @@
   QuicEpollConnectionHelperPeer::SetWriter(helper, NULL);
 
   EXPECT_EQ(QUIC_STREAM_CONNECTION_ERROR, client_->stream_error());
   EXPECT_EQ(QUIC_ERROR_MIGRATING_ADDRESS, client_->connection_error());
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace tools
 }  // namespace net