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"
@@ skipping 984 matching lines @@
   // Expect the default rtt of 100ms.
   EXPECT_EQ(static_cast<int64>(100 * kNumMicrosPerMilli),
             server_sent_packet_manager.GetRttStats()->initial_rtt_us());
   // Ensure the bandwidth is valid.
   client_sent_packet_manager.BandwidthEstimate();
   server_sent_packet_manager.BandwidthEstimate();
   server_thread_->Resume();
 }
 
 TEST_P(EndToEndTest, 0ByteConnectionId) {
-  ValueRestore<bool> old_flag(&FLAGS_allow_truncated_connection_ids_for_quic,
-                              true);
   client_config_.SetBytesForConnectionIdToSend(0);
   ASSERT_TRUE(Initialize());
 
   EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo"));
   EXPECT_EQ(200u, client_->response_headers()->parsed_response_code());
 
   QuicPacketHeader* header = QuicConnectionPeer::GetLastHeader(
       client_->client()->session()->connection());
   EXPECT_EQ(PACKET_0BYTE_CONNECTION_ID,
             header->public_header.connection_id_length);
 }
 
 TEST_P(EndToEndTest, 1ByteConnectionId) {
-  ValueRestore<bool> old_flag(&FLAGS_allow_truncated_connection_ids_for_quic,
-                              true);
   client_config_.SetBytesForConnectionIdToSend(1);
   ASSERT_TRUE(Initialize());
 
   EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo"));
   EXPECT_EQ(200u, client_->response_headers()->parsed_response_code());
   QuicPacketHeader* header = QuicConnectionPeer::GetLastHeader(
       client_->client()->session()->connection());
   EXPECT_EQ(PACKET_1BYTE_CONNECTION_ID,
             header->public_header.connection_id_length);
 }
 
 TEST_P(EndToEndTest, 4ByteConnectionId) {
-  ValueRestore<bool> old_flag(&FLAGS_allow_truncated_connection_ids_for_quic,
-                              true);
   client_config_.SetBytesForConnectionIdToSend(4);
   ASSERT_TRUE(Initialize());
 
   EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo"));
   EXPECT_EQ(200u, client_->response_headers()->parsed_response_code());
   QuicPacketHeader* header = QuicConnectionPeer::GetLastHeader(
       client_->client()->session()->connection());
   EXPECT_EQ(PACKET_4BYTE_CONNECTION_ID,
             header->public_header.connection_id_length);
 }
 
 TEST_P(EndToEndTest, 8ByteConnectionId) {
-  ValueRestore<bool> old_flag(&FLAGS_allow_truncated_connection_ids_for_quic,
-                              true);
   client_config_.SetBytesForConnectionIdToSend(8);
   ASSERT_TRUE(Initialize());
 
   EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo"));
   EXPECT_EQ(200u, client_->response_headers()->parsed_response_code());
   QuicPacketHeader* header = QuicConnectionPeer::GetLastHeader(
       client_->client()->session()->connection());
   EXPECT_EQ(PACKET_8BYTE_CONNECTION_ID,
             header->public_header.connection_id_length);
 }
 
 TEST_P(EndToEndTest, 15ByteConnectionId) {
-  ValueRestore<bool> old_flag(&FLAGS_allow_truncated_connection_ids_for_quic,
-                              true);
   client_config_.SetBytesForConnectionIdToSend(15);
   ASSERT_TRUE(Initialize());
 
   // Our server is permissive and allows for out of bounds values.
   EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo"));
   EXPECT_EQ(200u, client_->response_headers()->parsed_response_code());
   QuicPacketHeader* header = QuicConnectionPeer::GetLastHeader(
       client_->client()->session()->connection());
   EXPECT_EQ(PACKET_8BYTE_CONNECTION_ID,
             header->public_header.connection_id_length);
@@ skipping 297 matching lines @@
       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_original_packets*/,
+                         int /*num_original_bytes*/,
+                         int /*num_retransmitted_packets*/,
+                         int /*num_retransmitted_bytes*/,
+                         QuicTime::Delta /*delta_largest_observed*/) override {
+    ASSERT_FALSE(has_been_notified_);
+    has_been_notified_ = true;
+  }
+
+  bool has_been_notified() const { return has_been_notified_; }
+
+ protected:
+  // Object is ref counted.
+  ~TestAckNotifierDelegate() override { EXPECT_TRUE(has_been_notified_); }
+
+ private:
+  bool has_been_notified_ = false;
+};
+
+TEST_P(EndToEndTest, AckNotifierWithPacketLoss) {
+  // Verify that even in the presence of packet loss, an AckNotifierDelegate
+  // will get informed that the data it is interested in has been ACKed. This
+  // tests end-to-end ACK notification, and demonstrates that retransmissions do
+  // not break this functionality.
+  ValueRestore<bool> old_flag(&FLAGS_quic_attach_ack_notifiers_to_packets,
+                              true);
+
+  SetPacketLossPercentage(5);
+  ASSERT_TRUE(Initialize());
+
+  // Wait for the server SHLO before upping the packet loss.
+  client_->client()->WaitForCryptoHandshakeConfirmed();
+  SetPacketLossPercentage(30);
+
+  // Create a POST request and send the headers only.
+  HTTPMessage request(HttpConstants::HTTP_1_1, HttpConstants::POST, "/foo");
+  request.set_has_complete_message(false);
+  client_->SendMessage(request);
+
+  // The TestAckNotifierDelegate will cause a failure if not notified.
+  scoped_refptr<TestAckNotifierDelegate> delegate(new TestAckNotifierDelegate);
+
+  // Test the AckNotifier's ability to track multiple packets by making the
+  // request body exceed the size of a single packet.
+  string request_string =
+      "a request body bigger than one packet" + string(kMaxPacketSize, '.');
+
+  // Send the request, and register the delegate for ACKs.
+  client_->SendData(request_string, true, delegate.get());
+  client_->WaitForResponse();
+  EXPECT_EQ(kFooResponseBody, client_->response_body());
+  EXPECT_EQ(200u, client_->response_headers()->parsed_response_code());
+
+  // Send another request to flush out any pending ACKs on the server.
+  client_->SendSynchronousRequest(request_string);
+
+  // Make sure the delegate does get the notification it expects.
+  while (!delegate->has_been_notified()) {
+    // Waits for up to 50 ms.
+    client_->client()->WaitForEvents();
+  }
+}
+
 }  // namespace
 }  // namespace test
 }  // namespace tools
 }  // namespace net