Land Recent QUIC Changes until 03/09/2015.

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 <vector>
 
 #include "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 59 matching lines @@
 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_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_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_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();
   // TODO(rtenneti): Add kTBBR after BBR code is checked in.
   // QuicTag congestion_control_tags[] = {kRENO, kTBBR, kQBIC};
   QuicTag congestion_control_tags[] = {kRENO, kQBIC};
   QuicVersionVector spdy3_versions;
   QuicVersionVector spdy4_versions;
   for (QuicVersion version : all_supported_versions) {
     if (version > QUIC_VERSION_23) {
       spdy4_versions.push_back(version);
     } else {
       spdy3_versions.push_back(version);
     }
   }
   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) {
-        for (int spdy_version = 3; spdy_version <= 4; ++spdy_version) {
-          const QuicVersionVector* client_versions =
-              spdy_version == 3 ? &spdy3_versions : &spdy4_versions;
-          // Add an entry for server and client supporting all versions.
-          params.push_back(TestParams(*client_versions, all_supported_versions,
-                                      (*client_versions)[0], use_pacing != 0,
+      for (int spdy_version = 3; spdy_version <= 4; ++spdy_version) {
+        const QuicVersionVector* client_versions =
+            spdy_version == 3 ? &spdy3_versions : &spdy4_versions;
+        // Add an entry for server and client supporting all versions.
+        params.push_back(TestParams(*client_versions, all_supported_versions,
+                                    (*client_versions)[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 (QuicVersion version : *client_versions) {
+          QuicVersionVector server_supported_versions;
+          server_supported_versions.push_back(version);
+          params.push_back(TestParams(*client_versions,
+                                      server_supported_versions,
+                                      server_supported_versions[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 (QuicVersion version : *client_versions) {
-            QuicVersionVector server_supported_versions;
-            server_supported_versions.push_back(version);
-            params.push_back(
-                TestParams(*client_versions, server_supported_versions,
-                           server_supported_versions[0], use_pacing != 0,
-                           use_fec != 0, congestion_control_tag));
-          }
         }
       }
     }
   }
   return params;
 }
 
 class ServerDelegate : public PacketDroppingTestWriter::Delegate {
  public:
   ServerDelegate(TestWriterFactory* writer_factory,
@@ skipping 107 matching lines @@
   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;
-
-    if (GetParam().use_pacing) {
-      copt.push_back(kPACE);
-    }
     server_config_.SetConnectionOptionsToSend(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);
     }
@@ skipping 15 matching lines @@
                 client_->client()->session()->connection())),
         new ClientDelegate(client_->client()));
     return client_->client()->connected();
   }
 
   void SetUp() override {
     // The ownership of these gets transferred to the QuicPacketWriterWrapper
     // and TestWriterFactory when Initialize() is executed.
     client_writer_ = new PacketDroppingTestWriter();
     server_writer_ = new PacketDroppingTestWriter();
-    // TODO(ianswett): Remove this once it's fully rolled out.
-    FLAGS_quic_enable_pacing = false;
   }
 
   void TearDown() override { StopServer(); }
 
   void StartServer() {
     server_thread_.reset(
         new ServerThread(
             new QuicServer(server_config_, server_supported_versions_),
             server_address_,
             strike_register_no_startup_period_));
@@ skipping 589 matching lines @@
   // 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();
 
-  // BBR automatically enables pacing.
-  EXPECT_EQ(GetParam().use_pacing ||
-            (FLAGS_quic_allow_bbr &&
-             GetParam().congestion_control_tag == kTBBR),
-            server_sent_packet_manager.using_pacing());
-  EXPECT_EQ(GetParam().use_pacing ||
-            (FLAGS_quic_allow_bbr &&
-             GetParam().congestion_control_tag == kTBBR),
-            client_sent_packet_manager.using_pacing());
-
   EXPECT_EQ(kInitialRTT,
             client_sent_packet_manager.GetRttStats()->initial_rtt_us());
   EXPECT_EQ(kInitialRTT,
             server_sent_packet_manager.GetRttStats()->initial_rtt_us());
   server_thread_->Resume();
 }
 
 TEST_P(EndToEndTest, MaxInitialRTT) {
   // Client tries to suggest twice the server's max initial rtt and the server
   // uses the max.
@@ skipping 397 matching lines @@
   // Now verify that the server is not waiting for a final FIN or RST.
   server_thread_->Pause();
   QuicDispatcher* dispatcher =
       QuicServerPeer::GetDispatcher(server_thread_->server());
   QuicSession* session = dispatcher->session_map().begin()->second;
   EXPECT_EQ(0u, QuicSessionPeer::GetLocallyClosedStreamsHighestOffset(
       session).size());
   server_thread_->Resume();
 }
 
-TEST_P(EndToEndTest, EnablePacingViaFlag) {
-  // When pacing is enabled via command-line flag, it will always be enabled,
-  // regardless of the config. or the specific congestion-control algorithm.
-  ValueRestore<bool> old_flag(&FLAGS_quic_enable_pacing, true);
-  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();
-  EXPECT_TRUE(server_sent_packet_manager.using_pacing());
-  EXPECT_TRUE(client_sent_packet_manager.using_pacing());
-}
-
 // A TestAckNotifierDelegate verifies that its OnAckNotification method has been
 // called exactly once on destruction.
 class TestAckNotifierDelegate : public QuicAckNotifier::DelegateInterface {
  public:
   TestAckNotifierDelegate() {}
 
   void OnAckNotification(int /*num_retransmitted_packets*/,
                          int /*num_retransmitted_bytes*/,
                          QuicTime::Delta /*delta_largest_observed*/) override {
     ASSERT_FALSE(has_been_notified_);
@@ skipping 52 matching lines @@
     // Waits for up to 50 ms.
     client_->client()->WaitForEvents();
   }
   server_thread_->Resume();
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace tools
 }  // namespace net