net/quic/quic_packet_generator_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_generator.h"
   6
   7 #include <string>
   8
   9 #include "net/quic/crypto/crypto_protocol.h"
  10 #include "net/quic/crypto/null_encrypter.h"
  11 #include "net/quic/crypto/quic_decrypter.h"
  12 #include "net/quic/crypto/quic_encrypter.h"
  13 #include "net/quic/quic_flags.h"
  14 #include "net/quic/quic_utils.h"
  15 #include "net/quic/test_tools/quic_packet_creator_peer.h"
  16 #include "net/quic/test_tools/quic_packet_generator_peer.h"
  17 #include "net/quic/test_tools/quic_test_utils.h"
  18 #include "net/quic/test_tools/simple_quic_framer.h"
  19 #include "net/test/gtest_util.h"
  20 #include "testing/gmock/include/gmock/gmock.h"
  21 #include "testing/gtest/include/gtest/gtest.h"
  22
  23 using base::StringPiece;
  24 using std::string;
  25 using std::vector;
  26 using testing::InSequence;
  27 using testing::Return;
  28 using testing::SaveArg;
  29 using testing::StrictMock;
  30 using testing::_;
  31
  32 namespace net {
  33 namespace test {
  34 namespace {
  35
  36 const int64 kMinFecTimeoutMs = 5u;
  37
  38 static const FecSendPolicy kFecSendPolicyList[] = {
  39     FEC_ANY_TRIGGER,
  40     FEC_ALARM_TRIGGER,
  41 };
  42
  43 class MockDelegate : public QuicPacketGenerator::DelegateInterface {
  44  public:
  45   MockDelegate() {}
  46   ~MockDelegate() override {}
  47
  48   MOCK_METHOD2(ShouldGeneratePacket,
  49                bool(HasRetransmittableData retransmittable,
  50                     IsHandshake handshake));
  51   MOCK_METHOD1(PopulateAckFrame, void(QuicAckFrame*));
  52   MOCK_METHOD1(PopulateStopWaitingFrame, void(QuicStopWaitingFrame*));
  53   MOCK_METHOD1(OnSerializedPacket, void(const SerializedPacket& packet));
  54   MOCK_METHOD2(CloseConnection, void(QuicErrorCode, bool));
  55   MOCK_METHOD0(OnResetFecGroup, void());
  56
  57   void SetCanWriteAnything() {
  58     EXPECT_CALL(*this, ShouldGeneratePacket(_, _)).WillRepeatedly(Return(true));
  59     EXPECT_CALL(*this, ShouldGeneratePacket(NO_RETRANSMITTABLE_DATA, _))
  60         .WillRepeatedly(Return(true));
  61   }
  62
  63   void SetCanNotWrite() {
  64     EXPECT_CALL(*this, ShouldGeneratePacket(_, _))
  65         .WillRepeatedly(Return(false));
  66     EXPECT_CALL(*this, ShouldGeneratePacket(NO_RETRANSMITTABLE_DATA, _))
  67         .WillRepeatedly(Return(false));
  68   }
  69
  70   // Use this when only ack frames should be allowed to be written.
  71   void SetCanWriteOnlyNonRetransmittable() {
  72     EXPECT_CALL(*this, ShouldGeneratePacket(_, _))
  73         .WillRepeatedly(Return(false));
  74     EXPECT_CALL(*this, ShouldGeneratePacket(NO_RETRANSMITTABLE_DATA, _))
  75         .WillRepeatedly(Return(true));
  76   }
  77
  78  private:
  79   DISALLOW_COPY_AND_ASSIGN(MockDelegate);
  80 };
  81
  82 // Simple struct for describing the contents of a packet.
  83 // Useful in conjunction with a SimpleQuicFrame for validating that a packet
  84 // contains the expected frames.
  85 struct PacketContents {
  86   PacketContents()
  87       : num_ack_frames(0),
  88         num_connection_close_frames(0),
  89         num_goaway_frames(0),
  90         num_rst_stream_frames(0),
  91         num_stop_waiting_frames(0),
  92         num_stream_frames(0),
  93         num_ping_frames(0),
  94         num_mtu_discovery_frames(0),
  95         fec_group(0) {}
  96
  97   size_t num_ack_frames;
  98   size_t num_connection_close_frames;
  99   size_t num_goaway_frames;
 100   size_t num_rst_stream_frames;
 101   size_t num_stop_waiting_frames;
 102   size_t num_stream_frames;
 103   size_t num_ping_frames;
 104   size_t num_mtu_discovery_frames;
 105
 106   QuicFecGroupNumber fec_group;
 107 };
 108
 109 }  // namespace
 110
 111 class QuicPacketGeneratorTest : public ::testing::TestWithParam<FecSendPolicy> {
 112  public:
 113   QuicPacketGeneratorTest()
 114       : framer_(QuicSupportedVersions(),
 115                 QuicTime::Zero(),
 116                 Perspective::IS_CLIENT),
 117         generator_(42, &framer_, &random_, &delegate_),
 118         creator_(QuicPacketGeneratorPeer::GetPacketCreator(&generator_)) {
 119     generator_.set_fec_send_policy(GetParam());
 120   }
 121
 122   ~QuicPacketGeneratorTest() override {
 123     for (SerializedPacket& packet : packets_) {
 124       delete packet.packet;
 125       delete packet.retransmittable_frames;
 126     }
 127   }
 128
 129   void SavePacket(const SerializedPacket& packet) {
 130     packets_.push_back(packet);
 131     ASSERT_FALSE(packet.packet->owns_buffer());
 132     scoped_ptr<QuicEncryptedPacket> encrypted_deleter(packets_.back().packet);
 133     packets_.back().packet = packets_.back().packet->Clone();
 134   }
 135
 136  protected:
 137   QuicRstStreamFrame* CreateRstStreamFrame() {
 138     return new QuicRstStreamFrame(1, QUIC_STREAM_NO_ERROR, 0);
 139   }
 140
 141   QuicGoAwayFrame* CreateGoAwayFrame() {
 142     return new QuicGoAwayFrame(QUIC_NO_ERROR, 1, string());
 143   }
 144
 145   void CheckPacketContains(const PacketContents& contents,
 146                            size_t packet_index) {
 147     ASSERT_GT(packets_.size(), packet_index);
 148     const SerializedPacket& packet = packets_[packet_index];
 149     size_t num_retransmittable_frames =
 150         contents.num_connection_close_frames + contents.num_goaway_frames +
 151         contents.num_rst_stream_frames + contents.num_stream_frames +
 152         contents.num_ping_frames;
 153     size_t num_frames =
 154         contents.num_ack_frames + contents.num_stop_waiting_frames +
 155         contents.num_mtu_discovery_frames + num_retransmittable_frames;
 156
 157     if (num_retransmittable_frames == 0) {
 158       ASSERT_TRUE(packet.retransmittable_frames == nullptr);
 159     } else {
 160       ASSERT_TRUE(packet.retransmittable_frames != nullptr);
 161       EXPECT_EQ(num_retransmittable_frames,
 162                 packet.retransmittable_frames->frames().size());
 163     }
 164
 165     ASSERT_TRUE(packet.packet != nullptr);
 166     ASSERT_TRUE(simple_framer_.ProcessPacket(*packet.packet));
 167     EXPECT_EQ(num_frames, simple_framer_.num_frames());
 168     EXPECT_EQ(contents.num_ack_frames, simple_framer_.ack_frames().size());
 169     EXPECT_EQ(contents.num_connection_close_frames,
 170               simple_framer_.connection_close_frames().size());
 171     EXPECT_EQ(contents.num_goaway_frames,
 172               simple_framer_.goaway_frames().size());
 173     EXPECT_EQ(contents.num_rst_stream_frames,
 174               simple_framer_.rst_stream_frames().size());
 175     EXPECT_EQ(contents.num_stream_frames,
 176               simple_framer_.stream_frames().size());
 177     EXPECT_EQ(contents.num_stop_waiting_frames,
 178               simple_framer_.stop_waiting_frames().size());
 179     EXPECT_EQ(contents.fec_group, simple_framer_.header().fec_group);
 180
 181     // From the receiver's perspective, MTU discovery frames are ping frames.
 182     EXPECT_EQ(contents.num_ping_frames + contents.num_mtu_discovery_frames,
 183               simple_framer_.ping_frames().size());
 184   }
 185
 186   void CheckPacketHasSingleStreamFrame(size_t packet_index) {
 187     ASSERT_GT(packets_.size(), packet_index);
 188     const SerializedPacket& packet = packets_[packet_index];
 189     ASSERT_TRUE(packet.retransmittable_frames != nullptr);
 190     EXPECT_EQ(1u, packet.retransmittable_frames->frames().size());
 191     ASSERT_TRUE(packet.packet != nullptr);
 192     ASSERT_TRUE(simple_framer_.ProcessPacket(*packet.packet));
 193     EXPECT_EQ(1u, simple_framer_.num_frames());
 194     EXPECT_EQ(1u, simple_framer_.stream_frames().size());
 195   }
 196
 197   void CheckAllPacketsHaveSingleStreamFrame() {
 198     for (size_t i = 0; i < packets_.size(); i++) {
 199       CheckPacketHasSingleStreamFrame(i);
 200     }
 201   }
 202
 203   void CheckPacketIsFec(size_t packet_index,
 204                         QuicPacketSequenceNumber fec_group) {
 205     ASSERT_GT(packets_.size(), packet_index);
 206     const SerializedPacket& packet = packets_[packet_index];
 207     ASSERT_TRUE(packet.retransmittable_frames == nullptr);
 208     ASSERT_TRUE(packet.packet != nullptr);
 209     ASSERT_TRUE(simple_framer_.ProcessPacket(*packet.packet));
 210     EXPECT_TRUE(simple_framer_.header().fec_flag);
 211     EXPECT_EQ(fec_group, simple_framer_.fec_data().fec_group);
 212   }
 213
 214   QuicIOVector CreateData(size_t len) {
 215     data_array_.reset(new char[len]);
 216     memset(data_array_.get(), '?', len);
 217     iov_.iov_base = data_array_.get();
 218     iov_.iov_len = len;
 219     return QuicIOVector(&iov_, 1, len);
 220   }
 221
 222   QuicIOVector MakeIOVector(StringPiece s) {
 223     return ::net::MakeIOVector(s, &iov_);
 224   }
 225
 226   QuicFramer framer_;
 227   MockRandom random_;
 228   StrictMock<MockDelegate> delegate_;
 229   QuicPacketGenerator generator_;
 230   QuicPacketCreator* creator_;
 231   SimpleQuicFramer simple_framer_;
 232   vector<SerializedPacket> packets_;
 233
 234  private:
 235   scoped_ptr<char[]> data_array_;
 236   struct iovec iov_;
 237 };
 238
 239 class MockDebugDelegate : public QuicPacketGenerator::DebugDelegate {
 240  public:
 241   MOCK_METHOD1(OnFrameAddedToPacket,
 242                void(const QuicFrame&));
 243 };
 244
 245 // Run all end to end tests with all supported FEC send polocies.
 246 INSTANTIATE_TEST_CASE_P(FecSendPolicy,
 247                         QuicPacketGeneratorTest,
 248                         ::testing::ValuesIn(kFecSendPolicyList));
 249
 250 TEST_P(QuicPacketGeneratorTest, ShouldSendAck_NotWritable) {
 251   delegate_.SetCanNotWrite();
 252
 253   generator_.SetShouldSendAck(false);
 254   EXPECT_TRUE(generator_.HasQueuedFrames());
 255 }
 256
 257 TEST_P(QuicPacketGeneratorTest, ShouldSendAck_WritableAndShouldNotFlush) {
 258   StrictMock<MockDebugDelegate> debug_delegate;
 259
 260   generator_.set_debug_delegate(&debug_delegate);
 261   delegate_.SetCanWriteOnlyNonRetransmittable();
 262   generator_.StartBatchOperations();
 263
 264   EXPECT_CALL(delegate_, PopulateAckFrame(_));
 265   EXPECT_CALL(debug_delegate, OnFrameAddedToPacket(_)).Times(1);
 266
 267   generator_.SetShouldSendAck(false);
 268   EXPECT_TRUE(generator_.HasQueuedFrames());
 269 }
 270
 271 TEST_P(QuicPacketGeneratorTest, ShouldSendAck_WritableAndShouldFlush) {
 272   delegate_.SetCanWriteOnlyNonRetransmittable();
 273
 274   EXPECT_CALL(delegate_, PopulateAckFrame(_));
 275   EXPECT_CALL(delegate_, OnSerializedPacket(_))
 276       .WillOnce(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
 277
 278   generator_.SetShouldSendAck(false);
 279   EXPECT_FALSE(generator_.HasQueuedFrames());
 280
 281   PacketContents contents;
 282   contents.num_ack_frames = 1;
 283   CheckPacketContains(contents, 0);
 284 }
 285
 286 TEST_P(QuicPacketGeneratorTest, ShouldSendAck_MultipleCalls) {
 287   // Make sure that calling SetShouldSendAck multiple times does not result in a
 288   // crash. Previously this would result in multiple QuicFrames queued in the
 289   // packet generator, with all but the last with internal pointers to freed
 290   // memory.
 291   delegate_.SetCanWriteAnything();
 292
 293   // Only one AckFrame should be created.
 294   EXPECT_CALL(delegate_, PopulateAckFrame(_)).Times(1);
 295   EXPECT_CALL(delegate_, OnSerializedPacket(_))
 296       .Times(1)
 297       .WillOnce(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
 298
 299   generator_.StartBatchOperations();
 300   generator_.SetShouldSendAck(false);
 301   generator_.SetShouldSendAck(false);
 302   generator_.FinishBatchOperations();
 303 }
 304
 305 TEST_P(QuicPacketGeneratorTest, AddControlFrame_NotWritable) {
 306   delegate_.SetCanNotWrite();
 307
 308   generator_.AddControlFrame(QuicFrame(CreateRstStreamFrame()));
 309   EXPECT_TRUE(generator_.HasQueuedFrames());
 310 }
 311
 312 TEST_P(QuicPacketGeneratorTest, AddControlFrame_OnlyAckWritable) {
 313   delegate_.SetCanWriteOnlyNonRetransmittable();
 314
 315   generator_.AddControlFrame(QuicFrame(CreateRstStreamFrame()));
 316   EXPECT_TRUE(generator_.HasQueuedFrames());
 317 }
 318
 319 TEST_P(QuicPacketGeneratorTest, AddControlFrame_WritableAndShouldNotFlush) {
 320   delegate_.SetCanWriteAnything();
 321   generator_.StartBatchOperations();
 322
 323   generator_.AddControlFrame(QuicFrame(CreateRstStreamFrame()));
 324   EXPECT_TRUE(generator_.HasQueuedFrames());
 325 }
 326
 327 TEST_P(QuicPacketGeneratorTest, AddControlFrame_NotWritableBatchThenFlush) {
 328   delegate_.SetCanNotWrite();
 329   generator_.StartBatchOperations();
 330
 331   generator_.AddControlFrame(QuicFrame(CreateRstStreamFrame()));
 332   EXPECT_TRUE(generator_.HasQueuedFrames());
 333   generator_.FinishBatchOperations();
 334   EXPECT_TRUE(generator_.HasQueuedFrames());
 335
 336   EXPECT_CALL(delegate_, OnSerializedPacket(_))
 337       .WillOnce(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
 338   generator_.FlushAllQueuedFrames();
 339   EXPECT_FALSE(generator_.HasQueuedFrames());
 340
 341   PacketContents contents;
 342   contents.num_rst_stream_frames = 1;
 343   CheckPacketContains(contents, 0);
 344 }
 345
 346 TEST_P(QuicPacketGeneratorTest, AddControlFrame_WritableAndShouldFlush) {
 347   delegate_.SetCanWriteAnything();
 348
 349   EXPECT_CALL(delegate_, OnSerializedPacket(_))
 350       .WillOnce(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
 351
 352   generator_.AddControlFrame(QuicFrame(CreateRstStreamFrame()));
 353   EXPECT_FALSE(generator_.HasQueuedFrames());
 354
 355   PacketContents contents;
 356   contents.num_rst_stream_frames = 1;
 357   CheckPacketContains(contents, 0);
 358 }
 359
 360 TEST_P(QuicPacketGeneratorTest, ConsumeData_NotWritable) {
 361   delegate_.SetCanNotWrite();
 362
 363   QuicConsumedData consumed = generator_.ConsumeData(
 364       kHeadersStreamId, MakeIOVector("foo"), 2, true, MAY_FEC_PROTECT, nullptr);
 365   EXPECT_EQ(0u, consumed.bytes_consumed);
 366   EXPECT_FALSE(consumed.fin_consumed);
 367   EXPECT_FALSE(generator_.HasQueuedFrames());
 368 }
 369
 370 TEST_P(QuicPacketGeneratorTest, ConsumeData_WritableAndShouldNotFlush) {
 371   delegate_.SetCanWriteAnything();
 372   generator_.StartBatchOperations();
 373
 374   QuicConsumedData consumed = generator_.ConsumeData(
 375       kHeadersStreamId, MakeIOVector("foo"), 2, true, MAY_FEC_PROTECT, nullptr);
 376   EXPECT_EQ(3u, consumed.bytes_consumed);
 377   EXPECT_TRUE(consumed.fin_consumed);
 378   EXPECT_TRUE(generator_.HasQueuedFrames());
 379 }
 380
 381 TEST_P(QuicPacketGeneratorTest, ConsumeData_WritableAndShouldFlush) {
 382   delegate_.SetCanWriteAnything();
 383
 384   EXPECT_CALL(delegate_, OnSerializedPacket(_))
 385       .WillOnce(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
 386   QuicConsumedData consumed = generator_.ConsumeData(
 387       kHeadersStreamId, MakeIOVector("foo"), 2, true, MAY_FEC_PROTECT, nullptr);
 388   EXPECT_EQ(3u, consumed.bytes_consumed);
 389   EXPECT_TRUE(consumed.fin_consumed);
 390   EXPECT_FALSE(generator_.HasQueuedFrames());
 391
 392   PacketContents contents;
 393   contents.num_stream_frames = 1;
 394   CheckPacketContains(contents, 0);
 395 }
 396
 397 // Test the behavior of ConsumeData when the data consumed is for the crypto
 398 // handshake stream.  Ensure that the packet is always sent and padded even if
 399 // the generator operates in batch mode.
 400 TEST_P(QuicPacketGeneratorTest, ConsumeData_Handshake) {
 401   delegate_.SetCanWriteAnything();
 402   generator_.StartBatchOperations();
 403
 404   EXPECT_CALL(delegate_, OnSerializedPacket(_))
 405       .WillOnce(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
 406   QuicConsumedData consumed = generator_.ConsumeData(
 407       kCryptoStreamId, MakeIOVector("foo"), 0, false, MAY_FEC_PROTECT, nullptr);
 408   EXPECT_EQ(3u, consumed.bytes_consumed);
 409   EXPECT_FALSE(generator_.HasQueuedFrames());
 410
 411   PacketContents contents;
 412   contents.num_stream_frames = 1;
 413   CheckPacketContains(contents, 0);
 414
 415   ASSERT_EQ(1u, packets_.size());
 416   ASSERT_EQ(kDefaultMaxPacketSize, generator_.GetMaxPacketLength());
 417   EXPECT_EQ(kDefaultMaxPacketSize, packets_[0].packet->length());
 418 }
 419
 420 TEST_P(QuicPacketGeneratorTest, ConsumeData_EmptyData) {
 421   EXPECT_DFATAL(generator_.ConsumeData(kHeadersStreamId, MakeIOVector(""), 0,
 422                                        false, MAY_FEC_PROTECT, nullptr),
 423                 "Attempt to consume empty data without FIN.");
 424 }
 425
 426 TEST_P(QuicPacketGeneratorTest,
 427        ConsumeDataMultipleTimes_WritableAndShouldNotFlush) {
 428   delegate_.SetCanWriteAnything();
 429   generator_.StartBatchOperations();
 430
 431   generator_.ConsumeData(kHeadersStreamId, MakeIOVector("foo"), 2, true,
 432                          MAY_FEC_PROTECT, nullptr);
 433   QuicConsumedData consumed = generator_.ConsumeData(
 434       3, MakeIOVector("quux"), 7, false, MAY_FEC_PROTECT, nullptr);
 435   EXPECT_EQ(4u, consumed.bytes_consumed);
 436   EXPECT_FALSE(consumed.fin_consumed);
 437   EXPECT_TRUE(generator_.HasQueuedFrames());
 438 }
 439
 440 TEST_P(QuicPacketGeneratorTest, ConsumeData_BatchOperations) {
 441   delegate_.SetCanWriteAnything();
 442   generator_.StartBatchOperations();
 443
 444   generator_.ConsumeData(kHeadersStreamId, MakeIOVector("foo"), 2, true,
 445                          MAY_FEC_PROTECT, nullptr);
 446   QuicConsumedData consumed = generator_.ConsumeData(
 447       3, MakeIOVector("quux"), 7, false, MAY_FEC_PROTECT, nullptr);
 448   EXPECT_EQ(4u, consumed.bytes_consumed);
 449   EXPECT_FALSE(consumed.fin_consumed);
 450   EXPECT_TRUE(generator_.HasQueuedFrames());
 451
 452   // Now both frames will be flushed out.
 453   EXPECT_CALL(delegate_, OnSerializedPacket(_))
 454       .WillOnce(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
 455   generator_.FinishBatchOperations();
 456   EXPECT_FALSE(generator_.HasQueuedFrames());
 457
 458   PacketContents contents;
 459   contents.num_stream_frames = 2;
 460   CheckPacketContains(contents, 0);
 461 }
 462
 463 TEST_P(QuicPacketGeneratorTest, ConsumeDataFecOnMaxGroupSize) {
 464   delegate_.SetCanWriteAnything();
 465
 466   // Send FEC every two packets.
 467   creator_->set_max_packets_per_fec_group(2);
 468
 469   {
 470     InSequence dummy;
 471     EXPECT_CALL(delegate_, OnSerializedPacket(_))
 472         .WillOnce(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
 473     EXPECT_CALL(delegate_, OnSerializedPacket(_))
 474         .WillOnce(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
 475     if (generator_.fec_send_policy() == FEC_ALARM_TRIGGER) {
 476       // FEC packet is not sent when send policy is FEC_ALARM_TRIGGER, but FEC
 477       // group is closed.
 478       EXPECT_CALL(delegate_, OnResetFecGroup()).Times(1);
 479     } else {
 480       EXPECT_CALL(delegate_, OnSerializedPacket(_))
 481           .WillOnce(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
 482     }
 483     EXPECT_CALL(delegate_, OnSerializedPacket(_))
 484         .WillOnce(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
 485   }
 486
 487   // Send enough data to create 3 packets: two full and one partial. Send with
 488   // MUST_FEC_PROTECT flag.
 489   size_t data_len = 2 * kDefaultMaxPacketSize + 100;
 490   QuicConsumedData consumed = generator_.ConsumeData(
 491       3, CreateData(data_len), 0, true, MUST_FEC_PROTECT, nullptr);
 492   EXPECT_EQ(data_len, consumed.bytes_consumed);
 493   EXPECT_TRUE(consumed.fin_consumed);
 494   EXPECT_FALSE(generator_.HasQueuedFrames());
 495
 496   CheckPacketHasSingleStreamFrame(0);
 497   CheckPacketHasSingleStreamFrame(1);
 498   if (generator_.fec_send_policy() == FEC_ALARM_TRIGGER) {
 499     // FEC packet is not sent when send policy is FEC_ALARM_TRIGGER.
 500     CheckPacketHasSingleStreamFrame(2);
 501   } else {
 502     CheckPacketIsFec(2, 1);
 503     CheckPacketHasSingleStreamFrame(3);
 504   }
 505   EXPECT_TRUE(creator_->IsFecProtected());
 506
 507   // If FEC send policy is FEC_ANY_TRIGGER, then the FEC packet under
 508   // construction will be sent when one more packet is sent (since FEC group
 509   // size is 2), or when OnFecTimeout is called. Send more data with
 510   // MAY_FEC_PROTECT. This packet should also be protected, and FEC packet is
 511   // sent since FEC group size is reached.
 512   //
 513   // If FEC send policy is FEC_ALARM_TRIGGER, FEC group is closed when the group
 514   // size is reached. FEC packet is not sent.
 515   {
 516     InSequence dummy;
 517     EXPECT_CALL(delegate_, OnSerializedPacket(_))
 518         .WillOnce(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
 519     if (generator_.fec_send_policy() == FEC_ALARM_TRIGGER) {
 520       EXPECT_CALL(delegate_, OnResetFecGroup()).Times(1);
 521     } else {
 522       EXPECT_CALL(delegate_, OnSerializedPacket(_))
 523           .WillOnce(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
 524     }
 525   }
 526   consumed = generator_.ConsumeData(5, CreateData(1u), 0, true, MAY_FEC_PROTECT,
 527                                     nullptr);
 528   EXPECT_EQ(1u, consumed.bytes_consumed);
 529   if (generator_.fec_send_policy() == FEC_ALARM_TRIGGER) {
 530     CheckPacketHasSingleStreamFrame(3);
 531   } else {
 532     CheckPacketHasSingleStreamFrame(4);
 533     CheckPacketIsFec(5, 4);
 534   }
 535   EXPECT_FALSE(creator_->IsFecProtected());
 536 }
 537
 538 TEST_P(QuicPacketGeneratorTest, ConsumeDataSendsFecOnTimeout) {
 539   delegate_.SetCanWriteAnything();
 540   creator_->set_max_packets_per_fec_group(1000);
 541
 542   // Send data with MUST_FEC_PROTECT flag. No FEC packet is emitted, but the
 543   // creator FEC protects all data.
 544   EXPECT_CALL(delegate_, OnSerializedPacket(_))
 545       .WillOnce(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
 546   QuicConsumedData consumed = generator_.ConsumeData(3, CreateData(1u), 0, true,
 547                                                      MUST_FEC_PROTECT, nullptr);
 548   EXPECT_EQ(1u, consumed.bytes_consumed);
 549   EXPECT_TRUE(consumed.fin_consumed);
 550   CheckPacketHasSingleStreamFrame(0);
 551   EXPECT_TRUE(creator_->IsFecProtected());
 552
 553   // Send more data with MAY_FEC_PROTECT. This packet should also be protected,
 554   // and FEC packet is not yet sent.
 555   EXPECT_CALL(delegate_, OnSerializedPacket(_))
 556       .WillOnce(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
 557   consumed = generator_.ConsumeData(5, CreateData(1u), 0, true, MAY_FEC_PROTECT,
 558                                     nullptr);
 559   EXPECT_EQ(1u, consumed.bytes_consumed);
 560   CheckPacketHasSingleStreamFrame(1);
 561   EXPECT_TRUE(creator_->IsFecProtected());
 562
 563   // Calling OnFecTimeout should cause the FEC packet to be emitted.
 564   EXPECT_CALL(delegate_, OnSerializedPacket(_))
 565       .WillOnce(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
 566   generator_.OnFecTimeout();
 567   CheckPacketIsFec(2, 1);
 568   EXPECT_FALSE(creator_->IsFecProtected());
 569
 570   // Subsequent data is protected under the next FEC group. Send enough data to
 571   // create 2 more packets: one full and one partial.
 572   {
 573     InSequence dummy;
 574     EXPECT_CALL(delegate_, OnSerializedPacket(_))
 575         .WillOnce(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
 576     EXPECT_CALL(delegate_, OnSerializedPacket(_))
 577         .WillOnce(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
 578   }
 579   size_t data_len = kDefaultMaxPacketSize + 1;
 580   consumed = generator_.ConsumeData(7, CreateData(data_len), 0, true,
 581                                     MUST_FEC_PROTECT, nullptr);
 582   EXPECT_EQ(data_len, consumed.bytes_consumed);
 583   EXPECT_TRUE(consumed.fin_consumed);
 584   CheckPacketHasSingleStreamFrame(3);
 585   CheckPacketHasSingleStreamFrame(4);
 586   EXPECT_TRUE(creator_->IsFecProtected());
 587
 588   // Calling OnFecTimeout should cause the FEC packet to be emitted.
 589   EXPECT_CALL(delegate_, OnSerializedPacket(_))
 590       .WillOnce(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
 591   generator_.OnFecTimeout();
 592   CheckPacketIsFec(5, 4);
 593   EXPECT_FALSE(creator_->IsFecProtected());
 594 }
 595
 596 TEST_P(QuicPacketGeneratorTest, GetFecTimeoutFiniteOnlyOnFirstPacketInGroup) {
 597   delegate_.SetCanWriteAnything();
 598   creator_->set_max_packets_per_fec_group(6);
 599
 600   // Send enough data to create 2 packets: one full and one partial. Send with
 601   // MUST_FEC_PROTECT flag. No FEC packet is emitted yet, but the creator FEC
 602   // protects all data.
 603   {
 604     InSequence dummy;
 605     EXPECT_CALL(delegate_, OnSerializedPacket(_))
 606         .WillOnce(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
 607     EXPECT_CALL(delegate_, OnSerializedPacket(_))
 608         .WillOnce(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
 609   }
 610   size_t data_len = 1 * kDefaultMaxPacketSize + 100;
 611   QuicConsumedData consumed = generator_.ConsumeData(
 612       3, CreateData(data_len), 0, true, MUST_FEC_PROTECT, nullptr);
 613   EXPECT_EQ(data_len, consumed.bytes_consumed);
 614   EXPECT_TRUE(consumed.fin_consumed);
 615   EXPECT_FALSE(generator_.HasQueuedFrames());
 616   CheckPacketHasSingleStreamFrame(0);
 617   CheckPacketHasSingleStreamFrame(1);
 618   EXPECT_TRUE(creator_->IsFecProtected());
 619
 620   // GetFecTimeout returns finite timeout only for first packet in group.
 621   EXPECT_EQ(QuicTime::Delta::FromMilliseconds(kMinFecTimeoutMs),
 622             generator_.GetFecTimeout(/*sequence_number=*/1u));
 623   EXPECT_EQ(QuicTime::Delta::Infinite(),
 624             generator_.GetFecTimeout(/*sequence_number=*/2u));
 625
 626   // Send more data with MAY_FEC_PROTECT. This packet should also be protected,
 627   // and FEC packet is not yet sent.
 628   EXPECT_CALL(delegate_, OnSerializedPacket(_))
 629       .WillOnce(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
 630   consumed = generator_.ConsumeData(5, CreateData(1u), 0, true, MAY_FEC_PROTECT,
 631                                     nullptr);
 632   CheckPacketHasSingleStreamFrame(2);
 633   EXPECT_TRUE(creator_->IsFecProtected());
 634
 635   // GetFecTimeout returns finite timeout only for first packet in group.
 636   EXPECT_EQ(QuicTime::Delta::Infinite(),
 637             generator_.GetFecTimeout(/*sequence_number=*/3u));
 638
 639   // Calling OnFecTimeout should cause the FEC packet to be emitted.
 640   EXPECT_CALL(delegate_, OnSerializedPacket(_))
 641       .WillOnce(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
 642   generator_.OnFecTimeout();
 643   CheckPacketIsFec(3, /*fec_group=*/1u);
 644   EXPECT_FALSE(creator_->IsFecProtected());
 645
 646   // Subsequent data is protected under the next FEC group. Send enough data to
 647   // create 2 more packets: one full and one partial.
 648   {
 649     InSequence dummy;
 650     EXPECT_CALL(delegate_, OnSerializedPacket(_))
 651         .WillOnce(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
 652     EXPECT_CALL(delegate_, OnSerializedPacket(_))
 653         .WillOnce(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
 654   }
 655   data_len = kDefaultMaxPacketSize + 1u;
 656   consumed = generator_.ConsumeData(7, CreateData(data_len), 0, true,
 657                                     MUST_FEC_PROTECT, nullptr);
 658   EXPECT_EQ(data_len, consumed.bytes_consumed);
 659   EXPECT_TRUE(consumed.fin_consumed);
 660   CheckPacketHasSingleStreamFrame(4);
 661   CheckPacketHasSingleStreamFrame(5);
 662   EXPECT_TRUE(creator_->IsFecProtected());
 663
 664   // GetFecTimeout returns finite timeout for first packet in the new group.
 665   EXPECT_EQ(QuicTime::Delta::FromMilliseconds(kMinFecTimeoutMs),
 666             generator_.GetFecTimeout(/*sequence_number=*/5u));
 667   EXPECT_EQ(QuicTime::Delta::Infinite(),
 668             generator_.GetFecTimeout(/*sequence_number=*/6u));
 669
 670   // Calling OnFecTimeout should cause the FEC packet to be emitted.
 671   EXPECT_CALL(delegate_, OnSerializedPacket(_))
 672       .WillOnce(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
 673   generator_.OnFecTimeout();
 674   CheckPacketIsFec(6, /*fec_group=*/5u);
 675   EXPECT_FALSE(creator_->IsFecProtected());
 676
 677   // Send more data with MAY_FEC_PROTECT. No FEC protection, so GetFecTimeout
 678   // returns infinite.
 679   EXPECT_CALL(delegate_, OnSerializedPacket(_))
 680       .WillOnce(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
 681   consumed = generator_.ConsumeData(9, CreateData(1u), 0, true, MAY_FEC_PROTECT,
 682                                     nullptr);
 683   CheckPacketHasSingleStreamFrame(7);
 684   EXPECT_FALSE(creator_->IsFecProtected());
 685   EXPECT_EQ(QuicTime::Delta::Infinite(),
 686             generator_.GetFecTimeout(/*sequence_number=*/8u));
 687 }
 688
 689 TEST_P(QuicPacketGeneratorTest, ConsumeData_FramesPreviouslyQueued) {
 690   // Set the packet size be enough for two stream frames with 0 stream offset,
 691   // but not enough for a stream frame of 0 offset and one with non-zero offset.
 692   size_t length =
 693       NullEncrypter().GetCiphertextSize(0) +
 694       GetPacketHeaderSize(
 695           creator_->connection_id_length(), true,
 696           QuicPacketCreatorPeer::NextSequenceNumberLength(creator_),
 697           NOT_IN_FEC_GROUP) +
 698       // Add an extra 3 bytes for the payload and 1 byte so BytesFree is larger
 699       // than the GetMinStreamFrameSize.
 700       QuicFramer::GetMinStreamFrameSize(1, 0, false, NOT_IN_FEC_GROUP) + 3 +
 701       QuicFramer::GetMinStreamFrameSize(1, 0, true, NOT_IN_FEC_GROUP) + 1;
 702   generator_.SetMaxPacketLength(length, /*force=*/false);
 703   delegate_.SetCanWriteAnything();
 704   {
 705      InSequence dummy;
 706      EXPECT_CALL(delegate_, OnSerializedPacket(_))
 707          .WillOnce(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
 708      EXPECT_CALL(delegate_, OnSerializedPacket(_))
 709          .WillOnce(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
 710   }
 711   generator_.StartBatchOperations();
 712   // Queue enough data to prevent a stream frame with a non-zero offset from
 713   // fitting.
 714   QuicConsumedData consumed =
 715       generator_.ConsumeData(kHeadersStreamId, MakeIOVector("foo"), 0, false,
 716                              MAY_FEC_PROTECT, nullptr);
 717   EXPECT_EQ(3u, consumed.bytes_consumed);
 718   EXPECT_FALSE(consumed.fin_consumed);
 719   EXPECT_TRUE(generator_.HasQueuedFrames());
 720
 721   // This frame will not fit with the existing frame, causing the queued frame
 722   // to be serialized, and it will not fit with another frame like it, so it is
 723   // serialized by itself.
 724   consumed = generator_.ConsumeData(kHeadersStreamId, MakeIOVector("bar"), 3,
 725                                     true, MAY_FEC_PROTECT, nullptr);
 726   EXPECT_EQ(3u, consumed.bytes_consumed);
 727   EXPECT_TRUE(consumed.fin_consumed);
 728   EXPECT_FALSE(generator_.HasQueuedFrames());
 729
 730   PacketContents contents;
 731   contents.num_stream_frames = 1;
 732   CheckPacketContains(contents, 0);
 733   CheckPacketContains(contents, 1);
 734 }
 735
 736 TEST_P(QuicPacketGeneratorTest, NoFecPacketSentWhenBatchEnds) {
 737   delegate_.SetCanWriteAnything();
 738   creator_->set_max_packets_per_fec_group(6);
 739
 740   generator_.StartBatchOperations();
 741
 742   generator_.ConsumeData(3, MakeIOVector("foo"), 2, true, MUST_FEC_PROTECT,
 743                          nullptr);
 744   QuicConsumedData consumed = generator_.ConsumeData(
 745       5, MakeIOVector("quux"), 7, false, MUST_FEC_PROTECT, nullptr);
 746   EXPECT_EQ(4u, consumed.bytes_consumed);
 747   EXPECT_FALSE(consumed.fin_consumed);
 748   EXPECT_TRUE(generator_.HasQueuedFrames());
 749
 750   // Now both frames will be flushed out, but FEC packet is not yet sent.
 751   EXPECT_CALL(delegate_, OnSerializedPacket(_))
 752       .WillOnce(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
 753   generator_.FinishBatchOperations();
 754   EXPECT_FALSE(generator_.HasQueuedFrames());
 755
 756   PacketContents contents;
 757   contents.num_stream_frames = 2u;
 758   contents.fec_group = 1u;
 759   CheckPacketContains(contents, 0);
 760
 761   // Forcing FEC timeout causes FEC packet to be emitted.
 762   EXPECT_CALL(delegate_, OnSerializedPacket(_))
 763       .WillOnce(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
 764   generator_.OnFecTimeout();
 765   CheckPacketIsFec(1, /*fec_group=*/1u);
 766 }
 767
 768 TEST_P(QuicPacketGeneratorTest, FecTimeoutOnRttChange) {
 769   EXPECT_EQ(QuicTime::Delta::Zero(),
 770             QuicPacketGeneratorPeer::GetFecTimeout(&generator_));
 771   generator_.OnRttChange(QuicTime::Delta::FromMilliseconds(300));
 772   EXPECT_EQ(QuicTime::Delta::FromMilliseconds(150),
 773             QuicPacketGeneratorPeer::GetFecTimeout(&generator_));
 774 }
 775
 776 TEST_P(QuicPacketGeneratorTest, FecGroupSizeOnCongestionWindowChange) {
 777   delegate_.SetCanWriteAnything();
 778   creator_->set_max_packets_per_fec_group(50);
 779   EXPECT_EQ(50u, creator_->max_packets_per_fec_group());
 780   EXPECT_FALSE(creator_->IsFecGroupOpen());
 781
 782   // On reduced cwnd.
 783   generator_.OnCongestionWindowChange(7);
 784   EXPECT_EQ(3u, creator_->max_packets_per_fec_group());
 785
 786   // On increased cwnd.
 787   generator_.OnCongestionWindowChange(100);
 788   EXPECT_EQ(50u, creator_->max_packets_per_fec_group());
 789
 790   // On collapsed cwnd.
 791   generator_.OnCongestionWindowChange(1);
 792   EXPECT_EQ(2u, creator_->max_packets_per_fec_group());
 793 }
 794
 795 TEST_P(QuicPacketGeneratorTest, FecGroupSizeChangeWithOpenGroup) {
 796   delegate_.SetCanWriteAnything();
 797   generator_.StartBatchOperations();
 798   creator_->set_max_packets_per_fec_group(50);
 799   EXPECT_EQ(50u, creator_->max_packets_per_fec_group());
 800   EXPECT_FALSE(creator_->IsFecGroupOpen());
 801
 802   // Send enough data to create 4 packets with MUST_FEC_PROTECT flag. 3 packets
 803   // are sent, one is queued in the creator.
 804   {
 805     InSequence dummy;
 806     EXPECT_CALL(delegate_, OnSerializedPacket(_))
 807         .WillOnce(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
 808     EXPECT_CALL(delegate_, OnSerializedPacket(_))
 809         .WillOnce(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
 810     EXPECT_CALL(delegate_, OnSerializedPacket(_))
 811         .WillOnce(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
 812   }
 813   size_t data_len = 3 * kDefaultMaxPacketSize + 1;
 814   QuicConsumedData consumed = generator_.ConsumeData(
 815       7, CreateData(data_len), 0, true, MUST_FEC_PROTECT, nullptr);
 816   EXPECT_EQ(data_len, consumed.bytes_consumed);
 817   EXPECT_TRUE(creator_->IsFecGroupOpen());
 818
 819   // Change FEC groupsize.
 820   generator_.OnCongestionWindowChange(2);
 821   EXPECT_EQ(2u, creator_->max_packets_per_fec_group());
 822
 823   // If FEC send policy is FEC_ANY_TRIGGER, then send enough data to trigger one
 824   // unprotected data packet, causing the FEC packet to also be sent.
 825   //
 826   // If FEC send policy is FEC_ALARM_TRIGGER, FEC group is closed and FEC packet
 827   // is not sent.
 828   {
 829     InSequence dummy;
 830     EXPECT_CALL(delegate_, OnSerializedPacket(_))
 831         .WillOnce(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
 832     if (generator_.fec_send_policy() == FEC_ALARM_TRIGGER) {
 833       EXPECT_CALL(delegate_, OnResetFecGroup()).Times(1);
 834     } else {
 835       EXPECT_CALL(delegate_, OnSerializedPacket(_))
 836           .WillOnce(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
 837     }
 838   }
 839   consumed = generator_.ConsumeData(7, CreateData(kDefaultMaxPacketSize), 0,
 840                                     true, MAY_FEC_PROTECT, nullptr);
 841   EXPECT_EQ(kDefaultMaxPacketSize, consumed.bytes_consumed);
 842   if (generator_.fec_send_policy() == FEC_ANY_TRIGGER) {
 843     // Verify that one FEC packet was sent.
 844     CheckPacketIsFec(4, /*fec_group=*/1u);
 845   }
 846   EXPECT_FALSE(creator_->IsFecGroupOpen());
 847   EXPECT_FALSE(creator_->IsFecProtected());
 848 }
 849
 850 TEST_P(QuicPacketGeneratorTest, SwitchFecOnOff) {
 851   delegate_.SetCanWriteAnything();
 852   creator_->set_max_packets_per_fec_group(2);
 853   EXPECT_FALSE(creator_->IsFecProtected());
 854
 855   // Send one unprotected data packet.
 856   EXPECT_CALL(delegate_, OnSerializedPacket(_))
 857       .WillOnce(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
 858   QuicConsumedData consumed = generator_.ConsumeData(5, CreateData(1u), 0, true,
 859                                                      MAY_FEC_PROTECT, nullptr);
 860   EXPECT_EQ(1u, consumed.bytes_consumed);
 861   EXPECT_FALSE(generator_.HasQueuedFrames());
 862   EXPECT_FALSE(creator_->IsFecProtected());
 863   // Verify that one data packet was sent.
 864   PacketContents contents;
 865   contents.num_stream_frames = 1;
 866   CheckPacketContains(contents, 0);
 867
 868   {
 869     InSequence dummy;
 870     EXPECT_CALL(delegate_, OnSerializedPacket(_))
 871         .WillOnce(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
 872     EXPECT_CALL(delegate_, OnSerializedPacket(_))
 873         .WillOnce(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
 874     if (generator_.fec_send_policy() == FEC_ALARM_TRIGGER) {
 875       // If FEC send policy is FEC_ALARM_TRIGGER, FEC group is closed.
 876       EXPECT_CALL(delegate_, OnResetFecGroup()).Times(1);
 877     } else {
 878       EXPECT_CALL(delegate_, OnSerializedPacket(_))
 879           .WillOnce(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
 880     }
 881     EXPECT_CALL(delegate_, OnSerializedPacket(_))
 882         .WillOnce(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
 883   }
 884   // Send enough data to create 3 packets with MUST_FEC_PROTECT flag.
 885   size_t data_len = 2 * kDefaultMaxPacketSize + 100;
 886   consumed = generator_.ConsumeData(7, CreateData(data_len), 0, true,
 887                                     MUST_FEC_PROTECT, nullptr);
 888   EXPECT_EQ(data_len, consumed.bytes_consumed);
 889   EXPECT_FALSE(generator_.HasQueuedFrames());
 890
 891   // If FEC send policy is FEC_ANY_TRIGGER, verify that packets sent were 3 data
 892   // and 1 FEC.
 893   //
 894   // If FEC send policy is FEC_ALARM_TRIGGER, verify that packets sent were 3
 895   // data and FEC group is closed.
 896   CheckPacketHasSingleStreamFrame(1);
 897   CheckPacketHasSingleStreamFrame(2);
 898   if (generator_.fec_send_policy() == FEC_ALARM_TRIGGER) {
 899     CheckPacketHasSingleStreamFrame(3);
 900   } else {
 901     CheckPacketIsFec(3, /*fec_group=*/2u);
 902     CheckPacketHasSingleStreamFrame(4);
 903   }
 904
 905   // Calling OnFecTimeout should emit the pending FEC packet.
 906   EXPECT_CALL(delegate_, OnSerializedPacket(_))
 907       .WillOnce(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
 908   generator_.OnFecTimeout();
 909   if (generator_.fec_send_policy() == FEC_ALARM_TRIGGER) {
 910     CheckPacketIsFec(4, /*fec_group=*/4u);
 911   } else {
 912     CheckPacketIsFec(5, /*fec_group=*/5u);
 913   }
 914
 915   // Send one unprotected data packet.
 916   EXPECT_CALL(delegate_, OnSerializedPacket(_))
 917       .WillOnce(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
 918   consumed = generator_.ConsumeData(7, CreateData(1u), 0, true, MAY_FEC_PROTECT,
 919                                     nullptr);
 920   EXPECT_EQ(1u, consumed.bytes_consumed);
 921   EXPECT_FALSE(generator_.HasQueuedFrames());
 922   EXPECT_FALSE(creator_->IsFecProtected());
 923   // Verify that one unprotected data packet was sent.
 924   if (generator_.fec_send_policy() == FEC_ALARM_TRIGGER) {
 925     CheckPacketContains(contents, 5);
 926   } else {
 927     CheckPacketContains(contents, 6);
 928   }
 929 }
 930
 931 TEST_P(QuicPacketGeneratorTest, SwitchFecOnWithPendingFrameInCreator) {
 932   delegate_.SetCanWriteAnything();
 933   // Enable FEC.
 934   creator_->set_max_packets_per_fec_group(2);
 935
 936   generator_.StartBatchOperations();
 937   // Queue enough data to prevent a stream frame with a non-zero offset from
 938   // fitting.
 939   QuicConsumedData consumed = generator_.ConsumeData(7, CreateData(1u), 0, true,
 940                                                      MAY_FEC_PROTECT, nullptr);
 941   EXPECT_EQ(1u, consumed.bytes_consumed);
 942   EXPECT_TRUE(creator_->HasPendingFrames());
 943
 944   // Queue protected data for sending. Should cause queued frames to be flushed.
 945   EXPECT_CALL(delegate_, OnSerializedPacket(_))
 946       .WillOnce(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
 947   EXPECT_FALSE(creator_->IsFecProtected());
 948   consumed = generator_.ConsumeData(7, CreateData(1u), 0, true,
 949                                     MUST_FEC_PROTECT, nullptr);
 950   EXPECT_EQ(1u, consumed.bytes_consumed);
 951   PacketContents contents;
 952   contents.num_stream_frames = 1;
 953   // Transmitted packet was not FEC protected.
 954   CheckPacketContains(contents, 0);
 955   EXPECT_TRUE(creator_->IsFecProtected());
 956   EXPECT_TRUE(creator_->HasPendingFrames());
 957 }
 958
 959 TEST_P(QuicPacketGeneratorTest, SwitchFecOnWithPendingFramesInGenerator) {
 960   // Enable FEC.
 961   creator_->set_max_packets_per_fec_group(2);
 962
 963   // Queue control frames in generator.
 964   delegate_.SetCanNotWrite();
 965   generator_.SetShouldSendAck(true);
 966   delegate_.SetCanWriteAnything();
 967   generator_.StartBatchOperations();
 968
 969   // Set up frames to write into the creator when control frames are written.
 970   EXPECT_CALL(delegate_, PopulateAckFrame(_));
 971   EXPECT_CALL(delegate_, PopulateStopWaitingFrame(_));
 972
 973   // Generator should have queued control frames, and creator should be empty.
 974   EXPECT_TRUE(generator_.HasQueuedFrames());
 975   EXPECT_FALSE(creator_->HasPendingFrames());
 976   EXPECT_FALSE(creator_->IsFecProtected());
 977
 978   // Queue protected data for sending. Should cause queued frames to be flushed.
 979   EXPECT_CALL(delegate_, OnSerializedPacket(_))
 980       .WillOnce(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
 981   QuicConsumedData consumed = generator_.ConsumeData(7, CreateData(1u), 0, true,
 982                                                      MUST_FEC_PROTECT, nullptr);
 983   EXPECT_EQ(1u, consumed.bytes_consumed);
 984   PacketContents contents;
 985   contents.num_ack_frames = 1;
 986   contents.num_stop_waiting_frames = 1;
 987   CheckPacketContains(contents, 0);
 988
 989   // FEC protection should be on in creator.
 990   EXPECT_TRUE(creator_->IsFecProtected());
 991 }
 992
 993 TEST_P(QuicPacketGeneratorTest, SwitchFecOnOffWithSubsequentFramesProtected) {
 994   delegate_.SetCanWriteAnything();
 995
 996   // Enable FEC.
 997   creator_->set_max_packets_per_fec_group(2);
 998   EXPECT_FALSE(creator_->IsFecProtected());
 999
1000   // Queue stream frame to be protected in creator.
1001   generator_.StartBatchOperations();
1002   QuicConsumedData consumed = generator_.ConsumeData(5, CreateData(1u), 0, true,
1003                                                      MUST_FEC_PROTECT, nullptr);
1004   EXPECT_EQ(1u, consumed.bytes_consumed);
1005   // Creator has a pending protected frame.
1006   EXPECT_TRUE(creator_->HasPendingFrames());
1007   EXPECT_TRUE(creator_->IsFecProtected());
1008
1009   // Add enough unprotected data to exceed size of current packet, so that
1010   // current packet is sent. Both frames will be sent out in a single packet.
1011   EXPECT_CALL(delegate_, OnSerializedPacket(_))
1012       .WillOnce(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
1013   size_t data_len = kDefaultMaxPacketSize;
1014   consumed = generator_.ConsumeData(5, CreateData(data_len), 0, true,
1015                                     MAY_FEC_PROTECT, nullptr);
1016   EXPECT_EQ(data_len, consumed.bytes_consumed);
1017   PacketContents contents;
1018   contents.num_stream_frames = 2u;
1019   contents.fec_group = 1u;
1020   CheckPacketContains(contents, 0);
1021   // FEC protection should still be on in creator.
1022   EXPECT_TRUE(creator_->IsFecProtected());
1023 }
1024
1025 TEST_P(QuicPacketGeneratorTest, SwitchFecOnOffWithSubsequentPacketsProtected) {
1026   delegate_.SetCanWriteAnything();
1027
1028   // Enable FEC.
1029   creator_->set_max_packets_per_fec_group(2);
1030   EXPECT_FALSE(creator_->IsFecProtected());
1031
1032   // Send first packet, FEC protected.
1033   EXPECT_CALL(delegate_, OnSerializedPacket(_))
1034       .WillOnce(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
1035   QuicConsumedData consumed = generator_.ConsumeData(5, CreateData(1u), 0, true,
1036                                                      MUST_FEC_PROTECT, nullptr);
1037   EXPECT_EQ(1u, consumed.bytes_consumed);
1038   PacketContents contents;
1039   contents.num_stream_frames = 1u;
1040   contents.fec_group = 1u;
1041   CheckPacketContains(contents, 0);
1042
1043   // FEC should still be on in creator.
1044   EXPECT_TRUE(creator_->IsFecProtected());
1045
1046   // Send unprotected data to cause second packet to be sent, which gets
1047   // protected because it happens to fall within an open FEC group. Data packet
1048   // will be followed by FEC packet.
1049   {
1050     InSequence dummy;
1051     EXPECT_CALL(delegate_, OnSerializedPacket(_))
1052         .WillOnce(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
1053     if (generator_.fec_send_policy() == FEC_ALARM_TRIGGER) {
1054       EXPECT_CALL(delegate_, OnResetFecGroup()).Times(1);
1055     } else {
1056       EXPECT_CALL(delegate_, OnSerializedPacket(_))
1057           .WillOnce(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
1058     }
1059   }
1060   consumed = generator_.ConsumeData(5, CreateData(1u), 0, true, MAY_FEC_PROTECT,
1061                                     nullptr);
1062   EXPECT_EQ(1u, consumed.bytes_consumed);
1063   contents.num_stream_frames = 1u;
1064   CheckPacketContains(contents, 1);
1065   if (generator_.fec_send_policy() == FEC_ANY_TRIGGER) {
1066     // FEC packet is sent when send policy is FEC_ANY_TRIGGER.
1067     CheckPacketIsFec(2, /*fec_group=*/1u);
1068   }
1069
1070   // FEC protection should be off in creator.
1071   EXPECT_FALSE(creator_->IsFecProtected());
1072 }
1073
1074 TEST_P(QuicPacketGeneratorTest, SwitchFecOnOffThenOnWithCreatorProtectionOn) {
1075   delegate_.SetCanWriteAnything();
1076   generator_.StartBatchOperations();
1077
1078   // Enable FEC.
1079   creator_->set_max_packets_per_fec_group(2);
1080   EXPECT_FALSE(creator_->IsFecProtected());
1081
1082   // Queue one byte of FEC protected data.
1083   QuicConsumedData consumed = generator_.ConsumeData(5, CreateData(1u), 0, true,
1084                                                      MUST_FEC_PROTECT, nullptr);
1085   EXPECT_TRUE(creator_->HasPendingFrames());
1086
1087   // Add more unprotected data causing first packet to be sent, FEC protected.
1088   EXPECT_CALL(delegate_, OnSerializedPacket(_))
1089       .WillOnce(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
1090   size_t data_len = kDefaultMaxPacketSize;
1091   consumed = generator_.ConsumeData(5, CreateData(data_len), 0, true,
1092                                     MAY_FEC_PROTECT, nullptr);
1093   EXPECT_EQ(data_len, consumed.bytes_consumed);
1094   PacketContents contents;
1095   contents.num_stream_frames = 2u;
1096   contents.fec_group = 1u;
1097   CheckPacketContains(contents, 0);
1098
1099   // FEC group is still open in creator.
1100   EXPECT_TRUE(creator_->IsFecProtected());
1101
1102   // Add data that should be protected, large enough to cause second packet to
1103   // be sent. Data packet should be followed by FEC packet.
1104   {
1105     InSequence dummy;
1106     EXPECT_CALL(delegate_, OnSerializedPacket(_))
1107         .WillOnce(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
1108     if (generator_.fec_send_policy() == FEC_ALARM_TRIGGER) {
1109       EXPECT_CALL(delegate_, OnResetFecGroup()).Times(1);
1110     } else {
1111       EXPECT_CALL(delegate_, OnSerializedPacket(_))
1112           .WillOnce(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
1113     }
1114   }
1115   consumed = generator_.ConsumeData(5, CreateData(data_len), 0, true,
1116                                     MUST_FEC_PROTECT, nullptr);
1117   EXPECT_EQ(data_len, consumed.bytes_consumed);
1118   CheckPacketContains(contents, 1);
1119   if (generator_.fec_send_policy() == FEC_ANY_TRIGGER) {
1120     // FEC packet is sent when send policy is FEC_ANY_TRIGGER.
1121     CheckPacketIsFec(2, /*fec_group=*/1u);
1122   }
1123
1124   // FEC protection should remain on in creator.
1125   EXPECT_TRUE(creator_->IsFecProtected());
1126 }
1127
1128 TEST_P(QuicPacketGeneratorTest, ResetFecGroupNoTimeout) {
1129   delegate_.SetCanWriteAnything();
1130   // Send FEC packet after 2 packets.
1131   creator_->set_max_packets_per_fec_group(2);
1132   EXPECT_FALSE(creator_->IsFecProtected());
1133
1134   // Send two packets so that when this data is consumed, two packets are sent
1135   // out. In FEC_TRIGGER_ANY, this will cause an FEC packet to be sent out and
1136   // with FEC_TRIGGER_ALARM, this will cause a Reset to be called. In both
1137   // cases, the creator's fec protection will be turned off afterwards.
1138   {
1139     InSequence dummy;
1140     EXPECT_CALL(delegate_, OnSerializedPacket(_))
1141         .WillOnce(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
1142     EXPECT_CALL(delegate_, OnSerializedPacket(_))
1143         .WillOnce(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
1144     if (generator_.fec_send_policy() == FEC_ALARM_TRIGGER) {
1145       // FEC packet is not sent when send policy is FEC_ALARM_TRIGGER, but FEC
1146       // group is closed.
1147       EXPECT_CALL(delegate_, OnResetFecGroup()).Times(1);
1148     } else {
1149       EXPECT_CALL(delegate_, OnSerializedPacket(_))
1150           .WillOnce(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
1151     }
1152     // Fin Packet.
1153     EXPECT_CALL(delegate_, OnSerializedPacket(_))
1154         .WillOnce(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
1155   }
1156   size_t data_len = 2 * kDefaultMaxPacketSize;
1157   QuicConsumedData consumed = generator_.ConsumeData(
1158       5, CreateData(data_len), 0, true, MUST_FEC_PROTECT, nullptr);
1159   EXPECT_EQ(data_len, consumed.bytes_consumed);
1160   EXPECT_TRUE(consumed.fin_consumed);
1161   EXPECT_FALSE(generator_.HasQueuedFrames());
1162   CheckPacketHasSingleStreamFrame(0);
1163   CheckPacketHasSingleStreamFrame(1);
1164   if (generator_.fec_send_policy() == FEC_ALARM_TRIGGER) {
1165     // FEC packet is not sent when send policy is FEC_ALARM_TRIGGER.
1166     CheckPacketHasSingleStreamFrame(2);
1167   } else {
1168     // FEC packet is sent after 2 packets and when send policy is
1169     // FEC_ANY_TRIGGER.
1170     CheckPacketIsFec(2, 1);
1171     CheckPacketHasSingleStreamFrame(3);
1172   }
1173   EXPECT_TRUE(creator_->IsFecProtected());
1174
1175   // Do the same send  (with MUST_FEC_PROTECT) on a different stream id.
1176   {
1177     InSequence dummy;
1178     EXPECT_CALL(delegate_, OnSerializedPacket(_))
1179         .WillOnce(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
1180     // FEC packet is sent after 2 packets and when send policy is
1181     // FEC_ANY_TRIGGER. When policy is FEC_ALARM_TRIGGER, FEC group is closed
1182     // and FEC packet is not sent.
1183     if (generator_.fec_send_policy() == FEC_ALARM_TRIGGER) {
1184       EXPECT_CALL(delegate_, OnResetFecGroup()).Times(1);
1185     } else {
1186       EXPECT_CALL(delegate_, OnSerializedPacket(_))
1187           .WillOnce(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
1188     }
1189     EXPECT_CALL(delegate_, OnSerializedPacket(_))
1190         .WillOnce(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
1191     EXPECT_CALL(delegate_, OnSerializedPacket(_))
1192         .WillOnce(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
1193     // FEC packet is sent after 2 packets and when send policy is
1194     // FEC_ANY_TRIGGER. When policy is FEC_ALARM_TRIGGER, FEC group is closed
1195     // and FEC packet is not sent.
1196     if (generator_.fec_send_policy() == FEC_ALARM_TRIGGER) {
1197       EXPECT_CALL(delegate_, OnResetFecGroup()).Times(1);
1198     } else {
1199       EXPECT_CALL(delegate_, OnSerializedPacket(_))
1200           .WillOnce(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
1201     }
1202   }
1203   consumed = generator_.ConsumeData(7, CreateData(data_len), 0, true,
1204                                     MUST_FEC_PROTECT, nullptr);
1205   EXPECT_EQ(data_len, consumed.bytes_consumed);
1206   EXPECT_TRUE(consumed.fin_consumed);
1207   EXPECT_FALSE(generator_.HasQueuedFrames());
1208   if (generator_.fec_send_policy() == FEC_ALARM_TRIGGER) {
1209     CheckPacketHasSingleStreamFrame(3);
1210     CheckPacketHasSingleStreamFrame(4);
1211     CheckPacketHasSingleStreamFrame(5);
1212   } else {
1213     CheckPacketHasSingleStreamFrame(4);
1214     // FEC packet is sent after 2 packets and when send policy is
1215     // FEC_ANY_TRIGGER.
1216     CheckPacketIsFec(5, 4);
1217     CheckPacketHasSingleStreamFrame(6);
1218     CheckPacketHasSingleStreamFrame(7);
1219     // FEC packet is sent after 2 packets and when send policy is
1220     // FEC_ANY_TRIGGER.
1221     CheckPacketIsFec(8, 7);
1222   }
1223   EXPECT_TRUE(creator_->IsFecProtected());
1224 }
1225
1226 // 1. Create and send one packet with MUST_FEC_PROTECT.
1227 // 2. Call FecTimeout, expect FEC packet is sent.
1228 // 3. Do the same thing over again, with a different stream id.
1229 TEST_P(QuicPacketGeneratorTest, FecPacketSentOnFecTimeout) {
1230   delegate_.SetCanWriteAnything();
1231   creator_->set_max_packets_per_fec_group(1000);
1232   EXPECT_FALSE(creator_->IsFecProtected());
1233
1234   for (int i = 1; i < 4; i = i + 2) {
1235     // Send data with MUST_FEC_PROTECT flag. No FEC packet is emitted, but the
1236     // creator FEC protects all data.
1237     EXPECT_CALL(delegate_, OnSerializedPacket(_))
1238         .WillOnce(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
1239     QuicConsumedData consumed = generator_.ConsumeData(
1240         i + 2, CreateData(1u), 0, true, MUST_FEC_PROTECT, nullptr);
1241     EXPECT_EQ(1u, consumed.bytes_consumed);
1242     EXPECT_TRUE(consumed.fin_consumed);
1243     CheckPacketHasSingleStreamFrame(0);
1244     EXPECT_TRUE(creator_->IsFecProtected());
1245
1246     // Calling OnFecTimeout should cause the FEC packet to be emitted.
1247     EXPECT_CALL(delegate_, OnSerializedPacket(_))
1248         .WillOnce(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
1249     generator_.OnFecTimeout();
1250     CheckPacketIsFec(i, i);
1251     EXPECT_FALSE(creator_->IsFecProtected());
1252   }
1253 }
1254
1255 TEST_P(QuicPacketGeneratorTest, NotWritableThenBatchOperations) {
1256   delegate_.SetCanNotWrite();
1257
1258   generator_.SetShouldSendAck(false);
1259   generator_.AddControlFrame(QuicFrame(CreateRstStreamFrame()));
1260   EXPECT_TRUE(generator_.HasQueuedFrames());
1261
1262   delegate_.SetCanWriteAnything();
1263
1264   generator_.StartBatchOperations();
1265
1266   // When the first write operation is invoked, the ack frame will be returned.
1267   EXPECT_CALL(delegate_, PopulateAckFrame(_));
1268
1269   // Send some data and a control frame
1270   generator_.ConsumeData(3, MakeIOVector("quux"), 7, false, MAY_FEC_PROTECT,
1271                          nullptr);
1272   generator_.AddControlFrame(QuicFrame(CreateGoAwayFrame()));
1273
1274   // All five frames will be flushed out in a single packet.
1275   EXPECT_CALL(delegate_, OnSerializedPacket(_))
1276       .WillOnce(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
1277   generator_.FinishBatchOperations();
1278   EXPECT_FALSE(generator_.HasQueuedFrames());
1279
1280   PacketContents contents;
1281   contents.num_ack_frames = 1;
1282   contents.num_goaway_frames = 1;
1283   contents.num_rst_stream_frames = 1;
1284   contents.num_stream_frames = 1;
1285   CheckPacketContains(contents, 0);
1286 }
1287
1288 TEST_P(QuicPacketGeneratorTest, NotWritableThenBatchOperations2) {
1289   delegate_.SetCanNotWrite();
1290
1291   generator_.SetShouldSendAck(false);
1292   generator_.AddControlFrame(QuicFrame(CreateRstStreamFrame()));
1293   EXPECT_TRUE(generator_.HasQueuedFrames());
1294
1295   delegate_.SetCanWriteAnything();
1296
1297   generator_.StartBatchOperations();
1298
1299   // When the first write operation is invoked, the ack frame will be returned.
1300   EXPECT_CALL(delegate_, PopulateAckFrame(_));
1301
1302   {
1303     InSequence dummy;
1304     // All five frames will be flushed out in a single packet
1305     EXPECT_CALL(delegate_, OnSerializedPacket(_))
1306         .WillOnce(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
1307     EXPECT_CALL(delegate_, OnSerializedPacket(_))
1308         .WillOnce(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
1309   }
1310
1311   // Send enough data to exceed one packet
1312   size_t data_len = kDefaultMaxPacketSize + 100;
1313   QuicConsumedData consumed = generator_.ConsumeData(
1314       3, CreateData(data_len), 0, true, MAY_FEC_PROTECT, nullptr);
1315   EXPECT_EQ(data_len, consumed.bytes_consumed);
1316   EXPECT_TRUE(consumed.fin_consumed);
1317   generator_.AddControlFrame(QuicFrame(CreateGoAwayFrame()));
1318
1319   generator_.FinishBatchOperations();
1320   EXPECT_FALSE(generator_.HasQueuedFrames());
1321
1322   // The first packet should have the queued data and part of the stream data.
1323   PacketContents contents;
1324   contents.num_ack_frames = 1;
1325   contents.num_rst_stream_frames = 1;
1326   contents.num_stream_frames = 1;
1327   CheckPacketContains(contents, 0);
1328
1329   // The second should have the remainder of the stream data.
1330   PacketContents contents2;
1331   contents2.num_goaway_frames = 1;
1332   contents2.num_stream_frames = 1;
1333   CheckPacketContains(contents2, 1);
1334 }
1335
1336 TEST_P(QuicPacketGeneratorTest, TestConnectionIdLength) {
1337   generator_.SetConnectionIdLength(0);
1338   EXPECT_EQ(PACKET_0BYTE_CONNECTION_ID, creator_->connection_id_length());
1339   generator_.SetConnectionIdLength(1);
1340   EXPECT_EQ(PACKET_1BYTE_CONNECTION_ID, creator_->connection_id_length());
1341   generator_.SetConnectionIdLength(2);
1342   EXPECT_EQ(PACKET_4BYTE_CONNECTION_ID, creator_->connection_id_length());
1343   generator_.SetConnectionIdLength(3);
1344   EXPECT_EQ(PACKET_4BYTE_CONNECTION_ID, creator_->connection_id_length());
1345   generator_.SetConnectionIdLength(4);
1346   EXPECT_EQ(PACKET_4BYTE_CONNECTION_ID, creator_->connection_id_length());
1347   generator_.SetConnectionIdLength(5);
1348   EXPECT_EQ(PACKET_8BYTE_CONNECTION_ID, creator_->connection_id_length());
1349   generator_.SetConnectionIdLength(6);
1350   EXPECT_EQ(PACKET_8BYTE_CONNECTION_ID, creator_->connection_id_length());
1351   generator_.SetConnectionIdLength(7);
1352   EXPECT_EQ(PACKET_8BYTE_CONNECTION_ID, creator_->connection_id_length());
1353   generator_.SetConnectionIdLength(8);
1354   EXPECT_EQ(PACKET_8BYTE_CONNECTION_ID, creator_->connection_id_length());
1355   generator_.SetConnectionIdLength(9);
1356   EXPECT_EQ(PACKET_8BYTE_CONNECTION_ID, creator_->connection_id_length());
1357 }
1358
1359 // Test whether SetMaxPacketLength() works in the situation when the queue is
1360 // empty, and we send three packets worth of data.
1361 TEST_P(QuicPacketGeneratorTest, SetMaxPacketLength_Initial) {
1362   delegate_.SetCanWriteAnything();
1363
1364   // Send enough data for three packets.
1365   size_t data_len = 3 * kDefaultMaxPacketSize + 1;
1366   size_t packet_len = kDefaultMaxPacketSize + 100;
1367   ASSERT_LE(packet_len, kMaxPacketSize);
1368   generator_.SetMaxPacketLength(packet_len, /*force=*/false);
1369   EXPECT_EQ(packet_len, generator_.GetCurrentMaxPacketLength());
1370
1371   EXPECT_CALL(delegate_, OnSerializedPacket(_))
1372       .Times(3)
1373       .WillRepeatedly(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
1374   QuicConsumedData consumed =
1375       generator_.ConsumeData(kHeadersStreamId, CreateData(data_len),
1376                              /*offset=*/2,
1377                              /*fin=*/true, MAY_FEC_PROTECT, nullptr);
1378   EXPECT_EQ(data_len, consumed.bytes_consumed);
1379   EXPECT_TRUE(consumed.fin_consumed);
1380   EXPECT_FALSE(generator_.HasQueuedFrames());
1381
1382   // We expect three packets, and first two of them have to be of packet_len
1383   // size.  We check multiple packets (instead of just one) because we want to
1384   // ensure that |max_packet_length_| does not get changed incorrectly by the
1385   // generator after first packet is serialized.
1386   ASSERT_EQ(3u, packets_.size());
1387   EXPECT_EQ(packet_len, packets_[0].packet->length());
1388   EXPECT_EQ(packet_len, packets_[1].packet->length());
1389   CheckAllPacketsHaveSingleStreamFrame();
1390 }
1391
1392 // Test whether SetMaxPacketLength() works in the situation when we first write
1393 // data, then change packet size, then write data again.
1394 TEST_P(QuicPacketGeneratorTest, SetMaxPacketLength_Middle) {
1395   delegate_.SetCanWriteAnything();
1396
1397   // We send enough data to overflow default packet length, but not the altered
1398   // one.
1399   size_t data_len = kDefaultMaxPacketSize;
1400   size_t packet_len = kDefaultMaxPacketSize + 100;
1401   ASSERT_LE(packet_len, kMaxPacketSize);
1402
1403   // We expect to see three packets in total.
1404   EXPECT_CALL(delegate_, OnSerializedPacket(_))
1405       .Times(3)
1406       .WillRepeatedly(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
1407
1408   // Send two packets before packet size change.
1409   QuicConsumedData consumed =
1410       generator_.ConsumeData(kHeadersStreamId, CreateData(data_len),
1411                              /*offset=*/2,
1412                              /*fin=*/false, MAY_FEC_PROTECT, nullptr);
1413   EXPECT_EQ(data_len, consumed.bytes_consumed);
1414   EXPECT_FALSE(consumed.fin_consumed);
1415   EXPECT_FALSE(generator_.HasQueuedFrames());
1416
1417   // Make sure we already have two packets.
1418   ASSERT_EQ(2u, packets_.size());
1419
1420   // Increase packet size.
1421   generator_.SetMaxPacketLength(packet_len, /*force=*/false);
1422   EXPECT_EQ(packet_len, generator_.GetCurrentMaxPacketLength());
1423
1424   // Send a packet after packet size change.
1425   consumed = generator_.ConsumeData(kHeadersStreamId, CreateData(data_len),
1426                                     2 + data_len,
1427                                     /*fin=*/true, MAY_FEC_PROTECT, nullptr);
1428   EXPECT_EQ(data_len, consumed.bytes_consumed);
1429   EXPECT_TRUE(consumed.fin_consumed);
1430   EXPECT_FALSE(generator_.HasQueuedFrames());
1431
1432   // We expect first data chunk to get fragmented, but the second one to fit
1433   // into a single packet.
1434   ASSERT_EQ(3u, packets_.size());
1435   EXPECT_EQ(kDefaultMaxPacketSize, packets_[0].packet->length());
1436   EXPECT_LE(kDefaultMaxPacketSize, packets_[2].packet->length());
1437   CheckAllPacketsHaveSingleStreamFrame();
1438 }
1439
1440 // Test whether SetMaxPacketLength() works correctly when we change the packet
1441 // size in the middle of the batched packet.
1442 TEST_P(QuicPacketGeneratorTest, SetMaxPacketLength_Midpacket) {
1443   delegate_.SetCanWriteAnything();
1444   generator_.StartBatchOperations();
1445
1446   size_t first_write_len = kDefaultMaxPacketSize / 2;
1447   size_t second_write_len = kDefaultMaxPacketSize;
1448   size_t packet_len = kDefaultMaxPacketSize + 100;
1449   ASSERT_LE(packet_len, kMaxPacketSize);
1450
1451   // First send half of the packet worth of data.  We are in the batch mode, so
1452   // should not cause packet serialization.
1453   QuicConsumedData consumed =
1454       generator_.ConsumeData(kHeadersStreamId, CreateData(first_write_len),
1455                              /*offset=*/2,
1456                              /*fin=*/false, MAY_FEC_PROTECT, nullptr);
1457   EXPECT_EQ(first_write_len, consumed.bytes_consumed);
1458   EXPECT_FALSE(consumed.fin_consumed);
1459   EXPECT_TRUE(generator_.HasQueuedFrames());
1460
1461   // Make sure we have no packets so far.
1462   ASSERT_EQ(0u, packets_.size());
1463
1464   // Increase packet size.  Ensure it's not immediately enacted.
1465   generator_.SetMaxPacketLength(packet_len, /*force=*/false);
1466   EXPECT_EQ(packet_len, generator_.GetMaxPacketLength());
1467   EXPECT_EQ(kDefaultMaxPacketSize, generator_.GetCurrentMaxPacketLength());
1468
1469   // We expect to see exactly one packet serialized after that, since we are in
1470   // batch mode and we have sent approximately 3/2 of our MTU.
1471   EXPECT_CALL(delegate_, OnSerializedPacket(_))
1472       .WillOnce(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
1473
1474   // Send a packet worth of data to the same stream.  This should trigger
1475   // serialization of other packet.
1476   consumed =
1477       generator_.ConsumeData(kHeadersStreamId, CreateData(second_write_len),
1478                              /*offset=*/2 + first_write_len,
1479                              /*fin=*/true, MAY_FEC_PROTECT, nullptr);
1480   EXPECT_EQ(second_write_len, consumed.bytes_consumed);
1481   EXPECT_TRUE(consumed.fin_consumed);
1482   EXPECT_TRUE(generator_.HasQueuedFrames());
1483
1484   // We expect the first packet to contain two frames, and to not reflect the
1485   // packet size change.
1486   ASSERT_EQ(1u, packets_.size());
1487   EXPECT_EQ(kDefaultMaxPacketSize, packets_[0].packet->length());
1488
1489   PacketContents contents;
1490   contents.num_stream_frames = 2;
1491   CheckPacketContains(contents, 0);
1492 }
1493
1494 // Test whether SetMaxPacketLength() works correctly when we force the change of
1495 // the packet size in the middle of the batched packet.
1496 TEST_P(QuicPacketGeneratorTest, SetMaxPacketLength_MidpacketFlush) {
1497   delegate_.SetCanWriteAnything();
1498   generator_.StartBatchOperations();
1499
1500   size_t first_write_len = kDefaultMaxPacketSize / 2;
1501   size_t packet_len = kDefaultMaxPacketSize + 100;
1502   size_t second_write_len = packet_len + 1;
1503   ASSERT_LE(packet_len, kMaxPacketSize);
1504
1505   // First send half of the packet worth of data.  We are in the batch mode, so
1506   // should not cause packet serialization.
1507   QuicConsumedData consumed =
1508       generator_.ConsumeData(kHeadersStreamId, CreateData(first_write_len),
1509                              /*offset=*/2,
1510                              /*fin=*/false, MAY_FEC_PROTECT, nullptr);
1511   EXPECT_EQ(first_write_len, consumed.bytes_consumed);
1512   EXPECT_FALSE(consumed.fin_consumed);
1513   EXPECT_TRUE(generator_.HasQueuedFrames());
1514
1515   // Make sure we have no packets so far.
1516   ASSERT_EQ(0u, packets_.size());
1517
1518   // Expect a packet to be flushed.
1519   EXPECT_CALL(delegate_, OnSerializedPacket(_))
1520       .WillOnce(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
1521
1522   // Increase packet size.  Ensure it's immediately enacted.
1523   generator_.SetMaxPacketLength(packet_len, /*force=*/true);
1524   EXPECT_EQ(packet_len, generator_.GetMaxPacketLength());
1525   EXPECT_EQ(packet_len, generator_.GetCurrentMaxPacketLength());
1526   EXPECT_FALSE(generator_.HasQueuedFrames());
1527
1528   // We expect to see exactly one packet serialized after that, because we send
1529   // a value somewhat exceeding new max packet size, and the tail data does not
1530   // get serialized because we are still in the batch mode.
1531   EXPECT_CALL(delegate_, OnSerializedPacket(_))
1532       .WillOnce(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
1533
1534   // Send a more than a packet worth of data to the same stream.  This should
1535   // trigger serialization of one packet, and queue another one.
1536   consumed =
1537       generator_.ConsumeData(kHeadersStreamId, CreateData(second_write_len),
1538                              /*offset=*/2 + first_write_len,
1539                              /*fin=*/true, MAY_FEC_PROTECT, nullptr);
1540   EXPECT_EQ(second_write_len, consumed.bytes_consumed);
1541   EXPECT_TRUE(consumed.fin_consumed);
1542   EXPECT_TRUE(generator_.HasQueuedFrames());
1543
1544   // We expect the first packet to be underfilled, and the second packet be up
1545   // to the new max packet size.
1546   ASSERT_EQ(2u, packets_.size());
1547   EXPECT_GT(kDefaultMaxPacketSize, packets_[0].packet->length());
1548   EXPECT_EQ(packet_len, packets_[1].packet->length());
1549
1550   CheckAllPacketsHaveSingleStreamFrame();
1551 }
1552
1553 // Test sending an MTU probe, without any surrounding data.
1554 TEST_P(QuicPacketGeneratorTest, GenerateMtuDiscoveryPacket_Simple) {
1555   delegate_.SetCanWriteAnything();
1556
1557   const size_t target_mtu = kDefaultMaxPacketSize + 100;
1558   static_assert(target_mtu < kMaxPacketSize,
1559                 "The MTU probe used by the test exceeds maximum packet size");
1560
1561   EXPECT_CALL(delegate_, OnSerializedPacket(_))
1562       .WillOnce(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
1563
1564   generator_.GenerateMtuDiscoveryPacket(target_mtu, nullptr);
1565
1566   EXPECT_FALSE(generator_.HasQueuedFrames());
1567   ASSERT_EQ(1u, packets_.size());
1568   EXPECT_EQ(target_mtu, packets_[0].packet->length());
1569
1570   PacketContents contents;
1571   contents.num_mtu_discovery_frames = 1;
1572   CheckPacketContains(contents, 0);
1573 }
1574
1575 // Test sending an MTU probe.  Surround it with data, to ensure that it resets
1576 // the MTU to the value before the probe was sent.
1577 TEST_P(QuicPacketGeneratorTest, GenerateMtuDiscoveryPacket_SurroundedByData) {
1578   delegate_.SetCanWriteAnything();
1579
1580   const size_t target_mtu = kDefaultMaxPacketSize + 100;
1581   static_assert(target_mtu < kMaxPacketSize,
1582                 "The MTU probe used by the test exceeds maximum packet size");
1583
1584   // Send enough data so it would always cause two packets to be sent.
1585   const size_t data_len = target_mtu + 1;
1586
1587   // Send a total of five packets: two packets before the probe, the probe
1588   // itself, and two packets after the probe.
1589   EXPECT_CALL(delegate_, OnSerializedPacket(_))
1590       .Times(5)
1591       .WillRepeatedly(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
1592
1593   // Send data before the MTU probe.
1594   QuicConsumedData consumed =
1595       generator_.ConsumeData(kHeadersStreamId, CreateData(data_len),
1596                              /*offset=*/2,
1597                              /*fin=*/false, MAY_FEC_PROTECT, nullptr);
1598   EXPECT_EQ(data_len, consumed.bytes_consumed);
1599   EXPECT_FALSE(consumed.fin_consumed);
1600   EXPECT_FALSE(generator_.HasQueuedFrames());
1601
1602   // Send the MTU probe.
1603   generator_.GenerateMtuDiscoveryPacket(target_mtu, nullptr);
1604   EXPECT_FALSE(generator_.HasQueuedFrames());
1605
1606   // Send data after the MTU probe.
1607   consumed = generator_.ConsumeData(kHeadersStreamId, CreateData(data_len),
1608                                     /*offset=*/2 + data_len,
1609                                     /*fin=*/true, MAY_FEC_PROTECT, nullptr);
1610   EXPECT_EQ(data_len, consumed.bytes_consumed);
1611   EXPECT_TRUE(consumed.fin_consumed);
1612   EXPECT_FALSE(generator_.HasQueuedFrames());
1613
1614   ASSERT_EQ(5u, packets_.size());
1615   EXPECT_EQ(kDefaultMaxPacketSize, packets_[0].packet->length());
1616   EXPECT_EQ(target_mtu, packets_[2].packet->length());
1617   EXPECT_EQ(kDefaultMaxPacketSize, packets_[3].packet->length());
1618
1619   PacketContents probe_contents;
1620   probe_contents.num_mtu_discovery_frames = 1;
1621
1622   CheckPacketHasSingleStreamFrame(0);
1623   CheckPacketHasSingleStreamFrame(1);
1624   CheckPacketContains(probe_contents, 2);
1625   CheckPacketHasSingleStreamFrame(3);
1626   CheckPacketHasSingleStreamFrame(4);
1627 }
1628
1629 }  // namespace test
1630 }  // namespace net