Land Recent QUIC Changes.

net/quic/quic_connection_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 "net/quic/quic_connection.h"
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/stl_util.h"
 #include "net/base/net_errors.h"
 #include "net/quic/congestion_control/receive_algorithm_interface.h"
 #include "net/quic/congestion_control/send_algorithm_interface.h"
 #include "net/quic/crypto/null_encrypter.h"
 #include "net/quic/crypto/quic_decrypter.h"
 #include "net/quic/crypto/quic_encrypter.h"
-#include "net/quic/crypto/quic_random.h"
 #include "net/quic/quic_protocol.h"
 #include "net/quic/quic_sent_packet_manager.h"
 #include "net/quic/quic_utils.h"
 #include "net/quic/test_tools/mock_clock.h"
 #include "net/quic/test_tools/mock_random.h"
 #include "net/quic/test_tools/quic_connection_peer.h"
 #include "net/quic/test_tools/quic_framer_peer.h"
 #include "net/quic/test_tools/quic_packet_creator_peer.h"
 #include "net/quic/test_tools/quic_test_utils.h"
 #include "testing/gmock/include/gmock/gmock.h"
@@ skipping 439 matching lines @@
   TestConnectionHelper::TestAlarm* GetAckAlarm() {
     return reinterpret_cast<TestConnectionHelper::TestAlarm*>(
         QuicConnectionPeer::GetAckAlarm(this));
   }
 
   TestConnectionHelper::TestAlarm* GetRetransmissionAlarm() {
     return reinterpret_cast<TestConnectionHelper::TestAlarm*>(
         QuicConnectionPeer::GetRetransmissionAlarm(this));
   }
 
-  TestConnectionHelper::TestAlarm* GetAbandonFecAlarm() {
-    return reinterpret_cast<TestConnectionHelper::TestAlarm*>(
-        QuicConnectionPeer::GetAbandonFecAlarm(this));
-  }
-
   TestConnectionHelper::TestAlarm* GetSendAlarm() {
     return reinterpret_cast<TestConnectionHelper::TestAlarm*>(
         QuicConnectionPeer::GetSendAlarm(this));
   }
 
   TestConnectionHelper::TestAlarm* GetResumeWritesAlarm() {
     return reinterpret_cast<TestConnectionHelper::TestAlarm*>(
         QuicConnectionPeer::GetResumeWritesAlarm(this));
   }
 
   TestConnectionHelper::TestAlarm* GetTimeoutAlarm() {
     return reinterpret_cast<TestConnectionHelper::TestAlarm*>(
         QuicConnectionPeer::GetTimeoutAlarm(this));
   }
 
   using QuicConnection::SelectMutualVersion;
 
  private:
   TestConnectionHelper* helper_;
   TestPacketWriter* writer_;
 
   DISALLOW_COPY_AND_ASSIGN(TestConnection);
 };
 
 class QuicConnectionTest : public ::testing::TestWithParam<bool> {
  protected:
   QuicConnectionTest()
       : guid_(42),
         framer_(QuicSupportedVersions(), QuicTime::Zero(), false),
-        creator_(guid_, &framer_, QuicRandom::GetInstance(), false),
+        creator_(guid_, &framer_, &random_generator_, false),
         send_algorithm_(new StrictMock<MockSendAlgorithm>),
         helper_(new TestConnectionHelper(&clock_, &random_generator_)),
         writer_(new TestPacketWriter()),
         connection_(guid_, IPEndPoint(), helper_.get(), writer_.get(), false),
         frame1_(1, false, 0, MakeIOVector(data1)),
         frame2_(1, false, 3, MakeIOVector(data2)),
         accept_packet_(true) {
     connection_.set_visitor(&visitor_);
     connection_.SetSendAlgorithm(send_algorithm_);
     framer_.set_received_entropy_calculator(&entropy_calculator_);
@@ skipping 392 matching lines @@
   QuicPacketSequenceNumber num_packets = 256 * 2 + 1;
   for (QuicPacketSequenceNumber i = 0; i < num_packets; ++i) {
     SendStreamDataToPeer(1, "foo", i * 3, !kFin, NULL);
   }
 
   QuicAckFrame frame(num_packets, QuicTime::Zero(), 1);
   // Create an ack with 256 nacks, none adjacent to one another.
   for (QuicPacketSequenceNumber i = 1; i <= 256; ++i) {
     frame.received_info.missing_packets.insert(i * 2);
   }
+  frame.received_info.entropy_hash = 0;
   EXPECT_CALL(entropy_calculator_,
               EntropyHash(511)).WillOnce(testing::Return(0));
   EXPECT_CALL(*send_algorithm_, OnPacketAcked(_, _, _)).Times(256);
   EXPECT_CALL(*send_algorithm_, OnPacketLost(_, _)).Times(10);
   EXPECT_CALL(*send_algorithm_, OnPacketAbandoned(_, _)).Times(10);
   ProcessAckPacket(&frame);
 
   QuicReceivedPacketManager* received_packet_manager =
       QuicConnectionPeer::GetReceivedPacketManager(&connection_);
   // A truncated ack will not have the true largest observed.
   EXPECT_GT(num_packets,
             received_packet_manager->peer_largest_observed_packet());
 
   frame.received_info.missing_packets.erase(192);
+  frame.received_info.entropy_hash = 2;
 
   // Removing one missing packet allows us to ack 192 and one more range.
   EXPECT_CALL(*send_algorithm_, OnPacketAcked(_, _, _)).Times(2);
   EXPECT_CALL(*send_algorithm_, OnPacketLost(_, _)).Times(10);
   EXPECT_CALL(*send_algorithm_, OnPacketAbandoned(_, _)).Times(10);
   ProcessAckPacket(&frame);
   EXPECT_EQ(num_packets,
             received_packet_manager->peer_largest_observed_packet());
 }
 
@@ skipping 70 matching lines @@
 
   ProcessAckPacket(&frame2);
   // Now if the peer sends an ack which still reports the retransmitted packet
   // as missing, then that will count as a packet which instigates an ack.
   EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, NOT_RETRANSMISSION, _));
   ProcessAckPacket(&frame2);
   ProcessAckPacket(&frame2);
 
   // But an ack with no missing packets will not send an ack.
   frame2.received_info.missing_packets.clear();
