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 "net/base/net_errors.h"
 #include "net/quic/congestion_control/receive_algorithm_interface.h"
@@ skipping 371 matching lines @@
   }
 
   void SetReceiveAlgorithm(TestReceiveAlgorithm* receive_algorithm) {
      QuicConnectionPeer::SetReceiveAlgorithm(this, receive_algorithm);
   }
 
   void SetSendAlgorithm(SendAlgorithmInterface* send_algorithm) {
     QuicConnectionPeer::SetSendAlgorithm(this, send_algorithm);
   }
 
+  bool SendOrQueuePacket(EncryptionLevel level,
+                         QuicPacketSequenceNumber sequence_number,
+                         QuicPacket* packet,
+                         QuicPacketEntropyHash entropy_hash,
+                         HasRetransmittableData retransmittable) {
+    return SendOrQueuePacket(level,
+                             sequence_number,
+                             packet,
+                             entropy_hash,
+                             retransmittable,
+                             NO_FORCE);
+  }
+
   QuicConsumedData SendStreamData(QuicStreamId id,
                                   StringPiece data,
                                   QuicStreamOffset offset,
                                   bool fin) {
     struct iovec iov = {const_cast<char*>(data.data()),
                         static_cast<size_t>(data.size())};
     return SendvStreamData(id, &iov, 1, offset, fin);
   }
 
+  QuicConsumedData SendStreamDataAndNotifyWhenAcked(
+      QuicStreamId id,
+      StringPiece data,
+      QuicStreamOffset offset,
+      bool fin,
+      QuicAckNotifier::DelegateInterface* delegate) {
+    struct iovec iov = {const_cast<char*>(data.data()),
+                        static_cast<size_t>(data.size())};
+    return SendvStreamDataAndNotifyWhenAcked(id, &iov, 1, offset, fin,
+                                             delegate);
+  }
+
   QuicConsumedData SendStreamData3() {
     return SendStreamData(kStreamId3, "food", 0, !kFin);
   }
 
   QuicConsumedData SendStreamData5() {
     return SendStreamData(kStreamId5, "food2", 0, !kFin);
   }
 
   // The crypto stream has special semantics so that it is not blocked by a
   // congestion window limitation, and also so that it gets put into a separate
@@ skipping 73 matching lines @@
     EXPECT_CALL(*send_algorithm_, RetransmissionDelay()).WillRepeatedly(
         Return(QuicTime::Delta::Zero()));
     EXPECT_CALL(*send_algorithm_, BandwidthEstimate()).WillRepeatedly(Return(
         QuicBandwidth::FromKBitsPerSecond(100)));
     EXPECT_CALL(*send_algorithm_, SmoothedRtt()).WillRepeatedly(Return(
         QuicTime::Delta::FromMilliseconds(100)));
     ON_CALL(*send_algorithm_, SentPacket(_, _, _, _, _))
         .WillByDefault(Return(true));
     // TODO(rch): remove this.
     QuicConnection::g_acks_do_not_instigate_acks = true;
