Remove //net (except for Android test stuff) and sdch

net/quic/quic_packet_creator_test.cc

Index: net/quic/quic_packet_creator_test.cc
diff --git a/net/quic/quic_packet_creator_test.cc b/net/quic/quic_packet_creator_test.cc
deleted file mode 100644
index 84632cf89f7e97c06aa9e9ba19cbdc2cbd404d70..0000000000000000000000000000000000000000
--- a/net/quic/quic_packet_creator_test.cc
+++ /dev/null
@@ -1,1056 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "net/quic/quic_packet_creator.h"
-
-#include "base/stl_util.h"
-#include "net/quic/crypto/null_encrypter.h"
-#include "net/quic/crypto/quic_decrypter.h"
-#include "net/quic/crypto/quic_encrypter.h"
-#include "net/quic/quic_utils.h"
-#include "net/quic/test_tools/mock_random.h"
-#include "net/quic/test_tools/quic_framer_peer.h"
-#include "net/quic/test_tools/quic_packet_creator_peer.h"
-#include "net/quic/test_tools/quic_test_utils.h"
-#include "net/test/gtest_util.h"
-#include "testing/gmock/include/gmock/gmock.h"
-
-using base::StringPiece;
-using std::ostream;
-using std::string;
-using std::vector;
-using testing::DoAll;
-using testing::InSequence;
-using testing::Return;
-using testing::SaveArg;
-using testing::_;
-
-namespace net {
-namespace test {
-namespace {
-
-// Run tests with combinations of {QuicVersion, ToggleVersionSerialization}.
-struct TestParams {
-  TestParams(QuicVersion version,
-             bool version_serialization,
-             QuicConnectionIdLength length)
-      : version(version),
-        connection_id_length(length),
-        version_serialization(version_serialization) {
-  }
-
-  friend ostream& operator<<(ostream& os, const TestParams& p) {
-    os << "{ client_version: " << QuicVersionToString(p.version)
-       << " connection id length: " << p.connection_id_length
-       << " include version: " << p.version_serialization << " }";
-    return os;
-  }
-
-  QuicVersion version;
-  QuicConnectionIdLength connection_id_length;
-  bool version_serialization;
-};
-
-// Constructs various test permutations.
-vector<TestParams> GetTestParams() {
-  vector<TestParams> params;
-  QuicConnectionIdLength max = PACKET_8BYTE_CONNECTION_ID;
-  QuicVersionVector all_supported_versions = QuicSupportedVersions();
-  for (size_t i = 0; i < all_supported_versions.size(); ++i) {
-    params.push_back(TestParams(all_supported_versions[i], true, max));
-    params.push_back(TestParams(all_supported_versions[i], false, max));
-  }
-  params.push_back(TestParams(
-      all_supported_versions[0], true, PACKET_0BYTE_CONNECTION_ID));
-  params.push_back(TestParams(
-      all_supported_versions[0], true, PACKET_1BYTE_CONNECTION_ID));
-  params.push_back(TestParams(
-      all_supported_versions[0], true, PACKET_4BYTE_CONNECTION_ID));
-  return params;
-}
-
-class QuicPacketCreatorTest : public ::testing::TestWithParam<TestParams> {
- protected:
-  QuicPacketCreatorTest()
-      : server_framer_(SupportedVersions(GetParam().version), QuicTime::Zero(),
-                       true),
-        client_framer_(SupportedVersions(GetParam().version), QuicTime::Zero(),
-                       false),
-        sequence_number_(0),
-        connection_id_(2),
-        data_("foo"),
-        creator_(connection_id_, &client_framer_, &mock_random_) {
-    creator_.set_connection_id_length(GetParam().connection_id_length);
-    client_framer_.set_visitor(&framer_visitor_);
-    client_framer_.set_received_entropy_calculator(&entropy_calculator_);
-    server_framer_.set_visitor(&framer_visitor_);
-  }
-
-  ~QuicPacketCreatorTest() override {}
-
-  void ProcessPacket(QuicEncryptedPacket* encrypted) {
-    server_framer_.ProcessPacket(*encrypted);
-  }
-
-  void CheckStreamFrame(const QuicFrame& frame,
-                        QuicStreamId stream_id,
-                        const string& data,
-                        QuicStreamOffset offset,
-                        bool fin) {
-    EXPECT_EQ(STREAM_FRAME, frame.type);
-    ASSERT_TRUE(frame.stream_frame);
-    EXPECT_EQ(stream_id, frame.stream_frame->stream_id);
-    scoped_ptr<string> frame_data(frame.stream_frame->GetDataAsString());
-    EXPECT_EQ(data, *frame_data);
-    EXPECT_EQ(offset, frame.stream_frame->offset);
-    EXPECT_EQ(fin, frame.stream_frame->fin);
-  }
-
-  // Returns the number of bytes consumed by the header of packet, including
-  // the version.
-  size_t GetPacketHeaderOverhead(InFecGroup is_in_fec_group) {
-    return GetPacketHeaderSize(creator_.connection_id_length(),
-                               kIncludeVersion,
-                               creator_.next_sequence_number_length(),
-                               is_in_fec_group);
-  }
-
-  // Returns the number of bytes of overhead that will be added to a packet
-  // of maximum length.
-  size_t GetEncryptionOverhead() {
-    return creator_.max_packet_length() - client_framer_.GetMaxPlaintextSize(
-        creator_.max_packet_length());
-  }
-
-  // Returns the number of bytes consumed by the non-data fields of a stream
-  // frame, assuming it is the last frame in the packet
-  size_t GetStreamFrameOverhead(InFecGroup is_in_fec_group) {
-    return QuicFramer::GetMinStreamFrameSize(kClientDataStreamId1, kOffset,
-                                             true, is_in_fec_group);
-  }
-
-  // Enables and turns on FEC protection. Returns true if FEC protection is on.
-  bool SwitchFecProtectionOn(size_t max_packets_per_fec_group) {
-    creator_.set_max_packets_per_fec_group(max_packets_per_fec_group);
-    creator_.StartFecProtectingPackets();
-    return creator_.IsFecProtected();
-  }
-
-  static const QuicStreamOffset kOffset = 1u;
-
-  QuicFrames frames_;
-  QuicFramer server_framer_;
-  QuicFramer client_framer_;
-  testing::StrictMock<MockFramerVisitor> framer_visitor_;
-  QuicPacketSequenceNumber sequence_number_;
-  QuicConnectionId connection_id_;
-  string data_;
-  MockRandom mock_random_;
-  QuicPacketCreator creator_;
-  MockEntropyCalculator entropy_calculator_;
-};
-
-// Run all packet creator tests with all supported versions of QUIC, and with
-// and without version in the packet header, as well as doing a run for each
-// length of truncated connection id.
-INSTANTIATE_TEST_CASE_P(QuicPacketCreatorTests,
-                        QuicPacketCreatorTest,
-                        ::testing::ValuesIn(GetTestParams()));
-
-TEST_P(QuicPacketCreatorTest, SerializeFrames) {
-  frames_.push_back(QuicFrame(new QuicAckFrame(MakeAckFrame(0u))));
-  frames_.push_back(QuicFrame(new QuicStreamFrame(0u, false, 0u, IOVector())));
-  frames_.push_back(QuicFrame(new QuicStreamFrame(0u, true, 0u, IOVector())));
-  SerializedPacket serialized = creator_.SerializeAllFrames(frames_);
-  delete frames_[0].ack_frame;
-  delete frames_[1].stream_frame;
-  delete frames_[2].stream_frame;
-
-  {
-    InSequence s;
-    EXPECT_CALL(framer_visitor_, OnPacket());
-    EXPECT_CALL(framer_visitor_, OnUnauthenticatedPublicHeader(_));
-    EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_));
-    EXPECT_CALL(framer_visitor_, OnDecryptedPacket(_));
-    EXPECT_CALL(framer_visitor_, OnPacketHeader(_));
-    EXPECT_CALL(framer_visitor_, OnAckFrame(_));
-    EXPECT_CALL(framer_visitor_, OnStreamFrame(_));
-    EXPECT_CALL(framer_visitor_, OnStreamFrame(_));
-    EXPECT_CALL(framer_visitor_, OnPacketComplete());
-  }
-  ProcessPacket(serialized.packet);
-  delete serialized.packet;
-}
-
-TEST_P(QuicPacketCreatorTest, SerializeWithFEC) {
-  // Enable FEC protection, and send FEC packet every 6 packets.
-  EXPECT_TRUE(SwitchFecProtectionOn(6));
-  // Should return false since we do not have enough packets in the FEC group to
-  // trigger an FEC packet.
-  ASSERT_FALSE(creator_.ShouldSendFec(/*force_close=*/false));
-
-  frames_.push_back(QuicFrame(new QuicStreamFrame(0u, false, 0u, IOVector())));
-  SerializedPacket serialized = creator_.SerializeAllFrames(frames_);
-  delete frames_[0].stream_frame;
-
-  {
-    InSequence s;
-    EXPECT_CALL(framer_visitor_, OnPacket());
-    EXPECT_CALL(framer_visitor_, OnUnauthenticatedPublicHeader(_));
-    EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_));
-    EXPECT_CALL(framer_visitor_, OnDecryptedPacket(_));
-    EXPECT_CALL(framer_visitor_, OnPacketHeader(_));
-    EXPECT_CALL(framer_visitor_, OnFecProtectedPayload(_));
-    EXPECT_CALL(framer_visitor_, OnStreamFrame(_));
-    EXPECT_CALL(framer_visitor_, OnPacketComplete());
-  }
-  ProcessPacket(serialized.packet);
-  delete serialized.packet;
-
-  // Should return false since we do not have enough packets in the FEC group to
-  // trigger an FEC packet.
-  ASSERT_FALSE(creator_.ShouldSendFec(/*force_close=*/false));
-  // Should return true since there are packets in the FEC group.
-  ASSERT_TRUE(creator_.ShouldSendFec(/*force_close=*/true));
-
-  serialized = creator_.SerializeFec();
-  ASSERT_EQ(2u, serialized.sequence_number);
-  {
-    InSequence s;
-    EXPECT_CALL(framer_visitor_, OnPacket());
-    EXPECT_CALL(framer_visitor_, OnUnauthenticatedPublicHeader(_));
-    EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_));
-    EXPECT_CALL(framer_visitor_, OnDecryptedPacket(_));
-    EXPECT_CALL(framer_visitor_, OnPacketHeader(_));
-    EXPECT_CALL(framer_visitor_, OnFecData(_));
-    EXPECT_CALL(framer_visitor_, OnPacketComplete());
-  }
-  ProcessPacket(serialized.packet);
-  delete serialized.packet;
-}
-
-TEST_P(QuicPacketCreatorTest, SerializeChangingSequenceNumberLength) {
-  frames_.push_back(QuicFrame(new QuicAckFrame(MakeAckFrame(0u))));
-  creator_.AddSavedFrame(frames_[0]);
-  creator_.set_next_sequence_number_length(PACKET_4BYTE_SEQUENCE_NUMBER);
-  SerializedPacket serialized = creator_.SerializePacket();
-  // The sequence number length will not change mid-packet.
-  EXPECT_EQ(PACKET_1BYTE_SEQUENCE_NUMBER, serialized.sequence_number_length);
-
-  {
-    InSequence s;
-    EXPECT_CALL(framer_visitor_, OnPacket());
-    EXPECT_CALL(framer_visitor_, OnUnauthenticatedPublicHeader(_));
-    EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_));
-    EXPECT_CALL(framer_visitor_, OnDecryptedPacket(_));
-    EXPECT_CALL(framer_visitor_, OnPacketHeader(_));
-    EXPECT_CALL(framer_visitor_, OnAckFrame(_));
-    EXPECT_CALL(framer_visitor_, OnPacketComplete());
-  }
-  ProcessPacket(serialized.packet);
-  delete serialized.packet;
-
-  creator_.AddSavedFrame(frames_[0]);
-  serialized = creator_.SerializePacket();
-  // Now the actual sequence number length should have changed.
-  EXPECT_EQ(PACKET_4BYTE_SEQUENCE_NUMBER, serialized.sequence_number_length);
-  delete frames_[0].ack_frame;
-
-  {
-    InSequence s;
-    EXPECT_CALL(framer_visitor_, OnPacket());
-    EXPECT_CALL(framer_visitor_, OnUnauthenticatedPublicHeader(_));
-    EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_));
-    EXPECT_CALL(framer_visitor_, OnDecryptedPacket(_));
-    EXPECT_CALL(framer_visitor_, OnPacketHeader(_));
-    EXPECT_CALL(framer_visitor_, OnAckFrame(_));
-    EXPECT_CALL(framer_visitor_, OnPacketComplete());
-  }
-  ProcessPacket(serialized.packet);
-  delete serialized.packet;
-}
-
-TEST_P(QuicPacketCreatorTest, ChangeSequenceNumberLengthMidPacket) {
-  // Changing the sequence number length with queued frames in the creator
-  // should hold the change until after any currently queued frames are
-  // serialized.
-
-  // Packet 1.
-  // Queue a frame in the creator.
-  EXPECT_FALSE(creator_.HasPendingFrames());
-  QuicFrame ack_frame = QuicFrame(new QuicAckFrame(MakeAckFrame(0u)));
-  creator_.AddSavedFrame(ack_frame);
-
-  // Now change sequence number length.
-  creator_.set_next_sequence_number_length(PACKET_4BYTE_SEQUENCE_NUMBER);
-
-  // Add a STOP_WAITING frame since it contains a packet sequence number,
-  // whose length should be 1.
-  QuicStopWaitingFrame stop_waiting_frame;
-  EXPECT_TRUE(creator_.AddSavedFrame(QuicFrame(&stop_waiting_frame)));
-  EXPECT_TRUE(creator_.HasPendingFrames());
-
-  // Ensure the packet is successfully created.
-  SerializedPacket serialized = creator_.SerializePacket();
-  ASSERT_TRUE(serialized.packet);
-  EXPECT_EQ(PACKET_1BYTE_SEQUENCE_NUMBER, serialized.sequence_number_length);
-
-  // Verify that header in transmitted packet has 1 byte sequence length.
-  QuicPacketHeader header;
-  {
-    InSequence s;
-    EXPECT_CALL(framer_visitor_, OnPacket());
-    EXPECT_CALL(framer_visitor_, OnUnauthenticatedPublicHeader(_));
-    EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_));
-    EXPECT_CALL(framer_visitor_, OnDecryptedPacket(_));
-    EXPECT_CALL(framer_visitor_, OnPacketHeader(_)).WillOnce(
-        DoAll(SaveArg<0>(&header), Return(true)));
-    EXPECT_CALL(framer_visitor_, OnAckFrame(_));
-    EXPECT_CALL(framer_visitor_, OnStopWaitingFrame(_));
-    EXPECT_CALL(framer_visitor_, OnPacketComplete());
-  }
-  ProcessPacket(serialized.packet);
-  EXPECT_EQ(PACKET_1BYTE_SEQUENCE_NUMBER,
-            header.public_header.sequence_number_length);
-  delete serialized.packet;
-
-  // Packet 2.
-  EXPECT_FALSE(creator_.HasPendingFrames());
-  // Generate Packet 2 with one frame -- sequence number length should now
-  // change to 4 bytes.
-  EXPECT_TRUE(creator_.AddSavedFrame(QuicFrame(&stop_waiting_frame)));
-  EXPECT_TRUE(creator_.HasPendingFrames());
-
-  // Ensure the packet is successfully created.
-  serialized = creator_.SerializePacket();
-  ASSERT_TRUE(serialized.packet);
-  EXPECT_EQ(PACKET_4BYTE_SEQUENCE_NUMBER, serialized.sequence_number_length);
-
-  // Verify that header in transmitted packet has 4 byte sequence length.
-  {
-    InSequence s;
-    EXPECT_CALL(framer_visitor_, OnPacket());
-    EXPECT_CALL(framer_visitor_, OnUnauthenticatedPublicHeader(_));
-    EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_));
-    EXPECT_CALL(framer_visitor_, OnDecryptedPacket(_));
-    EXPECT_CALL(framer_visitor_, OnPacketHeader(_)).WillOnce(
-        DoAll(SaveArg<0>(&header), Return(true)));
-    EXPECT_CALL(framer_visitor_, OnStopWaitingFrame(_));
-    EXPECT_CALL(framer_visitor_, OnPacketComplete());
-  }
-  ProcessPacket(serialized.packet);
-  EXPECT_EQ(PACKET_4BYTE_SEQUENCE_NUMBER,
-            header.public_header.sequence_number_length);
-
-  delete serialized.packet;
-  delete ack_frame.ack_frame;
-}
-
-TEST_P(QuicPacketCreatorTest, SerializeWithFECChangingSequenceNumberLength) {
-  // Test goal is to test the following sequence (P1 => generate Packet 1):
-  // P1 <change seq num length> P2 FEC,
-  // and we expect that sequence number length should not change until the end
-  // of the open FEC group.
-
-  // Enable FEC protection, and send FEC packet every 6 packets.
-  EXPECT_TRUE(SwitchFecProtectionOn(6));
-  // Should return false since we do not have enough packets in the FEC group to
-  // trigger an FEC packet.
-  ASSERT_FALSE(creator_.ShouldSendFec(/*force_close=*/false));
-  frames_.push_back(QuicFrame(new QuicAckFrame(MakeAckFrame(0u))));
-
-  // Generate Packet 1.
-  creator_.AddSavedFrame(frames_[0]);
-  // Change the sequence number length mid-FEC group and it should not change.
-  creator_.set_next_sequence_number_length(PACKET_4BYTE_SEQUENCE_NUMBER);
-  SerializedPacket serialized = creator_.SerializePacket();
-  EXPECT_EQ(PACKET_1BYTE_SEQUENCE_NUMBER, serialized.sequence_number_length);
-
-  {
-    InSequence s;
-    EXPECT_CALL(framer_visitor_, OnPacket());
-    EXPECT_CALL(framer_visitor_, OnUnauthenticatedPublicHeader(_));
-    EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_));
-    EXPECT_CALL(framer_visitor_, OnDecryptedPacket(_));
-    EXPECT_CALL(framer_visitor_, OnPacketHeader(_));
-    EXPECT_CALL(framer_visitor_, OnFecProtectedPayload(_));
-    EXPECT_CALL(framer_visitor_, OnAckFrame(_));
-    EXPECT_CALL(framer_visitor_, OnPacketComplete());
-  }
-  ProcessPacket(serialized.packet);
-  delete serialized.packet;
-
-  // Generate Packet 2.
-  creator_.AddSavedFrame(frames_[0]);
-  serialized = creator_.SerializePacket();
-  EXPECT_EQ(PACKET_1BYTE_SEQUENCE_NUMBER, serialized.sequence_number_length);
-
-  {
-    InSequence s;
-    EXPECT_CALL(framer_visitor_, OnPacket());
-    EXPECT_CALL(framer_visitor_, OnUnauthenticatedPublicHeader(_));
-    EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_));
-    EXPECT_CALL(framer_visitor_, OnDecryptedPacket(_));
-    EXPECT_CALL(framer_visitor_, OnPacketHeader(_));
-    EXPECT_CALL(framer_visitor_, OnFecProtectedPayload(_));
-    EXPECT_CALL(framer_visitor_, OnAckFrame(_));
-    EXPECT_CALL(framer_visitor_, OnPacketComplete());
-  }
-  ProcessPacket(serialized.packet);
-  delete serialized.packet;
-
-  // Should return false since we do not have enough packets in the FEC group to
-  // trigger an FEC packet.
-  ASSERT_FALSE(creator_.ShouldSendFec(/*force_close=*/false));
-  // Should return true since there are packets in the FEC group.
-  ASSERT_TRUE(creator_.ShouldSendFec(/*force_close=*/true));
-
-  // Force generation of FEC packet.
-  serialized = creator_.SerializeFec();
-  EXPECT_EQ(PACKET_1BYTE_SEQUENCE_NUMBER, serialized.sequence_number_length);
-  ASSERT_EQ(3u, serialized.sequence_number);
-
-  {
-    InSequence s;
-    EXPECT_CALL(framer_visitor_, OnPacket());
-    EXPECT_CALL(framer_visitor_, OnUnauthenticatedPublicHeader(_));
-    EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_));
-    EXPECT_CALL(framer_visitor_, OnDecryptedPacket(_));
-    EXPECT_CALL(framer_visitor_, OnPacketHeader(_));
-    EXPECT_CALL(framer_visitor_, OnFecData(_));
-    EXPECT_CALL(framer_visitor_, OnPacketComplete());
-  }
-  ProcessPacket(serialized.packet);
-  delete serialized.packet;
-
-  // Ensure the next FEC group starts using the new sequence number length.
-  serialized = creator_.SerializeAllFrames(frames_);
-  EXPECT_EQ(PACKET_4BYTE_SEQUENCE_NUMBER, serialized.sequence_number_length);
-  delete frames_[0].ack_frame;
-  delete serialized.packet;
-}
-
-TEST_P(QuicPacketCreatorTest, ReserializeFramesWithSequenceNumberLength) {
-  // If the original packet sequence number length, the current sequence number
-  // length, and the configured send sequence number length are different, the
-  // retransmit must sent with the original length and the others do not change.
-  creator_.set_next_sequence_number_length(PACKET_4BYTE_SEQUENCE_NUMBER);
-  QuicPacketCreatorPeer::SetSequenceNumberLength(&creator_,
-                                                 PACKET_2BYTE_SEQUENCE_NUMBER);
-  QuicStreamFrame* stream_frame =
-      new QuicStreamFrame(kCryptoStreamId, /*fin=*/false, 0u, IOVector());
-  RetransmittableFrames frames;
-  frames.set_encryption_level(ENCRYPTION_NONE);
-  frames.AddStreamFrame(stream_frame);
-  SerializedPacket serialized =
-      creator_.ReserializeAllFrames(frames, PACKET_1BYTE_SEQUENCE_NUMBER);
-  EXPECT_EQ(PACKET_4BYTE_SEQUENCE_NUMBER,
-            creator_.next_sequence_number_length());
-  EXPECT_EQ(PACKET_2BYTE_SEQUENCE_NUMBER,
-            QuicPacketCreatorPeer::GetSequenceNumberLength(&creator_));
-  EXPECT_EQ(PACKET_1BYTE_SEQUENCE_NUMBER, serialized.sequence_number_length);
-
-  {
-    InSequence s;
-    EXPECT_CALL(framer_visitor_, OnPacket());
-    EXPECT_CALL(framer_visitor_, OnUnauthenticatedPublicHeader(_));
-    EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_));
-    EXPECT_CALL(framer_visitor_, OnDecryptedPacket(_));
-    EXPECT_CALL(framer_visitor_, OnPacketHeader(_));
-    EXPECT_CALL(framer_visitor_, OnStreamFrame(_));
-    EXPECT_CALL(framer_visitor_, OnPacketComplete());
-  }
-  ProcessPacket(serialized.packet);
-  delete serialized.packet;
-}
-
-TEST_P(QuicPacketCreatorTest, ReserializeFramesWithPadding) {
-  QuicStreamFrame* stream_frame =
-      new QuicStreamFrame(kCryptoStreamId, /*fin=*/false, /*offset=*/0,
-                          MakeIOVector("fake handshake message data"));
-  RetransmittableFrames frames;
-  frames.set_encryption_level(ENCRYPTION_NONE);
-  frames.AddStreamFrame(stream_frame);
-  SerializedPacket serialized = creator_.ReserializeAllFrames(
-      frames, creator_.next_sequence_number_length());
-  EXPECT_EQ(kDefaultMaxPacketSize, serialized.packet->length());
-  delete serialized.packet;
-}
-
-TEST_P(QuicPacketCreatorTest, ReserializeFramesWithFullPacketAndPadding) {
-  const size_t overhead = GetPacketHeaderOverhead(NOT_IN_FEC_GROUP)
-      + GetEncryptionOverhead() + GetStreamFrameOverhead(NOT_IN_FEC_GROUP);
-  size_t capacity = kDefaultMaxPacketSize - overhead;
-  for (int delta = -5; delta <= 0; ++delta) {
-    string data(capacity + delta, 'A');
-    size_t bytes_free = 0 - delta;
-
-    QuicStreamFrame* stream_frame = new QuicStreamFrame(
-        kCryptoStreamId, /*fin=*/false, kOffset, MakeIOVector(data));
-    RetransmittableFrames frames;
-    frames.set_encryption_level(ENCRYPTION_NONE);
-    frames.AddStreamFrame(stream_frame);
-    SerializedPacket serialized = creator_.ReserializeAllFrames(
-        frames, creator_.next_sequence_number_length());
-
-    // If there is not enough space in the packet to fit a padding frame
-    // (1 byte) and to expand the stream frame (another 2 bytes) the packet
-    // will not be padded.
-    if (bytes_free < 3) {
-      EXPECT_EQ(kDefaultMaxPacketSize - bytes_free,
-                serialized.packet->length());
-    } else {
-      EXPECT_EQ(kDefaultMaxPacketSize, serialized.packet->length());
-    }
-
-    delete serialized.packet;
-    frames_.clear();
-  }
-}
-
-TEST_P(QuicPacketCreatorTest, SerializeConnectionClose) {
-  QuicConnectionCloseFrame frame;
-  frame.error_code = QUIC_NO_ERROR;
-  frame.error_details = "error";
-
-  SerializedPacket serialized = creator_.SerializeConnectionClose(&frame);
-  ASSERT_EQ(1u, serialized.sequence_number);
-  ASSERT_EQ(1u, creator_.sequence_number());
-
-  InSequence s;
-  EXPECT_CALL(framer_visitor_, OnPacket());
-  EXPECT_CALL(framer_visitor_, OnUnauthenticatedPublicHeader(_));
-  EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_));
-  EXPECT_CALL(framer_visitor_, OnDecryptedPacket(_));
-  EXPECT_CALL(framer_visitor_, OnPacketHeader(_));
-  EXPECT_CALL(framer_visitor_, OnConnectionCloseFrame(_));
-  EXPECT_CALL(framer_visitor_, OnPacketComplete());
-
-  ProcessPacket(serialized.packet);
-  delete serialized.packet;
-}
-
-TEST_P(QuicPacketCreatorTest, SwitchFecOnOffWithNoGroup) {
-  // Enable FEC protection.
-  creator_.set_max_packets_per_fec_group(6);
-  EXPECT_TRUE(creator_.IsFecEnabled());
-  EXPECT_FALSE(creator_.IsFecProtected());
-
-  // Turn on FEC protection.
-  creator_.StartFecProtectingPackets();
-  EXPECT_TRUE(creator_.IsFecProtected());
-  // We have no packets in the FEC group, so no FEC packet can be created.
-  EXPECT_FALSE(creator_.ShouldSendFec(/*force_close=*/true));
-  // Since no packets are in FEC group yet, we should be able to turn FEC
-  // off with no trouble.
-  creator_.StopFecProtectingPackets();
-  EXPECT_FALSE(creator_.IsFecProtected());
-}
-
-TEST_P(QuicPacketCreatorTest, SwitchFecOnOffWithGroupInProgress) {
-  // Enable FEC protection, and send FEC packet every 6 packets.
-  EXPECT_TRUE(SwitchFecProtectionOn(6));
-  frames_.push_back(QuicFrame(new QuicStreamFrame(0u, false, 0u, IOVector())));
-  SerializedPacket serialized = creator_.SerializeAllFrames(frames_);
-  delete frames_[0].stream_frame;
-  delete serialized.packet;
-
-  EXPECT_TRUE(creator_.IsFecProtected());
-  // We do not have enough packets in the FEC group to trigger an FEC packet.
-  EXPECT_FALSE(creator_.ShouldSendFec(/*force_close=*/false));
-  // Should return true since there are packets in the FEC group.
-  EXPECT_TRUE(creator_.ShouldSendFec(/*force_close=*/true));
-
-  // Switching FEC off should not change creator state, since there is an
-  // FEC packet under construction.
-  EXPECT_DFATAL(creator_.StopFecProtectingPackets(),
-                "Cannot stop FEC protection with open FEC group.");
-  EXPECT_TRUE(creator_.IsFecProtected());
-  // Confirm that FEC packet is still under construction.
-  EXPECT_TRUE(creator_.ShouldSendFec(/*force_close=*/true));
-
-  serialized = creator_.SerializeFec();
-  delete serialized.packet;
-
-  // Switching FEC on/off should work now.
-  creator_.StopFecProtectingPackets();
-  EXPECT_FALSE(creator_.IsFecProtected());
-  creator_.StartFecProtectingPackets();
-  EXPECT_TRUE(creator_.IsFecProtected());
-}
-
-TEST_P(QuicPacketCreatorTest, SwitchFecOnWithStreamFrameQueued) {
-  // Add a stream frame to the creator.
-  QuicFrame frame;
-  size_t consumed = creator_.CreateStreamFrame(
-      1u, MakeIOVector("test"), 0u, false, &frame);
-  EXPECT_EQ(4u, consumed);
-  ASSERT_TRUE(frame.stream_frame);
-  EXPECT_TRUE(creator_.AddSavedFrame(frame));
-  EXPECT_TRUE(creator_.HasPendingFrames());
-
-  // Enable FEC protection, and send FEC packet every 6 packets.
-  creator_.set_max_packets_per_fec_group(6);
-  EXPECT_TRUE(creator_.IsFecEnabled());
-  EXPECT_DFATAL(creator_.StartFecProtectingPackets(),
-                "Cannot start FEC protection with pending frames.");
-  EXPECT_FALSE(creator_.IsFecProtected());
-
-  // Serialize packet for transmission.
-  SerializedPacket serialized = creator_.SerializePacket();
-  delete serialized.packet;
-  delete serialized.retransmittable_frames;
-  EXPECT_FALSE(creator_.HasPendingFrames());
-
-  // Since all pending frames have been serialized, turning FEC on should work.
-  creator_.StartFecProtectingPackets();
-  EXPECT_TRUE(creator_.IsFecProtected());
-}
-
-TEST_P(QuicPacketCreatorTest, CreateStreamFrame) {
-  QuicFrame frame;
-  size_t consumed = creator_.CreateStreamFrame(1u, MakeIOVector("test"), 0u,
-                                               false, &frame);
-  EXPECT_EQ(4u, consumed);
-  CheckStreamFrame(frame, 1u, "test", 0u, false);
-  delete frame.stream_frame;
-}
-
-TEST_P(QuicPacketCreatorTest, CreateStreamFrameFin) {
-  QuicFrame frame;
-  size_t consumed = creator_.CreateStreamFrame(1u, MakeIOVector("test"), 10u,
-                                               true, &frame);
-  EXPECT_EQ(4u, consumed);
-  CheckStreamFrame(frame, 1u, "test", 10u, true);
-  delete frame.stream_frame;
-}
-
-TEST_P(QuicPacketCreatorTest, CreateStreamFrameFinOnly) {
-  QuicFrame frame;
-  size_t consumed = creator_.CreateStreamFrame(1u, IOVector(), 0u, true,
-                                               &frame);
-  EXPECT_EQ(0u, consumed);
-  CheckStreamFrame(frame, 1u, string(), 0u, true);
-  delete frame.stream_frame;
-}
-
-TEST_P(QuicPacketCreatorTest, CreateAllFreeBytesForStreamFrames) {
-  const size_t overhead = GetPacketHeaderOverhead(NOT_IN_FEC_GROUP)
-                          + GetEncryptionOverhead();
-  for (size_t i = overhead; i < overhead + 100; ++i) {
-    creator_.set_max_packet_length(i);
-    const bool should_have_room = i > overhead + GetStreamFrameOverhead(
-        NOT_IN_FEC_GROUP);
-    ASSERT_EQ(should_have_room, creator_.HasRoomForStreamFrame(
-                                    kClientDataStreamId1, kOffset));
-    if (should_have_room) {
-      QuicFrame frame;
-      size_t bytes_consumed = creator_.CreateStreamFrame(
-          kClientDataStreamId1, MakeIOVector("testdata"), kOffset, false,
-          &frame);
-      EXPECT_LT(0u, bytes_consumed);
-      ASSERT_TRUE(creator_.AddSavedFrame(frame));
-      SerializedPacket serialized_packet = creator_.SerializePacket();
-      ASSERT_TRUE(serialized_packet.packet);
-      delete serialized_packet.packet;
-      delete serialized_packet.retransmittable_frames;
-    }
-  }
-}
-
-TEST_P(QuicPacketCreatorTest, StreamFrameConsumption) {
-  // Compute the total overhead for a single frame in packet.
-  const size_t overhead = GetPacketHeaderOverhead(NOT_IN_FEC_GROUP)
-      + GetEncryptionOverhead() + GetStreamFrameOverhead(NOT_IN_FEC_GROUP);
-  size_t capacity = kDefaultMaxPacketSize - overhead;
-  // Now, test various sizes around this size.
-  for (int delta = -5; delta <= 5; ++delta) {
-    string data(capacity + delta, 'A');
-    size_t bytes_free = delta > 0 ? 0 : 0 - delta;
-    QuicFrame frame;
-    size_t bytes_consumed = creator_.CreateStreamFrame(
-        kClientDataStreamId1, MakeIOVector(data), kOffset, false, &frame);
-    EXPECT_EQ(capacity - bytes_free, bytes_consumed);
-
-    ASSERT_TRUE(creator_.AddSavedFrame(frame));
-    // BytesFree() returns bytes available for the next frame, which will
-    // be two bytes smaller since the stream frame would need to be grown.
-    EXPECT_EQ(2u, creator_.ExpansionOnNewFrame());
-    size_t expected_bytes_free = bytes_free < 3 ? 0 : bytes_free - 2;
-    EXPECT_EQ(expected_bytes_free, creator_.BytesFree()) << "delta: " << delta;
-    SerializedPacket serialized_packet = creator_.SerializePacket();
-    ASSERT_TRUE(serialized_packet.packet);
-    delete serialized_packet.packet;
-    delete serialized_packet.retransmittable_frames;
-  }
-}
-
-TEST_P(QuicPacketCreatorTest, StreamFrameConsumptionWithFec) {
-  // Enable FEC protection, and send FEC packet every 6 packets.
-  EXPECT_TRUE(SwitchFecProtectionOn(6));
-  // Compute the total overhead for a single frame in packet.
-  const size_t overhead = GetPacketHeaderOverhead(IN_FEC_GROUP)
-      + GetEncryptionOverhead() + GetStreamFrameOverhead(IN_FEC_GROUP);
-  size_t capacity = kDefaultMaxPacketSize - overhead;
-  // Now, test various sizes around this size.
-  for (int delta = -5; delta <= 5; ++delta) {
-    string data(capacity + delta, 'A');
-    size_t bytes_free = delta > 0 ? 0 : 0 - delta;
-    QuicFrame frame;
-    size_t bytes_consumed = creator_.CreateStreamFrame(
-        kClientDataStreamId1, MakeIOVector(data), kOffset, false, &frame);
-    EXPECT_EQ(capacity - bytes_free, bytes_consumed);
-
-    ASSERT_TRUE(creator_.AddSavedFrame(frame));
-    // BytesFree() returns bytes available for the next frame. Since stream
-    // frame does not grow for FEC protected packets, this should be the same
-    // as bytes_free (bound by 0).
-    EXPECT_EQ(0u, creator_.ExpansionOnNewFrame());
-    size_t expected_bytes_free = bytes_free > 0 ? bytes_free : 0;
-    EXPECT_EQ(expected_bytes_free, creator_.BytesFree()) << "delta: " << delta;
-    SerializedPacket serialized_packet = creator_.SerializePacket();
-    ASSERT_TRUE(serialized_packet.packet);
-    delete serialized_packet.packet;
-    delete serialized_packet.retransmittable_frames;
-  }
-}
-
-TEST_P(QuicPacketCreatorTest, CryptoStreamFramePacketPadding) {
-  // Compute the total overhead for a single frame in packet.
-  const size_t overhead = GetPacketHeaderOverhead(NOT_IN_FEC_GROUP)
-      + GetEncryptionOverhead() + GetStreamFrameOverhead(NOT_IN_FEC_GROUP);
-  ASSERT_GT(kMaxPacketSize, overhead);
-  size_t capacity = kDefaultMaxPacketSize - overhead;
-  // Now, test various sizes around this size.
-  for (int delta = -5; delta <= 5; ++delta) {
-    string data(capacity + delta, 'A');
-    size_t bytes_free = delta > 0 ? 0 : 0 - delta;
-
-    QuicFrame frame;
-    size_t bytes_consumed = creator_.CreateStreamFrame(
-        kCryptoStreamId, MakeIOVector(data), kOffset, false, &frame);
-    EXPECT_LT(0u, bytes_consumed);
-    ASSERT_TRUE(creator_.AddSavedFrame(frame));
-    SerializedPacket serialized_packet = creator_.SerializePacket();
-    ASSERT_TRUE(serialized_packet.packet);
-    // If there is not enough space in the packet to fit a padding frame
-    // (1 byte) and to expand the stream frame (another 2 bytes) the packet
-    // will not be padded.
-    if (bytes_free < 3) {
-      EXPECT_EQ(kDefaultMaxPacketSize - bytes_free,
-                serialized_packet.packet->length());
-    } else {
-      EXPECT_EQ(kDefaultMaxPacketSize, serialized_packet.packet->length());
-    }
-    delete serialized_packet.packet;
-    delete serialized_packet.retransmittable_frames;
-  }
-}
-
-TEST_P(QuicPacketCreatorTest, NonCryptoStreamFramePacketNonPadding) {
-  // Compute the total overhead for a single frame in packet.
-  const size_t overhead = GetPacketHeaderOverhead(NOT_IN_FEC_GROUP)
-      + GetEncryptionOverhead() + GetStreamFrameOverhead(NOT_IN_FEC_GROUP);
-  ASSERT_GT(kDefaultMaxPacketSize, overhead);
-  size_t capacity = kDefaultMaxPacketSize - overhead;
-  // Now, test various sizes around this size.
-  for (int delta = -5; delta <= 5; ++delta) {
-    string data(capacity + delta, 'A');
-    size_t bytes_free = delta > 0 ? 0 : 0 - delta;
-
-    QuicFrame frame;
-    size_t bytes_consumed = creator_.CreateStreamFrame(
-        kClientDataStreamId1, MakeIOVector(data), kOffset, false, &frame);
-    EXPECT_LT(0u, bytes_consumed);
-    ASSERT_TRUE(creator_.AddSavedFrame(frame));
-    SerializedPacket serialized_packet = creator_.SerializePacket();
-    ASSERT_TRUE(serialized_packet.packet);
-    if (bytes_free > 0) {
-      EXPECT_EQ(kDefaultMaxPacketSize - bytes_free,
-                serialized_packet.packet->length());
-    } else {
-      EXPECT_EQ(kDefaultMaxPacketSize, serialized_packet.packet->length());
-    }
-    delete serialized_packet.packet;
-    delete serialized_packet.retransmittable_frames;
-  }
-}
-
-TEST_P(QuicPacketCreatorTest, SerializeVersionNegotiationPacket) {
-  QuicFramerPeer::SetIsServer(&client_framer_, true);
-  QuicVersionVector versions;
-  versions.push_back(test::QuicVersionMax());
-  scoped_ptr<QuicEncryptedPacket> encrypted(
-      creator_.SerializeVersionNegotiationPacket(versions));
-
-  {
-    InSequence s;
-    EXPECT_CALL(framer_visitor_, OnPacket());
-    EXPECT_CALL(framer_visitor_, OnUnauthenticatedPublicHeader(_));
-    EXPECT_CALL(framer_visitor_, OnVersionNegotiationPacket(_));
-  }
-  QuicFramerPeer::SetIsServer(&client_framer_, false);
-  client_framer_.ProcessPacket(*encrypted);
-}
-
-TEST_P(QuicPacketCreatorTest, UpdatePacketSequenceNumberLengthLeastAwaiting) {
-  EXPECT_EQ(PACKET_1BYTE_SEQUENCE_NUMBER,
-            creator_.next_sequence_number_length());
-
-  size_t max_packets_per_fec_group = 10;
-  creator_.set_max_packets_per_fec_group(max_packets_per_fec_group);
-  creator_.set_sequence_number(64 - max_packets_per_fec_group);
-  creator_.UpdateSequenceNumberLength(2, 10000 / kDefaultMaxPacketSize);
-  EXPECT_EQ(PACKET_1BYTE_SEQUENCE_NUMBER,
-            creator_.next_sequence_number_length());
-
-  creator_.set_sequence_number(64 * 256 - max_packets_per_fec_group);
-  creator_.UpdateSequenceNumberLength(2, 10000 / kDefaultMaxPacketSize);
-  EXPECT_EQ(PACKET_2BYTE_SEQUENCE_NUMBER,
-            creator_.next_sequence_number_length());
-
-  creator_.set_sequence_number(64 * 256 * 256 - max_packets_per_fec_group);
-  creator_.UpdateSequenceNumberLength(2, 10000 / kDefaultMaxPacketSize);
-  EXPECT_EQ(PACKET_4BYTE_SEQUENCE_NUMBER,
-            creator_.next_sequence_number_length());
-
-  creator_.set_sequence_number(
-      GG_UINT64_C(64) * 256 * 256 * 256 * 256 - max_packets_per_fec_group);
-  creator_.UpdateSequenceNumberLength(2, 10000 / kDefaultMaxPacketSize);
-  EXPECT_EQ(PACKET_6BYTE_SEQUENCE_NUMBER,
-            creator_.next_sequence_number_length());
-}
-
-TEST_P(QuicPacketCreatorTest, UpdatePacketSequenceNumberLengthBandwidth) {
-  EXPECT_EQ(PACKET_1BYTE_SEQUENCE_NUMBER,
-            creator_.next_sequence_number_length());
-
-  creator_.UpdateSequenceNumberLength(1, 10000 / kDefaultMaxPacketSize);
-  EXPECT_EQ(PACKET_1BYTE_SEQUENCE_NUMBER,
-            creator_.next_sequence_number_length());
-
-  creator_.UpdateSequenceNumberLength(1, 10000 * 256 / kDefaultMaxPacketSize);
-  EXPECT_EQ(PACKET_2BYTE_SEQUENCE_NUMBER,
-            creator_.next_sequence_number_length());
-
-  creator_.UpdateSequenceNumberLength(
-      1, 10000 * 256 * 256 / kDefaultMaxPacketSize);
-  EXPECT_EQ(PACKET_4BYTE_SEQUENCE_NUMBER,
-            creator_.next_sequence_number_length());
-
-  creator_.UpdateSequenceNumberLength(
-      1, GG_UINT64_C(1000) * 256 * 256 * 256 * 256 / kDefaultMaxPacketSize);
-  EXPECT_EQ(PACKET_6BYTE_SEQUENCE_NUMBER,
-            creator_.next_sequence_number_length());
-}
-
-TEST_P(QuicPacketCreatorTest, SerializeFrame) {
-  if (!GetParam().version_serialization) {
-    creator_.StopSendingVersion();
-  }
-  frames_.push_back(QuicFrame(new QuicStreamFrame(0u, false, 0u, IOVector())));
-  SerializedPacket serialized = creator_.SerializeAllFrames(frames_);
-  delete frames_[0].stream_frame;
-
-  QuicPacketHeader header;
-  {
-    InSequence s;
-    EXPECT_CALL(framer_visitor_, OnPacket());
-    EXPECT_CALL(framer_visitor_, OnUnauthenticatedPublicHeader(_));
-    EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_));
-    EXPECT_CALL(framer_visitor_, OnDecryptedPacket(_));
-    EXPECT_CALL(framer_visitor_, OnPacketHeader(_)).WillOnce(
-        DoAll(SaveArg<0>(&header), Return(true)));
-    EXPECT_CALL(framer_visitor_, OnStreamFrame(_));
-    EXPECT_CALL(framer_visitor_, OnPacketComplete());
-  }
-  ProcessPacket(serialized.packet);
-  EXPECT_EQ(GetParam().version_serialization,
-            header.public_header.version_flag);
-  delete serialized.packet;
-}
-
-TEST_P(QuicPacketCreatorTest, CreateStreamFrameTooLarge) {
-  if (!GetParam().version_serialization) {
-    creator_.StopSendingVersion();
-  }
-  // A string larger than fits into a frame.
-  size_t payload_length;
-  creator_.set_max_packet_length(GetPacketLengthForOneStream(
-      client_framer_.version(),
-      QuicPacketCreatorPeer::SendVersionInPacket(&creator_),
-      creator_.connection_id_length(),
-      PACKET_1BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP, &payload_length));
-  QuicFrame frame;
-  const string too_long_payload(payload_length * 2, 'a');
-  size_t consumed = creator_.CreateStreamFrame(
-      1u, MakeIOVector(too_long_payload), 0u, true, &frame);
-  EXPECT_EQ(payload_length, consumed);
-  const string payload(payload_length, 'a');
-  CheckStreamFrame(frame, 1u, payload, 0u, false);
-  delete frame.stream_frame;
-}
-
-TEST_P(QuicPacketCreatorTest, AddFrameAndSerialize) {
-  if (!GetParam().version_serialization) {
-    creator_.StopSendingVersion();
-  }
-  const size_t max_plaintext_size =
-      client_framer_.GetMaxPlaintextSize(creator_.max_packet_length());
-  EXPECT_FALSE(creator_.HasPendingFrames());
-  EXPECT_EQ(max_plaintext_size -
-            GetPacketHeaderSize(
-                creator_.connection_id_length(),
-                QuicPacketCreatorPeer::SendVersionInPacket(&creator_),
-                PACKET_1BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP),
-            creator_.BytesFree());
-
-  // Add a variety of frame types and then a padding frame.
-  QuicAckFrame ack_frame(MakeAckFrame(0u));
-  EXPECT_TRUE(creator_.AddSavedFrame(QuicFrame(&ack_frame)));
-  EXPECT_TRUE(creator_.HasPendingFrames());
-
-  QuicFrame frame;
-  size_t consumed = creator_.CreateStreamFrame(
-      1u, MakeIOVector("test"), 0u, false, &frame);
-  EXPECT_EQ(4u, consumed);
-  ASSERT_TRUE(frame.stream_frame);
-  EXPECT_TRUE(creator_.AddSavedFrame(frame));
-  EXPECT_TRUE(creator_.HasPendingFrames());
-
-  QuicPaddingFrame padding_frame;
-  EXPECT_TRUE(creator_.AddSavedFrame(QuicFrame(&padding_frame)));
-  EXPECT_TRUE(creator_.HasPendingFrames());
-  EXPECT_EQ(0u, creator_.BytesFree());
-
-  EXPECT_FALSE(creator_.AddSavedFrame(QuicFrame(&ack_frame)));
-
-  // Ensure the packet is successfully created.
-  SerializedPacket serialized = creator_.SerializePacket();
-  ASSERT_TRUE(serialized.packet);
-  delete serialized.packet;
-  ASSERT_TRUE(serialized.retransmittable_frames);
-  RetransmittableFrames* retransmittable = serialized.retransmittable_frames;
-  ASSERT_EQ(1u, retransmittable->frames().size());
-  EXPECT_EQ(STREAM_FRAME, retransmittable->frames()[0].type);
-  ASSERT_TRUE(retransmittable->frames()[0].stream_frame);
-  delete serialized.retransmittable_frames;
-
-  EXPECT_FALSE(creator_.HasPendingFrames());
-  EXPECT_EQ(max_plaintext_size -
-            GetPacketHeaderSize(
-                creator_.connection_id_length(),
-                QuicPacketCreatorPeer::SendVersionInPacket(&creator_),
-                PACKET_1BYTE_SEQUENCE_NUMBER,
-                NOT_IN_FEC_GROUP),
-            creator_.BytesFree());
-}
-
-TEST_P(QuicPacketCreatorTest, SerializeTruncatedAckFrameWithLargePacketSize) {
-  if (!GetParam().version_serialization) {
-    creator_.StopSendingVersion();
-  }
-  creator_.set_max_packet_length(kMaxPacketSize);
-
-  // Serialized length of ack frame with 2000 nack ranges should be limited by
-  // the number of nack ranges that can be fit in an ack frame.
-  QuicAckFrame ack_frame = MakeAckFrameWithNackRanges(2000u, 0u);
-  size_t frame_len = client_framer_.GetSerializedFrameLength(
-      QuicFrame(&ack_frame), creator_.BytesFree(), true, true,
-      NOT_IN_FEC_GROUP, PACKET_1BYTE_SEQUENCE_NUMBER);
-  EXPECT_GT(creator_.BytesFree(), frame_len);
-  EXPECT_GT(creator_.max_packet_length(), creator_.PacketSize());
-
-  // Add ack frame to creator.
-  EXPECT_TRUE(creator_.AddSavedFrame(QuicFrame(&ack_frame)));
-  EXPECT_TRUE(creator_.HasPendingFrames());
-  EXPECT_GT(creator_.max_packet_length(), creator_.PacketSize());
-  EXPECT_LT(0u, creator_.BytesFree());
-
-  // Make sure that an additional stream frame can be added to the packet.
-  QuicFrame stream_frame;
-  size_t consumed = creator_.CreateStreamFrame(
-      2u, MakeIOVector("test"), 0u, false, &stream_frame);
-  EXPECT_EQ(4u, consumed);
-  ASSERT_TRUE(stream_frame.stream_frame);
-  EXPECT_TRUE(creator_.AddSavedFrame(stream_frame));
-  EXPECT_TRUE(creator_.HasPendingFrames());
-
-  // Ensure the packet is successfully created, and the packet size estimate
-  // matches the serialized packet length.
-  EXPECT_CALL(entropy_calculator_,
-             EntropyHash(_)).WillOnce(testing::Return(0));
-  size_t est_packet_size = creator_.PacketSize();
-  SerializedPacket serialized = creator_.SerializePacket();
-  ASSERT_TRUE(serialized.packet);
-  EXPECT_EQ(est_packet_size,
-            client_framer_.GetMaxPlaintextSize(serialized.packet->length()));
-  delete serialized.retransmittable_frames;
-  delete serialized.packet;
-}
-
-TEST_P(QuicPacketCreatorTest, SerializeTruncatedAckFrameWithSmallPacketSize) {
-  if (!GetParam().version_serialization) {
-    creator_.StopSendingVersion();
-  }
-  creator_.set_max_packet_length(500u);
-
-  const size_t max_plaintext_size =
-      client_framer_.GetMaxPlaintextSize(creator_.max_packet_length());
-  EXPECT_EQ(max_plaintext_size - creator_.PacketSize(), creator_.BytesFree());
-
-  // Serialized length of ack frame with 2000 nack ranges should be limited by
-  // the packet size.
-  QuicAckFrame ack_frame = MakeAckFrameWithNackRanges(2000u, 0u);
-  size_t frame_len = client_framer_.GetSerializedFrameLength(
-      QuicFrame(&ack_frame), creator_.BytesFree(), true, true,
-      NOT_IN_FEC_GROUP, PACKET_1BYTE_SEQUENCE_NUMBER);
-  EXPECT_EQ(creator_.BytesFree(), frame_len);
-
-  // Add ack frame to creator.
-  EXPECT_TRUE(creator_.AddSavedFrame(QuicFrame(&ack_frame)));
-  EXPECT_TRUE(creator_.HasPendingFrames());
-  EXPECT_EQ(client_framer_.GetMaxPlaintextSize(creator_.max_packet_length()),
-            creator_.PacketSize());
-  EXPECT_EQ(0u, creator_.BytesFree());
-
-  // Ensure the packet is successfully created, and the packet size estimate
-  // may not match the serialized packet length.
-  EXPECT_CALL(entropy_calculator_,
-             EntropyHash(_)).WillOnce(Return(0));
-  size_t est_packet_size = creator_.PacketSize();
-  SerializedPacket serialized = creator_.SerializePacket();
-  ASSERT_TRUE(serialized.packet);
-  EXPECT_GE(est_packet_size,
-            client_framer_.GetMaxPlaintextSize(serialized.packet->length()));
-  delete serialized.packet;
-}
-
-
-TEST_P(QuicPacketCreatorTest, EntropyFlag) {
-  frames_.push_back(QuicFrame(new QuicStreamFrame(0u, false, 0u, IOVector())));
-
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 64; ++j) {
-      SerializedPacket serialized = creator_.SerializeAllFrames(frames_);
-      // Verify both BoolSource and hash algorithm.
-      bool expected_rand_bool =
-          (mock_random_.RandUint64() & (GG_UINT64_C(1) << j)) != 0;
-      bool observed_rand_bool =
-          (serialized.entropy_hash & (1 << ((j+1) % 8))) != 0;
-      uint8 rest_of_hash = serialized.entropy_hash & ~(1 << ((j+1) % 8));
-      EXPECT_EQ(expected_rand_bool, observed_rand_bool);
-      EXPECT_EQ(0, rest_of_hash);
-      delete serialized.packet;
-    }
-    // After 64 calls, BoolSource will refresh the bucket - make sure it does.
-    mock_random_.ChangeValue();
-  }
-
-  delete frames_[0].stream_frame;
-}
-
-}  // namespace
-}  // namespace test
-}  // namespace net