+  frame2.received_info.entropy_hash =
+      QuicConnectionPeer::GetSentEntropyHash(&connection_, retransmission);
   ProcessAckPacket(&frame2);
   ProcessAckPacket(&frame2);
 }
 
 TEST_F(QuicConnectionTest, LeastUnackedLower) {
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
 
   SendStreamDataToPeer(1, "foo", 0, !kFin, NULL);
   SendStreamDataToPeer(1, "bar", 3, !kFin, NULL);
   SendStreamDataToPeer(1, "eep", 6, !kFin, NULL);
@@ skipping 252 matching lines @@
 TEST_F(QuicConnectionTest, AbandonFECFromCongestionWindow) {
   connection_.options()->max_packets_per_fec_group = 1;
   // 1 Data and 1 FEC packet.
   EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(2);
   connection_.SendStreamDataWithString(1, "foo", 0, !kFin, NULL);
 
   const QuicTime::Delta retransmission_time =
       QuicTime::Delta::FromMilliseconds(5000);
   clock_.AdvanceTime(retransmission_time);
 
-  // Abandon FEC packet.
-  EXPECT_CALL(*send_algorithm_, OnPacketAbandoned(_, _)).Times(1);
+  // Abandon FEC packet and data packet.
+  EXPECT_CALL(*send_algorithm_, OnPacketAbandoned(_, _)).Times(2);
+  EXPECT_CALL(*send_algorithm_, OnRetransmissionTimeout());
+  EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(1);
   EXPECT_CALL(visitor_, OnCanWrite());
-  connection_.OnAbandonFecTimeout();
+  connection_.OnRetransmissionTimeout();
 }
 
 TEST_F(QuicConnectionTest, DontAbandonAckedFEC) {
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
   connection_.options()->max_packets_per_fec_group = 1;
 
   // 1 Data and 1 FEC packet.
   EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(6);
   connection_.SendStreamDataWithString(1, "foo", 0, !kFin, NULL);
   // Send some more data afterwards to ensure early retransmit doesn't trigger.
@@ skipping 10 matching lines @@
       QuicConnectionPeer::GetSentEntropyHash(&connection_, 1);
 
   EXPECT_CALL(*send_algorithm_, OnPacketAcked(_, _, _)).Times(1);
 
   ProcessAckPacket(&ack_fec);
 
   clock_.AdvanceTime(DefaultRetransmissionTime());
 
   // Don't abandon the acked FEC packet, but it will abandon 2 the subsequent
   // FEC packets.
-  EXPECT_CALL(*send_algorithm_, OnPacketAbandoned(_, _)).Times(2);
-  connection_.GetAbandonFecAlarm()->Fire();
+  EXPECT_CALL(*send_algorithm_, OnPacketAbandoned(_, _)).Times(5);
+  EXPECT_CALL(*send_algorithm_, OnRetransmissionTimeout());
+  EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(3);
+  connection_.GetRetransmissionAlarm()->Fire();
+}
+
+TEST_F(QuicConnectionTest, DontAbandonAllFEC) {
+  EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
+  connection_.options()->max_packets_per_fec_group = 1;
+
+  // 1 Data and 1 FEC packet.
+  EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(6);
+  connection_.SendStreamDataWithString(1, "foo", 0, !kFin, NULL);
+  // Send some more data afterwards to ensure early retransmit doesn't trigger.
+  connection_.SendStreamDataWithString(1, "foo", 3, !kFin, NULL);
+  // Advance the time so not all the FEC packets are abandoned.
+  clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(1));
+  connection_.SendStreamDataWithString(1, "foo", 6, !kFin, NULL);
+
+  QuicAckFrame ack_fec(5, QuicTime::Zero(), 1);
+  // Ack all data packets, but no fec packets.
+  ack_fec.received_info.missing_packets.insert(2);
+  ack_fec.received_info.missing_packets.insert(4);
+  ack_fec.received_info.entropy_hash =
+      QuicConnectionPeer::GetSentEntropyHash(&connection_, 5) ^
+      QuicConnectionPeer::GetSentEntropyHash(&connection_, 4) ^
+      QuicConnectionPeer::GetSentEntropyHash(&connection_, 3) ^
+      QuicConnectionPeer::GetSentEntropyHash(&connection_, 2) ^
+      QuicConnectionPeer::GetSentEntropyHash(&connection_, 1);
+
+  // Lose the first FEC packet and ack the three data packets.
+  EXPECT_CALL(*send_algorithm_, OnPacketAcked(_, _, _)).Times(3);
+  EXPECT_CALL(*send_algorithm_, OnPacketAbandoned(2, _));
+  EXPECT_CALL(*send_algorithm_, OnPacketLost(2, _));
+  ProcessAckPacket(&ack_fec);
+
+  clock_.AdvanceTime(DefaultRetransmissionTime().Subtract(
+      QuicTime::Delta::FromMilliseconds(1)));
+
+  // Don't abandon the acked FEC packet, but it will abandon 1 of the subsequent
+  // FEC packets.
+  EXPECT_CALL(*send_algorithm_, OnPacketAbandoned(4, _));
+  connection_.GetRetransmissionAlarm()->Fire();
+
+  // Ensure the connection's alarm is still set, in order to abandon the third
+  // FEC packet.
+  EXPECT_TRUE(connection_.GetRetransmissionAlarm()->IsSet());
 }
 
 TEST_F(QuicConnectionTest, FramePacking) {
   // Block the connection.
   connection_.GetSendAlarm()->Set(
       clock_.ApproximateNow().Add(QuicTime::Delta::FromSeconds(1)));
 
   // Send an ack and two stream frames in 1 packet by queueing them.
   connection_.SendAck();
   EXPECT_CALL(visitor_, OnCanWrite()).WillOnce(DoAll(
@@ skipping 301 matching lines @@
       QuicConnectionPeer::GetSentEntropyHash(&connection_, 1);
   // The first nack should trigger a fast retransmission, but we'll be
   // write blocked, so the packet will be queued.
   writer_->set_blocked(true);
 
   ProcessAckPacket(&nack_two);
   EXPECT_EQ(1u, connection_.NumQueuedPackets());
 
   // Now, ack the previous transmission.
   QuicAckFrame ack_all(3, QuicTime::Zero(), 0);
-  nack_two.received_info.entropy_hash =
+  ack_all.received_info.entropy_hash =
       QuicConnectionPeer::GetSentEntropyHash(&connection_, 3);
   ProcessAckPacket(&ack_all);
 
   // Unblock the socket and attempt to send the queued packets.  However,
   // since the previous transmission has been acked, we will not
   // send the retransmission.
   EXPECT_CALL(*send_algorithm_,
               OnPacketSent(_, _, _, _, _)).Times(0);
 
   writer_->set_blocked(false);
@@ skipping 121 matching lines @@
   EXPECT_EQ(5u, last_packet);
   SendStreamDataToPeer(3, "foo", 3, !kFin, &last_packet);  // Packet 6
   EXPECT_EQ(6u, last_packet);
 
   // Client will ack packets 1, 2, [!3], 4, 5.
   QuicAckFrame frame1(5, QuicTime::Zero(), 0);
   frame1.received_info.missing_packets.insert(3);
   frame1.received_info.entropy_hash =
       QuicConnectionPeer::GetSentEntropyHash(&connection_, 5) ^
       QuicConnectionPeer::GetSentEntropyHash(&connection_, 3) ^
-      QuicConnectionPeer::GetSentEntropyHash(&connection_, 1);
+      QuicConnectionPeer::GetSentEntropyHash(&connection_, 2);
 
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
 
   ProcessAckPacket(&frame1);
 
   // Now the client implicitly acks 3, and explicitly acks 6.
   QuicAckFrame frame2(6, QuicTime::Zero(), 0);
   frame2.received_info.entropy_hash =
       QuicConnectionPeer::GetSentEntropyHash(&connection_, 6);
 
@@ skipping 116 matching lines @@
 
   connection_.SetEncrypter(ENCRYPTION_INITIAL, new TaggingEncrypter(0x02));
   connection_.SetDefaultEncryptionLevel(ENCRYPTION_INITIAL);
   SendStreamDataToPeer(1, "foo", 0, !kFin, NULL);
   EXPECT_EQ(0x02020202u, final_bytes_of_last_packet());
 
   EXPECT_EQ(default_retransmission_time,
             connection_.GetRetransmissionAlarm()->deadline());
   {
     InSequence s;
-    EXPECT_CALL(*send_algorithm_, OnRetransmissionTimeout());
     EXPECT_CALL(*send_algorithm_, OnPacketAbandoned(1, _));
     EXPECT_CALL(*send_algorithm_, OnPacketAbandoned(2, _));
+    EXPECT_CALL(*send_algorithm_, OnRetransmissionTimeout());
     EXPECT_CALL(*send_algorithm_, OnPacketSent(_, 3, _, RTO_RETRANSMISSION, _));
     EXPECT_CALL(*send_algorithm_, OnPacketSent(_, 4, _, RTO_RETRANSMISSION, _));
   }
 
   // Simulate the retransmission alarm firing.
   clock_.AdvanceTime(DefaultRetransmissionTime());
   connection_.GetRetransmissionAlarm()->Fire();
 
   // Packet should have been sent with ENCRYPTION_NONE.
   EXPECT_EQ(0x01010101u, final_bytes_of_previous_packet());
@@ skipping 175 matching lines @@
   // Ack packets might generate some other packets, which are not
   // retransmissions. (More ack packets).
   EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, NOT_RETRANSMISSION, _))
       .Times(AnyNumber());
   EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, NACK_RETRANSMISSION, _))
       .WillOnce(DoAll(SaveArg<1>(&nack_sequence_number), Return(true)));
   QuicAckFrame ack(rto_sequence_number, QuicTime::Zero(), 0);
   // Ack the retransmitted packet.
   ack.received_info.missing_packets.insert(original_sequence_number);
   ack.received_info.missing_packets.insert(rto_sequence_number);
