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 91 matching lines @@
 };
 
 class EndToEndTest : public ::testing::Test {
  protected:
   EndToEndTest()
       : server_hostname_("localhost"),
         server_started_(false) {
     net::IPAddressNumber ip;
     CHECK(net::ParseIPLiteralToNumber("127.0.0.1", &ip));
     server_address_ = IPEndPoint(ip, 0);
+    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",
                "HTTP/1.1", "200", "OK", kBarResponseBody);
   }
 
   static void SetUpTestCase() {
     QuicInMemoryCache::GetInstance()->ResetForTests();
   }
 
   virtual QuicTestClient* CreateQuicClient() {
     QuicTestClient* client = new QuicTestClient(server_address_,
-                                                server_hostname_);
+                                                server_hostname_,
+                                                config_);
     client->Connect();
     return client;
   }
 
   virtual bool Initialize() {
     // Start the server first, because CreateQuicClient() attempts
     // to connect to the server.
     StartServer();
     client_.reset(CreateQuicClient());
     return client_->client()->connected();
   }
 
   virtual void TearDown() {
     StopServer();
   }
 
   void StartServer() {
     server_thread_.reset(new ServerThread(server_address_));
     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;
-    server_thread_->quit()->Signal();
-    server_thread_->Join();
+    if (server_thread_.get()) {
+      server_thread_->quit()->Signal();
+      server_thread_->Join();
+    }
   }
 
   void AddToCache(const StringPiece& method,
                   const StringPiece& path,
                   const StringPiece& version,
                   const StringPiece& response_code,
                   const StringPiece& response_detail,
                   const StringPiece& body) {
     BalsaHeaders request_headers, response_headers;
     request_headers.SetRequestFirstlineFromStringPieces(method,
@@ skipping 18 matching lines @@
       return;
     }
     cache->AddResponse(request_headers, response_headers, body);
   }
 
   IPEndPoint server_address_;
   string server_hostname_;
   scoped_ptr<ServerThread> server_thread_;
   scoped_ptr<QuicTestClient> client_;
   bool server_started_;
+  QuicConfig config_;
 };
 
 TEST_F(EndToEndTest, SimpleRequestResponse) {
   // TODO(rtenneti): Delete this when NSS is supported.
   if (!Aes128GcmEncrypter::IsSupported()) {
     LOG(INFO) << "AES GCM not supported. Test skipped.";
     return;
   }
 
   ASSERT_TRUE(Initialize());
@@ skipping 287 matching lines @@
       false, client_->GetOrCreateStream());
   EXPECT_DEBUG_DEATH({
     client_->SendData("eep", true);
     client_->WaitForResponse();
     EXPECT_EQ(QUIC_MULTIPLE_TERMINATION_OFFSETS, client_->stream_error());
   },
   "Check failed: !fin_buffered_");
 }
 
 /*TEST_F(EndToEndTest, Timeout) {
-  FLAGS_negotiated_timeout_us = 500;
+  config_.set_idle_connection_state_lifetime(
+      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_F(EndToEndTest, ResetConnection) {
   // TODO(rtenneti): Delete this when NSS is supported.
   if (!Aes128GcmEncrypter::IsSupported()) {
     LOG(INFO) << "AES GCM not supported. Test skipped.";
     return;
   }
 
   ASSERT_TRUE(Initialize());
 
   EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo"));
   EXPECT_EQ(200ul, client_->response_headers()->parsed_response_code());
   client_->ResetConnection();
   EXPECT_EQ(kBarResponseBody, client_->SendSynchronousRequest("/bar"));
   EXPECT_EQ(200ul, client_->response_headers()->parsed_response_code());
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace tools
 }  // namespace net