Revert 171096

net/quic/quic_framer_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 <algorithm>
-#include <map>
-#include <string>
 #include <vector>
 
 #include "base/hash_tables.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/port.h"
 #include "base/stl_util.h"
 #include "net/quic/quic_framer.h"
 #include "net/quic/quic_protocol.h"
 #include "net/quic/quic_utils.h"
 #include "net/quic/test_tools/quic_test_utils.h"
 
 using base::hash_set;
 using base::StringPiece;
-using std::map;
 using std::string;
 using std::vector;
 
 namespace net {
 
 namespace test {
 
 class TestEncrypter : public QuicEncrypter {
  public:
   virtual ~TestEncrypter() {}
@@ skipping 21 matching lines @@
     associated_data_ = associated_data.as_string();
     ciphertext_ = ciphertext.as_string();
     return new QuicData(ciphertext.data(), ciphertext.length());
   }
   string associated_data_;
   string ciphertext_;
 };
 
 // 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:
   TestQuicVisitor()
       : error_count_(0),
         packet_count_(0),
         frame_count_(0),
         fec_count_(0),
         complete_packets_(0),
         revived_packets_(0),
@@ skipping 459 matching lines @@
     0x34, 0x12,
     // flags
     0x00,
     // fec group
     0x00,
 
     // frame count
     0x01,
     // frame type (ack frame)
     0x02,
-    // num_acked_packets
-    0x03,
-    // smallest received packet sequence number
+    // largest received packet sequence number
+    0xBC, 0x9A, 0x78, 0x56,
+    0x34, 0x12,
+    // time delta
+    0x87, 0x96, 0xA5, 0xB4,
+    0xC3, 0xD2, 0xE1, 0x07,
+    // num_unacked_packets
+    0x02,
+    // unacked packet sequence number
     0xBA, 0x9A, 0x78, 0x56,
     0x34, 0x12,
-    // time
-    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,
+    // 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,
   };
 
   QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
   EXPECT_TRUE(framer_.ProcessPacket(self_address_, peer_address_, encrypted));
 
   EXPECT_TRUE(CheckDecryption(StringPiece(AsChars(packet), arraysize(packet))));
   EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
   ASSERT_TRUE(visitor_.header_.get());
 
   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 + 8) {
+      expected_error = "Unable to read largest received.";
+    } else if (i < kPacketHeaderSize + 16) {
+      expected_error = "Unable to read time received.";
     } else if (i < kPacketHeaderSize + 17) {
-      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) {
+      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.";
     }
 
     QuicEncryptedPacket encrypted(AsChars(packet), i, false);
     EXPECT_FALSE(framer_.ProcessPacket(self_address_, peer_address_,
                                        encrypted));
     EXPECT_EQ(expected_error, framer_.detailed_error());
     EXPECT_EQ(QUIC_INVALID_FRAME_DATA, framer_.error());
   }
 }
 
 TEST_F(QuicFramerTest, AckFrameTCP) {
   unsigned char packet[] = {
     // guid
     0x10, 0x32, 0x54, 0x76,
     0x98, 0xBA, 0xDC, 0xFE,
     // packet id
     0xBC, 0x9A, 0x78, 0x56,
     0x34, 0x12,
     // flags
     0x00,
     // fec group
     0x00,
 
     // frame count
     0x01,
     // frame type (ack frame)
     0x02,
-    // num_acked_packets
-    0x03,
-    // smallest received packet sequence number
+    // largest received packet sequence number
+    0xBC, 0x9A, 0x78, 0x56,
+    0x34, 0x12,
+    // time delta
+    0x87, 0x96, 0xA5, 0xB4,
+    0xC3, 0xD2, 0xE1, 0x07,
+    // num_unacked_packets
+    0x02,
+    // unacked packet sequence number
     0xBA, 0x9A, 0x78, 0x56,
     0x34, 0x12,
-    // time
-    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,
+    // 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
     0x01, 0x02,
     // ack_frame.congestion_info.tcp.receive_window
     0x03, 0x04,
   };
 
   QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
   EXPECT_TRUE(framer_.ProcessPacket(self_address_, peer_address_, encrypted));
 
   EXPECT_TRUE(CheckDecryption(StringPiece(AsChars(packet), arraysize(packet))));
   EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
   ASSERT_TRUE(visitor_.header_.get());
 
   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);
   EXPECT_EQ(0x0403, frame.congestion_info.tcp.receive_window);
 
   // Now test framing boundaries
   for (size_t i = kCongestionInfoOffset; i < kCongestionInfoOffset + 5; ++i) {
     string expected_error;
     if (i < kCongestionInfoOffset + 1) {
       expected_error = "Unable to read congestion info type.";
@@ skipping 21 matching lines @@
     0x34, 0x12,
     // flags
     0x00,
     // fec group
     0x00,
 
     // frame count
     0x01,
     // frame type (ack frame)
     0x02,
-    // num_acked_packets
-    0x03,
-    // smallest received packet sequence number
+    // largest received packet sequence number
+    0xBC, 0x9A, 0x78, 0x56,
+    0x34, 0x12,
+    // time delta
+    0x87, 0x96, 0xA5, 0xB4,
+    0xC3, 0xD2, 0xE1, 0x07,
+    // num_unacked_packets
+    0x02,
+    // unacked packet sequence number
     0xBA, 0x9A, 0x78, 0x56,
     0x34, 0x12,
-    // time
-    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,
+    // 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
     0x02, 0x03,
     // offset_time
     0x04, 0x05,
     // delta_time
     0x06, 0x07,
   };
 
   QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
   EXPECT_TRUE(framer_.ProcessPacket(self_address_, peer_address_, encrypted));
 
   EXPECT_TRUE(CheckDecryption(StringPiece(AsChars(packet), arraysize(packet))));
   EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
   ASSERT_TRUE(visitor_.header_.get());
 
   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);
 