-  ack.received_info.entropy_hash = QuicConnectionPeer::GetSentEntropyHash(
-      &connection_, rto_sequence_number - 1);
+  ack.received_info.entropy_hash =
+      QuicConnectionPeer::GetSentEntropyHash(&connection_,
+                                             rto_sequence_number - 1) ^
+      QuicConnectionPeer::GetSentEntropyHash(&connection_,
+                                             original_sequence_number);
   for (int i = 0; i < 3; i++) {
     ProcessAckPacket(&ack);
   }
   ASSERT_NE(0u, nack_sequence_number);
   EXPECT_FALSE(QuicConnectionPeer::IsSavedForRetransmission(
       &connection_, rto_sequence_number));
   ASSERT_TRUE(QuicConnectionPeer::IsSavedForRetransmission(
       &connection_, nack_sequence_number));
   EXPECT_TRUE(QuicConnectionPeer::IsRetransmission(
       &connection_, nack_sequence_number));
@@ skipping 18 matching lines @@
   connection_.SendStreamDataWithString(1, "foo", 0, !kFin, NULL);
   connection_.SendStreamDataWithString(2, "bar", 0, !kFin, NULL);
   QuicAlarm* retransmission_alarm = connection_.GetRetransmissionAlarm();
   EXPECT_TRUE(retransmission_alarm->IsSet());
 
   // Advance the time right before the RTO, then receive an ack for the first
   // packet to delay the RTO.
   clock_.AdvanceTime(DefaultRetransmissionTime());
   EXPECT_CALL(*send_algorithm_, OnPacketAcked(_, _, _)).Times(1);
   QuicAckFrame ack(1, QuicTime::Zero(), 0);
