Revert 171096

> Adding transmission times for every QUIC packet received in the AckFrame.
> Making the scheduler a strict mock for quic connection test.
> 
> Merge internal change: 39116450
> Merge internal change: 38802607
> 
> 
> Review URL: https://chromiumcodereview.appspot.com/11416155

TBR=rch@chromium.org
Review URL: https://codereview.chromium.org/11439003

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@171103 0039d316-1c4b-4281-b951-d872f2087c98

9 files changed, 853 insertions, 559 deletions

diff --git a/net/quic/congestion_control/quic_send_scheduler.cc b/net/quic/congestion_control/quic_send_scheduler.cc
index 6fa24eb..bc942de 100644
--- a/net/quic/congestion_control/quic_send_scheduler.cc
+++ b/net/quic/congestion_control/quic_send_scheduler.cc
@@ -97,7 +97,8 @@ void QuicSendScheduler::OnIncomingAckFrame(const QuicAckFrame& ack_frame) {
 
   while (it != it_upper) {
     QuicPacketSequenceNumber sequence_number = it->first;
-    if (ack_frame.received_info.ContainsAck(sequence_number)) {
+    if (ack_frame.received_info.missing_packets.find(sequence_number) ==
+        ack_frame.received_info.missing_packets.end()) {
       // Not missing, hence implicitly acked.
       scoped_ptr<PendingPacket> pending_packet_cleaner(it->second);
       acked_packets[sequence_number] = pending_packet_cleaner->BytesSent();
diff --git a/net/quic/congestion_control/quic_send_scheduler_test.cc b/net/quic/congestion_control/quic_send_scheduler_test.cc
index c6c5b87..ddfda15 100644
--- a/net/quic/congestion_control/quic_send_scheduler_test.cc
+++ b/net/quic/congestion_control/quic_send_scheduler_test.cc
@@ -59,7 +59,7 @@ TEST_F(QuicSendSchedulerTest, FixedRatePacing) {
     clock_.AdvanceTime(advance_time);
     acc_advance_time = acc_advance_time.Add(advance_time);
     // Ack the packet we sent.
-    ack.received_info.RecordAck(i, acc_advance_time);
+    ack.received_info.largest_received = i;
     sender_->OnIncomingAckFrame(ack);
   }
   EXPECT_EQ(QuicTime::FromMilliseconds(1200), acc_advance_time);
@@ -78,10 +78,8 @@ TEST_F(QuicSendSchedulerTest, AvailableCongestionWindow) {
     sender_->SentPacket(i, 100, false);
     EXPECT_EQ(kMaxPacketSize - (i * 100), sender_->AvailableCongestionWindow());
   }
-  // Ack the packets we sent.
-  for (int i = 1; i <= 12; i++) {
-    ack.received_info.RecordAck(i, QuicTime::FromMilliseconds(100));
-  }
+  // Ack the packet we sent.
+  ack.received_info.largest_received = 12;
   sender_->OnIncomingAckFrame(ack);
   EXPECT_EQ(kMaxPacketSize, sender_->AvailableCongestionWindow());
 }
@@ -99,7 +97,7 @@ TEST_F(QuicSendSchedulerTest, FixedRateBandwidth) {
     EXPECT_EQ(kMaxPacketSize, sender_->AvailableCongestionWindow());
     sender_->SentPacket(i, 1000, false);
     // Ack the packet we sent.
-    ack.received_info.RecordAck(i, clock_.Now());
+    ack.received_info.largest_received = i;
     sender_->OnIncomingAckFrame(ack);
   }
   EXPECT_EQ(100000, sender_->BandwidthEstimate());
@@ -119,7 +117,7 @@ TEST_F(QuicSendSchedulerTest, BandwidthWith3SecondGap) {
     EXPECT_EQ(kMaxPacketSize, sender_->AvailableCongestionWindow());
     sender_->SentPacket(i, 1000, false);
     // Ack the packet we sent.
-    ack.received_info.RecordAck(i, clock_.Now());
+    ack.received_info.largest_received = i;
     sender_->OnIncomingAckFrame(ack);
   }
   EXPECT_EQ(100000, sender_->BandwidthEstimate());
@@ -137,7 +135,7 @@ TEST_F(QuicSendSchedulerTest, BandwidthWith3SecondGap) {
     sender_->SentPacket(i + 100, 1000, false);
     clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(10));
     // Ack the packet we sent.
-    ack.received_info.RecordAck(i + 100, clock_.Now());
+    ack.received_info.largest_received = i + 100;
     sender_->OnIncomingAckFrame(ack);
   }
   EXPECT_EQ(100000, sender_->BandwidthEstimate());
@@ -164,9 +162,9 @@ TEST_F(QuicSendSchedulerTest, Pacing) {
     clock_.AdvanceTime(advance_time);
     acc_advance_time = acc_advance_time.Add(advance_time);
     // Ack the packets we sent.
-    ack.received_info.RecordAck(i - 2, clock_.Now());
+    ack.received_info.largest_received = i - 2;
     sender_->OnIncomingAckFrame(ack);
-    ack.received_info.RecordAck(i - 1, clock_.Now());
+    ack.received_info.largest_received = i - 1;
     sender_->OnIncomingAckFrame(ack);
   }
   EXPECT_EQ(QuicTime::FromMilliseconds(120), acc_advance_time);
diff --git a/net/quic/quic_connection.cc b/net/quic/quic_connection.cc
index 9c937b9..9905fec 100644
--- a/net/quic/quic_connection.cc
+++ b/net/quic/quic_connection.cc
@@ -24,14 +24,14 @@ using std::set;
 namespace net {
 
 // An arbitrary number we'll probably want to tune.
-const QuicPacketSequenceNumber kMaxAckedPackets = 5000u;
+const QuicPacketSequenceNumber kMaxUnackedPackets = 5000u;
 
 // The amount of time we wait before resending a packet.
 const int64 kDefaultResendTimeMs = 500;
 
 bool Near(QuicPacketSequenceNumber a, QuicPacketSequenceNumber b) {
   QuicPacketSequenceNumber delta = (a > b) ? a - b : b - a;
-  return delta <= kMaxAckedPackets;
+  return delta <= kMaxUnackedPackets;
 }
 
 QuicConnection::QuicConnection(QuicGuid guid,
@@ -105,7 +105,8 @@ bool QuicConnection::OnPacketHeader(const QuicPacketHeader& header) {
   ReceivedPacketInfo info = outgoing_ack_.received_info;
   // If this packet has already been seen, or that the sender
   // has told us will not be resent, then stop processing the packet.
-  if (info.ContainsAck(header.packet_sequence_number)) {
+  if (header.packet_sequence_number <= info.largest_received &&
+      info.missing_packets.count(header.packet_sequence_number) != 1) {
     return false;
   }
 
@@ -167,10 +168,12 @@ bool QuicConnection::ValidateAckFrame(const QuicAckFrame& incoming_ack) {
     return false;
   }
 
-  // We can't have too many acked packets, or our ack frames go over
-  // kMaxPacketSize.
-  DCHECK_LT(incoming_ack.received_info.received_packet_times.size(),
-            kMaxAckedPackets);
+  // We can't have too many missing or retransmitting packets, or our ack
+  // frames go over kMaxPacketSize.
+  DCHECK_LT(incoming_ack.received_info.missing_packets.size(),
+            kMaxUnackedPackets);
+  DCHECK_LT(incoming_ack.sent_info.non_retransmiting.size(),
+            kMaxUnackedPackets);
 
   if (incoming_ack.sent_info.least_unacked != 0 &&
       incoming_ack.sent_info.least_unacked < least_packet_awaiting_ack_) {
@@ -196,7 +199,9 @@ void QuicConnection::UpdatePacketInformationReceivedByPeer(
   // incoming_ack shows they've been seen by the peer.
   UnackedPacketMap::iterator it = unacked_packets_.begin();
   while (it != unacked_packets_.end()) {
-    if (incoming_ack.received_info.ContainsAck(it->first)) {
+    if ((it->first < incoming_ack.received_info.largest_received &&
+         !ContainsKey(incoming_ack.received_info.missing_packets, it->first)) ||
+        it->first == incoming_ack.received_info.largest_received) {
       // Packet was acked, so remove it from our unacked packet list.
       DVLOG(1) << "Got an ack for " << it->first;
       // TODO(rch): This is inefficient and should be sped up.
@@ -231,9 +236,17 @@ void QuicConnection::UpdatePacketInformationReceivedByPeer(
   // If we've gotten an ack for the lowest packet we were waiting on,
   // update that and the list of packets we advertise we will not resend.
   if (lowest_unacked > outgoing_ack_.sent_info.least_unacked) {
+    SequenceSet* non_retrans = &outgoing_ack_.sent_info.non_retransmiting;
+    // We don't need to advertise not-resending packets between the old
+    // and new values.
+    for (QuicPacketSequenceNumber i = outgoing_ack_.sent_info.least_unacked;
+         i < lowest_unacked; ++i) {
+      non_retrans->erase(i);
+    }
     // If all packets we sent have been acked, use the special value of 0
     if (lowest_unacked > packet_creator_.sequence_number()) {
       lowest_unacked = 0;
+      DCHECK_EQ(0u, non_retrans->size());
     }
     outgoing_ack_.sent_info.least_unacked = lowest_unacked;
   }
@@ -241,11 +254,22 @@ void QuicConnection::UpdatePacketInformationReceivedByPeer(
 
 void QuicConnection::UpdatePacketInformationSentByPeer(
     const QuicAckFrame& incoming_ack) {
-  // Make sure we also don't ack any packets lower than the peer's
+  // Iteratate through the packets which will the peer will not resend and
+  // remove them from our missing list.
+  for (SequenceSet::const_iterator it =
+           incoming_ack.sent_info.non_retransmiting.begin();
+       it != incoming_ack.sent_info.non_retransmiting.end(); ++it) {
+    DVLOG(1) << "no longer expecting " << *it;
+    outgoing_ack_.received_info.missing_packets.erase(*it);
+  }
+
+  // Make sure we also don't expect any packets lower than the peer's
   // last-packet-awaiting-ack.
   if (incoming_ack.sent_info.least_unacked > least_packet_awaiting_ack_) {
-    outgoing_ack_.received_info.ClearAcksBefore(
-        incoming_ack.sent_info.least_unacked);
+    for (QuicPacketSequenceNumber i = least_packet_awaiting_ack_;
+         i < incoming_ack.sent_info.least_unacked; ++i) {
+      outgoing_ack_.received_info.missing_packets.erase(i);
+    }
     least_packet_awaiting_ack_ = incoming_ack.sent_info.least_unacked;
   }
 
@@ -370,7 +394,23 @@ bool QuicConnection::OnCanWrite() {
 
 void QuicConnection::AckPacket(const QuicPacketHeader& header) {
   QuicPacketSequenceNumber sequence_number = header.packet_sequence_number;
-  outgoing_ack_.received_info.RecordAck(sequence_number, clock_->Now());
+  if (sequence_number > outgoing_ack_.received_info.largest_received) {
+    // We've got a new high sequence number.  Note any new intermediate missing
+    // packets, and update the last_ack data.
+    for (QuicPacketSequenceNumber i =
+             outgoing_ack_.received_info.largest_received + 1;
+         i < sequence_number; ++i) {
+      DVLOG(1) << "missing " << i;
+      outgoing_ack_.received_info.missing_packets.insert(i);
+    }
+    outgoing_ack_.received_info.largest_received = sequence_number;
+    outgoing_ack_.received_info.time_received = clock_->Now();
+  } else {
+    // We've gotten one of the out of order packets - remove it from our
+    // "missing packets" list.
+    DVLOG(1) << "Removing "  << sequence_number << " from missing list";
+    outgoing_ack_.received_info.missing_packets.erase(sequence_number);
+  }
   // TODO(alyssar) delay sending until we have data, or enough time has elapsed.
   if (frames_.size() > 0) {
     SendAck();
@@ -431,6 +471,11 @@ bool QuicConnection::SendPacket(QuicPacketSequenceNumber sequence_number,
         sequence_number < outgoing_ack_.sent_info.least_unacked) {
       outgoing_ack_.sent_info.least_unacked = sequence_number;
     }
+  } else {
+    if (outgoing_ack_.sent_info.least_unacked != 0 &&
+        sequence_number > outgoing_ack_.sent_info.least_unacked) {
+      outgoing_ack_.sent_info.non_retransmiting.insert(sequence_number);
+    }
   }
 
   scoped_ptr<QuicEncryptedPacket> encrypted(framer_.EncryptPacket(*packet));
diff --git a/net/quic/quic_connection_helper_test.cc b/net/quic/quic_connection_helper_test.cc
index 6cc83c8..c8d4327 100644
--- a/net/quic/quic_connection_helper_test.cc
+++ b/net/quic/quic_connection_helper_test.cc
@@ -132,9 +132,9 @@ class QuicConnectionHelperTest : public ::testing::Test {
     InitializeHeader(sequence_number);
 
     QuicAckFrame ack(0, QuicTime(), 0);
-
     ack.congestion_info.type = kFixRate;
     ack.congestion_info.fix_rate.bitrate_in_bytes_per_second = 100000;
+
     return ConstructPacket(header_, QuicFrame(&ack));
   }
 
diff --git a/net/quic/quic_connection_test.cc b/net/quic/quic_connection_test.cc
index 2e09a5b..cda67e8 100644
--- a/net/quic/quic_connection_test.cc
+++ b/net/quic/quic_connection_test.cc
@@ -16,12 +16,10 @@
 
 //DECLARE_int32(fake_packet_loss_percentage);
 
-using base::StringPiece;
 using std::map;
 using testing::_;
 using testing::ContainerEq;
 using testing::Return;
-using testing::StrictMock;
 
 namespace net {
 
@@ -189,7 +187,7 @@ class QuicConnectionTest : public ::testing::Test {
       : guid_(42),
         framer_(QuicDecrypter::Create(kNULL), QuicEncrypter::Create(kNULL)),
         creator_(guid_, &framer_),
-        scheduler_(new StrictMock<MockScheduler>),
+        scheduler_(new MockScheduler()),
         helper_(new TestConnectionHelper(&clock_)),
         connection_(guid_, IPEndPoint(), helper_),
         frame1_(1, false, 0, data1),
@@ -212,7 +210,6 @@ class QuicConnectionTest : public ::testing::Test {
   void ProcessPacket(QuicPacketSequenceNumber number) {
     EXPECT_CALL(visitor_, OnPacket(_, _, _, _))
         .WillOnce(Return(accept_packet_));
-    EXPECT_CALL(*scheduler_, SentPacket(_, _, _));
     ProcessDataPacket(number, 0);
   }
 
@@ -221,11 +218,9 @@ class QuicConnectionTest : public ::testing::Test {
     if (expect_revival) {
       EXPECT_CALL(visitor_, OnPacket(_, _, _, _)).Times(2).WillRepeatedly(
           Return(accept_packet_));
-      EXPECT_CALL(*scheduler_, SentPacket(_, _, _)).Times(2);
     } else {
       EXPECT_CALL(visitor_, OnPacket(_, _, _, _)).WillOnce(
           Return(accept_packet_));
-      EXPECT_CALL(*scheduler_, SentPacket(_, _, _));
     }
     ProcessDataPacket(number, 1);
   }
@@ -244,7 +239,6 @@ class QuicConnectionTest : public ::testing::Test {
     if (expect_revival) {
       EXPECT_CALL(visitor_, OnPacket(_, _, _, _)).WillOnce(
           Return(accept_packet_));
-      EXPECT_CALL(*scheduler_, SentPacket(_, _, _));
     }
 
     // Construct the decrypted data packet so we can compute the correct
@@ -277,29 +271,30 @@ class QuicConnectionTest : public ::testing::Test {
     delete fec_packet;
   }
 
-  void SendStreamDataToPeer(QuicStreamId id, StringPiece data,
-                      QuicStreamOffset offset, bool fin,
-                      QuicPacketSequenceNumber* last_packet) {
-    EXPECT_CALL(*scheduler_, SentPacket(_, _, _));
-    connection_.SendStreamData(id, data, offset, fin, last_packet);
-  }
-
-  void SendAckPacketToPeer() {
-    EXPECT_CALL(*scheduler_, SentPacket(_, _, _));
-    connection_.SendAck();
-  }
 
-  void ProcessAckPacket(QuicAckFrame* frame, bool expect_success = true) {
-    if (expect_success) {
-      EXPECT_CALL(*scheduler_, OnIncomingAckFrame(_));
-    }
+  void SendAckPacket(QuicAckFrame* frame) {
     scoped_ptr<QuicPacket> packet(creator_.AckPacket(frame).second);
     scoped_ptr<QuicEncryptedPacket> encrypted(framer_.EncryptPacket(*packet));
     connection_.ProcessUdpPacket(IPEndPoint(), IPEndPoint(), *encrypted);
   }
 
+  void SendAckPacket(QuicPacketSequenceNumber least_unacked) {
+    QuicAckFrame frame(0, QuicTime(), least_unacked);
+    SendAckPacket(&frame);
+  }
+
   bool IsMissing(QuicPacketSequenceNumber number) {
-    return !last_frame()->received_info.ContainsAck(number);
+    return last_frame()->received_info.missing_packets.find(number) !=
+        last_frame()->received_info.missing_packets.end();
+  }
+
+  size_t NonRetransmittingSize() {
+    return last_frame()->sent_info.non_retransmiting.size();
+  }
+
+  bool NonRetransmitting(QuicPacketSequenceNumber number) {
+    return last_frame()->sent_info.non_retransmiting.find(number) !=
+        last_frame()->sent_info.non_retransmiting.end();
   }
 
   QuicPacket* ConstructDataPacket(QuicPacketSequenceNumber number,
@@ -339,50 +334,50 @@ class QuicConnectionTest : public ::testing::Test {
 TEST_F(QuicConnectionTest, PacketsInOrder) {
   ProcessPacket(1);
   EXPECT_EQ(1u, last_frame()->received_info.largest_received);
-  EXPECT_EQ(1u, last_frame()->received_info.received_packet_times.size());
+  EXPECT_EQ(0u, last_frame()->received_info.missing_packets.size());
 
   ProcessPacket(2);
   EXPECT_EQ(2u, last_frame()->received_info.largest_received);
-  EXPECT_EQ(2u, last_frame()->received_info.received_packet_times.size());
+  EXPECT_EQ(0u, last_frame()->received_info.missing_packets.size());
 
   ProcessPacket(3);
   EXPECT_EQ(3u, last_frame()->received_info.largest_received);
-  EXPECT_EQ(3u, last_frame()->received_info.received_packet_times.size());
+  EXPECT_EQ(0u, last_frame()->received_info.missing_packets.size());
 }
 
 TEST_F(QuicConnectionTest, PacketsRejected) {
   ProcessPacket(1);
   EXPECT_EQ(1u, last_frame()->received_info.largest_received);
-  EXPECT_EQ(1u, last_frame()->received_info.received_packet_times.size());
+  EXPECT_EQ(0u, last_frame()->received_info.missing_packets.size());
 
   accept_packet_ = false;
   ProcessPacket(2);
   // We should not have an ack for two.
   EXPECT_EQ(1u, last_frame()->received_info.largest_received);
-  EXPECT_EQ(1u, last_frame()->received_info.received_packet_times.size());
+  EXPECT_EQ(0u, last_frame()->received_info.missing_packets.size());
 }
 
 TEST_F(QuicConnectionTest, PacketsOutOfOrder) {
   ProcessPacket(3);
   EXPECT_EQ(3u, last_frame()->received_info.largest_received);
-  EXPECT_EQ(1u, last_frame()->received_info.received_packet_times.size());
+  EXPECT_EQ(2u, last_frame()->received_info.missing_packets.size());
   EXPECT_TRUE(IsMissing(2));
   EXPECT_TRUE(IsMissing(1));
 
   ProcessPacket(2);
   EXPECT_EQ(3u, last_frame()->received_info.largest_received);
-  EXPECT_EQ(2u, last_frame()->received_info.received_packet_times.size());
+  EXPECT_EQ(1u, last_frame()->received_info.missing_packets.size());
   EXPECT_TRUE(IsMissing(1));
 
   ProcessPacket(1);
   EXPECT_EQ(3u, last_frame()->received_info.largest_received);
-  EXPECT_EQ(3u, last_frame()->received_info.received_packet_times.size());
+  EXPECT_EQ(0u, last_frame()->received_info.missing_packets.size());
 }
 
 TEST_F(QuicConnectionTest, DuplicatePacket) {
   ProcessPacket(3);
   EXPECT_EQ(3u, last_frame()->received_info.largest_received);
-  EXPECT_EQ(1u, last_frame()->received_info.received_packet_times.size());
+  EXPECT_EQ(2u, last_frame()->received_info.missing_packets.size());
   EXPECT_TRUE(IsMissing(2));
   EXPECT_TRUE(IsMissing(1));
 
@@ -390,26 +385,85 @@ TEST_F(QuicConnectionTest, DuplicatePacket) {
   // the visitor OnPacket() will be called.
   ProcessDataPacket(3, 0);
   EXPECT_EQ(3u, last_frame()->received_info.largest_received);
-  EXPECT_EQ(1u, last_frame()->received_info.received_packet_times.size());
+  EXPECT_EQ(2u, last_frame()->received_info.missing_packets.size());
+  EXPECT_TRUE(IsMissing(2));
+  EXPECT_TRUE(IsMissing(1));
+}
+
+TEST_F(QuicConnectionTest, LatePacketMarkedWillNotResend) {
+  ProcessPacket(5);
+  // Now send non-resending information, that we're not going to resend 3.
+  // The far end should stop waiting for it.
+  QuicPacketSequenceNumber largest_received = 0;
+  QuicTime time_received;
+  QuicPacketSequenceNumber least_unacked = 1;
+  QuicAckFrame frame(largest_received, time_received, least_unacked);
+  frame.sent_info.non_retransmiting.insert(3);
+  SendAckPacket(&frame);
+  // Force an ack to be sent.
+  connection_.SendAck();
+  EXPECT_EQ(5u, last_frame()->received_info.largest_received);
+  EXPECT_EQ(2u, last_frame()->received_info.missing_packets.size());
+  EXPECT_TRUE(IsMissing(4));
+  EXPECT_TRUE(IsMissing(2));
+
+  // Send packet 3 again, but do not set the expectation that
+  // the visitor OnPacket() will be called.
+  ProcessDataPacket(3, 0);
+  connection_.SendAck();
+  EXPECT_EQ(5u, last_frame()->received_info.largest_received);
+  EXPECT_EQ(2u, last_frame()->received_info.missing_packets.size());
+  EXPECT_TRUE(IsMissing(4));
+  EXPECT_TRUE(IsMissing(2));
+}
+
+TEST_F(QuicConnectionTest, PacketsOutOfOrderWithAdditionsAndNonResend) {
+  ProcessPacket(3);
+  EXPECT_EQ(3u, last_frame()->received_info.largest_received);
+  EXPECT_EQ(2u, last_frame()->received_info.missing_packets.size());
   EXPECT_TRUE(IsMissing(2));
   EXPECT_TRUE(IsMissing(1));
+
+  ProcessPacket(2);
+  EXPECT_EQ(3u, last_frame()->received_info.largest_received);
+  EXPECT_EQ(1u, last_frame()->received_info.missing_packets.size());
+  EXPECT_TRUE(IsMissing(1));
+
+  ProcessPacket(6);
+  EXPECT_EQ(6u, last_frame()->received_info.largest_received);
+  EXPECT_EQ(3u, last_frame()->received_info.missing_packets.size());
+  EXPECT_TRUE(IsMissing(1));
+  EXPECT_TRUE(IsMissing(4));
+  EXPECT_TRUE(IsMissing(5));
+
+  // Now send non-resending information, that we're not going to resend 4.
+  // The far end should stop waiting for it.
+  // In sending the ack, we also have sent packet 1, so we'll stop waiting for
+  // that as well.
+  QuicAckFrame frame(0, QuicTime(), 1);
+  frame.sent_info.non_retransmiting.insert(4);
+  SendAckPacket(&frame);
+  // Force an ack to be sent.
+  connection_.SendAck();
+  EXPECT_EQ(1u, last_frame()->received_info.missing_packets.size());
+  EXPECT_TRUE(IsMissing(5));
 }
 
 TEST_F(QuicConnectionTest, PacketsOutOfOrderWithAdditionsAndLeastAwaiting) {
   ProcessPacket(3);
   EXPECT_EQ(3u, last_frame()->received_info.largest_received);
-  EXPECT_EQ(1u, last_frame()->received_info.received_packet_times.size());
+  EXPECT_EQ(2u, last_frame()->received_info.missing_packets.size());
   EXPECT_TRUE(IsMissing(2));
   EXPECT_TRUE(IsMissing(1));
 
   ProcessPacket(2);
   EXPECT_EQ(3u, last_frame()->received_info.largest_received);
-  EXPECT_EQ(2u, last_frame()->received_info.received_packet_times.size());
+  EXPECT_EQ(1u, last_frame()->received_info.missing_packets.size());
   EXPECT_TRUE(IsMissing(1));
 
   ProcessPacket(5);
   EXPECT_EQ(5u, last_frame()->received_info.largest_received);
-  EXPECT_EQ(3u, last_frame()->received_info.received_packet_times.size());
+  EXPECT_EQ(2u, last_frame()->received_info.missing_packets.size());
   EXPECT_TRUE(IsMissing(1));
   EXPECT_TRUE(IsMissing(4));
 
@@ -418,53 +472,50 @@ TEST_F(QuicConnectionTest, PacketsOutOfOrderWithAdditionsAndLeastAwaiting) {
   // awaiting' is 4.  The connection should then realize 1 will not be
   // retransmitted, and will remove it from the missing list.
   QuicAckFrame frame(0, QuicTime(), 4);
-  ProcessAckPacket(&frame);
+  SendAckPacket(&frame);
   // Force an ack to be sent.
-  SendAckPacketToPeer();
-  EXPECT_EQ(2u, last_frame()->received_info.received_packet_times.size());
+  connection_.SendAck();
+  EXPECT_EQ(1u, last_frame()->received_info.missing_packets.size());
   EXPECT_TRUE(IsMissing(4));
 }
 
 TEST_F(QuicConnectionTest, RejectPacketTooFarOut) {
   // Call ProcessDataPacket rather than ProcessPacket, as we should not get a
   // packet call to the visitor.
-  ProcessDataPacket(6000, 0);
+  ProcessDataPacket(6000, 0);;
 
-  SendAckPacketToPeer();  // Packet 2
+  connection_.SendAck();  // Packet 2
   EXPECT_EQ(0u, last_frame()->received_info.largest_received);
 }
 
 TEST_F(QuicConnectionTest, LeastUnackedLower) {
-  SendStreamDataToPeer(1, "foo", 0, false, NULL);
-  SendStreamDataToPeer(1, "bar", 3, false, NULL);
-  SendStreamDataToPeer(1, "eep", 6, false, NULL);
+  connection_.SendStreamData(1, "foo", 0, false, NULL);
+  connection_.SendStreamData(1, "bar", 3, false, NULL);
+  connection_.SendStreamData(1, "eep", 6, false, NULL);
 
   // Start out saying the least unacked is 2
   creator_.set_sequence_number(5);
   QuicAckFrame frame(0, QuicTime(), 2);
-  ProcessAckPacket(&frame);
+  SendAckPacket(&frame);
 
   // Change it to 1, but lower the sequence number to fake out-of-order packets.
   // This should be fine.
   creator_.set_sequence_number(1);
   QuicAckFrame frame2(0, QuicTime(), 1);
-  // The scheduler will not process out of order acks.
-  ProcessAckPacket(&frame2, false);
+  SendAckPacket(&frame2);
 
   // Now claim it's one, but set the ordering so it was sent "after" the first
   // one.  This should cause a connection error.
   EXPECT_CALL(visitor_, ConnectionClose(QUIC_INVALID_ACK_DATA, false));
-  EXPECT_CALL(*scheduler_, SentPacket(_, _, _));
   creator_.set_sequence_number(7);
-  ProcessAckPacket(&frame2, false);
+  SendAckPacket(&frame2);
 }
 
 TEST_F(QuicConnectionTest, AckUnsentData) {
   // Ack a packet which has not been sent.
   EXPECT_CALL(visitor_, ConnectionClose(QUIC_INVALID_ACK_DATA, false));
-  EXPECT_CALL(*scheduler_, SentPacket(_, _, _));
   QuicAckFrame frame(1, QuicTime(), 0);
-  ProcessAckPacket(&frame, false);
+  SendAckPacket(&frame);
 }
 
 TEST_F(QuicConnectionTest, AckAll) {
@@ -472,45 +523,61 @@ TEST_F(QuicConnectionTest, AckAll) {
 
   creator_.set_sequence_number(1);
   QuicAckFrame frame1(1, QuicTime(), 1);
-  ProcessAckPacket(&frame1);
+  SendAckPacket(&frame1);
 
   // Send an ack with least_unacked == 0, which indicates that all packets
   // we have sent have been acked.
   QuicAckFrame frame2(1, QuicTime(), 0);
-  ProcessAckPacket(&frame2);
+  SendAckPacket(&frame2);
 }
 
 // This test is meant to validate that we can't overwhelm the far end with a ton
-// of acks.
+// of missing packets.
 // We will likely fix the protocol to allow more than 190 in flight, and the
 // test will need to be adjusted accordingly.
-TEST_F(QuicConnectionTest, TooManyAcked) {
-  SendStreamDataToPeer(1, "foo", 0, false, NULL);
+TEST_F(QuicConnectionTest, TooManyMissing) {
+  connection_.SendStreamData(1, "foo", 0, false, NULL);
+
+  EXPECT_CALL(visitor_, ConnectionClose(QUIC_PACKET_TOO_LARGE, false));
+  QuicAckFrame frame(1, QuicTime(), 0);
+  for (int i = 0; i < 5001; ++i) {
+    frame.received_info.missing_packets.insert(i);
+  }
+  SendAckPacket(&frame);
+}
+
+// See comment for TooManyMissing above.
+TEST_F(QuicConnectionTest, TooManyNonRetransmitting) {
+  connection_.SendStreamData(1, "foo", 0, false, NULL);
 
   EXPECT_CALL(visitor_, ConnectionClose(QUIC_PACKET_TOO_LARGE, false));
-  EXPECT_CALL(*scheduler_, SentPacket(_, _, _));
-  QuicAckFrame frame(0, QuicTime(), 0);
-  for (int i = 1; i < 5001; ++i) {
-    frame.received_info.RecordAck(i, QuicTime::FromMilliseconds(i));
+  QuicAckFrame frame(1, QuicTime(), 0);
+  for (int i = 0; i < 5001; ++i) {
+    frame.sent_info.non_retransmiting.insert(i);
   }
-  ProcessAckPacket(&frame, false);
+  SendAckPacket(&frame);
 }
 
 TEST_F(QuicConnectionTest, BasicSending) {
   QuicPacketSequenceNumber last_packet;
-  SendStreamDataToPeer(1, "foo", 0, false, &last_packet);  // Packet 1
+  connection_.SendStreamData(1, "foo", 0, false, &last_packet);  // Packet 1
   EXPECT_EQ(1u, last_packet);
-  SendAckPacketToPeer();  // Packet 2
+  connection_.SendAck();  // Packet 2
 
   EXPECT_EQ(1u, last_frame()->sent_info.least_unacked);
 
-  SendAckPacketToPeer();  // Packet 3
+  connection_.SendAck();  // Packet 3
   EXPECT_EQ(1u, last_frame()->sent_info.least_unacked);
+  EXPECT_EQ(1u, NonRetransmittingSize());
+  EXPECT_TRUE(NonRetransmitting(2));
 
-  SendStreamDataToPeer(1u, "bar", 3, false, &last_packet);  // Packet 4
+  connection_.SendStreamData(1, "bar", 3, false, &last_packet);  // Packet 4
   EXPECT_EQ(4u, last_packet);
-  SendAckPacketToPeer();  // Packet 5
+  connection_.SendAck();  // Packet 5
   EXPECT_EQ(1u, last_frame()->sent_info.least_unacked);
+  EXPECT_EQ(2u, NonRetransmittingSize());
+  EXPECT_TRUE(NonRetransmitting(2));
+  EXPECT_TRUE(NonRetransmitting(3));
 
   QuicConnectionVisitorInterface::AckedPackets expected_acks;
   expected_acks.insert(1);
@@ -518,12 +585,14 @@ TEST_F(QuicConnectionTest, BasicSending) {
   // Client acks up to packet 3
   EXPECT_CALL(visitor_, OnAck(ContainerEq(expected_acks)));
   QuicAckFrame frame(3, QuicTime(), 0);
-  ProcessAckPacket(&frame);
-  SendAckPacketToPeer();  // Packet 6
+  SendAckPacket(&frame);
+  connection_.SendAck();  // 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_frame()->sent_info.least_unacked);
+  EXPECT_EQ(1u, NonRetransmittingSize());
+  EXPECT_TRUE(NonRetransmitting(5));
 
   expected_acks.clear();
   expected_acks.insert(4);
@@ -531,41 +600,43 @@ TEST_F(QuicConnectionTest, BasicSending) {
   // Client acks up to packet 4, the last packet
   EXPECT_CALL(visitor_, OnAck(ContainerEq(expected_acks)));
   QuicAckFrame frame2(6, QuicTime(), 0);
-  ProcessAckPacket(&frame2);
-  SendAckPacketToPeer();  // Packet 7
+  SendAckPacket(&frame2);
+  connection_.SendAck();  // Packet 7
 
   // The least packet awaiting ack should now be the special value of 0
   EXPECT_EQ(0u, last_frame()->sent_info.least_unacked);
+  EXPECT_EQ(0u, NonRetransmittingSize());
 
   // If we force an ack, we shouldn't change our retransmit state.
-  SendAckPacketToPeer();  // Packet 8
+  connection_.SendAck();  // Packet 8
   EXPECT_EQ(0u, last_frame()->sent_info.least_unacked);
+  EXPECT_EQ(0u, NonRetransmittingSize());
 
   // But if we send more data it should.
-  SendStreamDataToPeer(1, "eep", 6, false, &last_packet);  // Packet 9
+  connection_.SendStreamData(1, "eep", 6, false, &last_packet);  // Packet 9
   EXPECT_EQ(9u, last_packet);
-  SendAckPacketToPeer();  // Packet10
+  connection_.SendAck();  // Packet10
   EXPECT_EQ(9u, last_frame()->sent_info.least_unacked);
 }
 
 // Test sending multiple acks from the connection to the session.
 TEST_F(QuicConnectionTest, MultipleAcks) {
   QuicPacketSequenceNumber last_packet;
-  SendStreamDataToPeer(1u, "foo", 0, false, &last_packet);  // Packet 1
+  connection_.SendStreamData(1, "foo", 0, false, &last_packet);  // Packet 1
   EXPECT_EQ(1u, last_packet);
-  SendStreamDataToPeer(3u, "foo", 0, false, &last_packet);  // Packet 2
+  connection_.SendStreamData(3, "foo", 0, false, &last_packet);  // Packet 2
   EXPECT_EQ(2u, last_packet);
-  SendAckPacketToPeer();  // Packet 3
-  SendStreamDataToPeer(5u, "foo", 0, false, &last_packet);  // Packet 4
+  connection_.SendAck();  // Packet 3
+  connection_.SendStreamData(5, "foo", 0, false, &last_packet);  // Packet 4
   EXPECT_EQ(4u, last_packet);
-  SendStreamDataToPeer(1u, "foo", 3, false, &last_packet);  // Packet 5
+  connection_.SendStreamData(1, "foo", 3, false, &last_packet);  // Packet 5
   EXPECT_EQ(5u, last_packet);
-  SendStreamDataToPeer(3u, "foo", 3, false, &last_packet);  // Packet 6
+  connection_.SendStreamData(3, "foo", 3, false, &last_packet);  // Packet 6
   EXPECT_EQ(6u, last_packet);
 
-  // Client will ack packets 1, [!2], 3, 4, 5
+  // Client will acks packets 1, [!2], 3, 4, 5
   QuicAckFrame frame1(5, QuicTime(), 0);
-  frame1.received_info.received_packet_times.erase(2);
+  frame1.received_info.missing_packets.insert(2);
 
   // 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.
@@ -575,7 +646,7 @@ TEST_F(QuicConnectionTest, MultipleAcks) {
   expected_acks.insert(5);
 
   EXPECT_CALL(visitor_, OnAck(ContainerEq(expected_acks)));
-  ProcessAckPacket(&frame1);
+  SendAckPacket(&frame1);
 
   // Now the client implicitly acks 2, and explicitly acks 6
   QuicAckFrame frame2(6, QuicTime(), 0);
@@ -585,7 +656,7 @@ TEST_F(QuicConnectionTest, MultipleAcks) {
   expected_acks.insert(6);
 
   EXPECT_CALL(visitor_, OnAck(ContainerEq(expected_acks)));
-  ProcessAckPacket(&frame2);
+  SendAckPacket(&frame2);
 }
 
 TEST_F(QuicConnectionTest, ReviveMissingPacketAfterFecPacket) {
@@ -629,14 +700,13 @@ TEST_F(QuicConnectionTest, TestResend) {
 
   QuicTime default_resend_time = clock_.Now().Add(kDefaultResendTime);
 
-  SendStreamDataToPeer(1, "foo", 0, false, NULL);
+  connection_.SendStreamData(1, "foo", 0, false, NULL);
   EXPECT_EQ(1u, last_header()->packet_sequence_number);
   EXPECT_EQ(1u, helper_->resend_alarms().size());
   EXPECT_EQ(default_resend_time,
             helper_->resend_alarms().find(1)->second);
   // Simulate the resend alarm firing
   clock_.AdvanceTime(kDefaultResendTime);
-  EXPECT_CALL(*scheduler_, SentPacket(_, _, _));
   connection_.MaybeResendPacket(1);
   EXPECT_EQ(2u, last_header()->packet_sequence_number);
 }
@@ -645,7 +715,7 @@ TEST_F(QuicConnectionTest, TestResend) {
 TEST_F(QuicConnectionTest, DISABLED_TestQueued) {
   EXPECT_EQ(0u, connection_.NumQueuedPackets());
   helper_->set_blocked(true);
-  SendStreamDataToPeer(1, "foo", 0, false, NULL);
+  connection_.SendStreamData(1, "foo", 0, false, NULL);
   EXPECT_EQ(1u, connection_.NumQueuedPackets());
 
   // Attempt to send all packets, but since we're actually still
@@ -667,15 +737,14 @@ TEST_F(QuicConnectionTest, CloseFecGroup) {
   ASSERT_EQ(1u, connection_.NumFecGroups());
 
   // Now send non-fec protected ack packet and close the group
-  QuicAckFrame frame(0, QuicTime(), 5);
-  ProcessAckPacket(&frame);
+  SendAckPacket(5);
   ASSERT_EQ(0u, connection_.NumFecGroups());
 }
 
 TEST_F(QuicConnectionTest, NoCongestionInfo) {
   TestCollector* collector(new TestCollector(NULL));
   connection_.SetCollector(collector);
-  SendAckPacketToPeer();
+  connection_.SendAck();
   EXPECT_EQ(kNone, last_frame()->congestion_info.type);
 }
 
@@ -685,7 +754,7 @@ TEST_F(QuicConnectionTest, WithCongestionInfo) {
   info.fix_rate.bitrate_in_bytes_per_second = 123;
   TestCollector* collector(new TestCollector(&info));
   connection_.SetCollector(collector);
-  SendAckPacketToPeer();
+  connection_.SendAck();
   EXPECT_EQ(kFixRate, last_frame()->congestion_info.type);
   EXPECT_EQ(info.fix_rate.bitrate_in_bytes_per_second,
       last_frame()->congestion_info.fix_rate.bitrate_in_bytes_per_second);
@@ -694,7 +763,7 @@ TEST_F(QuicConnectionTest, WithCongestionInfo) {
 TEST_F(QuicConnectionTest, UpdateCongestionInfo) {
   TestCollector* collector(new TestCollector(NULL));
   connection_.SetCollector(collector);
-  SendAckPacketToPeer();
+  connection_.SendAck();
   EXPECT_CALL(*collector, RecordIncomingPacket(_, _, _, _));
   ProcessPacket(1);
 }
@@ -702,7 +771,7 @@ TEST_F(QuicConnectionTest, UpdateCongestionInfo) {
 TEST_F(QuicConnectionTest, DontUpdateCongestionInfoForRevived) {
   TestCollector* collector(new TestCollector(NULL));
   connection_.SetCollector(collector);
-  SendAckPacketToPeer();
+  connection_.SendAck();
   // Process an FEC packet, and revive the missing data packet
   // but only contact the collector once.
   EXPECT_CALL(*collector, RecordIncomingPacket(_, _, _, _));
@@ -712,7 +781,6 @@ TEST_F(QuicConnectionTest, DontUpdateCongestionInfoForRevived) {
 TEST_F(QuicConnectionTest, InitialTimeout) {
   EXPECT_TRUE(connection_.connected());
   EXPECT_CALL(visitor_, ConnectionClose(QUIC_CONNECTION_TIMED_OUT, false));
-  EXPECT_CALL(*scheduler_, SentPacket(_, _, _));
 
   QuicTime default_timeout = clock_.Now().Add(
       QuicTime::Delta::FromMicroseconds(kDefaultTimeoutUs));
@@ -734,7 +802,7 @@ TEST_F(QuicConnectionTest, TimeoutAfterSend) {
   clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(5));
 
   // Send an ack so we don't set the resend alarm.
-  SendAckPacketToPeer();
+  connection_.SendAck();
   EXPECT_EQ(default_timeout, helper_->timeout_alarm());
 
   // The original alarm will fire.  We should not time out because we had a
@@ -749,7 +817,6 @@ TEST_F(QuicConnectionTest, TimeoutAfterSend) {
 
   // This time, we should time out.
   EXPECT_CALL(visitor_, ConnectionClose(QUIC_CONNECTION_TIMED_OUT, false));
-  EXPECT_CALL(*scheduler_, SentPacket(_, _, _));
   clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(5));
   EXPECT_EQ(default_timeout.Add(QuicTime::Delta::FromMilliseconds(5)),
             clock_.Now());
@@ -763,7 +830,6 @@ TEST_F(QuicConnectionTest, SendScheduler) {
   scoped_ptr<QuicPacket> packet(ConstructDataPacket(1, 0));
   EXPECT_CALL(*scheduler_, TimeUntilSend(true)).WillOnce(testing::Return(
       QuicTime::Delta()));
-  EXPECT_CALL(*scheduler_, SentPacket(_, _, _));
   connection_.SendPacket(1, packet.get(), true, false, false);
   EXPECT_EQ(0u, connection_.NumQueuedPackets());
 }
@@ -782,7 +848,6 @@ TEST_F(QuicConnectionTest, SendSchedulerForce) {
   // Test that if we force send a packet, it is not queued.
   scoped_ptr<QuicPacket> packet(ConstructDataPacket(1, 0));
   EXPECT_CALL(*scheduler_, TimeUntilSend(true)).Times(0);
-  EXPECT_CALL(*scheduler_, SentPacket(_, _, _));
   connection_.SendPacket(1, packet.get(), true, true, false);
   EXPECT_EQ(0u, connection_.NumQueuedPackets());
 }
@@ -811,7 +876,6 @@ TEST_F(QuicConnectionTest, SendSchedulerDelayThenSend) {
   EXPECT_CALL(*scheduler_, TimeUntilSend(true)).WillOnce(testing::Return(
       QuicTime::Delta()));
   clock_.AdvanceTime(QuicTime::Delta::FromMicroseconds(1));
-  EXPECT_CALL(*scheduler_, SentPacket(_, _, _));
   connection_.OnCanWrite();
   EXPECT_EQ(0u, connection_.NumQueuedPackets());
 }
@@ -858,10 +922,11 @@ TEST_F(QuicConnectionTest, SendSchedulerDelayThenAckAndSend) {
   // Now send non-retransmitting information, that we're not going to resend 3.
   // The far end should stop waiting for it.
   QuicAckFrame frame(0, QuicTime(), 1);
+  frame.sent_info.non_retransmiting.insert(3);
+  EXPECT_CALL(*scheduler_, OnIncomingAckFrame(testing::_));
   EXPECT_CALL(*scheduler_, TimeUntilSend(true)).WillRepeatedly(testing::Return(
       QuicTime::Delta()));
-  EXPECT_CALL(*scheduler_, SentPacket(_, _, _));
-  ProcessAckPacket(&frame);
+  SendAckPacket(&frame);
 
   EXPECT_EQ(0u, connection_.NumQueuedPackets());
   // Ensure alarm is not set
@@ -878,9 +943,11 @@ TEST_F(QuicConnectionTest, SendSchedulerDelayThenAckAndHold) {
   // Now send non-resending information, that we're not going to resend 3.
   // The far end should stop waiting for it.
   QuicAckFrame frame(0, QuicTime(), 1);
+  frame.sent_info.non_retransmiting.insert(3);
+  EXPECT_CALL(*scheduler_, OnIncomingAckFrame(testing::_));
   EXPECT_CALL(*scheduler_, TimeUntilSend(true)).WillOnce(testing::Return(
       QuicTime::Delta::FromMicroseconds(1)));
-  ProcessAckPacket(&frame);
+  SendAckPacket(&frame);
 
   EXPECT_EQ(1u, connection_.NumQueuedPackets());
 }
diff --git a/net/quic/quic_framer.cc b/net/quic/quic_framer.cc
index 8760a1c..708bd75 100644
--- a/net/quic/quic_framer.cc
+++ b/net/quic/quic_framer.cc
@@ -12,7 +12,6 @@
 #include "net/quic/quic_utils.h"
 
 using base::StringPiece;
-using std::map;
 
 namespace net {
 
@@ -354,46 +353,31 @@ bool QuicFramer::ProcessPDUFrame() {
 }
 
 bool QuicFramer::ProcessAckFrame(QuicAckFrame* frame) {
-  uint8 num_acked_packets;
-  if (!reader_->ReadBytes(&num_acked_packets, 1)) {
-    set_detailed_error("Unable to read num acked packets.");
+  if (!reader_->ReadUInt48(&frame->received_info.largest_received)) {
+    set_detailed_error("Unable to read largest received.");
     return false;
   }
+  uint64 time_received;
+  if (!reader_->ReadUInt64(&time_received)) {
+    set_detailed_error("Unable to read time received.");
+    return false;
+  }
+  frame->received_info.time_received =
+      QuicTime::FromMicroseconds(time_received);
 
-  uint64 smallest_received;
-  if (!reader_->ReadUInt48(&smallest_received)) {
-    set_detailed_error("Unable to read smallest received.");
+  uint8 num_unacked_packets;
+  if (!reader_->ReadBytes(&num_unacked_packets, 1)) {
+    set_detailed_error("Unable to read num unacked packets.");
     return false;
   }
 
-  if (num_acked_packets == 0u) {
-    // Ensures largest_received is set when no actual acks are transmitted.
-    frame->received_info.largest_received = smallest_received;
-  } else {
-    uint64 time_received_us;
-    if (!reader_->ReadUInt64(&time_received_us)) {
-      set_detailed_error("Unable to read time received.");
+  for (int i = 0; i < num_unacked_packets; ++i) {
+    QuicPacketSequenceNumber sequence_number;
+    if (!reader_->ReadUInt48(&sequence_number)) {
+      set_detailed_error("Unable to read sequence number in unacked packets.");
       return false;
     }
-
-    frame->received_info.RecordAck(
-        smallest_received, QuicTime::FromMicroseconds(time_received_us));
-
-    for (int i = 0; i < num_acked_packets - 1; ++i) {
-      uint8 sequence_delta;
-      if (!reader_->ReadBytes(&sequence_delta, 1)) {
-        set_detailed_error("Unable to read sequence delta in acked packets.");
-        return false;
-      }
-      int32 time_delta_us;
-      if (!reader_->ReadBytes(&time_delta_us, sizeof(time_delta_us))) {
-        set_detailed_error("Unable to read time delta in acked packets.");
-        return false;
-      }
-      frame->received_info.RecordAck(
-          smallest_received + sequence_delta,
-          QuicTime::FromMicroseconds(time_received_us + time_delta_us));
-    }
+    frame->received_info.missing_packets.insert(sequence_number);
   }
 
   if (!reader_->ReadUInt48(&frame->sent_info.least_unacked)) {
@@ -401,6 +385,21 @@ bool QuicFramer::ProcessAckFrame(QuicAckFrame* frame) {
     return false;
   }
 
+  uint8 num_non_retransmiting_packets;
+  if (!reader_->ReadBytes(&num_non_retransmiting_packets, 1)) {
+    set_detailed_error("Unable to read num non-retransmitting.");
+    return false;
+  }
+  for (uint8 i = 0; i < num_non_retransmiting_packets; ++i) {
+    QuicPacketSequenceNumber sequence_number;
+    if (!reader_->ReadUInt48(&sequence_number)) {
+      set_detailed_error(
+          "Unable to read sequence number in non-retransmitting.");
+      return false;
+    }
+    frame->sent_info.non_retransmiting.insert(sequence_number);
+  }
+
   uint8 congestion_info_type;
   if (!reader_->ReadBytes(&congestion_info_type, 1)) {
     set_detailed_error("Unable to read congestion info type.");
@@ -583,13 +582,13 @@ size_t QuicFramer::ComputeFramePayloadLength(const QuicFrame& frame) {
       break;  // Need to support this eventually :>
     case ACK_FRAME: {
       const QuicAckFrame& ack = *frame.ack_frame;
-      len += 1;  // num acked packets
       len += 6;  // largest received packet sequence number
-      if (ack.received_info.received_packet_times.size() > 0) {
-        len += 8;  // time
-        len += 5 * (ack.received_info.received_packet_times.size() - 1);
-      }
+      len += 8;  // time delta
+      len += 1;  // num missing packets
+      len += 6 * ack.received_info.missing_packets.size();
       len += 6;  // least packet sequence number awaiting an ack
+      len += 1;  // num non retransmitting packets
+      len += 6 * ack.sent_info.non_retransmiting.size();
       len += 1;  // congestion control type
       switch (ack.congestion_info.type) {
         case kNone:
@@ -657,41 +656,24 @@ bool QuicFramer::AppendStreamFramePayload(
 bool QuicFramer::AppendAckFramePayload(
     const QuicAckFrame& frame,
     QuicDataWriter* writer) {
-  uint8 num_acked_packets = frame.received_info.received_packet_times.size();
-  if (!writer->WriteBytes(&num_acked_packets, 1)) {
+  if (!writer->WriteUInt48(frame.received_info.largest_received)) {
     return false;
   }
-  if (num_acked_packets == 0) {
-    // Special case when no packets are acked, just transmit the largest.
-    if (!writer->WriteUInt48(frame.received_info.largest_received)) {
-      return false;
-    }
-  } else {
-    map<QuicPacketSequenceNumber, QuicTime>::const_iterator it =
-        frame.received_info.received_packet_times.begin();
 
-    QuicPacketSequenceNumber lowest_sequence = it->first;
-    if (!writer->WriteUInt48(lowest_sequence)) {
-      return false;
-    }
-
-    QuicTime lowest_time = it->second;
-    // TODO(ianswett): Use time deltas from the connection's first received
-    // packet.
-    if (!writer->WriteUInt64(lowest_time.ToMicroseconds())) {
-      return false;
-    }
+  if (!writer->WriteUInt64(
+      frame.received_info.time_received.ToMicroseconds())) {
+    return false;
+  }
 
-    for (++it; it != frame.received_info.received_packet_times.end(); ++it) {
-      QuicPacketSequenceNumber sequence_delta = it->first - lowest_sequence;
-      if (!writer->WriteBytes(&sequence_delta, 1)) {
-        return false;
-      }
+  size_t num_unacked_packets = frame.received_info.missing_packets.size();
+  if (!writer->WriteBytes(&num_unacked_packets, 1)) {
+    return false;
+  }
 
-      int32 time_delta_us = it->second.Subtract(lowest_time).ToMicroseconds();
-      if (!writer->WriteBytes(&time_delta_us, sizeof(time_delta_us))) {
-        return false;
-      }
+  SequenceSet::const_iterator it = frame.received_info.missing_packets.begin();
+  for (; it != frame.received_info.missing_packets.end(); ++it) {
+    if (!writer->WriteUInt48(*it)) {
+      return false;
     }
   }
 
@@ -699,6 +681,20 @@ bool QuicFramer::AppendAckFramePayload(
     return false;
   }
 
+  size_t num_non_retransmiting_packets =
+      frame.sent_info.non_retransmiting.size();
+  if (!writer->WriteBytes(&num_non_retransmiting_packets, 1)) {
+    return false;
+  }
+
+  it = frame.sent_info.non_retransmiting.begin();
+  while (it != frame.sent_info.non_retransmiting.end()) {
+    if (!writer->WriteUInt48(*it)) {
+      return false;
+    }
+    ++it;
+  }
+
   if (!writer->WriteBytes(&frame.congestion_info.type, 1)) {
     return false;
   }
diff --git a/net/quic/quic_framer_test.cc b/net/quic/quic_framer_test.cc
index 6a46d7d..e2f9f2d 100644
--- a/net/quic/quic_framer_test.cc
+++ b/net/quic/quic_framer_test.cc
@@ -3,8 +3,6 @@
 // found in the LICENSE file.
 
 #include <algorithm>
-#include <map>
-#include <string>
 #include <vector>
 
 #include "base/hash_tables.h"
@@ -19,7 +17,6 @@
 
 using base::hash_set;
 using base::StringPiece;
-using std::map;
 using std::string;
 using std::vector;
 
@@ -61,7 +58,7 @@ class TestDecrypter : public QuicDecrypter {
 
 // The offset of congestion info in our tests, given the size of our usual ack
 // frame.  This does NOT work for all packets.
-const int kCongestionInfoOffset = kPacketHeaderSize + 33;
+const int kCongestionInfoOffset = kPacketHeaderSize + 54;
 
 class TestQuicVisitor : public ::net::QuicFramerVisitorInterface {
  public:
@@ -541,25 +538,34 @@ TEST_F(QuicFramerTest, AckFrame) {
     0x01,
     // frame type (ack frame)
     0x02,
-    // num_acked_packets
-    0x03,
-    // smallest received packet sequence number
-    0xBA, 0x9A, 0x78, 0x56,
+    // largest received packet sequence number
+    0xBC, 0x9A, 0x78, 0x56,
     0x34, 0x12,
-    // time
+    // time delta
     0x87, 0x96, 0xA5, 0xB4,
     0xC3, 0xD2, 0xE1, 0x07,
-    // sequence delta
-    0x01,
-    // time delta
-    0x01, 0x00, 0x00, 0x00,
-    // sequence delta (skip one packet)
-    0x03,
-    // time delta
-    0x02, 0x00, 0x00, 0x00,
+    // num_unacked_packets
+    0x02,
+    // unacked packet sequence number
+    0xBA, 0x9A, 0x78, 0x56,
+    0x34, 0x12,
+    // unacked packet sequence number
+    0xBB, 0x9A, 0x78, 0x56,
+    0x34, 0x12,
     // least packet sequence number awaiting an ack
     0xA0, 0x9A, 0x78, 0x56,
     0x34, 0x12,
+    // num non retransmitting packets
+    0x03,
+    // non retransmitting packet sequence number
+    0xAE, 0x9A, 0x78, 0x56,
+    0x34, 0x12,
+    // non retransmitting packet sequence number
+    0xAF, 0x9A, 0x78, 0x56,
+    0x34, 0x12,
+    // non retransmitting packet sequence number
+    0xB0, 0x9A, 0x78, 0x56,
+    0x34, 0x12,
     // congestion feedback type (none)
     0x00,
   };
@@ -574,45 +580,45 @@ TEST_F(QuicFramerTest, AckFrame) {
   EXPECT_EQ(0u, visitor_.stream_frames_.size());
   ASSERT_EQ(1u, visitor_.ack_frames_.size());
   const QuicAckFrame& frame = *visitor_.ack_frames_[0];
-  ASSERT_EQ(3u, frame.received_info.received_packet_times.size());
-  map<QuicPacketSequenceNumber, QuicTime>::const_iterator iter =
-      frame.received_info.received_packet_times.begin();
-  EXPECT_EQ(GG_UINT64_C(0x0123456789ABA), iter->first);
-  EXPECT_EQ(QuicTime::FromMicroseconds(0x07E1D2C3B4A59687), iter->second);
-  ++iter;
-  EXPECT_EQ(GG_UINT64_C(0x0123456789ABB), iter->first);
-  EXPECT_EQ(QuicTime::FromMicroseconds(0x07E1D2C3B4A59688), iter->second);
-  ++iter;
-  EXPECT_EQ(GG_UINT64_C(0x0123456789ABD), iter->first);
-  EXPECT_EQ(QuicTime::FromMicroseconds(0x07E1D2C3B4A59689), iter->second);
-
+  EXPECT_EQ(GG_UINT64_C(0x0123456789ABC),
+            frame.received_info.largest_received);
+  EXPECT_EQ(QuicTime::FromMicroseconds(GG_UINT64_C(0x07E1D2C3B4A59687)),
+            frame.received_info.time_received);
+
+  const SequenceSet& sequence_nums = frame.received_info.missing_packets;
+  ASSERT_EQ(2u, sequence_nums.size());
+  EXPECT_EQ(1u, sequence_nums.count(GG_UINT64_C(0x0123456789ABB)));
+  EXPECT_EQ(1u, sequence_nums.count(GG_UINT64_C(0x0123456789ABA)));
   EXPECT_EQ(GG_UINT64_C(0x0123456789AA0), frame.sent_info.least_unacked);
+  ASSERT_EQ(3u, frame.sent_info.non_retransmiting.size());
+  const SequenceSet& non_retrans = frame.sent_info.non_retransmiting;
+  EXPECT_EQ(1u, non_retrans.count(GG_UINT64_C(0x0123456789AB0)));
+  EXPECT_EQ(1u, non_retrans.count(GG_UINT64_C(0x0123456789AAF)));
+  EXPECT_EQ(1u, non_retrans.count(GG_UINT64_C(0x0123456789AAE)));
   ASSERT_EQ(kNone, frame.congestion_info.type);
 
   // Now test framing boundaries
-  for (size_t i = kPacketHeaderSize; i < kPacketHeaderSize + 34; ++i) {
+  for (size_t i = kPacketHeaderSize; i < kPacketHeaderSize + 55; ++i) {
     string expected_error;
     if (i < kPacketHeaderSize + 1) {
       expected_error = "Unable to read frame count.";
     } else if (i < kPacketHeaderSize + 2) {
       expected_error = "Unable to read frame type.";
-    } else if (i < kPacketHeaderSize + 3) {
-      expected_error = "Unable to read num acked packets.";
-    } else if (i < kPacketHeaderSize + 9) {
-      expected_error = "Unable to read smallest received.";
-    } else if (i < kPacketHeaderSize + 17) {
+    } else if (i < kPacketHeaderSize + 8) {
+      expected_error = "Unable to read largest received.";
+    } else if (i < kPacketHeaderSize + 16) {
       expected_error = "Unable to read time received.";
-    } else if (i < kPacketHeaderSize + 18) {
-      expected_error = "Unable to read sequence delta in acked packets.";
-    } else if (i < kPacketHeaderSize + 22) {
-      expected_error = "Unable to read time delta in acked packets.";
-    } else if (i < kPacketHeaderSize + 23) {
-      expected_error = "Unable to read sequence delta in acked packets.";
-    } else if (i < kPacketHeaderSize + 27) {
-      expected_error = "Unable to read time delta in acked packets.";
-    } else if (i < kPacketHeaderSize + 33) {
+    } else if (i < kPacketHeaderSize + 17) {
+      expected_error = "Unable to read num unacked packets.";
+    } else if (i < kPacketHeaderSize + 29) {
+      expected_error = "Unable to read sequence number in unacked packets.";
+    } else if (i < kPacketHeaderSize + 35) {
       expected_error = "Unable to read least unacked.";
-    } else if (i < kPacketHeaderSize + 34) {
+    } else if (i < kPacketHeaderSize + 36) {
+      expected_error = "Unable to read num non-retransmitting.";
+    } else if (i < kPacketHeaderSize + 54) {
+      expected_error = "Unable to read sequence number in non-retransmitting.";
+    } else if (i < kPacketHeaderSize + 55) {
       expected_error = "Unable to read congestion info type.";
     }
 
@@ -641,25 +647,34 @@ TEST_F(QuicFramerTest, AckFrameTCP) {
     0x01,
     // frame type (ack frame)
     0x02,
-    // num_acked_packets
-    0x03,
-    // smallest received packet sequence number
-    0xBA, 0x9A, 0x78, 0x56,
+    // largest received packet sequence number
+    0xBC, 0x9A, 0x78, 0x56,
     0x34, 0x12,
-    // time
+    // time delta
     0x87, 0x96, 0xA5, 0xB4,
     0xC3, 0xD2, 0xE1, 0x07,
-    // sequence delta
-    0x01,
-    // time delta
-    0x01, 0x00, 0x00, 0x00,
-    // sequence delta (skip one packet)
-    0x03,
-    // time delta
-    0x02, 0x00, 0x00, 0x00,
+    // num_unacked_packets
+    0x02,
+    // unacked packet sequence number
+    0xBA, 0x9A, 0x78, 0x56,
+    0x34, 0x12,
+    // unacked packet sequence number
+    0xBB, 0x9A, 0x78, 0x56,
+    0x34, 0x12,
     // least packet sequence number awaiting an ack
     0xA0, 0x9A, 0x78, 0x56,
     0x34, 0x12,
+    // num non retransmitting packets
+    0x03,
+    // non retransmitting packet sequence number
+    0xAE, 0x9A, 0x78, 0x56,
+    0x34, 0x12,
+    // non retransmitting packet sequence number
+    0xAF, 0x9A, 0x78, 0x56,
+    0x34, 0x12,
+    // non retransmitting packet sequence number
+    0xB0, 0x9A, 0x78, 0x56,
+    0x34, 0x12,
     // congestion feedback type (tcp)
     0x01,
     // ack_frame.congestion_info.tcp.accumulated_number_of_lost_packets
@@ -678,19 +693,21 @@ TEST_F(QuicFramerTest, AckFrameTCP) {
   EXPECT_EQ(0u, visitor_.stream_frames_.size());
   ASSERT_EQ(1u, visitor_.ack_frames_.size());
   const QuicAckFrame& frame = *visitor_.ack_frames_[0];
-  ASSERT_EQ(3u, frame.received_info.received_packet_times.size());
-  map<QuicPacketSequenceNumber, QuicTime>::const_iterator iter =
-      frame.received_info.received_packet_times.begin();
-  EXPECT_EQ(GG_UINT64_C(0x0123456789ABA), iter->first);
-  EXPECT_EQ(QuicTime::FromMicroseconds(0x07E1D2C3B4A59687), iter->second);
-  ++iter;
-  EXPECT_EQ(GG_UINT64_C(0x0123456789ABB), iter->first);
-  EXPECT_EQ(QuicTime::FromMicroseconds(0x07E1D2C3B4A59688), iter->second);
-  ++iter;
-  EXPECT_EQ(GG_UINT64_C(0x0123456789ABD), iter->first);
-  EXPECT_EQ(QuicTime::FromMicroseconds(0x07E1D2C3B4A59689), iter->second);
-
+  EXPECT_EQ(GG_UINT64_C(0x0123456789ABC),
+            frame.received_info.largest_received);
+  EXPECT_EQ(QuicTime::FromMicroseconds(GG_UINT64_C(0x07E1D2C3B4A59687)),
+            frame.received_info.time_received);
+
+  const SequenceSet& sequence_nums = frame.received_info.missing_packets;
+  ASSERT_EQ(2u, sequence_nums.size());
+  EXPECT_EQ(1u, sequence_nums.count(GG_UINT64_C(0x0123456789ABB)));
+  EXPECT_EQ(1u, sequence_nums.count(GG_UINT64_C(0x0123456789ABA)));
   EXPECT_EQ(GG_UINT64_C(0x0123456789AA0), frame.sent_info.least_unacked);
+  ASSERT_EQ(3u, frame.sent_info.non_retransmiting.size());
+  const SequenceSet& non_retrans = frame.sent_info.non_retransmiting;
+  EXPECT_EQ(1u, non_retrans.count(GG_UINT64_C(0x0123456789AB0)));
+  EXPECT_EQ(1u, non_retrans.count(GG_UINT64_C(0x0123456789AAF)));
+  EXPECT_EQ(1u, non_retrans.count(GG_UINT64_C(0x0123456789AAE)));
   ASSERT_EQ(kTCP, frame.congestion_info.type);
   EXPECT_EQ(0x0201,
             frame.congestion_info.tcp.accumulated_number_of_lost_packets);
@@ -732,25 +749,34 @@ TEST_F(QuicFramerTest, AckFrameInterArrival) {
     0x01,
     // frame type (ack frame)
     0x02,
-    // num_acked_packets
-    0x03,
-    // smallest received packet sequence number
-    0xBA, 0x9A, 0x78, 0x56,
+    // largest received packet sequence number
+    0xBC, 0x9A, 0x78, 0x56,
     0x34, 0x12,
-    // time
+    // time delta
     0x87, 0x96, 0xA5, 0xB4,
     0xC3, 0xD2, 0xE1, 0x07,
-    // sequence delta
-    0x01,
-    // time delta
-    0x01, 0x00, 0x00, 0x00,
-    // sequence delta (skip one packet)
-    0x03,
-    // time delta
-    0x02, 0x00, 0x00, 0x00,
+    // num_unacked_packets
+    0x02,
+    // unacked packet sequence number
+    0xBA, 0x9A, 0x78, 0x56,
+    0x34, 0x12,
+    // unacked packet sequence number
+    0xBB, 0x9A, 0x78, 0x56,
+    0x34, 0x12,
     // least packet sequence number awaiting an ack
     0xA0, 0x9A, 0x78, 0x56,
     0x34, 0x12,
+    // num non retransmitting packets
+    0x03,
+    // non retransmitting packet sequence number
+    0xAE, 0x9A, 0x78, 0x56,
+    0x34, 0x12,
+    // non retransmitting packet sequence number
+    0xAF, 0x9A, 0x78, 0x56,
+    0x34, 0x12,
+    // non retransmitting packet sequence number
+    0xB0, 0x9A, 0x78, 0x56,
+    0x34, 0x12,
     // congestion feedback type (inter arrival)
     0x02,
     // accumulated_number_of_lost_packets
@@ -771,20 +797,21 @@ TEST_F(QuicFramerTest, AckFrameInterArrival) {
   EXPECT_EQ(0u, visitor_.stream_frames_.size());
   ASSERT_EQ(1u, visitor_.ack_frames_.size());
   const QuicAckFrame& frame = *visitor_.ack_frames_[0];
-  ASSERT_EQ(3u, frame.received_info.received_packet_times.size());
-  map<QuicPacketSequenceNumber, QuicTime>::const_iterator iter =
-      frame.received_info.received_packet_times.begin();
-  EXPECT_EQ(GG_UINT64_C(0x0123456789ABA), iter->first);
-  EXPECT_EQ(QuicTime::FromMicroseconds(0x07E1D2C3B4A59687), iter->second);
-  ++iter;
-  EXPECT_EQ(GG_UINT64_C(0x0123456789ABB), iter->first);
-  EXPECT_EQ(QuicTime::FromMicroseconds(0x07E1D2C3B4A59688), iter->second);
-  ++iter;
-  EXPECT_EQ(GG_UINT64_C(0x0123456789ABD), iter->first);
-  EXPECT_EQ(QuicTime::FromMicroseconds(0x07E1D2C3B4A59689), iter->second);
-
-  EXPECT_EQ(GG_UINT64_C(0x0123456789AA0),
-            frame.sent_info.least_unacked);
+  EXPECT_EQ(GG_UINT64_C(0x0123456789ABC),
+            frame.received_info.largest_received);
+  EXPECT_EQ(QuicTime::FromMicroseconds(GG_UINT64_C(0x07E1D2C3B4A59687)),
+            frame.received_info.time_received);
+
+  const SequenceSet& sequence_nums = frame.received_info.missing_packets;
+  ASSERT_EQ(2u, sequence_nums.size());
+  EXPECT_EQ(1u, sequence_nums.count(GG_UINT64_C(0x0123456789ABB)));
+  EXPECT_EQ(1u, sequence_nums.count(GG_UINT64_C(0x0123456789ABA)));
+  EXPECT_EQ(GG_UINT64_C(0x0123456789AA0), frame.sent_info.least_unacked);
+  ASSERT_EQ(3u, frame.sent_info.non_retransmiting.size());
+  const SequenceSet& non_retrans = frame.sent_info.non_retransmiting;
+  EXPECT_EQ(1u, non_retrans.count(GG_UINT64_C(0x0123456789AB0)));
+  EXPECT_EQ(1u, non_retrans.count(GG_UINT64_C(0x0123456789AAF)));
+  EXPECT_EQ(1u, non_retrans.count(GG_UINT64_C(0x0123456789AAE)));
   ASSERT_EQ(kInterArrival, frame.congestion_info.type);
   EXPECT_EQ(0x0302, frame.congestion_info.inter_arrival.
             accumulated_number_of_lost_packets);
@@ -828,25 +855,34 @@ TEST_F(QuicFramerTest, AckFrameFixRate) {
     0x01,
     // frame type (ack frame)
     0x02,
-    // num_acked_packets
-    0x03,
-    // smallest received packet sequence number
-    0xBA, 0x9A, 0x78, 0x56,
+    // largest received packet sequence number
+    0xBC, 0x9A, 0x78, 0x56,
     0x34, 0x12,
-    // time
+    // time delta
     0x87, 0x96, 0xA5, 0xB4,
     0xC3, 0xD2, 0xE1, 0x07,
-    // sequence delta
-    0x01,
-    // time delta
-    0x01, 0x00, 0x00, 0x00,
-    // sequence delta (skip one packet)
-    0x03,
-    // time delta
-    0x02, 0x00, 0x00, 0x00,
+    // num_unacked_packets
+    0x02,
+    // unacked packet sequence number
+    0xBA, 0x9A, 0x78, 0x56,
+    0x34, 0x12,
+    // unacked packet sequence number
+    0xBB, 0x9A, 0x78, 0x56,
+    0x34, 0x12,
     // least packet sequence number awaiting an ack
     0xA0, 0x9A, 0x78, 0x56,
     0x34, 0x12,
+    // num non retransmitting packets
+    0x03,
+    // non retransmitting packet sequence number
+    0xAE, 0x9A, 0x78, 0x56,
+    0x34, 0x12,
+    // non retransmitting packet sequence number
+    0xAF, 0x9A, 0x78, 0x56,
+    0x34, 0x12,
+    // non retransmitting packet sequence number
+    0xB0, 0x9A, 0x78, 0x56,
+    0x34, 0x12,
     // congestion feedback type (fix rate)
     0x03,
     // bitrate_in_bytes_per_second;
@@ -863,19 +899,21 @@ TEST_F(QuicFramerTest, AckFrameFixRate) {
   EXPECT_EQ(0u, visitor_.stream_frames_.size());
   ASSERT_EQ(1u, visitor_.ack_frames_.size());
   const QuicAckFrame& frame = *visitor_.ack_frames_[0];
-  ASSERT_EQ(3u, frame.received_info.received_packet_times.size());
-  map<QuicPacketSequenceNumber, QuicTime>::const_iterator iter =
-      frame.received_info.received_packet_times.begin();
-  EXPECT_EQ(GG_UINT64_C(0x0123456789ABA), iter->first);
-  EXPECT_EQ(QuicTime::FromMicroseconds(0x07E1D2C3B4A59687), iter->second);
-  ++iter;
-  EXPECT_EQ(GG_UINT64_C(0x0123456789ABB), iter->first);
-  EXPECT_EQ(QuicTime::FromMicroseconds(0x07E1D2C3B4A59688), iter->second);
-  ++iter;
-  EXPECT_EQ(GG_UINT64_C(0x0123456789ABD), iter->first);
-  EXPECT_EQ(QuicTime::FromMicroseconds(0x07E1D2C3B4A59689), iter->second);
-  EXPECT_EQ(GG_UINT64_C(0x0123456789AA0),
-            frame.sent_info.least_unacked);
+  EXPECT_EQ(GG_UINT64_C(0x0123456789ABC),
+            frame.received_info.largest_received);
+  EXPECT_EQ(QuicTime::FromMicroseconds(GG_UINT64_C(0x07E1D2C3B4A59687)),
+            frame.received_info.time_received);
+
+  const SequenceSet& sequence_nums = frame.received_info.missing_packets;
+  ASSERT_EQ(2u, sequence_nums.size());
+  EXPECT_EQ(1u, sequence_nums.count(GG_UINT64_C(0x0123456789ABB)));
+  EXPECT_EQ(1u, sequence_nums.count(GG_UINT64_C(0x0123456789ABA)));
+  EXPECT_EQ(GG_UINT64_C(0x0123456789AA0), frame.sent_info.least_unacked);
+  ASSERT_EQ(3u, frame.sent_info.non_retransmiting.size());
+  const SequenceSet& non_retrans = frame.sent_info.non_retransmiting;
+  EXPECT_EQ(1u, non_retrans.count(GG_UINT64_C(0x0123456789AB0)));
+  EXPECT_EQ(1u, non_retrans.count(GG_UINT64_C(0x0123456789AAF)));
+  EXPECT_EQ(1u, non_retrans.count(GG_UINT64_C(0x0123456789AAE)));
   ASSERT_EQ(kFixRate, frame.congestion_info.type);
   EXPECT_EQ(static_cast<uint32>(0x04030201),
             frame.congestion_info.fix_rate.bitrate_in_bytes_per_second);
@@ -914,25 +952,34 @@ TEST_F(QuicFramerTest, AckFrameInvalidFeedback) {
     0x01,
     // frame type (ack frame)
     0x02,
-    // num_acked_packets
-    0x03,
-    // smallest received packet sequence number
-    0xBA, 0x9A, 0x78, 0x56,
+    // largest received packet sequence number
+    0xBC, 0x9A, 0x78, 0x56,
     0x34, 0x12,
-    // time
+    // time delta
     0x87, 0x96, 0xA5, 0xB4,
     0xC3, 0xD2, 0xE1, 0x07,
-    // sequence delta
-    0x01,
-    // time delta
-    0x01, 0x00, 0x00, 0x00,
-    // sequence delta (skip one packet)
-    0x03,
-    // time delta
-    0x02, 0x00, 0x00, 0x00,
+    // num_unacked_packets
+    0x02,
+    // unacked packet sequence number
+    0xBA, 0x9A, 0x78, 0x56,
+    0x34, 0x12,
+    // unacked packet sequence number
+    0xBB, 0x9A, 0x78, 0x56,
+    0x34, 0x12,
     // least packet sequence number awaiting an ack
     0xA0, 0x9A, 0x78, 0x56,
     0x34, 0x12,
+    // num non retransmitting packets
+    0x03,
+    // non retransmitting packet sequence number
+    0xAE, 0x9A, 0x78, 0x56,
+    0x34, 0x12,
+    // non retransmitting packet sequence number
+    0xAF, 0x9A, 0x78, 0x56,
+    0x34, 0x12,
+    // non retransmitting packet sequence number
+    0xB0, 0x9A, 0x78, 0x56,
+    0x34, 0x12,
     // congestion feedback type (invalid)
     0x04,
   };
@@ -1041,25 +1088,35 @@ TEST_F(QuicFramerTest, ConnectionCloseFrame) {
     'n',
 
     // Ack frame.
-    // num_acked_packets
-    0x03,
-    // smallest received packet sequence number
-    0xBA, 0x9A, 0x78, 0x56,
+
+    // largest received packet sequence number
+    0xBC, 0x9A, 0x78, 0x56,
     0x34, 0x12,
-    // time
+    // time delta
     0x87, 0x96, 0xA5, 0xB4,
     0xC3, 0xD2, 0xE1, 0x07,
-    // sequence delta
-    0x01,
-    // time delta
-    0x01, 0x00, 0x00, 0x00,
-    // sequence delta (skip one packet)
-    0x03,
-    // time delta
-    0x02, 0x00, 0x00, 0x00,
+    // num_unacked_packets
+    0x02,
+    // unacked packet sequence number
+    0xBA, 0x9A, 0x78, 0x56,
+    0x34, 0x12,
+    // unacked packet sequence number
+    0xBB, 0x9A, 0x78, 0x56,
+    0x34, 0x12,
     // least packet sequence number awaiting an ack
     0xA0, 0x9A, 0x78, 0x56,
     0x34, 0x12,
+    // num non retransmitting packets
+    0x03,
+    // non retransmitting packet sequence number
+    0xAE, 0x9A, 0x78, 0x56,
+    0x34, 0x12,
+    // non retransmitting packet sequence number
+    0xAF, 0x9A, 0x78, 0x56,
+    0x34, 0x12,
+    // non retransmitting packet sequence number
+    0xB0, 0x9A, 0x78, 0x56,
+    0x34, 0x12,
     // congestion feedback type (inter arrival)
     0x02,
     // accumulated_number_of_lost_packets
@@ -1084,19 +1141,21 @@ TEST_F(QuicFramerTest, ConnectionCloseFrame) {
 
   ASSERT_EQ(1u, visitor_.ack_frames_.size());
   const QuicAckFrame& frame = *visitor_.ack_frames_[0];
-  ASSERT_EQ(3u, frame.received_info.received_packet_times.size());
-  map<QuicPacketSequenceNumber, QuicTime>::const_iterator iter =
-      frame.received_info.received_packet_times.begin();
-  EXPECT_EQ(GG_UINT64_C(0x0123456789ABA), iter->first);
-  EXPECT_EQ(QuicTime::FromMicroseconds(0x07E1D2C3B4A59687), iter->second);
-  ++iter;
-  EXPECT_EQ(GG_UINT64_C(0x0123456789ABB), iter->first);
-  EXPECT_EQ(QuicTime::FromMicroseconds(0x07E1D2C3B4A59688), iter->second);
-  ++iter;
-  EXPECT_EQ(GG_UINT64_C(0x0123456789ABD), iter->first);
-  EXPECT_EQ(QuicTime::FromMicroseconds(0x07E1D2C3B4A59689), iter->second);
-  EXPECT_EQ(GG_UINT64_C(0x0123456789AA0),
-            frame.sent_info.least_unacked);
+  EXPECT_EQ(GG_UINT64_C(0x0123456789ABC),
+            frame.received_info.largest_received);
+  EXPECT_EQ(QuicTime::FromMicroseconds(GG_UINT64_C(0x07E1D2C3B4A59687)),
+            frame.received_info.time_received);
+
+  const SequenceSet& sequence_nums = frame.received_info.missing_packets;
+  ASSERT_EQ(2u, sequence_nums.size());
+  EXPECT_EQ(1u, sequence_nums.count(GG_UINT64_C(0x0123456789ABB)));
+  EXPECT_EQ(1u, sequence_nums.count(GG_UINT64_C(0x0123456789ABA)));
+  EXPECT_EQ(GG_UINT64_C(0x0123456789AA0), frame.sent_info.least_unacked);
+  ASSERT_EQ(3u, frame.sent_info.non_retransmiting.size());
+  const SequenceSet& non_retrans = frame.sent_info.non_retransmiting;
+  EXPECT_EQ(1u, non_retrans.count(GG_UINT64_C(0x0123456789AB0)));
+  EXPECT_EQ(1u, non_retrans.count(GG_UINT64_C(0x0123456789AAF)));
+  EXPECT_EQ(1u, non_retrans.count(GG_UINT64_C(0x0123456789AAE)));
   ASSERT_EQ(kInterArrival, frame.congestion_info.type);
   EXPECT_EQ(0x0302, frame.congestion_info.inter_arrival.
             accumulated_number_of_lost_packets);
@@ -1230,16 +1289,20 @@ TEST_F(QuicFramerTest, ConstructAckFramePacket) {
   header.fec_group = 0;
 
   QuicAckFrame ack_frame;
-  ack_frame.received_info.RecordAck(
-      GG_UINT64_C(0x0123456789ABA),
-      QuicTime::FromMicroseconds(GG_UINT64_C(0x07E1D2C3B4A59687)));
-  ack_frame.received_info.RecordAck(
-      GG_UINT64_C(0x0123456789ABB),
-      QuicTime::FromMicroseconds(GG_UINT64_C(0x07E1D2C3B4A59688)));
-  ack_frame.received_info.RecordAck(
-      GG_UINT64_C(0x0123456789ABD),
-      QuicTime::FromMicroseconds(GG_UINT64_C(0x07E1D2C3B4A59689)));
+  ack_frame.received_info.largest_received = GG_UINT64_C(0x0123456789ABC);
+  ack_frame.received_info.time_received =
+      QuicTime::FromMicroseconds(GG_UINT64_C(0x07E1D2C3B4A59687));
+  ack_frame.received_info.missing_packets.insert(
+      GG_UINT64_C(0x0123456789ABB));
+  ack_frame.received_info.missing_packets.insert(
+      GG_UINT64_C(0x0123456789ABA));
   ack_frame.sent_info.least_unacked = GG_UINT64_C(0x0123456789AA0);
+  ack_frame.sent_info.non_retransmiting.insert(
+      GG_UINT64_C(0x0123456789AB0));
+  ack_frame.sent_info.non_retransmiting.insert(
+      GG_UINT64_C(0x0123456789AAF));
+  ack_frame.sent_info.non_retransmiting.insert(
+      GG_UINT64_C(0x0123456789AAE));
   ack_frame.congestion_info.type = kNone;
 
   QuicFrame frame;
@@ -1265,25 +1328,57 @@ TEST_F(QuicFramerTest, ConstructAckFramePacket) {
     0x01,
     // frame type (ack frame)
     0x02,
-    // num_acked_packets
-    0x03,
-    // smallest received packet sequence number
-    0xBA, 0x9A, 0x78, 0x56,
+    // largest received packet sequence number
+    0xBC, 0x9A, 0x78, 0x56,
     0x34, 0x12,
-    // time
+    // time delta
     0x87, 0x96, 0xA5, 0xB4,
     0xC3, 0xD2, 0xE1, 0x07,
-    // sequence delta
-    0x01,
-    // time delta
-    0x01, 0x00, 0x00, 0x00,
-    // sequence delta (skip one packet)
-    0x03,
-    // time delta
-    0x02, 0x00, 0x00, 0x00,
+    // num_unacked_packets
+    0x02,
+#if defined(OS_WIN)
+    // Windows hash_set order is different.
+    // unacked packet sequence number
+    0xBB, 0x9A, 0x78, 0x56,
+    0x34, 0x12,
+    // unacked packet sequence number
+    0xBA, 0x9A, 0x78, 0x56,
+    0x34, 0x12,
+#else
+    // unacked packet sequence number
+    0xBA, 0x9A, 0x78, 0x56,
+    0x34, 0x12,
+    // unacked packet sequence number
+    0xBB, 0x9A, 0x78, 0x56,
+    0x34, 0x12,
+#endif
     // least packet sequence number awaiting an ack
     0xA0, 0x9A, 0x78, 0x56,
     0x34, 0x12,
+    // num non retransmitting packets
+    0x03,
+#if defined(OS_WIN)
+    // Windows hash_set order is different.
+    // non retransmitting packet sequence number
+    0xB0, 0x9A, 0x78, 0x56,
+    0x34, 0x12,
+    // non retransmitting packet sequence number
+    0xAF, 0x9A, 0x78, 0x56,
+    0x34, 0x12,
+    // non retransmitting packet sequence number
+    0xAE, 0x9A, 0x78, 0x56,
+    0x34, 0x12,
+#else
+    // non retransmitting packet sequence number
+    0xAE, 0x9A, 0x78, 0x56,
+    0x34, 0x12,
+    // non retransmitting packet sequence number
+    0xAF, 0x9A, 0x78, 0x56,
+    0x34, 0x12,
+    // non retransmitting packet sequence number
+    0xB0, 0x9A, 0x78, 0x56,
+    0x34, 0x12,
+#endif
     // congestion feedback type (none)
     0x00,
   };
@@ -1306,16 +1401,20 @@ TEST_F(QuicFramerTest, ConstructAckFramePacketTCP) {
   header.fec_group = 0;
 
   QuicAckFrame ack_frame;
-  ack_frame.received_info.RecordAck(
-      GG_UINT64_C(0x0123456789ABA),
-      QuicTime::FromMicroseconds(GG_UINT64_C(0x07E1D2C3B4A59687)));
-  ack_frame.received_info.RecordAck(
-      GG_UINT64_C(0x0123456789ABB),
-      QuicTime::FromMicroseconds(GG_UINT64_C(0x07E1D2C3B4A59688)));
-  ack_frame.received_info.RecordAck(
-      GG_UINT64_C(0x0123456789ABD),
-      QuicTime::FromMicroseconds(GG_UINT64_C(0x07E1D2C3B4A59689)));
+  ack_frame.received_info.largest_received = GG_UINT64_C(0x0123456789ABC);
+  ack_frame.received_info.time_received =
+      QuicTime::FromMicroseconds(GG_UINT64_C(0x07E1D2C3B4A59687));
+  ack_frame.received_info.missing_packets.insert(
+      GG_UINT64_C(0x0123456789ABB));
+  ack_frame.received_info.missing_packets.insert(
+      GG_UINT64_C(0x0123456789ABA));
   ack_frame.sent_info.least_unacked = GG_UINT64_C(0x0123456789AA0);
+  ack_frame.sent_info.non_retransmiting.insert(
+      GG_UINT64_C(0x0123456789AB0));
+  ack_frame.sent_info.non_retransmiting.insert(
+      GG_UINT64_C(0x0123456789AAF));
+  ack_frame.sent_info.non_retransmiting.insert(
+      GG_UINT64_C(0x0123456789AAE));
   ack_frame.congestion_info.type = kTCP;
   ack_frame.congestion_info.tcp.accumulated_number_of_lost_packets = 0x0201;
   ack_frame.congestion_info.tcp.receive_window = 0x0403;
@@ -1343,25 +1442,57 @@ TEST_F(QuicFramerTest, ConstructAckFramePacketTCP) {
     0x01,
     // frame type (ack frame)
     0x02,
-    // num_acked_packets
-    0x03,
-    // smallest received packet sequence number
-    0xBA, 0x9A, 0x78, 0x56,
+    // largest received packet sequence number
+    0xBC, 0x9A, 0x78, 0x56,
     0x34, 0x12,
-    // time
+    // time delta
     0x87, 0x96, 0xA5, 0xB4,
     0xC3, 0xD2, 0xE1, 0x07,
-    // sequence delta
-    0x01,
-    // time delta
-    0x01, 0x00, 0x00, 0x00,
-    // sequence delta (skip one packet)
-    0x03,
-    // time delta
-    0x02, 0x00, 0x00, 0x00,
+    // num_unacked_packets
+    0x02,
+#if defined(OS_WIN)
+    // Windows hash_set order is different.
+    // unacked packet sequence number
+    0xBB, 0x9A, 0x78, 0x56,
+    0x34, 0x12,
+    // unacked packet sequence number
+    0xBA, 0x9A, 0x78, 0x56,
+    0x34, 0x12,
+#else
+    // unacked packet sequence number
+    0xBA, 0x9A, 0x78, 0x56,
+    0x34, 0x12,
+    // unacked packet sequence number
+    0xBB, 0x9A, 0x78, 0x56,
+    0x34, 0x12,
+#endif
     // least packet sequence number awaiting an ack
     0xA0, 0x9A, 0x78, 0x56,
     0x34, 0x12,
+    // num non retransmitting packets
+    0x03,
+#if defined(OS_WIN)
+    // Windows hash_set order is different.
+    // non retransmitting packet sequence number
+    0xB0, 0x9A, 0x78, 0x56,
+    0x34, 0x12,
+    // non retransmitting packet sequence number
+    0xAF, 0x9A, 0x78, 0x56,
+    0x34, 0x12,
+    // non retransmitting packet sequence number
+    0xAE, 0x9A, 0x78, 0x56,
+    0x34, 0x12,
+#else
+    // non retransmitting packet sequence number
+    0xAE, 0x9A, 0x78, 0x56,
+    0x34, 0x12,
+    // non retransmitting packet sequence number
+    0xAF, 0x9A, 0x78, 0x56,
+    0x34, 0x12,
+    // non retransmitting packet sequence number
+    0xB0, 0x9A, 0x78, 0x56,
+    0x34, 0x12,
+#endif
     // congestion feedback type (tcp)
     0x01,
     // ack_frame.congestion_info.tcp.accumulated_number_of_lost_packets
@@ -1388,16 +1519,20 @@ TEST_F(QuicFramerTest, ConstructAckFramePacketInterArrival) {
   header.fec_group = 0;
 
   QuicAckFrame ack_frame;
-  ack_frame.received_info.RecordAck(
-      GG_UINT64_C(0x0123456789ABA),
-      QuicTime::FromMicroseconds(GG_UINT64_C(0x07E1D2C3B4A59687)));
-  ack_frame.received_info.RecordAck(
-      GG_UINT64_C(0x0123456789ABB),
-      QuicTime::FromMicroseconds(GG_UINT64_C(0x07E1D2C3B4A59688)));
-  ack_frame.received_info.RecordAck(
-      GG_UINT64_C(0x0123456789ABD),
-      QuicTime::FromMicroseconds(GG_UINT64_C(0x07E1D2C3B4A59689)));
+  ack_frame.received_info.largest_received = GG_UINT64_C(0x0123456789ABC);
+  ack_frame.received_info.time_received =
+      QuicTime::FromMicroseconds(GG_UINT64_C(0x07E1D2C3B4A59687));
+  ack_frame.received_info.missing_packets.insert(
+      GG_UINT64_C(0x0123456789ABB));
+  ack_frame.received_info.missing_packets.insert(
+      GG_UINT64_C(0x0123456789ABA));
   ack_frame.sent_info.least_unacked = GG_UINT64_C(0x0123456789AA0);
+  ack_frame.sent_info.non_retransmiting.insert(
+      GG_UINT64_C(0x0123456789AB0));
+  ack_frame.sent_info.non_retransmiting.insert(
+      GG_UINT64_C(0x0123456789AAF));
+  ack_frame.sent_info.non_retransmiting.insert(
+      GG_UINT64_C(0x0123456789AAE));
   ack_frame.congestion_info.type = kInterArrival;
   ack_frame.congestion_info.inter_arrival.accumulated_number_of_lost_packets
       = 0x0302;
@@ -1427,25 +1562,57 @@ TEST_F(QuicFramerTest, ConstructAckFramePacketInterArrival) {
     0x01,
     // frame type (ack frame)
     0x02,
-    // num_acked_packets
-    0x03,
-    // smallest received packet sequence number
-    0xBA, 0x9A, 0x78, 0x56,
+    // largest received packet sequence number
+    0xBC, 0x9A, 0x78, 0x56,
     0x34, 0x12,
-    // time
+    // time delta
     0x87, 0x96, 0xA5, 0xB4,
     0xC3, 0xD2, 0xE1, 0x07,
-    // sequence delta
-    0x01,
-    // time delta
-    0x01, 0x00, 0x00, 0x00,
-    // sequence delta (skip one packet)
-    0x03,
-    // time delta
-    0x02, 0x00, 0x00, 0x00,
+    // num_unacked_packets
+    0x02,
+#if defined(OS_WIN)
+    // Windows hash_set order is different.
+    // unacked packet sequence number
+    0xBB, 0x9A, 0x78, 0x56,
+    0x34, 0x12,
+    // unacked packet sequence number
+    0xBA, 0x9A, 0x78, 0x56,
+    0x34, 0x12,
+#else
+    // unacked packet sequence number
+    0xBA, 0x9A, 0x78, 0x56,
+    0x34, 0x12,
+    // unacked packet sequence number
+    0xBB, 0x9A, 0x78, 0x56,
+    0x34, 0x12,
+#endif
     // least packet sequence number awaiting an ack
     0xA0, 0x9A, 0x78, 0x56,
     0x34, 0x12,
+    // num non retransmitting packets
+    0x03,
+#if defined(OS_WIN)
+    // Windows hash_set order is different.
+    // non retransmitting packet sequence number
+    0xB0, 0x9A, 0x78, 0x56,
+    0x34, 0x12,
+    // non retransmitting packet sequence number
+    0xAF, 0x9A, 0x78, 0x56,
+    0x34, 0x12,
+    // non retransmitting packet sequence number
+    0xAE, 0x9A, 0x78, 0x56,
+    0x34, 0x12,
+#else
+    // non retransmitting packet sequence number
+    0xAE, 0x9A, 0x78, 0x56,
+    0x34, 0x12,
+    // non retransmitting packet sequence number
+    0xAF, 0x9A, 0x78, 0x56,
+    0x34, 0x12,
+    // non retransmitting packet sequence number
+    0xB0, 0x9A, 0x78, 0x56,
+    0x34, 0x12,
+#endif
     // congestion feedback type (inter arrival)
     0x02,
     // accumulated_number_of_lost_packets
@@ -1474,16 +1641,20 @@ TEST_F(QuicFramerTest, ConstructAckFramePacketFixRate) {
   header.fec_group = 0;
 
   QuicAckFrame ack_frame;
-  ack_frame.received_info.RecordAck(
-      GG_UINT64_C(0x0123456789ABA),
-      QuicTime::FromMicroseconds(GG_UINT64_C(0x07E1D2C3B4A59687)));
-  ack_frame.received_info.RecordAck(
-      GG_UINT64_C(0x0123456789ABB),
-      QuicTime::FromMicroseconds(GG_UINT64_C(0x07E1D2C3B4A59688)));
-  ack_frame.received_info.RecordAck(
-      GG_UINT64_C(0x0123456789ABD),
-      QuicTime::FromMicroseconds(GG_UINT64_C(0x07E1D2C3B4A59689)));
+  ack_frame.received_info.largest_received = GG_UINT64_C(0x0123456789ABC);
+  ack_frame.received_info.time_received =
+      QuicTime::FromMicroseconds(GG_UINT64_C(0x07E1D2C3B4A59687));
+  ack_frame.received_info.missing_packets.insert(
+      GG_UINT64_C(0x0123456789ABB));
+  ack_frame.received_info.missing_packets.insert(
+      GG_UINT64_C(0x0123456789ABA));
   ack_frame.sent_info.least_unacked = GG_UINT64_C(0x0123456789AA0);
+  ack_frame.sent_info.non_retransmiting.insert(
+      GG_UINT64_C(0x0123456789AB0));
+  ack_frame.sent_info.non_retransmiting.insert(
+      GG_UINT64_C(0x0123456789AAF));
+  ack_frame.sent_info.non_retransmiting.insert(
+      GG_UINT64_C(0x0123456789AAE));
   ack_frame.congestion_info.type = kFixRate;
   ack_frame.congestion_info.fix_rate.bitrate_in_bytes_per_second
       = 0x04030201;
@@ -1511,25 +1682,57 @@ TEST_F(QuicFramerTest, ConstructAckFramePacketFixRate) {
     0x01,
     // frame type (ack frame)
     0x02,
-    // num_acked_packets
-    0x03,
-    // smallest received packet sequence number
-    0xBA, 0x9A, 0x78, 0x56,
+    // largest received packet sequence number
+    0xBC, 0x9A, 0x78, 0x56,
     0x34, 0x12,
-    // time
+    // time delta
     0x87, 0x96, 0xA5, 0xB4,
     0xC3, 0xD2, 0xE1, 0x07,
-    // sequence delta
-    0x01,
-    // time delta
-    0x01, 0x00, 0x00, 0x00,
-    // sequence delta (skip one packet)
-    0x03,
-    // time delta
-    0x02, 0x00, 0x00, 0x00,
+    // num_unacked_packets
+    0x02,
+#if defined(OS_WIN)
+    // Windows hash_set order is different.
+    // unacked packet sequence number
+    0xBB, 0x9A, 0x78, 0x56,
+    0x34, 0x12,
+    // unacked packet sequence number
+    0xBA, 0x9A, 0x78, 0x56,
+    0x34, 0x12,
+#else
+    // unacked packet sequence number
+    0xBA, 0x9A, 0x78, 0x56,
+    0x34, 0x12,
+    // unacked packet sequence number
+    0xBB, 0x9A, 0x78, 0x56,
+    0x34, 0x12,
+#endif
     // least packet sequence number awaiting an ack
     0xA0, 0x9A, 0x78, 0x56,
     0x34, 0x12,
+    // num non retransmitting packets
+    0x03,
+#if defined(OS_WIN)
+    // Windows hash_set order is different.
+    // non retransmitting packet sequence number
+    0xB0, 0x9A, 0x78, 0x56,
+    0x34, 0x12,
+    // non retransmitting packet sequence number
+    0xAF, 0x9A, 0x78, 0x56,
+    0x34, 0x12,
+    // non retransmitting packet sequence number
+    0xAE, 0x9A, 0x78, 0x56,
+    0x34, 0x12,
+#else
+    // non retransmitting packet sequence number
+    0xAE, 0x9A, 0x78, 0x56,
+    0x34, 0x12,
+    // non retransmitting packet sequence number
+    0xAF, 0x9A, 0x78, 0x56,
+    0x34, 0x12,
+    // non retransmitting packet sequence number
+    0xB0, 0x9A, 0x78, 0x56,
+    0x34, 0x12,
+#endif
     // congestion feedback type (fix rate)
     0x03,
     // bitrate_in_bytes_per_second;
@@ -1554,16 +1757,20 @@ TEST_F(QuicFramerTest, ConstructAckFramePacketInvalidFeedback) {
   header.fec_group = 0;
 
   QuicAckFrame ack_frame;
-  ack_frame.received_info.RecordAck(
-      GG_UINT64_C(0x0123456789ABA),
-      QuicTime::FromMicroseconds(GG_UINT64_C(0x07E1D2C3B4A59687)));
-  ack_frame.received_info.RecordAck(
-      GG_UINT64_C(0x0123456789ABB),
-      QuicTime::FromMicroseconds(GG_UINT64_C(0x07E1D2C3B4A59688)));
-  ack_frame.received_info.RecordAck(
-      GG_UINT64_C(0x0123456789ABD),
-      QuicTime::FromMicroseconds(GG_UINT64_C(0x07E1D2C3B4A59689)));
+  ack_frame.received_info.largest_received = GG_UINT64_C(0x0123456789ABC);
+  ack_frame.received_info.time_received =
+      QuicTime::FromMicroseconds(GG_UINT64_C(0x07E1D2C3B4A59687));
+  ack_frame.received_info.missing_packets.insert(
+      GG_UINT64_C(0x0123456789ABB));
+  ack_frame.received_info.missing_packets.insert(
+      GG_UINT64_C(0x0123456789ABA));
   ack_frame.sent_info.least_unacked = GG_UINT64_C(0x0123456789AA0);
+  ack_frame.sent_info.non_retransmiting.insert(
+      GG_UINT64_C(0x0123456789AB0));
+  ack_frame.sent_info.non_retransmiting.insert(
+      GG_UINT64_C(0x0123456789AAF));
+  ack_frame.sent_info.non_retransmiting.insert(
+      GG_UINT64_C(0x0123456789AAE));
   ack_frame.congestion_info.type =
       static_cast<CongestionFeedbackType>(kFixRate + 1);
 
@@ -1650,16 +1857,20 @@ TEST_F(QuicFramerTest, ConstructCloseFramePacket) {
   close_frame.error_details = "because I can";
 
   QuicAckFrame* ack_frame = &close_frame.ack_frame;
-  ack_frame->received_info.RecordAck(
-      GG_UINT64_C(0x0123456789ABA),
-      QuicTime::FromMicroseconds(GG_UINT64_C(0x07E1D2C3B4A59687)));
-  ack_frame->received_info.RecordAck(
-      GG_UINT64_C(0x0123456789ABB),
-      QuicTime::FromMicroseconds(GG_UINT64_C(0x07E1D2C3B4A59688)));
-  ack_frame->received_info.RecordAck(
-      GG_UINT64_C(0x0123456789ABD),
-      QuicTime::FromMicroseconds(GG_UINT64_C(0x07E1D2C3B4A59689)));
+  ack_frame->received_info.largest_received = GG_UINT64_C(0x0123456789ABC);
+  ack_frame->received_info.time_received =
+      QuicTime::FromMicroseconds(GG_UINT64_C(0x07E1D2C3B4A59687));
+  ack_frame->received_info.missing_packets.insert(
+      GG_UINT64_C(0x0123456789ABB));
+  ack_frame->received_info.missing_packets.insert(
+      GG_UINT64_C(0x0123456789ABA));
   ack_frame->sent_info.least_unacked = GG_UINT64_C(0x0123456789AA0);
+  ack_frame->sent_info.non_retransmiting.insert(
+      GG_UINT64_C(0x0123456789AB0));
+  ack_frame->sent_info.non_retransmiting.insert(
+      GG_UINT64_C(0x0123456789AAF));
+  ack_frame->sent_info.non_retransmiting.insert(
+      GG_UINT64_C(0x0123456789AAE));
   ack_frame->congestion_info.type = kInterArrival;
   ack_frame->congestion_info.inter_arrival.accumulated_number_of_lost_packets
       = 0x0302;
@@ -1698,26 +1909,58 @@ TEST_F(QuicFramerTest, ConstructCloseFramePacket) {
     'n',
 
     // Ack frame.
-    // num_acked_packets
-    0x03,
-    // smallest received packet sequence number
-    0xBA, 0x9A, 0x78, 0x56,
+
+    // largest received packet sequence number
+    0xBC, 0x9A, 0x78, 0x56,
     0x34, 0x12,
-    // time
+    // time delta
     0x87, 0x96, 0xA5, 0xB4,
     0xC3, 0xD2, 0xE1, 0x07,
-    // sequence delta
-    0x01,
-    // time delta
-    0x01, 0x00, 0x00, 0x00,
-    // sequence delta (skip one packet)
-    0x03,
-    // time delta
-    0x02, 0x00, 0x00, 0x00,
-
+    // num_unacked_packets
+    0x02,
+#if defined(OS_WIN)
+    // Windows hash_set order is different.
+    // unacked packet sequence number
+    0xBB, 0x9A, 0x78, 0x56,
+    0x34, 0x12,
+    // unacked packet sequence number
+    0xBA, 0x9A, 0x78, 0x56,
+    0x34, 0x12,
+#else
+    // unacked packet sequence number
+    0xBA, 0x9A, 0x78, 0x56,
+    0x34, 0x12,
+    // unacked packet sequence number
+    0xBB, 0x9A, 0x78, 0x56,
+    0x34, 0x12,
+#endif
     // least packet sequence number awaiting an ack
     0xA0, 0x9A, 0x78, 0x56,
     0x34, 0x12,
+    // num non retransmitting packets
+    0x03,
+#if defined(OS_WIN)
+    // Windows hash_set order is different.
+    // non retransmitting packet sequence number
+    0xB0, 0x9A, 0x78, 0x56,
+    0x34, 0x12,
+    // non retransmitting packet sequence number
+    0xAF, 0x9A, 0x78, 0x56,
+    0x34, 0x12,
+    // non retransmitting packet sequence number
+    0xAE, 0x9A, 0x78, 0x56,
+    0x34, 0x12,
+#else
+    // non retransmitting packet sequence number
+    0xAE, 0x9A, 0x78, 0x56,
+    0x34, 0x12,
+    // non retransmitting packet sequence number
+    0xAF, 0x9A, 0x78, 0x56,
+    0x34, 0x12,
+    // non retransmitting packet sequence number
+    0xB0, 0x9A, 0x78, 0x56,
+    0x34, 0x12,
+#endif
     // congestion feedback type (inter arrival)
     0x02,
     // accumulated_number_of_lost_packets
diff --git a/net/quic/quic_protocol.cc b/net/quic/quic_protocol.cc
index 6296446..878ffee 100644
--- a/net/quic/quic_protocol.cc
+++ b/net/quic/quic_protocol.cc
@@ -3,10 +3,8 @@
 // found in the LICENSE file.
 
 #include "net/quic/quic_protocol.h"
-#include "base/stl_util.h"
 
 using base::StringPiece;
-using std::map;
 using std::ostream;
 
 namespace net {
@@ -23,87 +21,30 @@ QuicStreamFrame::QuicStreamFrame(QuicStreamId stream_id,
       data(data) {
 }
 
-// TODO(ianswett): Initializing largest_received to 0 should not be necessary.
-ReceivedPacketInfo::ReceivedPacketInfo() : largest_received(0) {}
+ReceivedPacketInfo::ReceivedPacketInfo() {}
 
 ReceivedPacketInfo::~ReceivedPacketInfo() {}
 
-void ReceivedPacketInfo::RecordAck(QuicPacketSequenceNumber sequence_number,
-                                   QuicTime time) {
-  DCHECK(!ContainsAck(sequence_number));
-  received_packet_times[sequence_number] = time;
-  if (largest_received < sequence_number) {
-    largest_received = sequence_number;
-  }
-}
-
-bool ReceivedPacketInfo::ContainsAck(
-    QuicPacketSequenceNumber sequence_number) const {
-  return ContainsKey(received_packet_times, sequence_number);
-}
-
-void ReceivedPacketInfo::ClearAcksBefore(
-    QuicPacketSequenceNumber least_unacked) {
-  for (QuicPacketSequenceNumber i = received_packet_times.begin()->first;
-       i < least_unacked; ++i) {
-    received_packet_times.erase(i);
-  }
-}
-
 SentPacketInfo::SentPacketInfo() {}
 
 SentPacketInfo::~SentPacketInfo() {}
 
-QuicAckFrame::QuicAckFrame(QuicPacketSequenceNumber largest_received,
-                           QuicTime time_received,
-                           QuicPacketSequenceNumber least_unacked) {
-  received_info.largest_received = largest_received;
-  for (QuicPacketSequenceNumber seq_num = 1;
-       seq_num <= largest_received; ++seq_num) {
-    received_info.RecordAck(seq_num, time_received);
-  }
-  sent_info.least_unacked = least_unacked;
-  congestion_info.type = kNone;
-}
-
 ostream& operator<<(ostream& os, const QuicAckFrame& s) {
-  os << "sent info { least_waiting: " << s.sent_info.least_unacked << " } "
-     << "received info { largest_received: "
-     << s.received_info.largest_received
-     << " received packets: [ ";
-  for (map<QuicPacketSequenceNumber, QuicTime>::const_iterator it =
-           s.received_info.received_packet_times.begin();
-       it != s.received_info.received_packet_times.end(); ++it) {
-    os << it->first << "@" << it->second.ToMilliseconds() << " ";
+  os << "largest_received: " << s.received_info.largest_received
+     << " time: " << s.received_info.time_received.ToMicroseconds()
+     << " missing: ";
+  for (SequenceSet::const_iterator it = s.received_info.missing_packets.begin();
+       it != s.received_info.missing_packets.end(); ++it) {
+    os << *it << " ";
   }
 
-  os << "] } congestion info { type: " << s.congestion_info.type;
-  switch (s.congestion_info.type) {
-    case kNone:
-      break;
-    case kInterArrival: {
-      const CongestionFeedbackMessageInterArrival& inter_arrival =
-          s.congestion_info.inter_arrival;
-      os << " accumulated_number_of_lost_packets: "
-         << inter_arrival.accumulated_number_of_lost_packets;
-      os << " offset_time: " << inter_arrival.offset_time;
-      os << " delta_time: " << inter_arrival.delta_time;
-      break;
-    }
-    case kFixRate: {
-      os << " bitrate_in_bytes_per_second: "
-         << s.congestion_info.fix_rate.bitrate_in_bytes_per_second;
-      break;
-    }
-    case kTCP: {
-      const CongestionFeedbackMessageTCP& tcp = s.congestion_info.tcp;
-      os << " accumulated_number_of_lost_packets: "
-         << tcp.accumulated_number_of_lost_packets;
-      os << " receive_window: " << tcp.receive_window;
-      break;
-    }
+  os << " least_waiting: " << s.sent_info.least_unacked
+     << " no_retransmit: ";
+  for (SequenceSet::const_iterator it = s.sent_info.non_retransmiting.begin();
+       it != s.sent_info.non_retransmiting.end(); ++it) {
+    os << *it << " ";
   }
-  os << " }\n";
+  os << "\n";
   return os;
 }
 
diff --git a/net/quic/quic_protocol.h b/net/quic/quic_protocol.h
index 9a8fd22..a24e5e9 100644
--- a/net/quic/quic_protocol.h
+++ b/net/quic/quic_protocol.h
@@ -6,7 +6,6 @@
 #define NET_QUIC_QUIC_PROTOCOL_H_
 
 #include <limits>
-#include <map>
 #include <ostream>
 #include <utility>
 #include <vector>
@@ -169,16 +168,14 @@ typedef base::hash_set<QuicPacketSequenceNumber> SequenceSet;
 struct NET_EXPORT_PRIVATE ReceivedPacketInfo {
   ReceivedPacketInfo();
   ~ReceivedPacketInfo();
-
-  void RecordAck(QuicPacketSequenceNumber sequence_number, QuicTime time);
-  bool ContainsAck(QuicPacketSequenceNumber sequence_number) const;
-  void ClearAcksBefore(QuicPacketSequenceNumber least_unacked);
-
   // The highest packet sequence number we've received from the peer.
   QuicPacketSequenceNumber largest_received;
-
-  // The set of all received packets and their arrival times.
-  std::map<QuicPacketSequenceNumber, QuicTime> received_packet_times;
+  // The time at which we received the above packet.
+  QuicTime time_received;
+  // The set of packets which we're expecting and have not received.
+  // This includes any packets between the lowest and largest_received
+  // which we have neither seen nor been informed are non-retransmitting.
+  SequenceSet missing_packets;
 };
 
 struct NET_EXPORT_PRIVATE SentPacketInfo {
@@ -186,6 +183,9 @@ struct NET_EXPORT_PRIVATE SentPacketInfo {
   ~SentPacketInfo();
   // The lowest packet we've sent which is unacked, and we expect an ack for.
   QuicPacketSequenceNumber least_unacked;
+  // The set of packets between least_unacked and the last packet we have sent
+  // which we will not resend.
+  SequenceSet non_retransmiting;
 };
 
 // Defines for all types of congestion feedback that will be negotiated in QUIC,
@@ -241,11 +241,14 @@ struct NET_EXPORT_PRIVATE CongestionInfo {
 
 struct NET_EXPORT_PRIVATE QuicAckFrame {
   QuicAckFrame() {}
-  // Testing convenience method to construct a QuicAckFrame with all packets
-  // from least_unacked to largest_received acked at time_received.
   QuicAckFrame(QuicPacketSequenceNumber largest_received,
                QuicTime time_received,
-               QuicPacketSequenceNumber least_unacked);
+               QuicPacketSequenceNumber least_unacked) {
+    received_info.largest_received = largest_received;
+    received_info.time_received = time_received;
+    sent_info.least_unacked = least_unacked;
+    congestion_info.type = kNone;
+  }
 
   NET_EXPORT_PRIVATE friend std::ostream& operator<<(std::ostream& os,
                                                      const QuicAckFrame& s);