-  EXPECT_EQ(GG_UINT64_C(0x0123456789AA0),
-            frame.sent_info.least_unacked);
+  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);
   EXPECT_EQ(0x0504, frame.congestion_info.inter_arrival.offset_time);
   EXPECT_EQ(0x0706, frame.congestion_info.inter_arrival.delta_time);
 
   // Now test framing boundaries
   for (size_t i = kCongestionInfoOffset; i < kCongestionInfoOffset + 5; ++i) {
     string expected_error;
     if (i < kCongestionInfoOffset + 1) {
@@ skipping 23 matching lines @@
     0x34, 0x12,
     // flags
     0x00,
     // fec group
     0x00,
 
     // frame count
     0x01,
     // frame type (ack frame)
     0x02,
-    // num_acked_packets
-    0x03,
-    // smallest received packet sequence number
+    // largest received packet sequence number
+    0xBC, 0x9A, 0x78, 0x56,
+    0x34, 0x12,
+    // time delta
+    0x87, 0x96, 0xA5, 0xB4,
+    0xC3, 0xD2, 0xE1, 0x07,
+    // num_unacked_packets
+    0x02,
+    // unacked packet sequence number
     0xBA, 0x9A, 0x78, 0x56,
     0x34, 0x12,
-    // time
-    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,
+    // 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;
     0x01, 0x02, 0x03, 0x04,
   };
 
   QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
   EXPECT_TRUE(framer_.ProcessPacket(self_address_, peer_address_, encrypted));
 
   EXPECT_TRUE(CheckDecryption(StringPiece(AsChars(packet), arraysize(packet))));
   EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
   ASSERT_TRUE(visitor_.header_.get());
 
   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);
 
   // Now test framing boundaries
   for (size_t i = kCongestionInfoOffset; i < kCongestionInfoOffset + 5; ++i) {
     string expected_error;
     if (i < kCongestionInfoOffset + 1) {
       expected_error = "Unable to read congestion info type.";
     } else if (i < kCongestionInfoOffset + 5) {
@@ skipping 18 matching lines @@
     0x34, 0x12,
     // flags
     0x00,
     // fec group
     0x00,
 
     // frame count
     0x01,
     // frame type (ack frame)
     0x02,
-    // num_acked_packets
-    0x03,
-    // smallest received packet sequence number
+    // largest received packet sequence number
+    0xBC, 0x9A, 0x78, 0x56,
+    0x34, 0x12,
+    // time delta
+    0x87, 0x96, 0xA5, 0xB4,
+    0xC3, 0xD2, 0xE1, 0x07,
+    // num_unacked_packets
+    0x02,
+    // unacked packet sequence number
     0xBA, 0x9A, 0x78, 0x56,
     0x34, 0x12,
-    // time
-    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,
+    // 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,
   };
 
   QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
   EXPECT_FALSE(framer_.ProcessPacket(self_address_, peer_address_, encrypted));
   EXPECT_TRUE(CheckDecryption(StringPiece(AsChars(packet), arraysize(packet))));
   EXPECT_EQ(QUIC_INVALID_FRAME_DATA, framer_.error());
 }
 