+    EXPECT_CALL(visitor_, HasPendingHandshake()).Times(AnyNumber());
   }
 
   ~QuicConnectionTest() {
     // TODO(rch): remove this.
     QuicConnection::g_acks_do_not_instigate_acks = false;
   }
 
   QuicAckFrame* outgoing_ack() {
     outgoing_ack_.reset(QuicConnectionPeer::CreateAckFrame(&connection_));
     return outgoing_ack_.get();
@@ skipping 17 matching lines @@
 
   uint32 final_bytes_of_last_packet() {
     return helper_->final_bytes_of_last_packet();
   }
 
   void use_tagging_decrypter() {
     helper_->use_tagging_decrypter();
   }
 
   void ProcessPacket(QuicPacketSequenceNumber number) {
-    EXPECT_CALL(visitor_, OnPacket(_, _, _, _))
-        .WillOnce(Return(accept_packet_));
+    EXPECT_CALL(visitor_, OnStreamFrames(_)).WillOnce(Return(accept_packet_));
     ProcessDataPacket(number, 0, !kEntropyFlag);
   }
 
   QuicPacketEntropyHash ProcessFramePacket(QuicFrame frame) {
     QuicFrames frames;
     frames.push_back(QuicFrame(frame));
     QuicPacketCreatorPeer::SetSendVersionInPacket(&creator_,
                                                   connection_.is_server());
     SerializedPacket serialized_packet = creator_.SerializeAllFrames(frames);
     scoped_ptr<QuicPacket> packet(serialized_packet.packet);
@@ skipping 27 matching lines @@
                           QuicFecGroupNumber fec_group) {
     scoped_ptr<QuicPacket> packet(ConstructClosePacket(number, fec_group));
     scoped_ptr<QuicEncryptedPacket> encrypted(framer_.EncryptPacket(
         ENCRYPTION_NONE, number, *packet));
     connection_.ProcessUdpPacket(IPEndPoint(), IPEndPoint(), *encrypted);
   }
 
   size_t ProcessFecProtectedPacket(QuicPacketSequenceNumber number,
                                  bool expect_revival, bool entropy_flag) {
     if (expect_revival) {
-      EXPECT_CALL(visitor_, OnPacket(_, _, _, _)).WillOnce(DoAll(
-          SaveArg<2>(&revived_header_), Return(accept_packet_)));
+      EXPECT_CALL(visitor_, OnStreamFrames(_)).WillOnce(Return(accept_packet_));
     }
-    EXPECT_CALL(visitor_, OnPacket(_, _, _, _)).WillOnce(Return(accept_packet_))
+    EXPECT_CALL(visitor_, OnStreamFrames(_)).WillOnce(Return(accept_packet_))
         .RetiresOnSaturation();
     return ProcessDataPacket(number, 1, entropy_flag);
   }
 
   // Processes an FEC packet that covers the packets that would have been
   // received.
   size_t ProcessFecPacket(QuicPacketSequenceNumber number,
                           QuicPacketSequenceNumber min_protected_packet,
                           bool expect_revival,
                           bool entropy_flag,
                           QuicPacket* packet) {
     if (expect_revival) {
-      EXPECT_CALL(visitor_, OnPacket(_, _, _, _)).WillOnce(DoAll(
-          SaveArg<2>(&revived_header_), Return(accept_packet_)));
+      EXPECT_CALL(visitor_, OnStreamFrames(_)).WillOnce(Return(accept_packet_));
     }
 
     // Construct the decrypted data packet so we can compute the correct
     // redundancy. If |packet| has been provided then use that, otherwise
     // construct a default data packet.
     scoped_ptr<QuicPacket> data_packet;
     if (packet) {
       data_packet.reset(packet);
     } else {
       data_packet.reset(ConstructDataPacket(number, 1, !kEntropyFlag));
@@ skipping 130 matching lines @@
 
   MockSendAlgorithm* send_algorithm_;
   TestReceiveAlgorithm* receive_algorithm_;
   MockClock clock_;
   MockRandom random_generator_;
   TestConnectionHelper* helper_;
   TestConnection connection_;
   StrictMock<MockConnectionVisitor> visitor_;
 
   QuicPacketHeader header_;
-  QuicPacketHeader revived_header_;
   QuicStreamFrame frame1_;
   QuicStreamFrame frame2_;
   scoped_ptr<QuicAckFrame> outgoing_ack_;
   bool accept_packet_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(QuicConnectionTest);
 };
 
 TEST_F(QuicConnectionTest, PacketsInOrder) {
@@ skipping 47 matching lines @@
 
 TEST_F(QuicConnectionTest, DuplicatePacket) {
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
 
   ProcessPacket(3);
   EXPECT_EQ(3u, outgoing_ack()->received_info.largest_observed);
   EXPECT_TRUE(IsMissing(2));
   EXPECT_TRUE(IsMissing(1));
 
   // Send packet 3 again, but do not set the expectation that
-  // the visitor OnPacket() will be called.
+  // the visitor OnStreamFrames() will be called.
   ProcessDataPacket(3, 0, !kEntropyFlag);
   EXPECT_EQ(3u, outgoing_ack()->received_info.largest_observed);
   EXPECT_TRUE(IsMissing(2));
   EXPECT_TRUE(IsMissing(1));
 }
 
 TEST_F(QuicConnectionTest, PacketsOutOfOrderWithAdditionsAndLeastAwaiting) {
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
 
   ProcessPacket(3);
@@ skipping 25 matching lines @@
 
 TEST_F(QuicConnectionTest, RejectPacketTooFarOut) {
   // Call ProcessDataPacket rather than ProcessPacket, as we should not get a
   // packet call to the visitor.
   EXPECT_CALL(visitor_, ConnectionClose(QUIC_INVALID_PACKET_HEADER, false));
   ProcessDataPacket(6000, 0, !kEntropyFlag);
 }
 
 TEST_F(QuicConnectionTest, TruncatedAck) {
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
-  EXPECT_CALL(visitor_, OnAck(_)).Times(testing::AnyNumber());
   EXPECT_CALL(*send_algorithm_, OnIncomingAck(_, _, _)).Times(2);
   EXPECT_CALL(*send_algorithm_, OnIncomingLoss(_)).Times(1);
   for (int i = 0; i < 200; ++i) {
     SendStreamDataToPeer(1, "foo", i * 3, !kFin, NULL);
   }
 
   QuicAckFrame frame(0, QuicTime::Zero(), 1);
   frame.received_info.largest_observed = 193;
   InsertMissingPacketsBetween(&frame.received_info, 1, 193);
   frame.received_info.entropy_hash =
@@ skipping 99 matching lines @@
 
   SendStreamDataToPeer(1, "foo", 0, !kFin, NULL);
   SendStreamDataToPeer(1, "bar", 3, !kFin, NULL);
   SendStreamDataToPeer(1, "eep", 6, !kFin, NULL);
   EXPECT_CALL(*send_algorithm_, OnIncomingAck(_, _, _)).Times(2);
 
   // Start out saying the largest observed is 2.
   QuicAckFrame frame(2, QuicTime::Zero(), 0);
   frame.received_info.entropy_hash = QuicConnectionPeer::GetSentEntropyHash(
       &connection_, 2);
-  EXPECT_CALL(visitor_, OnAck(_));
   ProcessAckPacket(&frame, true);
 
   // Now change it to 1, and it should cause a connection error.
   QuicAckFrame frame2(1, QuicTime::Zero(), 0);
   EXPECT_CALL(visitor_, ConnectionClose(QUIC_INVALID_ACK_DATA, false));
   ProcessAckPacket(&frame2, false);
 }
 
 TEST_F(QuicConnectionTest, LeastUnackedGreaterThanPacketSequenceNumber) {
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
@@ skipping 149 matching lines @@
   EXPECT_EQ(1u, last_ack()->sent_info.least_unacked);
 
   SendAckPacketToPeer();  // Packet 3
   EXPECT_EQ(1u, last_ack()->sent_info.least_unacked);
 
   SendStreamDataToPeer(1u, "bar", 3, !kFin, &last_packet);  // Packet 4
   EXPECT_EQ(4u, last_packet);
   SendAckPacketToPeer();  // Packet 5
   EXPECT_EQ(1u, last_ack()->sent_info.least_unacked);
 
-  SequenceNumberSet expected_acks;
-  expected_acks.insert(1);
-
   // Peer acks up to packet 3.
-  EXPECT_CALL(visitor_, OnAck(ContainerEq(expected_acks)));
   QuicAckFrame frame(3, QuicTime::Zero(), 0);
   frame.received_info.entropy_hash =
       QuicConnectionPeer::GetSentEntropyHash(&connection_, 3);
   ProcessAckPacket(&frame, true);
   SendAckPacketToPeer();  // Packet 6
 
   // As soon as we've acked one, we skip ack packets 2 and 3 and note lack of
   // ack for 4.
   EXPECT_EQ(4u, last_ack()->sent_info.least_unacked);
 
-  expected_acks.clear();
-  expected_acks.insert(4);
-
   // Peer acks up to packet 4, the last packet.
-  EXPECT_CALL(visitor_, OnAck(ContainerEq(expected_acks)));
   QuicAckFrame frame2(6, QuicTime::Zero(), 0);
   frame2.received_info.entropy_hash =
       QuicConnectionPeer::GetSentEntropyHash(&connection_, 6);
   ProcessAckPacket(&frame2, true);  // Acks don't instigate acks.
 
   // Verify that we did not send an ack.
   EXPECT_EQ(6u, last_header()->packet_sequence_number);
 
   // So the last ack has not changed.
   EXPECT_EQ(4u, last_ack()->sent_info.least_unacked);
@@ skipping 76 matching lines @@
   EXPECT_CALL(*send_algorithm_, SentPacket(_, _, _, _, _)).Times(2);
   connection_.SendStreamData(1, "foo", 0, !kFin);
 
   QuicAckFrame ack_fec(2, QuicTime::Zero(), 1);
   // Data packet missing.
   ack_fec.received_info.missing_packets.insert(1);
   ack_fec.received_info.entropy_hash =
       QuicConnectionPeer::GetSentEntropyHash(&connection_, 2) ^
       QuicConnectionPeer::GetSentEntropyHash(&connection_, 1);
 
-  EXPECT_CALL(visitor_, OnAck(_)).Times(1);
   EXPECT_CALL(*send_algorithm_, OnIncomingAck(_, _, _)).Times(1);
   EXPECT_CALL(*send_algorithm_, OnIncomingLoss(_)).Times(1);
 
   ProcessAckPacket(&ack_fec, true);
 
   clock_.AdvanceTime(DefaultRetransmissionTime());
 
   // Abandon only data packet, FEC has been acked.
   EXPECT_CALL(*send_algorithm_, AbandoningPacket(sequence_number, _)).Times(1);
   // Send only data packet.
@@ skipping 221 matching lines @@
   EXPECT_CALL(*send_algorithm_, OnIncomingAck(_, _, _)).Times(2);
   EXPECT_CALL(*send_algorithm_, OnIncomingLoss(_)).Times(1);
   EXPECT_CALL(*send_algorithm_, AbandoningPacket(2, _)).Times(1);
   QuicPacketSequenceNumber last_packet;
   QuicByteCount second_packet_size;
   SendStreamDataToPeer(1, "foo", 0, !kFin, &last_packet);  // Packet 1
   second_packet_size =
       SendStreamDataToPeer(1, "foos", 3, !kFin, &last_packet);  // Packet 2
   SendStreamDataToPeer(1, "fooos", 7, !kFin, &last_packet);  // Packet 3
 
-  SequenceNumberSet expected_acks;
-  expected_acks.insert(1);
-  EXPECT_CALL(visitor_, OnAck(ContainerEq(expected_acks)));
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
 
   // Peer acks one but not two or three.  Right now we only retransmit on
   // explicit nack, so it should not trigger a retransimission.
   QuicAckFrame ack_one(1, QuicTime::Zero(), 0);
   ack_one.received_info.entropy_hash =
       QuicConnectionPeer::GetSentEntropyHash(&connection_, 1);
   ProcessAckPacket(&ack_one, true);
   ProcessAckPacket(&ack_one, true);
   ProcessAckPacket(&ack_one, true);
 
-  expected_acks.clear();
-  expected_acks.insert(3);
-  EXPECT_CALL(visitor_, OnAck(ContainerEq(expected_acks)));
-
   // Peer acks up to 3 with two explicitly missing.  Two nacks should cause no
   // change.
   QuicAckFrame nack_two(3, QuicTime::Zero(), 0);
   nack_two.received_info.missing_packets.insert(2);
   nack_two.received_info.entropy_hash =
       QuicConnectionPeer::GetSentEntropyHash(&connection_, 3) ^
       QuicConnectionPeer::GetSentEntropyHash(&connection_, 2) ^
       QuicConnectionPeer::GetSentEntropyHash(&connection_, 1);
   ProcessAckPacket(&nack_two, true);
   ProcessAckPacket(&nack_two, true);
@@ skipping 36 matching lines @@
   // Make a truncated ack frame.
   QuicAckFrame frame(0, QuicTime::Zero(), 1);
   frame.received_info.largest_observed = 193;
   InsertMissingPacketsBetween(&frame.received_info, 1, 193);
   frame.received_info.entropy_hash =
       QuicConnectionPeer::GetSentEntropyHash(&connection_, 193) ^
       QuicConnectionPeer::GetSentEntropyHash(&connection_, 192);
 
   EXPECT_CALL(*send_algorithm_, OnIncomingAck(_, _, _)).Times(1);
   EXPECT_CALL(*send_algorithm_, OnIncomingLoss(_)).Times(1);
-  EXPECT_CALL(visitor_, OnAck(_)).Times(1);
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
   ProcessAckPacket(&frame, true);
   EXPECT_TRUE(QuicConnectionPeer::GetReceivedTruncatedAck(&connection_));
 
   QuicConnectionPeer::SetMaxPacketsPerRetransmissionAlarm(&connection_, 200);
   clock_.AdvanceTime(DefaultRetransmissionTime());
   // Only packets that are less than largest observed should be retransmitted.
   EXPECT_CALL(*send_algorithm_, AbandoningPacket(_, _)).Times(192);
   EXPECT_CALL(*send_algorithm_, SentPacket(_, _, _, _, _)).Times(192);
   connection_.OnRetransmissionTimeout();
@@ skipping 21 matching lines @@
 
   // Ack 12, nack 1-11
   QuicAckFrame nack(12, QuicTime::Zero(), 0);
   for (int i = 1; i < 12; ++i) {
     nack.received_info.missing_packets.insert(i);
   }
 
   nack.received_info.entropy_hash =
       QuicConnectionPeer::GetSentEntropyHash(&connection_, 12) ^
       QuicConnectionPeer::GetSentEntropyHash(&connection_, 11);
-  SequenceNumberSet expected_acks;
-  expected_acks.insert(12);
-  EXPECT_CALL(visitor_, OnAck(ContainerEq(expected_acks)));
 
   // Nack three times.
   ProcessAckPacket(&nack, true);
   ProcessAckPacket(&nack, true);
   // The third call should trigger retransmitting 10 packets.
   EXPECT_CALL(*send_algorithm_, SentPacket(_, _, _, _, _)).Times(10);
   ProcessAckPacket(&nack, true);
 
   // The fourth call should trigger retransmitting the 11th packet.
   EXPECT_CALL(*send_algorithm_, SentPacket(_, _, _, _, _)).Times(1);
@@ skipping 18 matching lines @@
   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(2);
   frame1.received_info.entropy_hash =
       QuicConnectionPeer::GetSentEntropyHash(&connection_, 5) ^
       QuicConnectionPeer::GetSentEntropyHash(&connection_, 2) ^
       QuicConnectionPeer::GetSentEntropyHash(&connection_, 1);
 
-  // The connection should pass up acks for 1, 4, 5.  2 is not acked, and 3 was
-  // an ackframe so should not be passed up.
-  SequenceNumberSet expected_acks;
-  expected_acks.insert(1);
-  expected_acks.insert(4);
-  expected_acks.insert(5);
-
-  EXPECT_CALL(visitor_, OnAck(ContainerEq(expected_acks)));
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
 
   ProcessAckPacket(&frame1, true);
 
   // Now the client implicitly acks 2, and explicitly acks 6
   QuicAckFrame frame2(6, QuicTime::Zero(), 0);
   frame2.received_info.entropy_hash =
       QuicConnectionPeer::GetSentEntropyHash(&connection_, 6);
-  expected_acks.clear();
-  // Both acks should be passed up.
-  expected_acks.insert(2);
-  expected_acks.insert(6);
 
-  EXPECT_CALL(visitor_, OnAck(ContainerEq(expected_acks)));
   ProcessAckPacket(&frame2, true);
 }
 
 TEST_F(QuicConnectionTest, DontLatchUnackedPacket) {
   EXPECT_CALL(*send_algorithm_, OnIncomingAck(_, _, _)).Times(1);
   SendStreamDataToPeer(1, "foo", 0, !kFin, NULL);  // Packet 1;
   SendAckPacketToPeer();  // Packet 2
 
-  // This sets least unacked to 3 (unsent packet), since we don't need
-  // an ack for Packet 2 (ack packet).
-  SequenceNumberSet expected_acks;
-  expected_acks.insert(1);
-  // Peer acks packet 1.
-  EXPECT_CALL(visitor_, OnAck(ContainerEq(expected_acks)));
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
   QuicAckFrame frame(1, QuicTime::Zero(), 0);
   frame.received_info.entropy_hash = QuicConnectionPeer::GetSentEntropyHash(
       &connection_, 1);
   ProcessAckPacket(&frame, true);
 
   // Verify that our internal state has least-unacked as 3.
   EXPECT_EQ(3u, outgoing_ack()->sent_info.least_unacked);
 
   // When we send an ack, we make sure our least-unacked makes sense.  In this
   // case since we're not waiting on an ack for 2 and all packets are acked, we
   // set it to 3.
   SendAckPacketToPeer();  // Packet 3
   // Since this was an ack packet, we set least_unacked to 4.
   EXPECT_EQ(4u, outgoing_ack()->sent_info.least_unacked);
   // Check that the outgoing ack had its sequence number as least_unacked.
   EXPECT_EQ(3u, last_ack()->sent_info.least_unacked);
 
   SendStreamDataToPeer(1, "bar", 3, false, NULL);  // Packet 4
   EXPECT_EQ(4u, outgoing_ack()->sent_info.least_unacked);
   SendAckPacketToPeer();  // Packet 5
   EXPECT_EQ(4u, last_ack()->sent_info.least_unacked);
 }
 
 TEST_F(QuicConnectionTest, ReviveMissingPacketAfterFecPacket) {
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
 
   // Don't send missing packet 1.
   ProcessFecPacket(2, 1, true, !kEntropyFlag, NULL);
-  EXPECT_FALSE(revived_header_.entropy_flag);
+  // Entropy flag should be false, so entropy should be 0.
+  EXPECT_EQ(0u, QuicConnectionPeer::ReceivedEntropyHash(&connection_, 2));
 }
 
 TEST_F(QuicConnectionTest, ReviveMissingPacketAfterDataPacketThenFecPacket) {
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
 
   ProcessFecProtectedPacket(1, false, kEntropyFlag);
   // Don't send missing packet 2.
   ProcessFecPacket(3, 1, true, !kEntropyFlag, NULL);
-  EXPECT_TRUE(revived_header_.entropy_flag);
+  // Entropy flag should be true, so entropy should not be 0.
+  EXPECT_NE(0u, QuicConnectionPeer::ReceivedEntropyHash(&connection_, 2));
 }
 
 TEST_F(QuicConnectionTest, ReviveMissingPacketAfterDataPacketsThenFecPacket) {
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
 
   ProcessFecProtectedPacket(1, false, !kEntropyFlag);
   // Don't send missing packet 2.
   ProcessFecProtectedPacket(3, false, !kEntropyFlag);
   ProcessFecPacket(4, 1, true, kEntropyFlag, NULL);
-  EXPECT_TRUE(revived_header_.entropy_flag);
+  // Entropy flag should be true, so entropy should not be 0.
+  EXPECT_NE(0u, QuicConnectionPeer::ReceivedEntropyHash(&connection_, 2));
 }
 
 TEST_F(QuicConnectionTest, ReviveMissingPacketAfterDataPacket) {
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
 
   // Don't send missing packet 1.
   ProcessFecPacket(3, 1, false, !kEntropyFlag, NULL);
   // out of order
   ProcessFecProtectedPacket(2, true, !kEntropyFlag);
-  EXPECT_FALSE(revived_header_.entropy_flag);
+  // Entropy flag should be false, so entropy should be 0.
+  EXPECT_EQ(0u, QuicConnectionPeer::ReceivedEntropyHash(&connection_, 2));
 }
 
 TEST_F(QuicConnectionTest, ReviveMissingPacketAfterDataPackets) {
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
 
   ProcessFecProtectedPacket(1, false, !kEntropyFlag);
   // Don't send missing packet 2.
   ProcessFecPacket(6, 1, false, kEntropyFlag, NULL);
   ProcessFecProtectedPacket(3, false, kEntropyFlag);
   ProcessFecProtectedPacket(4, false, kEntropyFlag);
   ProcessFecProtectedPacket(5, true, !kEntropyFlag);
-  EXPECT_TRUE(revived_header_.entropy_flag);
+  // Entropy flag should be true, so entropy should be 0.
+  EXPECT_NE(0u, QuicConnectionPeer::ReceivedEntropyHash(&connection_, 2));
 }
 
 TEST_F(QuicConnectionTest, TestRetransmit) {
   QuicTime default_retransmission_time = clock_.ApproximateNow().Add(
       DefaultRetransmissionTime());
   SendStreamDataToPeer(1, "foo", 0, !kFin, NULL);
   EXPECT_EQ(1u, outgoing_ack()->sent_info.least_unacked);
 
   EXPECT_EQ(1u, last_header()->packet_sequence_number);
   EXPECT_EQ(default_retransmission_time,
@@ skipping 92 matching lines @@
   // Process an encrypted packet which can not yet be decrypted
   // which should result in the packet being buffered.
   ProcessDataPacketAtLevel(1, false, kEntropyFlag, ENCRYPTION_INITIAL);
 
   // Transition to the new encryption state and process another
   // encrypted packet which should result in the original packet being
   // processed.
   connection_.SetDecrypter(new StrictTaggingDecrypter(tag));
   connection_.SetDefaultEncryptionLevel(ENCRYPTION_INITIAL);
   connection_.SetEncrypter(ENCRYPTION_INITIAL, new TaggingEncrypter(tag));
-  EXPECT_CALL(visitor_, OnPacket(_, _, _, _)).Times(2).WillRepeatedly(
+  EXPECT_CALL(visitor_, OnStreamFrames(_)).Times(2).WillRepeatedly(
       Return(true));
   ProcessDataPacketAtLevel(2, false, kEntropyFlag, ENCRYPTION_INITIAL);
 
   // Finally, process a third packet and note that we do not
   // reprocess the buffered packet.
-  EXPECT_CALL(visitor_, OnPacket(_, _, _, _)).WillOnce(Return(true));
+  EXPECT_CALL(visitor_, OnStreamFrames(_)).WillOnce(Return(true));
   ProcessDataPacketAtLevel(3, false, kEntropyFlag, ENCRYPTION_INITIAL);
 }
 
 TEST_F(QuicConnectionTest, TestRetransmitOrder) {
   QuicByteCount first_packet_size;
   EXPECT_CALL(*send_algorithm_, SentPacket(_, _, _, _, _)).WillOnce(
       DoAll(SaveArg<2>(&first_packet_size), Return(true)));
   EXPECT_CALL(*send_algorithm_, AbandoningPacket(_, _)).Times(2);
 
   connection_.SendStreamData(1, "first_packet", 0, !kFin);
@@ skipping 68 matching lines @@
   // Make sure that RTO is not started when the packet is queued.
   EXPECT_EQ(0u, QuicConnectionPeer::GetNumRetransmissionTimeouts(&connection_));
 
   // Test that RTO is started once we write to the socket.
   helper_->set_blocked(false);
   EXPECT_CALL(visitor_, OnCanWrite());
   connection_.OnCanWrite();
   EXPECT_EQ(1u, QuicConnectionPeer::GetNumRetransmissionTimeouts(&connection_));
 }
 
+TEST_F(QuicConnectionTest, DelayRTOWithAckReceipt) {
+  EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
+  EXPECT_CALL(*send_algorithm_, SentPacket(_, _, _, NOT_RETRANSMISSION, _))
+      .Times(2);
+  connection_.SendStreamData(1, "foo", 0, !kFin);
+  connection_.SendStreamData(2, "bar", 0, !kFin);
+  EXPECT_EQ(2u, QuicConnectionPeer::GetNumRetransmissionTimeouts(&connection_));
+
+  // Advance the time right before the RTO, then receive an ack for the first
+  // packet to delay the RTO.
+  clock_.AdvanceTime(DefaultRetransmissionTime());
+  EXPECT_EQ(2u, QuicConnectionPeer::GetNumRetransmissionTimeouts(&connection_));
+  EXPECT_CALL(*send_algorithm_, OnIncomingAck(_, _, _)).Times(1);
+  QuicAckFrame ack(1, QuicTime::Zero(), 0);
+  ProcessAckPacket(&ack, true);
+  EXPECT_EQ(1u, QuicConnectionPeer::GetNumRetransmissionTimeouts(&connection_));
+
+  // Move forward past the original RTO and ensure the RTO is still pending.
+  clock_.AdvanceTime(DefaultRetransmissionTime());
+  EXPECT_EQ(1u, QuicConnectionPeer::GetNumRetransmissionTimeouts(&connection_));
+
+  // Ensure the second packet gets retransmitted when it finally fires.
+  EXPECT_TRUE(
+      QuicConnectionPeer::GetRetransmissionAlarm(&connection_)->IsSet());
+  EXPECT_GE(
+      QuicConnectionPeer::GetRetransmissionAlarm(&connection_)->deadline(),
+      clock_.ApproximateNow());
+  clock_.AdvanceTime(DefaultRetransmissionTime());
+  EXPECT_LT(
+      QuicConnectionPeer::GetRetransmissionAlarm(&connection_)->deadline(),
+      clock_.ApproximateNow());
+  EXPECT_CALL(*send_algorithm_, SentPacket(_, _, _, IS_RETRANSMISSION, _));
+  EXPECT_CALL(*send_algorithm_, AbandoningPacket(_, _));
+  connection_.OnRetransmissionTimeout();
+
+  // The new retransmitted sequence number should now be in the timeout queue.
+  EXPECT_EQ(1u, QuicConnectionPeer::GetNumRetransmissionTimeouts(&connection_));
+}
+
 TEST_F(QuicConnectionTest, TestQueued) {
   EXPECT_EQ(0u, connection_.NumQueuedPackets());
   helper_->set_blocked(true);
   connection_.SendStreamData(1, "foo", 0, !kFin);
   EXPECT_EQ(1u, connection_.NumQueuedPackets());
 
   // Attempt to send all packets, but since we're actually still
   // blocked, they should all remain queued.
   EXPECT_FALSE(connection_.OnCanWrite());
   EXPECT_EQ(1u, connection_.NumQueuedPackets());
@@ skipping 364 matching lines @@
 TEST_F(QuicConnectionTest, MissingPacketsBeforeLeastUnacked) {
   QuicAckFrame ack(0, QuicTime::Zero(), 4);
   // Set the sequence number of the ack packet to be least unacked (4)
   creator_.set_sequence_number(3);
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
   ProcessAckPacket(&ack, true);
   EXPECT_TRUE(outgoing_ack()->received_info.missing_packets.empty());
 }
 
 TEST_F(QuicConnectionTest, ReceivedEntropyHashCalculation) {
-  EXPECT_CALL(visitor_, OnPacket(_, _, _, _)).WillRepeatedly(Return(true));
+  EXPECT_CALL(visitor_, OnStreamFrames(_)).WillRepeatedly(Return(true));
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
   ProcessDataPacket(1, 1, kEntropyFlag);
   ProcessDataPacket(4, 1, kEntropyFlag);
   ProcessDataPacket(3, 1, !kEntropyFlag);
   ProcessDataPacket(7, 1, kEntropyFlag);
   EXPECT_EQ(146u, outgoing_ack()->received_info.entropy_hash);
 }
 
 TEST_F(QuicConnectionTest, UpdateEntropyForReceivedPackets) {
-  EXPECT_CALL(visitor_, OnPacket(_, _, _, _)).WillRepeatedly(Return(true));
+  EXPECT_CALL(visitor_, OnStreamFrames(_)).WillRepeatedly(Return(true));
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
   ProcessDataPacket(1, 1, kEntropyFlag);
   ProcessDataPacket(5, 1, kEntropyFlag);
   ProcessDataPacket(4, 1, !kEntropyFlag);
   EXPECT_EQ(34u, outgoing_ack()->received_info.entropy_hash);
   // Make 4th packet my least unacked, and update entropy for 2, 3 packets.
   QuicAckFrame ack(0, QuicTime::Zero(), 4);
   QuicPacketEntropyHash kRandomEntropyHash = 129u;
   ack.sent_info.entropy_hash = kRandomEntropyHash;
   creator_.set_sequence_number(5);
   QuicPacketEntropyHash six_packet_entropy_hash = 0;
   if (ProcessAckPacket(&ack, true)) {
     six_packet_entropy_hash = 1 << 6;
   }
 
   EXPECT_EQ((kRandomEntropyHash + (1 << 5) + six_packet_entropy_hash),
             outgoing_ack()->received_info.entropy_hash);
 }
 
 TEST_F(QuicConnectionTest, UpdateEntropyHashUptoCurrentPacket) {
-  EXPECT_CALL(visitor_, OnPacket(_, _, _, _)).WillRepeatedly(Return(true));
+  EXPECT_CALL(visitor_, OnStreamFrames(_)).WillRepeatedly(Return(true));
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
   ProcessDataPacket(1, 1, kEntropyFlag);
   ProcessDataPacket(5, 1, !kEntropyFlag);
   ProcessDataPacket(22, 1, kEntropyFlag);
   EXPECT_EQ(66u, outgoing_ack()->received_info.entropy_hash);
   creator_.set_sequence_number(22);
   QuicPacketEntropyHash kRandomEntropyHash = 85u;
   // Current packet is the least unacked packet.
   QuicAckFrame ack(0, QuicTime::Zero(), 23);
   ack.sent_info.entropy_hash = kRandomEntropyHash;
   QuicPacketEntropyHash ack_entropy_hash =  ProcessAckPacket(&ack, true);
   EXPECT_EQ((kRandomEntropyHash + ack_entropy_hash),
             outgoing_ack()->received_info.entropy_hash);
   ProcessDataPacket(25, 1, kEntropyFlag);
   EXPECT_EQ((kRandomEntropyHash + ack_entropy_hash + (1 << (25 % 8))),
             outgoing_ack()->received_info.entropy_hash);
 }
 
 TEST_F(QuicConnectionTest, EntropyCalculationForTruncatedAck) {
-  EXPECT_CALL(visitor_, OnPacket(_, _, _, _)).WillRepeatedly(Return(true));
+  EXPECT_CALL(visitor_, OnStreamFrames(_)).WillRepeatedly(Return(true));
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
   QuicPacketEntropyHash entropy[51];
   entropy[0] = 0;
   for (int i = 1; i < 51; ++i) {
     bool should_send = i % 10 != 0;
     bool entropy_flag = (i & (i - 1)) != 0;
     if (!should_send) {
       entropy[i] = entropy[i - 1];
       continue;
     }
@@ skipping 104 matching lines @@
 
   // Now force another packet.  The connection should transition into
   // NEGOTIATED_VERSION state and tell the packet creator to StopSendingVersion.
   header.public_header.version_flag = false;
   QuicFrames frames;
   QuicFrame frame(&frame1_);
   frames.push_back(frame);
   scoped_ptr<QuicPacket> packet(
       framer_.BuildUnsizedDataPacket(header, frames).packet);
   encrypted.reset(framer_.EncryptPacket(ENCRYPTION_NONE, 12, *packet));
-  EXPECT_CALL(visitor_, OnPacket(_, _, _, _)).Times(1);
+  EXPECT_CALL(visitor_, OnStreamFrames(_)).Times(1);
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
   connection_.ProcessUdpPacket(IPEndPoint(), IPEndPoint(), *encrypted);
 
   ASSERT_FALSE(QuicPacketCreatorPeer::SendVersionInPacket(
       QuicConnectionPeer::GetPacketCreator(&connection_)));
 }
 
 TEST_F(QuicConnectionTest, BadVersionNegotiation) {
   QuicPacketHeader header;
   header.public_header.guid = guid_;
@@ skipping 40 matching lines @@
   connection_.OnRetransmissionTimeout();
 
   // Retransmit due to explicit nacks
   QuicAckFrame nack_three(4, QuicTime::Zero(), 0);
   nack_three.received_info.missing_packets.insert(3);
   nack_three.received_info.entropy_hash =
       QuicConnectionPeer::GetSentEntropyHash(&connection_, 4) ^
       QuicConnectionPeer::GetSentEntropyHash(&connection_, 3) ^
       QuicConnectionPeer::GetSentEntropyHash(&connection_, 2);
   QuicFrame frame(&nack_three);
-  EXPECT_CALL(visitor_, OnAck(_));
   EXPECT_CALL(*send_algorithm_, OnIncomingAck(_, _, _)).Times(1);
   EXPECT_CALL(*send_algorithm_, OnIncomingLoss(_)).Times(1);
   EXPECT_CALL(visitor_, OnCanWrite()).Times(3).WillRepeatedly(Return(true));
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
 
   ProcessFramePacket(frame);
   ProcessFramePacket(frame);
   ProcessFramePacket(frame);
 
   EXPECT_CALL(*send_algorithm_, SmoothedRtt()).WillOnce(
@@ skipping 75 matching lines @@
   QuicFrames frames;
   frames.push_back(stream_frame);
   frames.push_back(close_frame);
   scoped_ptr<QuicPacket> packet(
       framer_.BuildUnsizedDataPacket(header_, frames).packet);
   EXPECT_TRUE(NULL != packet.get());
   scoped_ptr<QuicEncryptedPacket> encrypted(framer_.EncryptPacket(
       ENCRYPTION_NONE, 1, *packet));
 
   EXPECT_CALL(visitor_, ConnectionClose(QUIC_PEER_GOING_AWAY, true));
-  EXPECT_CALL(visitor_, OnPacket(_, _, _, _)).Times(0);
+  EXPECT_CALL(visitor_, OnStreamFrames(_)).Times(0);
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
 
   connection_.ProcessUdpPacket(IPEndPoint(), IPEndPoint(), *encrypted);
 }
 
 TEST_F(QuicConnectionTest, SelectMutualVersion) {
   // Set the connection to speak the lowest quic version.
   connection_.set_version(QuicVersionMin());
   EXPECT_EQ(QuicVersionMin(), connection_.version());
 
@@ skipping 63 matching lines @@
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
 
   // 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_.SendStreamDataAndNotifyWhenAcked(1, "foo", 0, !kFin, &delegate);
 
   // Process an ACK from the server which should trigger the callback.
-  EXPECT_CALL(visitor_, OnAck(_)).Times(1);
   EXPECT_CALL(*send_algorithm_, OnIncomingAck(_, _, _)).Times(1);
   QuicAckFrame frame(1, QuicTime::Zero(), 0);
   ProcessAckPacket(&frame, true);
 }
 
 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(visitor_, OnAck(_)).Times(1);
   EXPECT_CALL(*send_algorithm_, OnIncomingAck(_, _, _)).Times(2);
   EXPECT_CALL(*send_algorithm_, OnIncomingLoss(_)).Times(1);
 
   // 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_.SendStreamDataAndNotifyWhenAcked(1, "foo", 0, !kFin, &delegate);
 
   // Send some other data which we will ACK.
   connection_.SendStreamData(1, "foo", 0, !kFin);
   connection_.SendStreamData(1, "bar", 0, !kFin);
 
   // 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);
   ProcessAckPacket(&frame, true);
 }
 
 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);;
 
-  // OnAck called twice: once with missing packet, once after retransmit.
-  EXPECT_CALL(visitor_, OnAck(_)).Times(2);
-
   // In total expect ACKs for all 4 packets.
   EXPECT_CALL(*send_algorithm_, OnIncomingAck(_, _, _)).Times(4);
 
   // We will lose the second packet.
   EXPECT_CALL(*send_algorithm_, OnIncomingLoss(_)).Times(1);
 
   // Send four packets, and register to be notified on ACK of packet 2.
   connection_.SendStreamData(1, "foo", 0, !kFin);
   connection_.SendStreamDataAndNotifyWhenAcked(1, "bar", 0, !kFin, &delegate);
   connection_.SendStreamData(1, "baz", 0, !kFin);
@@ skipping 22 matching lines @@
 //                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(visitor_, OnAck(_)).Times(1);
   EXPECT_CALL(*send_algorithm_, OnIncomingAck(_, _, _)).Times(1);
 
   // Send one packet, and register to be notified on ACK.
   connection_.SendStreamDataAndNotifyWhenAcked(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);
@@ skipping 78 matching lines @@
   scoped_ptr<MockQuicConnectionDebugVisitor>
       debug_visitor(new StrictMock<MockQuicConnectionDebugVisitor>);
   connection_.set_debug_visitor(debug_visitor.get());
   EXPECT_CALL(*debug_visitor, OnPacketHeader(Ref(header))).Times(1);
   connection_.OnPacketHeader(header);
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net