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"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/singleton.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/time/time.h"
 #include "net/base/ip_endpoint.h"
 #include "net/quic/congestion_control/tcp_cubic_sender.h"
 #include "net/quic/crypto/aes_128_gcm_12_encrypter.h"
 #include "net/quic/crypto/null_encrypter.h"
 #include "net/quic/quic_flags.h"
 #include "net/quic/quic_framer.h"
 #include "net/quic/quic_packet_creator.h"
 #include "net/quic/quic_protocol.h"
 #include "net/quic/quic_sent_packet_manager.h"
 #include "net/quic/quic_server_id.h"
+#include "net/quic/quic_utils.h"
 #include "net/quic/test_tools/quic_connection_peer.h"
 #include "net/quic/test_tools/quic_flow_controller_peer.h"
+#include "net/quic/test_tools/quic_sent_packet_manager_peer.h"
 #include "net/quic/test_tools/quic_session_peer.h"
 #include "net/quic/test_tools/quic_test_utils.h"
 #include "net/quic/test_tools/reliable_quic_stream_peer.h"
 #include "net/test/gtest_util.h"
 #include "net/tools/epoll_server/epoll_server.h"
 #include "net/tools/quic/quic_epoll_connection_helper.h"
 #include "net/tools/quic/quic_in_memory_cache.h"
 #include "net/tools/quic/quic_packet_writer_wrapper.h"
 #include "net/tools/quic/quic_server.h"
 #include "net/tools/quic/quic_socket_utils.h"
 #include "net/tools/quic/quic_spdy_client_stream.h"
 #include "net/tools/quic/test_tools/http_message.h"
 #include "net/tools/quic/test_tools/packet_dropping_test_writer.h"
 #include "net/tools/quic/test_tools/quic_client_peer.h"
 #include "net/tools/quic/test_tools/quic_dispatcher_peer.h"
 #include "net/tools/quic/test_tools/quic_in_memory_cache_peer.h"
 #include "net/tools/quic/test_tools/quic_server_peer.h"
 #include "net/tools/quic/test_tools/quic_test_client.h"
 #include "net/tools/quic/test_tools/server_thread.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::StringPiece;
 using base::WaitableEvent;
 using net::EpollServer;
 using net::test::GenerateBody;
 using net::test::QuicConnectionPeer;
 using net::test::QuicFlowControllerPeer;
