Change from re-transmitting an packet with a retransmit number to sending a new packet with a new s…

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 <vector>
 
 #include "base/hash_tables.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 212 matching lines @@
 }
 
 TEST_F(QuicFramerTest, LargePacket) {
   unsigned char packet[kMaxPacketSize + 1] = {
     // guid
     0x10, 0x32, 0x54, 0x76,
     0x98, 0xBA, 0xDC, 0xFE,
     // packet id
     0xBC, 0x9A, 0x78, 0x56,
     0x34, 0x12,
-    // retransmission count
-    0x01,
     // transmission time
     0x87, 0x96, 0xA5, 0xB4,
     0xC3, 0xD2, 0xE1, 0xF0,
     // flags
     0x00,
     // fec group
     0x00,
     // frame count
     0x01,
   };
@@ skipping 11 matching lines @@
 }
 
 TEST_F(QuicFramerTest, PacketHeader) {
   unsigned char packet[] = {
     // guid
     0x10, 0x32, 0x54, 0x76,
     0x98, 0xBA, 0xDC, 0xFE,
     // packet id
     0xBC, 0x9A, 0x78, 0x56,
     0x34, 0x12,
-    // retransmission count
-    0x01,
     // transmission time
     0x87, 0x96, 0xA5, 0xB4,
     0xC3, 0xD2, 0xE1, 0xF0,
     // flags
     0x00,
     // fec group
     0x00,
   };
 
   QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
   EXPECT_FALSE(framer_.ProcessPacket(self_address_, peer_address_, encrypted));
 
   EXPECT_EQ(QUIC_INVALID_FRAME_DATA, framer_.error());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_EQ(GG_UINT64_C(0xFEDCBA9876543210), visitor_.header_->guid);
-  EXPECT_EQ(0x1, visitor_.header_->retransmission_count);
   EXPECT_EQ(GG_UINT64_C(0x123456789ABC),
             visitor_.header_->packet_sequence_number);
   EXPECT_EQ(GG_UINT64_C(0xF0E1D2C3B4A59687),
             visitor_.header_->transmission_time);
   EXPECT_EQ(0x00, visitor_.header_->flags);
   EXPECT_EQ(0x00, visitor_.header_->fec_group);
 
   // Now test framing boundaries
-  for (int i = 0; i < 25; ++i) {
+  for (int i = 0; i < 24; ++i) {
     string expected_error;
     if (i < 8) {
       expected_error = "Unable to read GUID.";
     } else if (i < 14) {
       expected_error = "Unable to read sequence number.";
-    } else if (i < 15) {
-      expected_error = "Unable to read retransmission count.";
+    } else if (i < 22) {
+      expected_error = "Unable to read transmission time.";
     } else if (i < 23) {
-      expected_error = "Unable to read transmission time.";
+      expected_error = "Unable to read flags.";
     } else if (i < 24) {
-      expected_error = "Unable to read flags.";
-    } else if (i < 25) {
       expected_error = "Unable to read fec group.";
     }
 
     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_PACKET_HEADER, framer_.error());
   }
 }
 
 TEST_F(QuicFramerTest, StreamFrame) {
   unsigned char packet[] = {
     // guid
     0x10, 0x32, 0x54, 0x76,
     0x98, 0xBA, 0xDC, 0xFE,
     // packet id
     0xBC, 0x9A, 0x78, 0x56,
     0x34, 0x12,
-    // retransmission count
-    0x01,
     // transmission time
     0x87, 0x96, 0xA5, 0xB4,
     0xC3, 0xD2, 0xE1, 0xF0,
     // flags
     0x00,
     // fec group
     0x00,
 
     // frame count
     0x01,
@@ skipping 60 matching lines @@
 TEST_F(QuicFramerTest, RejectPacket) {
   visitor_.accept_packet_ = false;
 
   unsigned char packet[] = {
     // guid
     0x10, 0x32, 0x54, 0x76,
     0x98, 0xBA, 0xDC, 0xFE,
     // packet id
     0xBC, 0x9A, 0x78, 0x56,
     0x34, 0x12,
-    // retransmission count
-    0x01,
     // transmission time
     0x87, 0x96, 0xA5, 0xB4,
     0xC3, 0xD2, 0xE1, 0xF0,
     // flags
     0x00,
     // fec group
     0x00,
 
     // frame count
     0x01,
@@ skipping 42 matching lines @@
     // data length
     0x0c, 0x00,
     // data
     'h',  'e',  'l',  'l',
     'o',  ' ',  'w',  'o',
     'r',  'l',  'd',  '!',
   };
 
   QuicPacketHeader header;
   header.guid = GG_UINT64_C(0xFEDCBA9876543210);
-  header.retransmission_count = 0x01;
   header.packet_sequence_number = GG_UINT64_C(0x123456789ABC);
   header.transmission_time = GG_UINT64_C(0xF0E1D2C3B4A59687);
   header.flags = PACKET_FLAGS_NONE;
   header.fec_group = 0;
 
   // Do not encrypt the payload because the revived payload is post-encryption.
   EXPECT_TRUE(framer_.ProcessRevivedPacket(header,
                                            StringPiece(AsChars(payload),
                                                        arraysize(payload))));
 
   EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
   ASSERT_EQ(1, visitor_.revived_packets_);
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_EQ(GG_UINT64_C(0xFEDCBA9876543210), visitor_.header_->guid);
-  EXPECT_EQ(0x1, visitor_.header_->retransmission_count);
   EXPECT_EQ(GG_UINT64_C(0x123456789ABC),
             visitor_.header_->packet_sequence_number);
   EXPECT_EQ(GG_UINT64_C(0xF0E1D2C3B4A59687),
             visitor_.header_->transmission_time);
   EXPECT_EQ(0x00, visitor_.header_->flags);
   EXPECT_EQ(0x00, visitor_.header_->fec_group);
 
 
   ASSERT_EQ(1u, visitor_.stream_frames_.size());
   EXPECT_EQ(0u, visitor_.ack_frames_.size());
   EXPECT_EQ(GG_UINT64_C(0x01020304), visitor_.stream_frames_[0]->stream_id);
   EXPECT_TRUE(visitor_.stream_frames_[0]->fin);
   EXPECT_EQ(GG_UINT64_C(0xBA98FEDC32107654),
             visitor_.stream_frames_[0]->offset);
   EXPECT_EQ("hello world!", visitor_.stream_frames_[0]->data);
 }
 
 TEST_F(QuicFramerTest, StreamFrameInFecGroup) {
   unsigned char packet[] = {
     // guid
     0x10, 0x32, 0x54, 0x76,
     0x98, 0xBA, 0xDC, 0xFE,
     // packet id
     0xBC, 0x9A, 0x78, 0x56,
     0x12, 0x34,
-    // retransmission count
-    0x01,
     // transmission time
     0x87, 0x96, 0xA5, 0xB4,
     0xC3, 0xD2, 0xE1, 0xF0,
     // flags
     0x00,
     // fec group
     0x02,
 
     // frame count
     0x01,
@@ skipping 36 matching lines @@
 }
 
 TEST_F(QuicFramerTest, AckFrame) {
   unsigned char packet[] = {
     // guid
     0x10, 0x32, 0x54, 0x76,
     0x98, 0xBA, 0xDC, 0xFE,
     // packet id
     0xBC, 0x9A, 0x78, 0x56,
     0x34, 0x12,
-    // retransmission count
-    0x01,
     // transmission time
     0x87, 0x96, 0xA5, 0xB4,
     0xC3, 0xD2, 0xE1, 0xF0,
     // flags
     0x00,
     // fec group
     0x00,
 
     // frame count
     0x01,
@@ skipping 94 matching lines @@
 }
 
 TEST_F(QuicFramerTest, AckFrameTCP) {
   unsigned char packet[] = {
     // guid
     0x10, 0x32, 0x54, 0x76,
     0x98, 0xBA, 0xDC, 0xFE,
     // packet id
     0xBC, 0x9A, 0x78, 0x56,
     0x34, 0x12,
-    // retransmission count
-    0x01,
     // transmission time
     0x87, 0x96, 0xA5, 0xB4,
     0xC3, 0xD2, 0xE1, 0xF0,
     // flags
     0x00,
     // fec group
     0x00,
 
     // frame count
     0x01,
@@ skipping 87 matching lines @@
 }
 
 TEST_F(QuicFramerTest, AckFrameInterArrival) {
   unsigned char packet[] = {
     // guid
     0x10, 0x32, 0x54, 0x76,
     0x98, 0xBA, 0xDC, 0xFE,
     // packet id
     0xBC, 0x9A, 0x78, 0x56,
     0x34, 0x12,
-    // retransmission count
-    0x01,
     // transmission time
     0x87, 0x96, 0xA5, 0xB4,
     0xC3, 0xD2, 0xE1, 0xF0,
     // flags
     0x00,
     // fec group
     0x00,
 
     // frame count
     0x01,
@@ skipping 91 matching lines @@
 }
 
 TEST_F(QuicFramerTest, AckFrameFixRate) {
   unsigned char packet[] = {
     // guid
     0x10, 0x32, 0x54, 0x76,
     0x98, 0xBA, 0xDC, 0xFE,
     // packet id
     0xBC, 0x9A, 0x78, 0x56,
     0x34, 0x12,
-    // retransmission count
-    0x01,
     // transmission time
     0x87, 0x96, 0xA5, 0xB4,
     0xC3, 0xD2, 0xE1, 0xF0,
     // flags
     0x00,
     // fec group
     0x00,
 
     // frame count
     0x01,
@@ skipping 82 matching lines @@
 
 
 TEST_F(QuicFramerTest, AckFrameInvalidFeedback) {
   unsigned char packet[] = {
     // guid
     0x10, 0x32, 0x54, 0x76,
     0x98, 0xBA, 0xDC, 0xFE,
     // packet id
     0xBC, 0x9A, 0x78, 0x56,
     0x34, 0x12,
-    // retransmission count
-    0x01,
     // transmission time
     0x87, 0x96, 0xA5, 0xB4,
     0xC3, 0xD2, 0xE1, 0xF0,
     // flags
     0x00,
     // fec group
     0x00,
 
     // frame count
     0x01,
@@ skipping 38 matching lines @@
 }
 
 TEST_F(QuicFramerTest, RstStreamFrame) {
   unsigned char packet[] = {
     // guid
     0x10, 0x32, 0x54, 0x76,
     0x98, 0xBA, 0xDC, 0xFE,
     // packet id
     0xBC, 0x9A, 0x78, 0x56,
     0x34, 0x12,
-    // retransmission count
-    0x01,
     // transmission time
     0x87, 0x96, 0xA5, 0xB4,
     0xC3, 0xD2, 0xE1, 0xF0,
     // flags
     0x00,
     // fec group
     0x00,
 
     // frame count
     0x01,
@@ skipping 51 matching lines @@
 }
 
 TEST_F(QuicFramerTest, ConnectionCloseFrame) {
   unsigned char packet[] = {
     // guid
     0x10, 0x32, 0x54, 0x76,
     0x98, 0xBA, 0xDC, 0xFE,
     // packet id
     0xBC, 0x9A, 0x78, 0x56,
     0x34, 0x12,
-    // retransmission count
-    0x01,
     // transmission time
     0x87, 0x96, 0xA5, 0xB4,
     0xC3, 0xD2, 0xE1, 0xF0,
     // flags
     0x00,
     // fec group
     0x00,
 
 
     // frame count
@@ skipping 108 matching lines @@
 }
 
 TEST_F(QuicFramerTest, FecPacket) {
   unsigned char packet[] = {
     // guid
     0x10, 0x32, 0x54, 0x76,
     0x98, 0xBA, 0xDC, 0xFE,
     // packet id
     0xBC, 0x9A, 0x78, 0x56,
     0x34, 0x12,
-    // retransmission count
-    0x01,
     // transmission time
     0x87, 0x96, 0xA5, 0xB4,
     0xC3, 0xD2, 0xE1, 0xF0,
     // flags (FEC)
     0x01,
     // fec group
     0x01,
 
     // first protected packet
     0xBB, 0x9A, 0x78, 0x56,
@@ skipping 17 matching lines @@
   ASSERT_EQ(1, visitor_.fec_count_);
   const QuicFecData& fec_data = *visitor_.fec_data_[0];
   EXPECT_EQ(GG_UINT64_C(0x0123456789ABB),
             fec_data.min_protected_packet_sequence_number);
   EXPECT_EQ("abcdefghijklmnop", fec_data.redundancy);
 }
 
 TEST_F(QuicFramerTest, ConstructStreamFramePacket) {
   QuicPacketHeader header;
   header.guid = GG_UINT64_C(0xFEDCBA9876543210);
-  header.retransmission_count = 0x01;
   header.packet_sequence_number = GG_UINT64_C(0x123456789ABC);
   header.transmission_time = GG_UINT64_C(0xF0E1D2C3B4A59687);
   header.flags = PACKET_FLAGS_NONE;
   header.fec_group = 0;
 
   QuicStreamFrame stream_frame;
   stream_frame.stream_id = 0x01020304;
   stream_frame.fin = true;
   stream_frame.offset = GG_UINT64_C(0xBA98FEDC32107654);
   stream_frame.data = "hello world!";
 
   QuicFrame frame;
   frame.type = STREAM_FRAME;
   frame.stream_frame = &stream_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,
-    // retransmission count
-    0x01,
     // transmission time
     0x87, 0x96, 0xA5, 0xB4,
     0xC3, 0xD2, 0xE1, 0xF0,
     // flags
     0x00,
     // fec group
     0x00,
 
     // frame count
     0x01,
     // frame type (stream frame)
     0x00,
     // stream id
     0x04, 0x03, 0x02, 0x01,
     // fin
     0x01,
     // offset
     0x54, 0x76, 0x10, 0x32,
     0xDC, 0xFE, 0x98, 0xBA,
     // data length
     0x0c, 0x00,
     // data
     'h',  'e',  'l',  'l',
     'o',  ' ',  'w',  'o',
     'r',  'l',  'd',  '!',
   };
 
   QuicPacket* data;
-  ASSERT_TRUE(framer_.ConstructFragementDataPacket(header, frames, &data));
+  ASSERT_TRUE(framer_.ConstructFrameDataPacket(header, frames, &data));
 
   test::CompareCharArraysWithHexError("constructed packet",
                                       data->data(), data->length(),
                                       AsChars(packet), arraysize(packet));
 
   delete data;
 }
 
 TEST_F(QuicFramerTest, ConstructAckFramePacket) {
   QuicPacketHeader header;
   header.guid = GG_UINT64_C(0xFEDCBA9876543210);
-  header.retransmission_count = 0x01;
   header.packet_sequence_number = GG_UINT64_C(0x123456789ABC);
   header.transmission_time = GG_UINT64_C(0xF0E1D2C3B4A59687);
   header.flags = PACKET_FLAGS_NONE;
   header.fec_group = 0;
 
   QuicAckFrame ack_frame;
   ack_frame.received_info.largest_received = GG_UINT64_C(0x0123456789ABC);
   ack_frame.received_info.time_received = GG_UINT64_C(0xF0E1D2C3B4A59687);
   ack_frame.received_info.missing_packets.insert(
       GG_UINT64_C(0x0123456789ABB));
@@ skipping 15 matching lines @@
   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,
-    // retransmission count
-    0x01,
     // transmission time
     0x87, 0x96, 0xA5, 0xB4,
     0xC3, 0xD2, 0xE1, 0xF0,
     // flags
     0x00,
     // fec group
     0x00,
 
     // frame count
     0x01,
@@ skipping 46 matching lines @@
     0x34, 0x12,
     // non retransmitting packet sequence number
     0xB0, 0x9A, 0x78, 0x56,
     0x34, 0x12,
 #endif
     // congestion feedback type (none)
     0x00,
   };
 
   QuicPacket* data;
-  EXPECT_TRUE(framer_.ConstructFragementDataPacket(header, frames, &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.retransmission_count = 0x01;
   header.packet_sequence_number = GG_UINT64_C(0x123456789ABC);
   header.transmission_time = GG_UINT64_C(0xF0E1D2C3B4A59687);
   header.flags = PACKET_FLAGS_NONE;
   header.fec_group = 0;
 
   QuicAckFrame ack_frame;
   ack_frame.received_info.largest_received = GG_UINT64_C(0x0123456789ABC);
   ack_frame.received_info.time_received = GG_UINT64_C(0xF0E1D2C3B4A59687);
   ack_frame.received_info.missing_packets.insert(
       GG_UINT64_C(0x0123456789ABB));
@@ skipping 17 matching lines @@
   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,
-    // retransmission count
-    0x01,
     // transmission time
     0x87, 0x96, 0xA5, 0xB4,
     0xC3, 0xD2, 0xE1, 0xF0,
     // flags
     0x00,
     // fec group
     0x00,
 
     // frame count
     0x01,
@@ skipping 50 matching lines @@
 #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_.ConstructFragementDataPacket(header, frames, &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.retransmission_count = 0x01;
   header.packet_sequence_number = GG_UINT64_C(0x123456789ABC);
   header.transmission_time = GG_UINT64_C(0xF0E1D2C3B4A59687);
   header.flags = PACKET_FLAGS_NONE;
   header.fec_group = 0;
 
   QuicAckFrame ack_frame;
   ack_frame.received_info.largest_received = GG_UINT64_C(0x0123456789ABC);
   ack_frame.received_info.time_received = GG_UINT64_C(0xF0E1D2C3B4A59687);
   ack_frame.received_info.missing_packets.insert(
       GG_UINT64_C(0x0123456789ABB));
@@ skipping 19 matching lines @@
   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,
-    // retransmission count
-    0x01,
     // transmission time
     0x87, 0x96, 0xA5, 0xB4,
     0xC3, 0xD2, 0xE1, 0xF0,
     // flags
     0x00,
     // fec group
     0x00,
 
     // frame count
     0x01,
@@ skipping 52 matching lines @@
     0x02,
     // accumulated_number_of_lost_packets
     0x02, 0x03,
     // offset_time
     0x04, 0x05,
     // delta_time
     0x06, 0x07,
   };
 
   QuicPacket* data;
-  EXPECT_TRUE(framer_.ConstructFragementDataPacket(header, frames, &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.retransmission_count = 0x01;
   header.packet_sequence_number = GG_UINT64_C(0x123456789ABC);
   header.transmission_time = GG_UINT64_C(0xF0E1D2C3B4A59687);
   header.flags = PACKET_FLAGS_NONE;
   header.fec_group = 0;
 
   QuicAckFrame ack_frame;
   ack_frame.received_info.largest_received = GG_UINT64_C(0x0123456789ABC);
   ack_frame.received_info.time_received = GG_UINT64_C(0xF0E1D2C3B4A59687);
   ack_frame.received_info.missing_packets.insert(
       GG_UINT64_C(0x0123456789ABB));
@@ skipping 17 matching lines @@
   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,
-    // retransmission count
-    0x01,
     // transmission time
     0x87, 0x96, 0xA5, 0xB4,
     0xC3, 0xD2, 0xE1, 0xF0,
     // flags
     0x00,
     // fec group
     0x00,
 
     // frame count
     0x01,
@@ skipping 48 matching lines @@
     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_.ConstructFragementDataPacket(header, frames, &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.retransmission_count = 0x01;
   header.packet_sequence_number = GG_UINT64_C(0x123456789ABC);
   header.transmission_time = GG_UINT64_C(0xF0E1D2C3B4A59687);
   header.flags = PACKET_FLAGS_NONE;
   header.fec_group = 0;
 
   QuicAckFrame ack_frame;
   ack_frame.received_info.largest_received = GG_UINT64_C(0x0123456789ABC);
   ack_frame.received_info.time_received = GG_UINT64_C(0xF0E1D2C3B4A59687);
   ack_frame.received_info.missing_packets.insert(
       GG_UINT64_C(0x0123456789ABB));
@@ skipping 10 matching lines @@
       static_cast<CongestionFeedbackType>(kFixRate + 1);
 
   QuicFrame frame;
   frame.type = ACK_FRAME;
   frame.ack_frame = &ack_frame;
 
   QuicFrames frames;
   frames.push_back(frame);
 
   QuicPacket* data;
-  EXPECT_FALSE(framer_.ConstructFragementDataPacket(header, frames, &data));
+  EXPECT_FALSE(framer_.ConstructFrameDataPacket(header, frames, &data));
 }
 
 TEST_F(QuicFramerTest, ConstructRstFramePacket) {
   QuicPacketHeader header;
   header.guid = GG_UINT64_C(0xFEDCBA9876543210);
-  header.retransmission_count = 0x01;
   header.packet_sequence_number = GG_UINT64_C(0x123456789ABC);
   header.transmission_time = GG_UINT64_C(0xF0E1D2C3B4A59687);
   header.flags = PACKET_FLAGS_NONE;
   header.fec_group = 0;
 
   QuicRstStreamFrame rst_frame;
   rst_frame.stream_id = 0x01020304;
   rst_frame.error_code = static_cast<QuicErrorCode>(0x05060708);
   rst_frame.offset = GG_UINT64_C(0xBA98FEDC32107654);
   rst_frame.error_details = "because I can";
 
   unsigned char packet[] = {
     // guid
     0x10, 0x32, 0x54, 0x76,
     0x98, 0xBA, 0xDC, 0xFE,
     // packet id
     0xBC, 0x9A, 0x78, 0x56,
     0x34, 0x12,
-    // retransmission count
-    0x01,
     // transmission time
     0x87, 0x96, 0xA5, 0xB4,
     0xC3, 0xD2, 0xE1, 0xF0,
     // flags
     0x00,
     // fec group
     0x00,
 
     // frame count
     0x01,
@@ skipping 14 matching lines @@
     'I',  ' ',  'c',  'a',
     'n',
   };
 
   QuicFrame frame(&rst_frame);
 
   QuicFrames frames;
   frames.push_back(frame);
 
   QuicPacket* data;
-  EXPECT_TRUE(framer_.ConstructFragementDataPacket(header, frames, &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, ConstructCloseFramePacket) {
   QuicPacketHeader header;
   header.guid = GG_UINT64_C(0xFEDCBA9876543210);
-  header.retransmission_count = 0x01;
   header.packet_sequence_number = GG_UINT64_C(0x123456789ABC);
   header.transmission_time = GG_UINT64_C(0xF0E1D2C3B4A59687);
   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;
@@ skipping 21 matching lines @@
   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,
-    // retransmission count
-    0x01,
     // transmission time
     0x87, 0x96, 0xA5, 0xB4,
     0xC3, 0xD2, 0xE1, 0xF0,
     // flags
     0x00,
     // fec group
     0x00,
 
     // frame count
     0x01,
@@ skipping 64 matching lines @@
     0x02,
     // accumulated_number_of_lost_packets
     0x02, 0x03,
     // offset_time
     0x04, 0x05,
     // delta_time
     0x06, 0x07,
   };
 
   QuicPacket* data;
-  EXPECT_TRUE(framer_.ConstructFragementDataPacket(header, frames, &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, ConstructFecPacket) {
   QuicPacketHeader header;
   header.guid = GG_UINT64_C(0xFEDCBA9876543210);
-  header.retransmission_count = 0x01;
   header.packet_sequence_number = (GG_UINT64_C(0x123456789ABC));
   header.transmission_time = GG_UINT64_C(0xF0E1D2C3B4A59687);
   header.flags = PACKET_FLAGS_FEC;
   header.fec_group = 1;
 
   QuicFecData fec_data;
   fec_data.fec_group = 1;
   fec_data.min_protected_packet_sequence_number =
       GG_UINT64_C(0x123456789ABB);
   fec_data.redundancy = "abcdefghijklmnop";
 
   unsigned char packet[] = {
     // guid
     0x10, 0x32, 0x54, 0x76,
     0x98, 0xBA, 0xDC, 0xFE,
     // packet id
     0xBC, 0x9A, 0x78, 0x56,
     0x34, 0x12,
-    // retransmission count
-    0x01,
     // transmission time
     0x87, 0x96, 0xA5, 0xB4,
     0xC3, 0xD2, 0xE1, 0xF0,
     // flags
     0x01,
     // fec group
     0x01,
     // first protected packet
     0xBB, 0x9A, 0x78, 0x56,
     0x34, 0x12,
     // redundancy
     'a',  'b',  'c',  'd',
     'e',  'f',  'g',  'h',
     'i',  'j',  'k',  'l',
     'm',  'n',  'o',  'p',
   };
 
   QuicPacket* data;
   EXPECT_TRUE(framer_.ConstructFecPacket(header, fec_data, &data));
 
   test::CompareCharArraysWithHexError("constructed packet",
                                       data->data(), data->length(),
                                       AsChars(packet), arraysize(packet));
 
   delete data;
 }
 
-TEST_F(QuicFramerTest, IncrementRetransmitCount) {
-  QuicPacketHeader header;
-  header.guid = GG_UINT64_C(0xFEDCBA9876543210);
-  header.retransmission_count = 1;
-  header.packet_sequence_number = GG_UINT64_C(0x123456789ABC);
-  header.transmission_time = GG_UINT64_C(0xF0E1D2C3B4A59687);
-  header.flags = PACKET_FLAGS_NONE;
-  header.fec_group = 0;
-
-  QuicStreamFrame stream_frame;
-  stream_frame.stream_id = 0x01020304;
-  stream_frame.fin = true;
-  stream_frame.offset = GG_UINT64_C(0xBA98FEDC32107654);
-  stream_frame.data = "hello world!";
-
-  QuicFrame frame;
-  frame.type = STREAM_FRAME;
-  frame.stream_frame = &stream_frame;
-
-  QuicFrames frames;
-  frames.push_back(frame);
-
-  QuicPacket *original;
-  ASSERT_TRUE(framer_.ConstructFragementDataPacket(
-      header, frames, &original));
-  EXPECT_EQ(header.retransmission_count, framer_.GetRetransmitCount(original));
-
-  header.retransmission_count = 2;
-  QuicPacket *retransmitted;
-  ASSERT_TRUE(framer_.ConstructFragementDataPacket(
-      header, frames, &retransmitted));
-
-  framer_.IncrementRetransmitCount(original);
-  EXPECT_EQ(header.retransmission_count, framer_.GetRetransmitCount(original));
-
-  test::CompareCharArraysWithHexError(
-      "constructed packet", original->data(), original->length(),
-      retransmitted->data(), retransmitted->length());
-  delete original;
-  delete retransmitted;
-}
-
 TEST_F(QuicFramerTest, EncryptPacket) {
   unsigned char packet[] = {
     // guid
     0x10, 0x32, 0x54, 0x76,
     0x98, 0xBA, 0xDC, 0xFE,
     // packet id
     0xBC, 0x9A, 0x78, 0x56,
     0x34, 0x12,
-    // retransmission count
-    0x01,
     // transmission time
     0x87, 0x96, 0xA5, 0xB4,
     0xC3, 0xD2, 0xE1, 0xF0,
     // flags
     0x01,
     // fec group
     0x01,
     // first protected packet
     0xBB, 0x9A, 0x78, 0x56,
     0x34, 0x12,
     // redundancy
     'a',  'b',  'c',  'd',
     'e',  'f',  'g',  'h',
     'i',  'j',  'k',  'l',
     'm',  'n',  'o',  'p',
   };
 
-  QuicPacket raw(AsChars(packet), arraysize(packet), false);
+  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