@@ skipping 88 matching lines @@
 
     // error details length
     0x0d, 0x00,
     // error details
     'b',  'e',  'c',  'a',
     'u',  's',  'e',  ' ',
     'I',  ' ',  'c',  'a',
     'n',
 
     // Ack frame.
-    // num_acked_packets
-    0x03,
-    // smallest received packet sequence number
+
+    // largest received packet sequence number
+    0xBC, 0x9A, 0x78, 0x56,
+    0x34, 0x12,
+    // time delta
+    0x87, 0x96, 0xA5, 0xB4,
+    0xC3, 0xD2, 0xE1, 0x07,
+    // num_unacked_packets
+    0x02,
+    // unacked packet sequence number
     0xBA, 0x9A, 0x78, 0x56,
     0x34, 0x12,
-    // time
-    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,
+    // 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
     0x02, 0x03,
     // offset_time
     0x04, 0x05,
     // delta_time
     0x06, 0x07,
   };
 
   QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
   EXPECT_TRUE(framer_.ProcessPacket(self_address_, peer_address_, encrypted));
 
   EXPECT_TRUE(CheckDecryption(StringPiece(AsChars(packet), arraysize(packet))));
   EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
   ASSERT_TRUE(visitor_.header_.get());
 
   EXPECT_EQ(0u, visitor_.stream_frames_.size());
 
   EXPECT_EQ(0x05060708, visitor_.connection_close_frame_.error_code);
   EXPECT_EQ("because I can", visitor_.connection_close_frame_.error_details);
 
   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);
   EXPECT_EQ(0x0504,
             frame.congestion_info.inter_arrival.offset_time);
   EXPECT_EQ(0x0706,
             frame.congestion_info.inter_arrival.delta_time);
 
   // Now test framing boundaries
   for (size_t i = kPacketHeaderSize + 3; i < kPacketHeaderSize + 21; ++i) {
@@ skipping 113 matching lines @@
 }
 
 TEST_F(QuicFramerTest, ConstructAckFramePacket) {
   QuicPacketHeader header;
   header.guid = GG_UINT64_C(0xFEDCBA9876543210);
   header.packet_sequence_number = GG_UINT64_C(0x123456789ABC);
   header.flags = PACKET_FLAGS_NONE;
   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;
   frame.type = ACK_FRAME;
   frame.ack_frame = &ack_frame;
 
   QuicFrames frames;
   frames.push_back(frame);
 
   unsigned char packet[] = {
     // guid
     0x10, 0x32, 0x54, 0x76,
     0x98, 0xBA, 0xDC, 0xFE,
     // packet id
     0xBC, 0x9A, 0x78, 0x56,
     0x34, 0x12,
     // flags
     0x00,
     // fec group
     0x00,
 
     // frame count
     0x01,
     // frame type (ack frame)
     0x02,
-    // num_acked_packets
-    0x03,
-    // smallest received packet sequence number
+    // largest received packet sequence number
+    0xBC, 0x9A, 0x78, 0x56,
+    0x34, 0x12,
+    // time delta
+    0x87, 0x96, 0xA5, 0xB4,
+    0xC3, 0xD2, 0xE1, 0x07,
+    // 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,
-    // time
-    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,
+#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,
   };
 
   QuicPacket* data;
   EXPECT_TRUE(framer_.ConstructFrameDataPacket(header, frames, &data));
 
   test::CompareCharArraysWithHexError("constructed packet",
                                       data->data(), data->length(),
                                       AsChars(packet), arraysize(packet));
 
   delete data;
 }
 
 TEST_F(QuicFramerTest, ConstructAckFramePacketTCP) {
   QuicPacketHeader header;
   header.guid = GG_UINT64_C(0xFEDCBA9876543210);
   header.packet_sequence_number = GG_UINT64_C(0x123456789ABC);
   header.flags = PACKET_FLAGS_NONE;
   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;
 
   QuicFrame frame;
   frame.type = ACK_FRAME;
   frame.ack_frame = &ack_frame;
 
   QuicFrames frames;
   frames.push_back(frame);
 
   unsigned char packet[] = {
     // guid
     0x10, 0x32, 0x54, 0x76,
     0x98, 0xBA, 0xDC, 0xFE,
     // packet id
     0xBC, 0x9A, 0x78, 0x56,
     0x34, 0x12,
     // flags
     0x00,
     // fec group
     0x00,
 
     // frame count
     0x01,
     // frame type (ack frame)
     0x02,
-    // num_acked_packets
-    0x03,
-    // smallest received packet sequence number
+    // largest received packet sequence number
+    0xBC, 0x9A, 0x78, 0x56,
+    0x34, 0x12,
+    // time delta
+    0x87, 0x96, 0xA5, 0xB4,
+    0xC3, 0xD2, 0xE1, 0x07,
+    // 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,
-    // time
-    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,
+#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
     0x01, 0x02,
     // ack_frame.congestion_info.tcp.receive_window
     0x03, 0x04,
   };
 
   QuicPacket* data;
   EXPECT_TRUE(framer_.ConstructFrameDataPacket(header, frames, &data));
 
   test::CompareCharArraysWithHexError("constructed packet",
                                       data->data(), data->length(),
                                       AsChars(packet), arraysize(packet));
 
   delete data;
 }
 
 TEST_F(QuicFramerTest, ConstructAckFramePacketInterArrival) {
   QuicPacketHeader header;
   header.guid = GG_UINT64_C(0xFEDCBA9876543210);
   header.packet_sequence_number = GG_UINT64_C(0x123456789ABC);
   header.flags = PACKET_FLAGS_NONE;
   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;
   ack_frame.congestion_info.inter_arrival.offset_time = 0x0504;
   ack_frame.congestion_info.inter_arrival.delta_time = 0x0706;
 
   QuicFrame frame;
   frame.type = ACK_FRAME;
   frame.ack_frame = &ack_frame;
 
   QuicFrames frames;
   frames.push_back(frame);
 
   unsigned char packet[] = {
     // guid
     0x10, 0x32, 0x54, 0x76,
     0x98, 0xBA, 0xDC, 0xFE,
     // packet id
     0xBC, 0x9A, 0x78, 0x56,
     0x34, 0x12,
     // flags
     0x00,
     // fec group
     0x00,
 
     // frame count
     0x01,
     // frame type (ack frame)
     0x02,
-    // num_acked_packets
-    0x03,
-    // smallest received packet sequence number
+    // largest received packet sequence number
+    0xBC, 0x9A, 0x78, 0x56,
+    0x34, 0x12,
+    // time delta
+    0x87, 0x96, 0xA5, 0xB4,
+    0xC3, 0xD2, 0xE1, 0x07,
+    // 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,
-    // time
-    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,
+#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
     0x02, 0x03,
     // offset_time
     0x04, 0x05,
     // delta_time
     0x06, 0x07,
   };
 
   QuicPacket* data;
   EXPECT_TRUE(framer_.ConstructFrameDataPacket(header, frames, &data));
 
   test::CompareCharArraysWithHexError("constructed packet",
                                       data->data(), data->length(),
                                       AsChars(packet), arraysize(packet));
 
   delete data;
 }
 
 TEST_F(QuicFramerTest, ConstructAckFramePacketFixRate) {
   QuicPacketHeader header;
   header.guid = GG_UINT64_C(0xFEDCBA9876543210);
   header.packet_sequence_number = GG_UINT64_C(0x123456789ABC);
   header.flags = PACKET_FLAGS_NONE;
   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;
 
   QuicFrame frame;
   frame.type = ACK_FRAME;
   frame.ack_frame = &ack_frame;
 
   QuicFrames frames;
   frames.push_back(frame);
 
   unsigned char packet[] = {
     // guid
     0x10, 0x32, 0x54, 0x76,
     0x98, 0xBA, 0xDC, 0xFE,
     // packet id
     0xBC, 0x9A, 0x78, 0x56,
     0x34, 0x12,
     // flags
     0x00,
     // fec group
     0x00,
 
     // frame count
     0x01,
     // frame type (ack frame)
     0x02,
-    // num_acked_packets
-    0x03,
-    // smallest received packet sequence number
+    // largest received packet sequence number
+    0xBC, 0x9A, 0x78, 0x56,
+    0x34, 0x12,
+    // time delta
+    0x87, 0x96, 0xA5, 0xB4,
+    0xC3, 0xD2, 0xE1, 0x07,
+    // 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,
-    // time
-    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,
+#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;
     0x01, 0x02, 0x03, 0x04,
   };
 
   QuicPacket* data;
   EXPECT_TRUE(framer_.ConstructFrameDataPacket(header, frames, &data));
 
   test::CompareCharArraysWithHexError("constructed packet",
                                       data->data(), data->length(),
                                       AsChars(packet), arraysize(packet));
 
   delete data;
 }
 
 TEST_F(QuicFramerTest, ConstructAckFramePacketInvalidFeedback) {
   QuicPacketHeader header;
   header.guid = GG_UINT64_C(0xFEDCBA9876543210);
   header.packet_sequence_number = GG_UINT64_C(0x123456789ABC);
   header.flags = PACKET_FLAGS_NONE;
   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);
 
   QuicFrame frame;
   frame.type = ACK_FRAME;
   frame.ack_frame = &ack_frame;
 
   QuicFrames frames;
   frames.push_back(frame);
 