+using net::test::QuicSentPacketManagerPeer;
 using net::test::QuicSessionPeer;
 using net::test::ReliableQuicStreamPeer;
 using net::test::ValueRestore;
 using net::test::kClientDataStreamId1;
 using net::tools::test::PacketDroppingTestWriter;
 using net::tools::test::QuicDispatcherPeer;
 using net::tools::test::QuicServerPeer;
 using std::ostream;
 using std::string;
 using std::vector;
 
 namespace net {
 namespace tools {
 namespace test {
 namespace {
 
 const char* kFooResponseBody = "Artichoke hearts make me happy.";
 const char* kBarResponseBody = "Palm hearts are pretty delicious, also.";
 
 // Run all tests with the cross products of all versions.
 struct TestParams {
   TestParams(const QuicVersionVector& client_supported_versions,
              const QuicVersionVector& server_supported_versions,
              QuicVersion negotiated_version,
-             bool use_pacing)
+             bool use_pacing,
+             bool use_fec,
+             QuicTag congestion_control_tag)
       : client_supported_versions(client_supported_versions),
         server_supported_versions(server_supported_versions),
         negotiated_version(negotiated_version),
-        use_pacing(use_pacing) {
+        use_pacing(use_pacing),
+        use_fec(use_fec),
+        congestion_control_tag(congestion_control_tag) {
   }
 
   friend ostream& operator<<(ostream& os, const TestParams& p) {
     os << "{ server_supported_versions: "
        << QuicVersionVectorToString(p.server_supported_versions);
     os << " client_supported_versions: "
        << QuicVersionVectorToString(p.client_supported_versions);
     os << " negotiated_version: " << QuicVersionToString(p.negotiated_version);
-    os << " use_pacing: " << p.use_pacing << " }";
+    os << " use_pacing: " << p.use_pacing;
+    os << " use_fec: " << p.use_fec;
+    os << " congestion_control_tag: "
+       << QuicUtils::TagToString(p.congestion_control_tag) << " }";
     return os;
   }
 
   QuicVersionVector client_supported_versions;
   QuicVersionVector server_supported_versions;
   QuicVersion negotiated_version;
   bool use_pacing;
+  bool use_fec;
+  QuicTag congestion_control_tag;
 };
 
 // Constructs various test permutations.
 vector<TestParams> GetTestParams() {
   vector<TestParams> params;
   QuicVersionVector all_supported_versions = QuicSupportedVersions();
-  for (int use_pacing = 0; use_pacing < 2; ++use_pacing) {
-    // Add an entry for server and client supporting all versions.
-    params.push_back(TestParams(all_supported_versions,
-                                all_supported_versions,
-                                all_supported_versions[0],
-                                use_pacing != 0));
+  // TODO(rtenneti): Add kTBBR after BBR code is checked in.
+  // QuicTag congestion_control_tags[] = {kRENO, kTBBR, kQBIC};
+  QuicTag congestion_control_tags[] = {kRENO, kQBIC};
+  for (size_t congestion_control_index = 0;
+       congestion_control_index < arraysize(congestion_control_tags);
+       congestion_control_index++) {
+    QuicTag congestion_control_tag =
+        congestion_control_tags[congestion_control_index];
+    for (int use_fec = 0; use_fec < 2; ++use_fec) {
+      for (int use_pacing = 0; use_pacing < 2; ++use_pacing) {
+        // Add an entry for server and client supporting all versions.
+        params.push_back(TestParams(all_supported_versions,
+                                    all_supported_versions,
+                                    all_supported_versions[0],
+                                    use_pacing != 0,
+                                    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);
+        // 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));
+        }
       }
-      params.push_back(TestParams(all_supported_versions,
-                                  server_supported_versions,
-                                  server_supported_versions[0],
-                                  use_pacing != 0));
     }
   }
   return params;
 }
 
 class ServerDelegate : public PacketDroppingTestWriter::Delegate {
  public:
   explicit ServerDelegate(QuicDispatcher* dispatcher)
       : dispatcher_(dispatcher) {}
   virtual ~ServerDelegate() {}
@@ skipping 21 matching lines @@
         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_supported_versions_ = GetParam().client_supported_versions;
     server_supported_versions_ = GetParam().server_supported_versions;
     negotiated_version_ = GetParam().negotiated_version;
     FLAGS_enable_quic_pacing = GetParam().use_pacing;
+    FLAGS_enable_quic_fec = GetParam().use_fec;
 
     if (negotiated_version_ >= QUIC_VERSION_19) {
       FLAGS_enable_quic_connection_flow_control_2 = true;
     }
     VLOG(1) << "Using Configuration: " << GetParam();
 
     client_config_.SetDefaults();
     server_config_.SetDefaults();
 
     // Use different flow control windows for client/server.
@@ skipping 68 matching lines @@
     server_config_.SetInitialStreamFlowControlWindowToSend(window);
   }
 
   void set_server_initial_session_flow_control_receive_window(uint32 window) {
     CHECK(server_thread_.get() == NULL);
     DLOG(INFO) << "Setting server initial session flow control window: "
                << window;
     server_config_.SetInitialSessionFlowControlWindowToSend(window);
   }
 
+  const QuicSentPacketManager *
+  GetSentPacketManagerFromFirstServerSession() const {
+    QuicDispatcher* dispatcher =
+        QuicServerPeer::GetDispatcher(server_thread_->server());
+    QuicSession* session = dispatcher->session_map().begin()->second;
+    return &session->connection()->sent_packet_manager();
+  }
+
   bool Initialize() {
+    QuicTagVector copt;
+
+    // TODO(nimia): Consider setting the congestion control algorithm for the
+    // client as well according to the test parameter.
+    copt.push_back(GetParam().congestion_control_tag);
+
+    if (GetParam().use_fec) {
+      // Set FEC config in client's connection options and in client session.
+      copt.push_back(kFHDR);
+    }
+
+    client_config_.SetConnectionOptionsToSend(copt);
+
     // Start the server first, because CreateQuicClient() attempts
     // to connect to the server.
     StartServer();
     client_.reset(CreateQuicClient(client_writer_));
+    if (GetParam().use_fec) {
+      // Set FecPolicy to always protect data on all streams.
+      client_->SetFecPolicy(FEC_PROTECT_ALWAYS);
+    }
     static EpollEvent event(EPOLLOUT, false);
     client_writer_->Initialize(
         reinterpret_cast<QuicEpollConnectionHelper*>(
             QuicConnectionPeer::GetHelper(
                 client_->client()->session()->connection())),
         new ClientDelegate(client_->client()));
     return client_->client()->connected();
   }
 
   virtual void SetUp() OVERRIDE {
@@ skipping 387 matching lines @@
     // 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, LargePostFec) {
-  ValueRestore<bool> old_flag(&FLAGS_enable_quic_fec, true);
-
-  // Connect without packet loss to avoid issues with losing handshake packets,
-  // and then up the packet loss rate (b/10126687).
-  ASSERT_TRUE(Initialize());
-
-  // Wait for the server SHLO before upping the packet loss.
-  client_->client()->WaitForCryptoHandshakeConfirmed();
-  SetPacketLossPercentage(30);
-
-  // Verify that FEC is enabled.
-  QuicPacketCreator* creator = QuicConnectionPeer::GetPacketCreator(
-      client_->client()->session()->connection());
-  EXPECT_TRUE(creator->IsFecEnabled());
-
-  // Set FecPolicy to always protect data on all streams.
-  client_->SetFecPolicy(FEC_PROTECT_ALWAYS);
-
-  string body;
-  GenerateBody(&body, 10240);
-
-  HTTPMessage request(HttpConstants::HTTP_1_1,
-                      HttpConstants::POST, "/foo");
-  request.AddBody(body, true);
-  EXPECT_EQ(kFooResponseBody, client_->SendCustomSynchronousRequest(request));
-  VerifyCleanConnection(true);
-}
-
-TEST_P(EndToEndTest, ClientSpecifiedFecProtectionForHeaders) {
-  ValueRestore<bool> old_flag(&FLAGS_enable_quic_fec, true);
-
-  // Set FEC config in client's connection options and in client session.
-  QuicTagVector copt;
-  copt.push_back(kFHDR);
-  client_config_.SetConnectionOptionsToSend(copt);
-
-  // Connect without packet loss to avoid issues with losing handshake packets,
-  // and then up the packet loss rate (b/10126687).
+TEST_P(EndToEndTest, CorrectlyConfiguredFec) {
   ASSERT_TRUE(Initialize());
   client_->client()->WaitForCryptoHandshakeConfirmed();
   server_thread_->WaitForCryptoHandshakeConfirmed();
 
-  // Verify that FEC is enabled.
-  QuicPacketCreator* creator = QuicConnectionPeer::GetPacketCreator(
-      client_->client()->session()->connection());
-  EXPECT_TRUE(creator->IsFecEnabled());
+  FecPolicy expected_policy =
+      GetParam().use_fec ? FEC_PROTECT_ALWAYS : FEC_PROTECT_OPTIONAL;
 
-  // Verify that server headers stream is FEC protected.
+  // Verify that server's FEC configuration is correct.
   server_thread_->Pause();
   QuicDispatcher* dispatcher =
       QuicServerPeer::GetDispatcher(server_thread_->server());
   ASSERT_EQ(1u, dispatcher->session_map().size());
   QuicSession* session = dispatcher->session_map().begin()->second;
-  EXPECT_EQ(FEC_PROTECT_ALWAYS,
+  EXPECT_EQ(expected_policy,
             QuicSessionPeer::GetHeadersStream(session)->fec_policy());
   server_thread_->Resume();
 
-  // Verify that at the client, headers stream is protected and other data
-  // streams are optionally protected.
-  EXPECT_EQ(FEC_PROTECT_ALWAYS, QuicSessionPeer::GetHeadersStream(
-      client_->client()->session())->fec_policy());
-  EXPECT_EQ(FEC_PROTECT_OPTIONAL, client_->GetOrCreateStream()->fec_policy());
+  // Verify that client's FEC configuration is correct.
+  EXPECT_EQ(expected_policy,
+            QuicSessionPeer::GetHeadersStream(
+                client_->client()->session())->fec_policy());
+  EXPECT_EQ(expected_policy,
+            client_->GetOrCreateStream()->fec_policy());
 }
 
 // TODO(shess): This is flaky on ChromiumOS bots.
 // http://crbug.com/374871
 TEST_P(EndToEndTest, DISABLED_LargePostSmallBandwidthLargeBuffer) {
   ASSERT_TRUE(Initialize());
   SetPacketSendDelay(QuicTime::Delta::FromMicroseconds(1));
   // 256KB per second with a 256KB buffer from server to client.  Wireless
   // clients commonly have larger buffers, but our max CWND is 200.
   server_writer_->set_max_bandwidth_and_buffer_size(
@@ skipping 133 matching lines @@
   // Open two simultaneous streams.
   client_->SendMessage(request);
   client_->SendMessage(request);
   client_->WaitForResponse();
 
   EXPECT_FALSE(client_->connected());
   EXPECT_EQ(QUIC_STREAM_CONNECTION_ERROR, client_->stream_error());
   EXPECT_EQ(QUIC_TOO_MANY_OPEN_STREAMS, client_->connection_error());
 }
 
+TEST_P(EndToEndTest, NegotiateCongestionControl) {
+  ASSERT_TRUE(Initialize());
+  client_->client()->WaitForCryptoHandshakeConfirmed();
+
+  CongestionControlType expected_congestion_control_type;
+  switch (GetParam().congestion_control_tag) {
+    case kRENO:
+      expected_congestion_control_type = kReno;
+      break;
+    case kTBBR:
+      expected_congestion_control_type = kBBR;
+      break;
+    case kQBIC:
+      expected_congestion_control_type = kCubic;
+      break;
+    default:
+      DLOG(FATAL) << "Unexpected congestion control tag";
+  }
+
+  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);
   // 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) {
   // 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);
 
   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());
-  QuicSession* session = dispatcher->session_map().begin()->second;
   const QuicSentPacketManager& client_sent_packet_manager =
       client_->client()->session()->connection()->sent_packet_manager();
   const QuicSentPacketManager& server_sent_packet_manager =
-      session->connection()->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(FLAGS_enable_quic_pacing,
             server_sent_packet_manager.using_pacing());
   EXPECT_EQ(FLAGS_enable_quic_pacing,
@@ skipping 172 matching lines @@
 
 TEST_P(EndToEndTest, ConnectionMigrationClientIPChanged) {
   // Tests that the client's IP can not change during an established QUIC
   // connection. If it changes, the connection is closed by the server as we do
   // not yet support IP migration.
   ASSERT_TRUE(Initialize());
 
   EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo"));
   EXPECT_EQ(200u, client_->response_headers()->parsed_response_code());
 
-  scoped_ptr<WrongAddressWriter> writer(new WrongAddressWriter());
+  WrongAddressWriter* writer = new WrongAddressWriter();
 
   writer->set_writer(new QuicDefaultPacketWriter(client_->client()->fd()));
   QuicConnectionPeer::SetWriter(client_->client()->session()->connection(),
-                                writer.get());
+                                writer,
+                                true  /* owns_writer */);
 
   client_->SendSynchronousRequest("/bar");
 
   EXPECT_EQ(QUIC_STREAM_CONNECTION_ERROR, client_->stream_error());
   EXPECT_EQ(QUIC_ERROR_MIGRATING_ADDRESS, client_->connection_error());
 }
 
 TEST_P(EndToEndTest, ConnectionMigrationClientPortChanged) {
   // Tests that the client's port can change during an established QUIC
   // connection, and that doing so does not result in the connection being
@@ skipping 196 matching lines @@
       session->flow_controller();
   EXPECT_EQ(kSessionIFCW, QuicFlowControllerPeer::ReceiveWindowSize(
       server_connection_flow_controller));
   server_thread_->Resume();
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace tools
 }  // namespace net