+  ack.received_info.entropy_hash =
+      QuicConnectionPeer::GetSentEntropyHash(&connection_, 1);
   ProcessAckPacket(&ack);
   EXPECT_TRUE(retransmission_alarm->IsSet());
 
   // Move forward past the original RTO and ensure the RTO is still pending.
   clock_.AdvanceTime(DefaultRetransmissionTime());
 
   // Ensure the second packet gets retransmitted when it finally fires.
   EXPECT_TRUE(retransmission_alarm->IsSet());
   EXPECT_GE(retransmission_alarm->deadline(), clock_.ApproximateNow());
   clock_.AdvanceTime(DefaultRetransmissionTime());
@@ skipping 954 matching lines @@
   // Create a delegate which we expect to be called.
   MockAckNotifierDelegate delegate;
   EXPECT_CALL(delegate, OnAckNotification()).Times(1);;
 
   // Send some data, which will register the delegate to be notified.
   connection_.SendStreamDataWithString(1, "foo", 0, !kFin, &delegate);
 
   // Process an ACK from the server which should trigger the callback.
   EXPECT_CALL(*send_algorithm_, OnPacketAcked(_, _, _)).Times(1);
   QuicAckFrame frame(1, QuicTime::Zero(), 0);
+  frame.received_info.entropy_hash =
+      QuicConnectionPeer::GetSentEntropyHash(&connection_, 1);
   ProcessAckPacket(&frame);
 }
 
 TEST_F(QuicConnectionTest, AckNotifierFailToTriggerCallback) {
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
 
   // Create a delegate which we don't expect to be called.
   MockAckNotifierDelegate delegate;
   EXPECT_CALL(delegate, OnAckNotification()).Times(0);;
 
   EXPECT_CALL(*send_algorithm_, OnPacketAcked(_, _, _)).Times(2);
 
   // Send some data, which will register the delegate to be notified. This will
   // not be ACKed and so the delegate should never be called.
   connection_.SendStreamDataWithString(1, "foo", 0, !kFin, &delegate);
 
   // Send some other data which we will ACK.
   connection_.SendStreamDataWithString(1, "foo", 0, !kFin, NULL);
   connection_.SendStreamDataWithString(1, "bar", 0, !kFin, NULL);
 
   // Now we receive ACK for packets 2 and 3, but importantly missing packet 1
   // which we registered to be notified about.
   QuicAckFrame frame(3, QuicTime::Zero(), 0);
   frame.received_info.missing_packets.insert(1);
+  frame.received_info.entropy_hash =
+      QuicConnectionPeer::GetSentEntropyHash(&connection_, 3) ^
+      QuicConnectionPeer::GetSentEntropyHash(&connection_, 1);
   EXPECT_CALL(*send_algorithm_, OnPacketLost(_, _));
   EXPECT_CALL(*send_algorithm_, OnPacketAbandoned(_, _));
   ProcessAckPacket(&frame);
 }
 
 TEST_F(QuicConnectionTest, AckNotifierCallbackAfterRetransmission) {
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
 
   // Create a delegate which we expect to be called.
   MockAckNotifierDelegate delegate;
   EXPECT_CALL(delegate, OnAckNotification()).Times(1);;
 
   // In total expect ACKs for all 4 packets.
   EXPECT_CALL(*send_algorithm_, OnPacketAcked(_, _, _)).Times(4);
 
   // Send four packets, and register to be notified on ACK of packet 2.
   connection_.SendStreamDataWithString(1, "foo", 0, !kFin, NULL);
   connection_.SendStreamDataWithString(1, "bar", 0, !kFin, &delegate);
   connection_.SendStreamDataWithString(1, "baz", 0, !kFin, NULL);
   connection_.SendStreamDataWithString(1, "qux", 0, !kFin, NULL);
 
   // Now we receive ACK for packets 1, 3, and 4, which invokes fast retransmit.
   QuicAckFrame frame(4, QuicTime::Zero(), 0);
   frame.received_info.missing_packets.insert(2);
+  frame.received_info.entropy_hash =
+      QuicConnectionPeer::GetSentEntropyHash(&connection_, 4) ^
+      QuicConnectionPeer::GetSentEntropyHash(&connection_, 2) ^
+      QuicConnectionPeer::GetSentEntropyHash(&connection_, 1);
   EXPECT_CALL(*send_algorithm_, OnPacketLost(2, _));
   EXPECT_CALL(*send_algorithm_, OnPacketAbandoned(2, _));
   EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _));
   ProcessAckPacket(&frame);
 
   // Now we get an ACK for packet 5 (retransmitted packet 2), which should
   // trigger the callback.
   QuicAckFrame second_ack_frame(5, QuicTime::Zero(), 0);
