src/net/quic/quic_packet_creator_test.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "net/quic/quic_packet_creator.h"
   6
   7 #include "base/stl_util.h"
   8 #include "net/quic/crypto/null_encrypter.h"
   9 #include "net/quic/crypto/quic_decrypter.h"
  10 #include "net/quic/crypto/quic_encrypter.h"
  11 #include "net/quic/quic_utils.h"
  12 #include "net/quic/test_tools/mock_random.h"
  13 #include "net/quic/test_tools/quic_framer_peer.h"
  14 #include "net/quic/test_tools/quic_packet_creator_peer.h"
  15 #include "net/quic/test_tools/quic_test_utils.h"
  16 #include "net/test/gtest_util.h"
  17 #include "testing/gmock/include/gmock/gmock.h"
  18
  19 using base::StringPiece;
  20 using std::ostream;
  21 using std::string;
  22 using std::vector;
  23 using testing::DoAll;
  24 using testing::InSequence;
  25 using testing::Return;
  26 using testing::SaveArg;
  27 using testing::_;
  28
  29 namespace net {
  30 namespace test {
  31 namespace {
  32
  33 // Run tests with combinations of {QuicVersion, ToggleVersionSerialization}.
  34 struct TestParams {
  35   TestParams(QuicVersion version,
  36              bool version_serialization)
  37       : version(version),
  38         version_serialization(version_serialization) {
  39   }
  40
  41   friend ostream& operator<<(ostream& os, const TestParams& p) {
  42     os << "{ client_version: " << QuicVersionToString(p.version)
  43        << " include version: " << p.version_serialization << " }";
  44     return os;
  45   }
  46
  47   QuicVersion version;
  48   bool version_serialization;
  49 };
  50
  51 // Constructs various test permutations.
  52 vector<TestParams> GetTestParams() {
  53   vector<TestParams> params;
  54   QuicVersionVector all_supported_versions = QuicSupportedVersions();
  55   for (size_t i = 0; i < all_supported_versions.size(); ++i) {
  56     params.push_back(TestParams(all_supported_versions[i], true));
  57     params.push_back(TestParams(all_supported_versions[i], false));
  58   }
  59   return params;
  60 }
  61
  62 class QuicPacketCreatorTest : public ::testing::TestWithParam<TestParams> {
  63  protected:
  64   QuicPacketCreatorTest()
  65       : server_framer_(SupportedVersions(GetParam().version), QuicTime::Zero(),
  66                        true),
  67         client_framer_(SupportedVersions(GetParam().version), QuicTime::Zero(),
  68                        false),
  69         sequence_number_(0),
  70         connection_id_(2),
  71         data_("foo"),
  72         creator_(connection_id_, &client_framer_, &mock_random_) {
  73     client_framer_.set_visitor(&framer_visitor_);
  74     client_framer_.set_received_entropy_calculator(&entropy_calculator_);
  75     server_framer_.set_visitor(&framer_visitor_);
  76   }
  77
  78   virtual ~QuicPacketCreatorTest() OVERRIDE {
  79   }
  80
  81   void ProcessPacket(QuicPacket* packet) {
  82     scoped_ptr<QuicEncryptedPacket> encrypted(
  83         server_framer_.EncryptPacket(ENCRYPTION_NONE, sequence_number_,
  84                                      *packet));
  85     server_framer_.ProcessPacket(*encrypted);
  86   }
  87
  88   void CheckStreamFrame(const QuicFrame& frame,
  89                         QuicStreamId stream_id,
  90                         const string& data,
  91                         QuicStreamOffset offset,
  92                         bool fin) {
  93     EXPECT_EQ(STREAM_FRAME, frame.type);
  94     ASSERT_TRUE(frame.stream_frame);
  95     EXPECT_EQ(stream_id, frame.stream_frame->stream_id);
  96     scoped_ptr<string> frame_data(frame.stream_frame->GetDataAsString());
  97     EXPECT_EQ(data, *frame_data);
  98     EXPECT_EQ(offset, frame.stream_frame->offset);
  99     EXPECT_EQ(fin, frame.stream_frame->fin);
 100   }
 101
 102   // Returns the number of bytes consumed by the header of packet, including
 103   // the version.
 104   size_t GetPacketHeaderOverhead(InFecGroup is_in_fec_group) {
 105     return GetPacketHeaderSize(creator_.connection_id_length(),
 106                                kIncludeVersion,
 107                                creator_.next_sequence_number_length(),
 108                                is_in_fec_group);
 109   }
 110
 111   // Returns the number of bytes of overhead that will be added to a packet
 112   // of maximum length.
 113   size_t GetEncryptionOverhead() {
 114     return creator_.max_packet_length() - client_framer_.GetMaxPlaintextSize(
 115         creator_.max_packet_length());
 116   }
 117
 118   // Returns the number of bytes consumed by the non-data fields of a stream
 119   // frame, assuming it is the last frame in the packet
 120   size_t GetStreamFrameOverhead(InFecGroup is_in_fec_group) {
 121     return QuicFramer::GetMinStreamFrameSize(kClientDataStreamId1, kOffset,
 122                                              true, is_in_fec_group);
 123   }
 124
 125   // Enables and turns on FEC protection. Returns true if FEC protection is on.
 126   bool SwitchFecProtectionOn(size_t max_packets_per_fec_group) {
 127     creator_.set_max_packets_per_fec_group(max_packets_per_fec_group);
 128     creator_.StartFecProtectingPackets();
 129     return creator_.IsFecProtected();
 130   }
 131
 132   static const QuicStreamOffset kOffset = 1u;
 133
 134   QuicFrames frames_;
 135   QuicFramer server_framer_;
 136   QuicFramer client_framer_;
 137   testing::StrictMock<MockFramerVisitor> framer_visitor_;
 138   QuicPacketSequenceNumber sequence_number_;
 139   QuicConnectionId connection_id_;
 140   string data_;
 141   MockRandom mock_random_;
 142   QuicPacketCreator creator_;
 143   MockEntropyCalculator entropy_calculator_;
 144 };
 145
 146 // Run all packet creator tests with all supported versions of QUIC, and with
 147 // and without version in the packet header.
 148 INSTANTIATE_TEST_CASE_P(QuicPacketCreatorTests,
 149                         QuicPacketCreatorTest,
 150                         ::testing::ValuesIn(GetTestParams()));
 151
 152 TEST_P(QuicPacketCreatorTest, SerializeFrames) {
 153   frames_.push_back(QuicFrame(new QuicAckFrame(MakeAckFrame(0u))));
 154   frames_.push_back(QuicFrame(new QuicStreamFrame(0u, false, 0u, IOVector())));
 155   frames_.push_back(QuicFrame(new QuicStreamFrame(0u, true, 0u, IOVector())));
 156   SerializedPacket serialized = creator_.SerializeAllFrames(frames_);
 157   delete frames_[0].ack_frame;
 158   delete frames_[1].stream_frame;
 159   delete frames_[2].stream_frame;
 160
 161   {
 162     InSequence s;
 163     EXPECT_CALL(framer_visitor_, OnPacket());
 164     EXPECT_CALL(framer_visitor_, OnUnauthenticatedPublicHeader(_));
 165     EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_));
 166     EXPECT_CALL(framer_visitor_, OnDecryptedPacket(_));
 167     EXPECT_CALL(framer_visitor_, OnPacketHeader(_));
 168     EXPECT_CALL(framer_visitor_, OnAckFrame(_));
 169     EXPECT_CALL(framer_visitor_, OnStreamFrame(_));
 170     EXPECT_CALL(framer_visitor_, OnStreamFrame(_));
 171     EXPECT_CALL(framer_visitor_, OnPacketComplete());
 172   }
 173   ProcessPacket(serialized.packet);
 174   delete serialized.packet;
 175 }
 176
 177 TEST_P(QuicPacketCreatorTest, SerializeWithFEC) {
 178   // Enable FEC protection, and send FEC packet every 6 packets.
 179   EXPECT_TRUE(SwitchFecProtectionOn(6));
 180   // Should return false since we do not have enough packets in the FEC group to
 181   // trigger an FEC packet.
 182   ASSERT_FALSE(creator_.ShouldSendFec(/*force_close=*/false));
 183
 184   frames_.push_back(QuicFrame(new QuicStreamFrame(0u, false, 0u, IOVector())));
 185   SerializedPacket serialized = creator_.SerializeAllFrames(frames_);
 186   delete frames_[0].stream_frame;
 187
 188   {
 189     InSequence s;
 190     EXPECT_CALL(framer_visitor_, OnPacket());
 191     EXPECT_CALL(framer_visitor_, OnUnauthenticatedPublicHeader(_));
 192     EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_));
 193     EXPECT_CALL(framer_visitor_, OnDecryptedPacket(_));
 194     EXPECT_CALL(framer_visitor_, OnPacketHeader(_));
 195     EXPECT_CALL(framer_visitor_, OnFecProtectedPayload(_));
 196     EXPECT_CALL(framer_visitor_, OnStreamFrame(_));
 197     EXPECT_CALL(framer_visitor_, OnPacketComplete());
 198   }
 199   ProcessPacket(serialized.packet);
 200   delete serialized.packet;
 201
 202   // Should return false since we do not have enough packets in the FEC group to
 203   // trigger an FEC packet.
 204   ASSERT_FALSE(creator_.ShouldSendFec(/*force_close=*/false));
 205   // Should return true since there are packets in the FEC group.
 206   ASSERT_TRUE(creator_.ShouldSendFec(/*force_close=*/true));
 207
 208   serialized = creator_.SerializeFec();
 209   ASSERT_EQ(2u, serialized.sequence_number);
 210   {
 211     InSequence s;
 212     EXPECT_CALL(framer_visitor_, OnPacket());
 213     EXPECT_CALL(framer_visitor_, OnUnauthenticatedPublicHeader(_));
 214     EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_));
 215     EXPECT_CALL(framer_visitor_, OnDecryptedPacket(_));
 216     EXPECT_CALL(framer_visitor_, OnPacketHeader(_));
 217     EXPECT_CALL(framer_visitor_, OnFecData(_));
 218     EXPECT_CALL(framer_visitor_, OnPacketComplete());
 219   }
 220   ProcessPacket(serialized.packet);
 221   delete serialized.packet;
 222 }
 223
 224 TEST_P(QuicPacketCreatorTest, SerializeChangingSequenceNumberLength) {
 225   frames_.push_back(QuicFrame(new QuicAckFrame(MakeAckFrame(0u))));
 226   creator_.AddSavedFrame(frames_[0]);
 227   creator_.set_next_sequence_number_length(PACKET_4BYTE_SEQUENCE_NUMBER);
 228   SerializedPacket serialized = creator_.SerializePacket();
 229   // The sequence number length will not change mid-packet.
 230   EXPECT_EQ(PACKET_1BYTE_SEQUENCE_NUMBER, serialized.sequence_number_length);
 231
 232   {
 233     InSequence s;
 234     EXPECT_CALL(framer_visitor_, OnPacket());
 235     EXPECT_CALL(framer_visitor_, OnUnauthenticatedPublicHeader(_));
 236     EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_));
 237     EXPECT_CALL(framer_visitor_, OnDecryptedPacket(_));
 238     EXPECT_CALL(framer_visitor_, OnPacketHeader(_));
 239     EXPECT_CALL(framer_visitor_, OnAckFrame(_));
 240     EXPECT_CALL(framer_visitor_, OnPacketComplete());
 241   }
 242   ProcessPacket(serialized.packet);
 243   delete serialized.packet;
 244
 245   creator_.AddSavedFrame(frames_[0]);
 246   serialized = creator_.SerializePacket();
 247   // Now the actual sequence number length should have changed.
 248   EXPECT_EQ(PACKET_4BYTE_SEQUENCE_NUMBER, serialized.sequence_number_length);
 249   delete frames_[0].ack_frame;
 250
 251   {
 252     InSequence s;
 253     EXPECT_CALL(framer_visitor_, OnPacket());
 254     EXPECT_CALL(framer_visitor_, OnUnauthenticatedPublicHeader(_));
 255     EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_));
 256     EXPECT_CALL(framer_visitor_, OnDecryptedPacket(_));
 257     EXPECT_CALL(framer_visitor_, OnPacketHeader(_));
 258     EXPECT_CALL(framer_visitor_, OnAckFrame(_));
 259     EXPECT_CALL(framer_visitor_, OnPacketComplete());
 260   }
 261   ProcessPacket(serialized.packet);
 262   delete serialized.packet;
 263 }
 264
 265 TEST_P(QuicPacketCreatorTest, ChangeSequenceNumberLengthMidPacket) {
 266   // Changing the sequence number length with queued frames in the creator
 267   // should hold the change until after any currently queued frames are
 268   // serialized.
 269
 270   // Packet 1.
 271   // Queue a frame in the creator.
 272   EXPECT_FALSE(creator_.HasPendingFrames());
 273   QuicFrame ack_frame = QuicFrame(new QuicAckFrame(MakeAckFrame(0u)));
 274   creator_.AddSavedFrame(ack_frame);
 275
 276   // Now change sequence number length.
 277   creator_.set_next_sequence_number_length(PACKET_4BYTE_SEQUENCE_NUMBER);
 278
 279   // Add a STOP_WAITING frame since it contains a packet sequence number,
 280   // whose length should be 1.
 281   QuicStopWaitingFrame stop_waiting_frame;
 282   EXPECT_TRUE(creator_.AddSavedFrame(QuicFrame(&stop_waiting_frame)));
 283   EXPECT_TRUE(creator_.HasPendingFrames());
 284
 285   // Ensure the packet is successfully created.
 286   SerializedPacket serialized = creator_.SerializePacket();
 287   ASSERT_TRUE(serialized.packet);
 288   EXPECT_EQ(PACKET_1BYTE_SEQUENCE_NUMBER, serialized.sequence_number_length);
 289
 290   // Verify that header in transmitted packet has 1 byte sequence length.
 291   QuicPacketHeader header;
 292   {
 293     InSequence s;
 294     EXPECT_CALL(framer_visitor_, OnPacket());
 295     EXPECT_CALL(framer_visitor_, OnUnauthenticatedPublicHeader(_));
 296     EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_));
 297     EXPECT_CALL(framer_visitor_, OnDecryptedPacket(_));
 298     EXPECT_CALL(framer_visitor_, OnPacketHeader(_)).WillOnce(
 299         DoAll(SaveArg<0>(&header), Return(true)));
 300     EXPECT_CALL(framer_visitor_, OnAckFrame(_));
 301     EXPECT_CALL(framer_visitor_, OnStopWaitingFrame(_));
 302     EXPECT_CALL(framer_visitor_, OnPacketComplete());
 303   }
 304   ProcessPacket(serialized.packet);
 305   EXPECT_EQ(PACKET_1BYTE_SEQUENCE_NUMBER,
 306             header.public_header.sequence_number_length);
 307   delete serialized.packet;
 308
 309   // Packet 2.
 310   EXPECT_FALSE(creator_.HasPendingFrames());
 311   // Generate Packet 2 with one frame -- sequence number length should now
 312   // change to 4 bytes.
 313   EXPECT_TRUE(creator_.AddSavedFrame(QuicFrame(&stop_waiting_frame)));
 314   EXPECT_TRUE(creator_.HasPendingFrames());
 315
 316   // Ensure the packet is successfully created.
 317   serialized = creator_.SerializePacket();
 318   ASSERT_TRUE(serialized.packet);
 319   EXPECT_EQ(PACKET_4BYTE_SEQUENCE_NUMBER, serialized.sequence_number_length);
 320
 321   // Verify that header in transmitted packet has 4 byte sequence length.
 322   {
 323     InSequence s;
 324     EXPECT_CALL(framer_visitor_, OnPacket());
 325     EXPECT_CALL(framer_visitor_, OnUnauthenticatedPublicHeader(_));
 326     EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_));
 327     EXPECT_CALL(framer_visitor_, OnDecryptedPacket(_));
 328     EXPECT_CALL(framer_visitor_, OnPacketHeader(_)).WillOnce(
 329         DoAll(SaveArg<0>(&header), Return(true)));
 330     EXPECT_CALL(framer_visitor_, OnStopWaitingFrame(_));
 331     EXPECT_CALL(framer_visitor_, OnPacketComplete());
 332   }
 333   ProcessPacket(serialized.packet);
 334   EXPECT_EQ(PACKET_4BYTE_SEQUENCE_NUMBER,
 335             header.public_header.sequence_number_length);
 336
 337   delete serialized.packet;
 338   delete ack_frame.ack_frame;
 339 }
 340
 341 TEST_P(QuicPacketCreatorTest, SerializeWithFECChangingSequenceNumberLength) {
 342   // Test goal is to test the following sequence (P1 => generate Packet 1):
 343   // P1 <change seq num length> P2 FEC,
 344   // and we expect that sequence number length should not change until the end
 345   // of the open FEC group.
 346
 347   // Enable FEC protection, and send FEC packet every 6 packets.
 348   EXPECT_TRUE(SwitchFecProtectionOn(6));
 349   // Should return false since we do not have enough packets in the FEC group to
 350   // trigger an FEC packet.
 351   ASSERT_FALSE(creator_.ShouldSendFec(/*force_close=*/false));
 352   frames_.push_back(QuicFrame(new QuicAckFrame(MakeAckFrame(0u))));
 353
 354   // Generate Packet 1.
 355   creator_.AddSavedFrame(frames_[0]);
 356   // Change the sequence number length mid-FEC group and it should not change.
 357   creator_.set_next_sequence_number_length(PACKET_4BYTE_SEQUENCE_NUMBER);
 358   SerializedPacket serialized = creator_.SerializePacket();
 359   EXPECT_EQ(PACKET_1BYTE_SEQUENCE_NUMBER, serialized.sequence_number_length);
 360
 361   {
 362     InSequence s;
 363     EXPECT_CALL(framer_visitor_, OnPacket());
 364     EXPECT_CALL(framer_visitor_, OnUnauthenticatedPublicHeader(_));
 365     EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_));
 366     EXPECT_CALL(framer_visitor_, OnDecryptedPacket(_));
 367     EXPECT_CALL(framer_visitor_, OnPacketHeader(_));
 368     EXPECT_CALL(framer_visitor_, OnFecProtectedPayload(_));
 369     EXPECT_CALL(framer_visitor_, OnAckFrame(_));
 370     EXPECT_CALL(framer_visitor_, OnPacketComplete());
 371   }
 372   ProcessPacket(serialized.packet);
 373   delete serialized.packet;
 374
 375   // Generate Packet 2.
 376   creator_.AddSavedFrame(frames_[0]);
 377   serialized = creator_.SerializePacket();
 378   EXPECT_EQ(PACKET_1BYTE_SEQUENCE_NUMBER, serialized.sequence_number_length);
 379
 380   {
 381     InSequence s;
 382     EXPECT_CALL(framer_visitor_, OnPacket());
 383     EXPECT_CALL(framer_visitor_, OnUnauthenticatedPublicHeader(_));
 384     EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_));
 385     EXPECT_CALL(framer_visitor_, OnDecryptedPacket(_));
 386     EXPECT_CALL(framer_visitor_, OnPacketHeader(_));
 387     EXPECT_CALL(framer_visitor_, OnFecProtectedPayload(_));
 388     EXPECT_CALL(framer_visitor_, OnAckFrame(_));
 389     EXPECT_CALL(framer_visitor_, OnPacketComplete());
 390   }
 391   ProcessPacket(serialized.packet);
 392   delete serialized.packet;
 393
 394   // Should return false since we do not have enough packets in the FEC group to
 395   // trigger an FEC packet.
 396   ASSERT_FALSE(creator_.ShouldSendFec(/*force_close=*/false));
 397   // Should return true since there are packets in the FEC group.
 398   ASSERT_TRUE(creator_.ShouldSendFec(/*force_close=*/true));
 399
 400   // Force generation of FEC packet.
 401   serialized = creator_.SerializeFec();
 402   EXPECT_EQ(PACKET_1BYTE_SEQUENCE_NUMBER, serialized.sequence_number_length);
 403   ASSERT_EQ(3u, serialized.sequence_number);
 404
 405   {
 406     InSequence s;
 407     EXPECT_CALL(framer_visitor_, OnPacket());
 408     EXPECT_CALL(framer_visitor_, OnUnauthenticatedPublicHeader(_));
 409     EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_));
 410     EXPECT_CALL(framer_visitor_, OnDecryptedPacket(_));
 411     EXPECT_CALL(framer_visitor_, OnPacketHeader(_));
 412     EXPECT_CALL(framer_visitor_, OnFecData(_));
 413     EXPECT_CALL(framer_visitor_, OnPacketComplete());
 414   }
 415   ProcessPacket(serialized.packet);
 416   delete serialized.packet;
 417
 418   // Ensure the next FEC group starts using the new sequence number length.
 419   serialized = creator_.SerializeAllFrames(frames_);
 420   EXPECT_EQ(PACKET_4BYTE_SEQUENCE_NUMBER, serialized.sequence_number_length);
 421   delete frames_[0].ack_frame;
 422   delete serialized.packet;
 423 }
 424
 425 TEST_P(QuicPacketCreatorTest, ReserializeFramesWithSequenceNumberLength) {
 426   // If the original packet sequence number length, the current sequence number
 427   // length, and the configured send sequence number length are different, the
 428   // retransmit must sent with the original length and the others do not change.
 429   creator_.set_next_sequence_number_length(PACKET_4BYTE_SEQUENCE_NUMBER);
 430   QuicPacketCreatorPeer::SetSequenceNumberLength(&creator_,
 431                                                  PACKET_2BYTE_SEQUENCE_NUMBER);
 432   frames_.push_back(QuicFrame(new QuicStreamFrame(0u, false, 0u, IOVector())));
 433   SerializedPacket serialized =
 434       creator_.ReserializeAllFrames(frames_, PACKET_1BYTE_SEQUENCE_NUMBER);
 435   EXPECT_EQ(PACKET_4BYTE_SEQUENCE_NUMBER,
 436             creator_.next_sequence_number_length());
 437   EXPECT_EQ(PACKET_2BYTE_SEQUENCE_NUMBER,
 438             QuicPacketCreatorPeer::GetSequenceNumberLength(&creator_));
 439   EXPECT_EQ(PACKET_1BYTE_SEQUENCE_NUMBER, serialized.sequence_number_length);
 440   delete frames_[0].stream_frame;
 441
 442   {
 443     InSequence s;
 444     EXPECT_CALL(framer_visitor_, OnPacket());
 445     EXPECT_CALL(framer_visitor_, OnUnauthenticatedPublicHeader(_));
 446     EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_));
 447     EXPECT_CALL(framer_visitor_, OnDecryptedPacket(_));
 448     EXPECT_CALL(framer_visitor_, OnPacketHeader(_));
 449     EXPECT_CALL(framer_visitor_, OnStreamFrame(_));
 450     EXPECT_CALL(framer_visitor_, OnPacketComplete());
 451   }
 452   ProcessPacket(serialized.packet);
 453   delete serialized.packet;
 454 }
 455
 456 TEST_P(QuicPacketCreatorTest, ReserializeFramesWithPadding) {
 457   scoped_ptr<QuicStreamFrame> stream_frame(
 458       new QuicStreamFrame(kCryptoStreamId, /*fin=*/ false, /*offset=*/ 0,
 459                           MakeIOVector("fake handshake message data")));
 460   frames_.push_back(QuicFrame(stream_frame.get()));
 461   SerializedPacket serialized =
 462       creator_.ReserializeAllFrames(frames_,
 463                                     creator_.next_sequence_number_length());
 464
 465   EXPECT_EQ(client_framer_.GetMaxPlaintextSize(kDefaultMaxPacketSize),
 466             serialized.packet->length());
 467   delete serialized.packet;
 468 }
 469
 470 TEST_P(QuicPacketCreatorTest, ReserializeFramesWithFullPacketAndPadding) {
 471   const size_t overhead = GetPacketHeaderOverhead(NOT_IN_FEC_GROUP)
 472       + GetEncryptionOverhead() + GetStreamFrameOverhead(NOT_IN_FEC_GROUP);
 473   size_t capacity = kDefaultMaxPacketSize - overhead;
 474   for (int delta = -5; delta <= 0; ++delta) {
 475     string data(capacity + delta, 'A');
 476     size_t bytes_free = 0 - delta;
 477
 478     scoped_ptr<QuicStreamFrame> stream_frame(
 479         new QuicStreamFrame(kCryptoStreamId, /*fin=*/ false, kOffset,
 480                             MakeIOVector(data)));
 481     frames_.push_back(QuicFrame(stream_frame.get()));
 482     SerializedPacket serialized =
 483         creator_.ReserializeAllFrames(frames_,
 484                                       creator_.next_sequence_number_length());
 485
 486     // If there is not enough space in the packet to fit a padding frame
 487     // (1 byte) and to expand the stream frame (another 2 bytes) the packet
 488     // will not be padded.
 489     if (bytes_free < 3) {
 490       EXPECT_EQ(client_framer_.GetMaxPlaintextSize(kDefaultMaxPacketSize)
 491                 - bytes_free, serialized.packet->length());
 492     } else {
 493       EXPECT_EQ(client_framer_.GetMaxPlaintextSize(kDefaultMaxPacketSize),
 494                 serialized.packet->length());
 495     }
 496
 497     delete serialized.packet;
 498     frames_.clear();
 499   }
 500 }
 501
 502 TEST_P(QuicPacketCreatorTest, SerializeConnectionClose) {
 503   QuicConnectionCloseFrame frame;
 504   frame.error_code = QUIC_NO_ERROR;
 505   frame.error_details = "error";
 506
 507   SerializedPacket serialized = creator_.SerializeConnectionClose(&frame);
 508   ASSERT_EQ(1u, serialized.sequence_number);
 509   ASSERT_EQ(1u, creator_.sequence_number());
 510
 511   InSequence s;
 512   EXPECT_CALL(framer_visitor_, OnPacket());
 513   EXPECT_CALL(framer_visitor_, OnUnauthenticatedPublicHeader(_));
 514   EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_));
 515   EXPECT_CALL(framer_visitor_, OnDecryptedPacket(_));
 516   EXPECT_CALL(framer_visitor_, OnPacketHeader(_));
 517   EXPECT_CALL(framer_visitor_, OnConnectionCloseFrame(_));
 518   EXPECT_CALL(framer_visitor_, OnPacketComplete());
 519
 520   ProcessPacket(serialized.packet);
 521   delete serialized.packet;
 522 }
 523
 524 TEST_P(QuicPacketCreatorTest, SwitchFecOnOffWithNoGroup) {
 525   // Enable FEC protection.
 526   creator_.set_max_packets_per_fec_group(6);
 527   EXPECT_TRUE(creator_.IsFecEnabled());
 528   EXPECT_FALSE(creator_.IsFecProtected());
 529
 530   // Turn on FEC protection.
 531   creator_.StartFecProtectingPackets();
 532   EXPECT_TRUE(creator_.IsFecProtected());
 533   // We have no packets in the FEC group, so no FEC packet can be created.
 534   EXPECT_FALSE(creator_.ShouldSendFec(/*force_close=*/true));
 535   // Since no packets are in FEC group yet, we should be able to turn FEC
 536   // off with no trouble.
 537   creator_.StopFecProtectingPackets();
 538   EXPECT_FALSE(creator_.IsFecProtected());
 539 }
 540
 541 TEST_P(QuicPacketCreatorTest, SwitchFecOnOffWithGroupInProgress) {
 542   // Enable FEC protection, and send FEC packet every 6 packets.
 543   EXPECT_TRUE(SwitchFecProtectionOn(6));
 544   frames_.push_back(QuicFrame(new QuicStreamFrame(0u, false, 0u, IOVector())));
 545   SerializedPacket serialized = creator_.SerializeAllFrames(frames_);
 546   delete frames_[0].stream_frame;
 547   delete serialized.packet;
 548
 549   EXPECT_TRUE(creator_.IsFecProtected());
 550   // We do not have enough packets in the FEC group to trigger an FEC packet.
 551   EXPECT_FALSE(creator_.ShouldSendFec(/*force_close=*/false));
 552   // Should return true since there are packets in the FEC group.
 553   EXPECT_TRUE(creator_.ShouldSendFec(/*force_close=*/true));
 554
 555   // Switching FEC off should not change creator state, since there is an
 556   // FEC packet under construction.
 557   EXPECT_DFATAL(creator_.StopFecProtectingPackets(),
 558                 "Cannot stop FEC protection with open FEC group.");
 559   EXPECT_TRUE(creator_.IsFecProtected());
 560   // Confirm that FEC packet is still under construction.
 561   EXPECT_TRUE(creator_.ShouldSendFec(/*force_close=*/true));
 562
 563   serialized = creator_.SerializeFec();
 564   delete serialized.packet;
 565
 566   // Switching FEC on/off should work now.
 567   creator_.StopFecProtectingPackets();
 568   EXPECT_FALSE(creator_.IsFecProtected());
 569   creator_.StartFecProtectingPackets();
 570   EXPECT_TRUE(creator_.IsFecProtected());
 571 }
 572
 573 TEST_P(QuicPacketCreatorTest, SwitchFecOnWithStreamFrameQueued) {
 574   // Add a stream frame to the creator.
 575   QuicFrame frame;
 576   size_t consumed = creator_.CreateStreamFrame(
 577       1u, MakeIOVector("test"), 0u, false, &frame);
 578   EXPECT_EQ(4u, consumed);
 579   ASSERT_TRUE(frame.stream_frame);
 580   EXPECT_TRUE(creator_.AddSavedFrame(frame));
 581   EXPECT_TRUE(creator_.HasPendingFrames());
 582
 583   // Enable FEC protection, and send FEC packet every 6 packets.
 584   creator_.set_max_packets_per_fec_group(6);
 585   EXPECT_TRUE(creator_.IsFecEnabled());
 586   EXPECT_DFATAL(creator_.StartFecProtectingPackets(),
 587                 "Cannot start FEC protection with pending frames.");
 588   EXPECT_FALSE(creator_.IsFecProtected());
 589
 590   // Serialize packet for transmission.
 591   SerializedPacket serialized = creator_.SerializePacket();
 592   delete serialized.packet;
 593   delete serialized.retransmittable_frames;
 594   EXPECT_FALSE(creator_.HasPendingFrames());
 595
 596   // Since all pending frames have been serialized, turning FEC on should work.
 597   creator_.StartFecProtectingPackets();
 598   EXPECT_TRUE(creator_.IsFecProtected());
 599 }
 600
 601 TEST_P(QuicPacketCreatorTest, CreateStreamFrame) {
 602   QuicFrame frame;
 603   size_t consumed = creator_.CreateStreamFrame(1u, MakeIOVector("test"), 0u,
 604                                                false, &frame);
 605   EXPECT_EQ(4u, consumed);
 606   CheckStreamFrame(frame, 1u, "test", 0u, false);
 607   delete frame.stream_frame;
 608 }
 609
 610 TEST_P(QuicPacketCreatorTest, CreateStreamFrameFin) {
 611   QuicFrame frame;
 612   size_t consumed = creator_.CreateStreamFrame(1u, MakeIOVector("test"), 10u,
 613                                                true, &frame);
 614   EXPECT_EQ(4u, consumed);
 615   CheckStreamFrame(frame, 1u, "test", 10u, true);
 616   delete frame.stream_frame;
 617 }
 618
 619 TEST_P(QuicPacketCreatorTest, CreateStreamFrameFinOnly) {
 620   QuicFrame frame;
 621   size_t consumed = creator_.CreateStreamFrame(1u, IOVector(), 0u, true,
 622                                                &frame);
 623   EXPECT_EQ(0u, consumed);
 624   CheckStreamFrame(frame, 1u, string(), 0u, true);
 625   delete frame.stream_frame;
 626 }
 627
 628 TEST_P(QuicPacketCreatorTest, CreateAllFreeBytesForStreamFrames) {
 629   const size_t overhead = GetPacketHeaderOverhead(NOT_IN_FEC_GROUP)
 630                           + GetEncryptionOverhead();
 631   for (size_t i = overhead; i < overhead + 100; ++i) {
 632     creator_.set_max_packet_length(i);
 633     const bool should_have_room = i > overhead + GetStreamFrameOverhead(
 634         NOT_IN_FEC_GROUP);
 635     ASSERT_EQ(should_have_room, creator_.HasRoomForStreamFrame(
 636                                     kClientDataStreamId1, kOffset));
 637     if (should_have_room) {
 638       QuicFrame frame;
 639       size_t bytes_consumed = creator_.CreateStreamFrame(
 640           kClientDataStreamId1, MakeIOVector("testdata"), kOffset, false,
 641           &frame);
 642       EXPECT_LT(0u, bytes_consumed);
 643       ASSERT_TRUE(creator_.AddSavedFrame(frame));
 644       SerializedPacket serialized_packet = creator_.SerializePacket();
 645       ASSERT_TRUE(serialized_packet.packet);
 646       delete serialized_packet.packet;
 647       delete serialized_packet.retransmittable_frames;
 648     }
 649   }
 650 }
 651
 652 TEST_P(QuicPacketCreatorTest, StreamFrameConsumption) {
 653   // Compute the total overhead for a single frame in packet.
 654   const size_t overhead = GetPacketHeaderOverhead(NOT_IN_FEC_GROUP)
 655       + GetEncryptionOverhead() + GetStreamFrameOverhead(NOT_IN_FEC_GROUP);
 656   size_t capacity = kDefaultMaxPacketSize - overhead;
 657   // Now, test various sizes around this size.
 658   for (int delta = -5; delta <= 5; ++delta) {
 659     string data(capacity + delta, 'A');
 660     size_t bytes_free = delta > 0 ? 0 : 0 - delta;
 661     QuicFrame frame;
 662     size_t bytes_consumed = creator_.CreateStreamFrame(
 663         kClientDataStreamId1, MakeIOVector(data), kOffset, false, &frame);
 664     EXPECT_EQ(capacity - bytes_free, bytes_consumed);
 665
 666     ASSERT_TRUE(creator_.AddSavedFrame(frame));
 667     // BytesFree() returns bytes available for the next frame, which will
 668     // be two bytes smaller since the stream frame would need to be grown.
 669     EXPECT_EQ(2u, creator_.ExpansionOnNewFrame());
 670     size_t expected_bytes_free = bytes_free < 3 ? 0 : bytes_free - 2;
 671     EXPECT_EQ(expected_bytes_free, creator_.BytesFree()) << "delta: " << delta;
 672     SerializedPacket serialized_packet = creator_.SerializePacket();
 673     ASSERT_TRUE(serialized_packet.packet);
 674     delete serialized_packet.packet;
 675     delete serialized_packet.retransmittable_frames;
 676   }
 677 }
 678
 679 TEST_P(QuicPacketCreatorTest, StreamFrameConsumptionWithFec) {
 680   // Enable FEC protection, and send FEC packet every 6 packets.
 681   EXPECT_TRUE(SwitchFecProtectionOn(6));
 682   // Compute the total overhead for a single frame in packet.
 683   const size_t overhead = GetPacketHeaderOverhead(IN_FEC_GROUP)
 684       + GetEncryptionOverhead() + GetStreamFrameOverhead(IN_FEC_GROUP);
 685   size_t capacity = kDefaultMaxPacketSize - overhead;
 686   // Now, test various sizes around this size.
 687   for (int delta = -5; delta <= 5; ++delta) {
 688     string data(capacity + delta, 'A');
 689     size_t bytes_free = delta > 0 ? 0 : 0 - delta;
 690     QuicFrame frame;
 691     size_t bytes_consumed = creator_.CreateStreamFrame(
 692         kClientDataStreamId1, MakeIOVector(data), kOffset, false, &frame);
 693     EXPECT_EQ(capacity - bytes_free, bytes_consumed);
 694
 695     ASSERT_TRUE(creator_.AddSavedFrame(frame));
 696     // BytesFree() returns bytes available for the next frame. Since stream
 697     // frame does not grow for FEC protected packets, this should be the same
 698     // as bytes_free (bound by 0).
 699     EXPECT_EQ(0u, creator_.ExpansionOnNewFrame());
 700     size_t expected_bytes_free = bytes_free > 0 ? bytes_free : 0;
 701     EXPECT_EQ(expected_bytes_free, creator_.BytesFree()) << "delta: " << delta;
 702     SerializedPacket serialized_packet = creator_.SerializePacket();
 703     ASSERT_TRUE(serialized_packet.packet);
 704     delete serialized_packet.packet;
 705     delete serialized_packet.retransmittable_frames;
 706   }
 707 }
 708
 709 TEST_P(QuicPacketCreatorTest, CryptoStreamFramePacketPadding) {
 710   // Compute the total overhead for a single frame in packet.
 711   const size_t overhead = GetPacketHeaderOverhead(NOT_IN_FEC_GROUP)
 712       + GetEncryptionOverhead() + GetStreamFrameOverhead(NOT_IN_FEC_GROUP);
 713   ASSERT_GT(kMaxPacketSize, overhead);
 714   size_t capacity = kDefaultMaxPacketSize - overhead;
 715   // Now, test various sizes around this size.
 716   for (int delta = -5; delta <= 5; ++delta) {
 717     string data(capacity + delta, 'A');
 718     size_t bytes_free = delta > 0 ? 0 : 0 - delta;
 719
 720     QuicFrame frame;
 721     size_t bytes_consumed = creator_.CreateStreamFrame(
 722         kCryptoStreamId, MakeIOVector(data), kOffset, false, &frame);
 723     EXPECT_LT(0u, bytes_consumed);
 724     ASSERT_TRUE(creator_.AddSavedFrame(frame));
 725     SerializedPacket serialized_packet = creator_.SerializePacket();
 726     ASSERT_TRUE(serialized_packet.packet);
 727     // If there is not enough space in the packet to fit a padding frame
 728     // (1 byte) and to expand the stream frame (another 2 bytes) the packet
 729     // will not be padded.
 730     if (bytes_free < 3) {
 731       EXPECT_EQ(client_framer_.GetMaxPlaintextSize(kDefaultMaxPacketSize)
 732                 - bytes_free, serialized_packet.packet->length());
 733     } else {
 734       EXPECT_EQ(client_framer_.GetMaxPlaintextSize(kDefaultMaxPacketSize),
 735                 serialized_packet.packet->length());
 736     }
 737     delete serialized_packet.packet;
 738     delete serialized_packet.retransmittable_frames;
 739   }
 740 }
 741
 742 TEST_P(QuicPacketCreatorTest, NonCryptoStreamFramePacketNonPadding) {
 743   // Compute the total overhead for a single frame in packet.
 744   const size_t overhead = GetPacketHeaderOverhead(NOT_IN_FEC_GROUP)
 745       + GetEncryptionOverhead() + GetStreamFrameOverhead(NOT_IN_FEC_GROUP);
 746   ASSERT_GT(kDefaultMaxPacketSize, overhead);
 747   size_t capacity = kDefaultMaxPacketSize - overhead;
 748   // Now, test various sizes around this size.
 749   for (int delta = -5; delta <= 5; ++delta) {
 750     string data(capacity + delta, 'A');
 751     size_t bytes_free = delta > 0 ? 0 : 0 - delta;
 752
 753     QuicFrame frame;
 754     size_t bytes_consumed = creator_.CreateStreamFrame(
 755         kClientDataStreamId1, MakeIOVector(data), kOffset, false, &frame);
 756     EXPECT_LT(0u, bytes_consumed);
 757     ASSERT_TRUE(creator_.AddSavedFrame(frame));
 758     SerializedPacket serialized_packet = creator_.SerializePacket();
 759     ASSERT_TRUE(serialized_packet.packet);
 760     if (bytes_free > 0) {
 761       EXPECT_EQ(client_framer_.GetMaxPlaintextSize(kDefaultMaxPacketSize)
 762                 - bytes_free, serialized_packet.packet->length());
 763     } else {
 764       EXPECT_EQ(client_framer_.GetMaxPlaintextSize(kDefaultMaxPacketSize),
 765                 serialized_packet.packet->length());
 766     }
 767     delete serialized_packet.packet;
 768     delete serialized_packet.retransmittable_frames;
 769   }
 770 }
 771
 772 TEST_P(QuicPacketCreatorTest, SerializeVersionNegotiationPacket) {
 773   QuicFramerPeer::SetIsServer(&client_framer_, true);
 774   QuicVersionVector versions;
 775   versions.push_back(test::QuicVersionMax());
 776   scoped_ptr<QuicEncryptedPacket> encrypted(
 777       creator_.SerializeVersionNegotiationPacket(versions));
 778
 779   {
 780     InSequence s;
 781     EXPECT_CALL(framer_visitor_, OnPacket());
 782     EXPECT_CALL(framer_visitor_, OnUnauthenticatedPublicHeader(_));
 783     EXPECT_CALL(framer_visitor_, OnVersionNegotiationPacket(_));
 784   }
 785   QuicFramerPeer::SetIsServer(&client_framer_, false);
 786   client_framer_.ProcessPacket(*encrypted);
 787 }
 788
 789 TEST_P(QuicPacketCreatorTest, UpdatePacketSequenceNumberLengthLeastAwaiting) {
 790   EXPECT_EQ(PACKET_1BYTE_SEQUENCE_NUMBER,
 791             creator_.next_sequence_number_length());
 792
 793   size_t max_packets_per_fec_group = 10;
 794   creator_.set_max_packets_per_fec_group(max_packets_per_fec_group);
 795   creator_.set_sequence_number(64 - max_packets_per_fec_group);
 796   creator_.UpdateSequenceNumberLength(2, 10000);
 797   EXPECT_EQ(PACKET_1BYTE_SEQUENCE_NUMBER,
 798             creator_.next_sequence_number_length());
 799
 800   creator_.set_sequence_number(64 * 256 - max_packets_per_fec_group);
 801   creator_.UpdateSequenceNumberLength(2, 10000);
 802   EXPECT_EQ(PACKET_2BYTE_SEQUENCE_NUMBER,
 803             creator_.next_sequence_number_length());
 804
 805   creator_.set_sequence_number(64 * 256 * 256 - max_packets_per_fec_group);
 806   creator_.UpdateSequenceNumberLength(2, 10000);
 807   EXPECT_EQ(PACKET_4BYTE_SEQUENCE_NUMBER,
 808             creator_.next_sequence_number_length());
 809
 810   creator_.set_sequence_number(
 811       GG_UINT64_C(64) * 256 * 256 * 256 * 256 - max_packets_per_fec_group);
 812   creator_.UpdateSequenceNumberLength(2, 10000);
 813   EXPECT_EQ(PACKET_6BYTE_SEQUENCE_NUMBER,
 814             creator_.next_sequence_number_length());
 815 }
 816
 817 TEST_P(QuicPacketCreatorTest, UpdatePacketSequenceNumberLengthBandwidth) {
 818   EXPECT_EQ(PACKET_1BYTE_SEQUENCE_NUMBER,
 819             creator_.next_sequence_number_length());
 820
 821   creator_.UpdateSequenceNumberLength(1, 10000);
 822   EXPECT_EQ(PACKET_1BYTE_SEQUENCE_NUMBER,
 823             creator_.next_sequence_number_length());
 824
 825   creator_.UpdateSequenceNumberLength(1, 10000 * 256);
 826   EXPECT_EQ(PACKET_2BYTE_SEQUENCE_NUMBER,
 827             creator_.next_sequence_number_length());
 828
 829   creator_.UpdateSequenceNumberLength(1, 10000 * 256 * 256);
 830   EXPECT_EQ(PACKET_4BYTE_SEQUENCE_NUMBER,
 831             creator_.next_sequence_number_length());
 832
 833   creator_.UpdateSequenceNumberLength(
 834       1, GG_UINT64_C(1000) * 256 * 256 * 256 * 256);
 835   EXPECT_EQ(PACKET_6BYTE_SEQUENCE_NUMBER,
 836             creator_.next_sequence_number_length());
 837 }
 838
 839 TEST_P(QuicPacketCreatorTest, CreateStreamFrameWithNotifier) {
 840   // Ensure that if CreateStreamFrame does not consume any data (e.g. a FIN only
 841   // frame) then any QuicAckNotifier that is passed in still gets attached to
 842   // the frame.
 843   scoped_refptr<MockAckNotifierDelegate> delegate(new MockAckNotifierDelegate);
 844   QuicAckNotifier notifier(delegate.get());
 845   QuicFrame frame;
 846   IOVector empty_iovector;
 847   bool fin = true;
 848   size_t consumed_bytes = creator_.CreateStreamFrameWithNotifier(
 849       1u, empty_iovector, 0u, fin, &notifier, &frame);
 850   EXPECT_EQ(0u, consumed_bytes);
 851   EXPECT_EQ(&notifier, frame.stream_frame->notifier);
 852   delete frame.stream_frame;
 853 }
 854
 855 TEST_P(QuicPacketCreatorTest, SerializeFrame) {
 856   if (!GetParam().version_serialization) {
 857     creator_.StopSendingVersion();
 858   }
 859   frames_.push_back(QuicFrame(new QuicStreamFrame(0u, false, 0u, IOVector())));
 860   SerializedPacket serialized = creator_.SerializeAllFrames(frames_);
 861   delete frames_[0].stream_frame;
 862
 863   QuicPacketHeader header;
 864   {
 865     InSequence s;
 866     EXPECT_CALL(framer_visitor_, OnPacket());
 867     EXPECT_CALL(framer_visitor_, OnUnauthenticatedPublicHeader(_));
 868     EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_));
 869     EXPECT_CALL(framer_visitor_, OnDecryptedPacket(_));
 870     EXPECT_CALL(framer_visitor_, OnPacketHeader(_)).WillOnce(
 871         DoAll(SaveArg<0>(&header), Return(true)));
 872     EXPECT_CALL(framer_visitor_, OnStreamFrame(_));
 873     EXPECT_CALL(framer_visitor_, OnPacketComplete());
 874   }
 875   ProcessPacket(serialized.packet);
 876   EXPECT_EQ(GetParam().version_serialization,
 877             header.public_header.version_flag);
 878   delete serialized.packet;
 879 }
 880
 881 TEST_P(QuicPacketCreatorTest, CreateStreamFrameTooLarge) {
 882   if (!GetParam().version_serialization) {
 883     creator_.StopSendingVersion();
 884   }
 885   // A string larger than fits into a frame.
 886   size_t payload_length;
 887   creator_.set_max_packet_length(GetPacketLengthForOneStream(
 888       client_framer_.version(),
 889       QuicPacketCreatorPeer::SendVersionInPacket(&creator_),
 890       PACKET_1BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP, &payload_length));
 891   QuicFrame frame;
 892   const string too_long_payload(payload_length * 2, 'a');
 893   size_t consumed = creator_.CreateStreamFrame(
 894       1u, MakeIOVector(too_long_payload), 0u, true, &frame);
 895   EXPECT_EQ(payload_length, consumed);
 896   const string payload(payload_length, 'a');
 897   CheckStreamFrame(frame, 1u, payload, 0u, false);
 898   delete frame.stream_frame;
 899 }
 900
 901 TEST_P(QuicPacketCreatorTest, AddFrameAndSerialize) {
 902   if (!GetParam().version_serialization) {
 903     creator_.StopSendingVersion();
 904   }
 905   const size_t max_plaintext_size =
 906       client_framer_.GetMaxPlaintextSize(creator_.max_packet_length());
 907   EXPECT_FALSE(creator_.HasPendingFrames());
 908   EXPECT_EQ(max_plaintext_size -
 909             GetPacketHeaderSize(
 910                 creator_.connection_id_length(),
 911                 QuicPacketCreatorPeer::SendVersionInPacket(&creator_),
 912                 PACKET_1BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP),
 913             creator_.BytesFree());
 914
 915   // Add a variety of frame types and then a padding frame.
 916   QuicAckFrame ack_frame(MakeAckFrame(0u));
 917   EXPECT_TRUE(creator_.AddSavedFrame(QuicFrame(&ack_frame)));
 918   EXPECT_TRUE(creator_.HasPendingFrames());
 919
 920   QuicCongestionFeedbackFrame congestion_feedback;
 921   congestion_feedback.type = kTCP;
 922   congestion_feedback.tcp.receive_window = 0x4030;
 923   EXPECT_TRUE(creator_.AddSavedFrame(QuicFrame(&congestion_feedback)));
 924   EXPECT_TRUE(creator_.HasPendingFrames());
 925
 926   QuicFrame frame;
 927   size_t consumed = creator_.CreateStreamFrame(
 928       1u, MakeIOVector("test"), 0u, false, &frame);
 929   EXPECT_EQ(4u, consumed);
 930   ASSERT_TRUE(frame.stream_frame);
 931   EXPECT_TRUE(creator_.AddSavedFrame(frame));
 932   EXPECT_TRUE(creator_.HasPendingFrames());
 933
 934   QuicPaddingFrame padding_frame;
 935   EXPECT_TRUE(creator_.AddSavedFrame(QuicFrame(&padding_frame)));
 936   EXPECT_TRUE(creator_.HasPendingFrames());
 937   EXPECT_EQ(0u, creator_.BytesFree());
 938
 939   EXPECT_FALSE(creator_.AddSavedFrame(QuicFrame(&ack_frame)));
 940
 941   // Ensure the packet is successfully created.
 942   SerializedPacket serialized = creator_.SerializePacket();
 943   ASSERT_TRUE(serialized.packet);
 944   delete serialized.packet;
 945   ASSERT_TRUE(serialized.retransmittable_frames);
 946   RetransmittableFrames* retransmittable = serialized.retransmittable_frames;
 947   ASSERT_EQ(1u, retransmittable->frames().size());
 948   EXPECT_EQ(STREAM_FRAME, retransmittable->frames()[0].type);
 949   ASSERT_TRUE(retransmittable->frames()[0].stream_frame);
 950   delete serialized.retransmittable_frames;
 951
 952   EXPECT_FALSE(creator_.HasPendingFrames());
 953   EXPECT_EQ(max_plaintext_size -
 954             GetPacketHeaderSize(
 955                 creator_.connection_id_length(),
 956                 QuicPacketCreatorPeer::SendVersionInPacket(&creator_),
 957                 PACKET_1BYTE_SEQUENCE_NUMBER,
 958                 NOT_IN_FEC_GROUP),
 959             creator_.BytesFree());
 960 }
 961
 962 TEST_P(QuicPacketCreatorTest, SerializeTruncatedAckFrameWithLargePacketSize) {
 963   if (!GetParam().version_serialization) {
 964     creator_.StopSendingVersion();
 965   }
 966   creator_.set_max_packet_length(kMaxPacketSize);
 967   const size_t max_plaintext_size =
 968       client_framer_.GetMaxPlaintextSize(creator_.max_packet_length());
 969
 970   // Serialized length of ack frame with 2000 nack ranges should be limited by
 971   // the number of nack ranges that can be fit in an ack frame.
 972   QuicAckFrame ack_frame = MakeAckFrameWithNackRanges(2000u, 0u);
 973   size_t frame_len = client_framer_.GetSerializedFrameLength(
 974       QuicFrame(&ack_frame), creator_.BytesFree(), true, true,
 975       NOT_IN_FEC_GROUP, PACKET_1BYTE_SEQUENCE_NUMBER);
 976   EXPECT_GT(creator_.BytesFree(), frame_len);
 977   EXPECT_GT(max_plaintext_size, creator_.PacketSize());
 978
 979   // Add ack frame to creator.
 980   EXPECT_TRUE(creator_.AddSavedFrame(QuicFrame(&ack_frame)));
 981   EXPECT_TRUE(creator_.HasPendingFrames());
 982   EXPECT_GT(max_plaintext_size, creator_.PacketSize());
 983   EXPECT_LT(0u, creator_.BytesFree());
 984
 985   // Make sure that an additional stream frame can be added to the packet.
 986   QuicFrame stream_frame;
 987   size_t consumed = creator_.CreateStreamFrame(
 988       2u, MakeIOVector("test"), 0u, false, &stream_frame);
 989   EXPECT_EQ(4u, consumed);
 990   ASSERT_TRUE(stream_frame.stream_frame);
 991   EXPECT_TRUE(creator_.AddSavedFrame(stream_frame));
 992   EXPECT_TRUE(creator_.HasPendingFrames());
 993
 994   // Ensure the packet is successfully created, and the packet size estimate
 995   // matches the serialized packet length.
 996   EXPECT_CALL(entropy_calculator_,
 997              EntropyHash(_)).WillOnce(testing::Return(0));
 998   size_t est_packet_size = creator_.PacketSize();
 999   SerializedPacket serialized = creator_.SerializePacket();
1000   ASSERT_TRUE(serialized.packet);
1001   EXPECT_EQ(est_packet_size, serialized.packet->length());
1002   delete serialized.retransmittable_frames;
1003   delete serialized.packet;
1004 }
1005
1006 TEST_P(QuicPacketCreatorTest, SerializeTruncatedAckFrameWithSmallPacketSize) {
1007   if (!GetParam().version_serialization) {
1008     creator_.StopSendingVersion();
1009   }
1010   creator_.set_max_packet_length(500u);
1011
1012   const size_t max_plaintext_size =
1013       client_framer_.GetMaxPlaintextSize(creator_.max_packet_length());
1014   EXPECT_EQ(max_plaintext_size - creator_.PacketSize(), creator_.BytesFree());
1015
1016   // Serialized length of ack frame with 2000 nack ranges should be limited by
1017   // the packet size.
1018   QuicAckFrame ack_frame = MakeAckFrameWithNackRanges(2000u, 0u);
1019   size_t frame_len = client_framer_.GetSerializedFrameLength(
1020       QuicFrame(&ack_frame), creator_.BytesFree(), true, true,
1021       NOT_IN_FEC_GROUP, PACKET_1BYTE_SEQUENCE_NUMBER);
1022   EXPECT_EQ(creator_.BytesFree(), frame_len);
1023
1024   // Add ack frame to creator.
1025   EXPECT_TRUE(creator_.AddSavedFrame(QuicFrame(&ack_frame)));
1026   EXPECT_TRUE(creator_.HasPendingFrames());
1027   EXPECT_EQ(max_plaintext_size, creator_.PacketSize());
1028   EXPECT_EQ(0u, creator_.BytesFree());
1029
1030   // Ensure the packet is successfully created, and the packet size estimate
1031   // may not match the serialized packet length.
1032   EXPECT_CALL(entropy_calculator_,
1033              EntropyHash(_)).WillOnce(Return(0));
1034   size_t est_packet_size = creator_.PacketSize();
1035   SerializedPacket serialized = creator_.SerializePacket();
1036   ASSERT_TRUE(serialized.packet);
1037   EXPECT_GE(est_packet_size, serialized.packet->length());
1038   delete serialized.packet;
1039 }
1040
1041
1042 TEST_P(QuicPacketCreatorTest, EntropyFlag) {
1043   frames_.push_back(QuicFrame(new QuicStreamFrame(0u, false, 0u, IOVector())));
1044
1045   for (int i = 0; i < 2; ++i) {
1046     for (int j = 0; j < 64; ++j) {
1047       SerializedPacket serialized = creator_.SerializeAllFrames(frames_);
1048       // Verify both BoolSource and hash algorithm.
1049       bool expected_rand_bool =
1050           (mock_random_.RandUint64() & (GG_UINT64_C(1) << j)) != 0;
1051       bool observed_rand_bool =
1052           (serialized.entropy_hash & (1 << ((j+1) % 8))) != 0;
1053       uint8 rest_of_hash = serialized.entropy_hash & ~(1 << ((j+1) % 8));
1054       EXPECT_EQ(expected_rand_bool, observed_rand_bool);
1055       EXPECT_EQ(0, rest_of_hash);
1056       delete serialized.packet;
1057     }
1058     // After 64 calls, BoolSource will refresh the bucket - make sure it does.
1059     mock_random_.ChangeValue();
1060   }
1061
1062   delete frames_[0].stream_frame;
1063 }
1064
1065 }  // namespace
1066 }  // namespace test
1067 }  // namespace net