@@ skipping 66 matching lines @@
   header.guid = GG_UINT64_C(0xFEDCBA9876543210);
   header.packet_sequence_number = GG_UINT64_C(0x123456789ABC);
   header.flags = PACKET_FLAGS_NONE;
   header.fec_group = 0;
 
   QuicConnectionCloseFrame close_frame;
   close_frame.error_code = static_cast<QuicErrorCode>(0x05060708);
   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;
   ack_frame->congestion_info.inter_arrival.offset_time = 0x0504;
   ack_frame->congestion_info.inter_arrival.delta_time = 0x0706;
 
   QuicFrame frame(&close_frame);
 
   QuicFrames frames;
   frames.push_back(frame);
@@ skipping 18 matching lines @@
     0x08, 0x07, 0x06, 0x05,
     // error details length
     0x0d, 0x00,
     // error details
     'b',  'e',  'c',  'a',
     'u',  's',  'e',  ' ',
     'I',  ' ',  'c',  'a',
     'n',
 
     // Ack frame.
-    // num_acked_packets
-    0x03,
-    // smallest received packet sequence number
+
+    // largest received packet sequence number
+    0xBC, 0x9A, 0x78, 0x56,
+    0x34, 0x12,
+    // time delta
+    0x87, 0x96, 0xA5, 0xB4,
+    0xC3, 0xD2, 0xE1, 0x07,
+    // 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,
-    // time
-    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,
-
+#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
     0x02, 0x03,
     // offset_time
     0x04, 0x05,
     // delta_time
     0x06, 0x07,
   };
 
@@ skipping 76 matching lines @@
   QuicPacket raw(AsChars(packet), arraysize(packet), false, PACKET_FLAGS_NONE);
   scoped_ptr<QuicEncryptedPacket> encrypted(framer_.EncryptPacket(raw));
 
   ASSERT_TRUE(encrypted.get() != NULL);
   EXPECT_TRUE(CheckEncryption(StringPiece(AsChars(packet), arraysize(packet))));
 }
 
 }  // namespace test
 
 }  // namespace net