+  second_ack_frame.received_info.entropy_hash =
+      QuicConnectionPeer::GetSentEntropyHash(&connection_, 5);
   ProcessAckPacket(&second_ack_frame);
 }
 
 // TODO(rjshade): Add a similar test that FEC recovery on peer (and resulting
 //                ACK) triggers notification on our end.
 TEST_F(QuicConnectionTest, AckNotifierCallbackAfterFECRecovery) {
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
   EXPECT_CALL(visitor_, OnCanWrite()).Times(1).WillOnce(Return(true));
 
   // Create a delegate which we expect to be called.
   MockAckNotifierDelegate delegate;
   EXPECT_CALL(delegate, OnAckNotification()).Times(1);;
 
   // Expect ACKs for 1 packet.
   EXPECT_CALL(*send_algorithm_, OnPacketAcked(_, _, _)).Times(1);
 
   // Send one packet, and register to be notified on ACK.
   connection_.SendStreamDataWithString(1, "foo", 0, !kFin, &delegate);
 
   // Ack packet gets dropped, but we receive an FEC packet that covers it.
   // Should recover the Ack packet and trigger the notification callback.
   QuicFrames frames;
 
   QuicAckFrame ack_frame(1, QuicTime::Zero(), 0);
+  ack_frame.received_info.entropy_hash =
+      QuicConnectionPeer::GetSentEntropyHash(&connection_, 1);
   frames.push_back(QuicFrame(&ack_frame));
 
   // Dummy stream frame to satisfy expectations set elsewhere.
   frames.push_back(QuicFrame(&frame1_));
 
   QuicPacketHeader ack_header;
   ack_header.public_header.guid = guid_;
   ack_header.public_header.reset_flag = false;
   ack_header.public_header.version_flag = false;
   ack_header.entropy_flag = !kEntropyFlag;
@@ skipping 79 matching lines @@
                         true);
   TestConnection client(guid_, IPEndPoint(), helper_.get(), writer_.get(),
                         false);
   EXPECT_TRUE(client.sent_packet_manager().using_pacing());
   EXPECT_FALSE(server.sent_packet_manager().using_pacing());
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net