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_utils.h"
  14 #include "net/quic/test_tools/quic_packet_creator_peer.h"
  15 #include "net/quic/test_tools/quic_packet_generator_peer.h"
  16 #include "net/quic/test_tools/quic_test_utils.h"
  17 #include "net/quic/test_tools/simple_quic_framer.h"
  18 #include "testing/gmock/include/gmock/gmock.h"
  19 #include "testing/gtest/include/gtest/gtest.h"
  20
  21 using base::StringPiece;
  22 using std::string;
  23 using testing::InSequence;
  24 using testing::Return;
  25 using testing::SaveArg;
  26 using testing::StrictMock;
  27 using testing::_;
  28
  29 namespace net {
  30 namespace test {
  31 namespace {
  32
  33 class MockDelegate : public QuicPacketGenerator::DelegateInterface {
  34  public:
  35   MockDelegate() {}
  36   virtual ~MockDelegate() OVERRIDE {}
  37
  38   MOCK_METHOD3(ShouldGeneratePacket,
  39                bool(TransmissionType transmission_type,
  40                     HasRetransmittableData retransmittable,
  41                     IsHandshake handshake));
  42   MOCK_METHOD0(CreateAckFrame, QuicAckFrame*());
  43   MOCK_METHOD0(CreateFeedbackFrame, QuicCongestionFeedbackFrame*());
  44   MOCK_METHOD0(CreateStopWaitingFrame, QuicStopWaitingFrame*());
  45   MOCK_METHOD1(OnSerializedPacket, bool(const SerializedPacket& packet));
  46   MOCK_METHOD2(CloseConnection, void(QuicErrorCode, bool));
  47
  48   void SetCanWriteAnything() {
  49     EXPECT_CALL(*this, ShouldGeneratePacket(NOT_RETRANSMISSION, _, _))
  50         .WillRepeatedly(Return(true));
  51     EXPECT_CALL(*this, ShouldGeneratePacket(NOT_RETRANSMISSION,
  52                                             NO_RETRANSMITTABLE_DATA, _))
  53         .WillRepeatedly(Return(true));
  54   }
  55
  56   void SetCanNotWrite() {
  57     EXPECT_CALL(*this, ShouldGeneratePacket(NOT_RETRANSMISSION, _, _))
  58         .WillRepeatedly(Return(false));
  59     EXPECT_CALL(*this, ShouldGeneratePacket(NOT_RETRANSMISSION,
  60                                             NO_RETRANSMITTABLE_DATA, _))
  61         .WillRepeatedly(Return(false));
  62   }
  63
  64   // Use this when only ack and feedback frames should be allowed to be written.
  65   void SetCanWriteOnlyNonRetransmittable() {
  66     EXPECT_CALL(*this, ShouldGeneratePacket(NOT_RETRANSMISSION, _, _))
  67         .WillRepeatedly(Return(false));
  68     EXPECT_CALL(*this, ShouldGeneratePacket(NOT_RETRANSMISSION,
  69                                             NO_RETRANSMITTABLE_DATA, _))
  70         .WillRepeatedly(Return(true));
  71   }
  72
  73  private:
  74   DISALLOW_COPY_AND_ASSIGN(MockDelegate);
  75 };
  76
  77 // Simple struct for describing the contents of a packet.
  78 // Useful in conjunction with a SimpleQuicFrame for validating
  79 // that a packet contains the expected frames.
  80 struct PacketContents {
  81   PacketContents()
  82       : num_ack_frames(0),
  83         num_connection_close_frames(0),
  84         num_feedback_frames(0),
  85         num_goaway_frames(0),
  86         num_rst_stream_frames(0),
  87         num_stop_waiting_frames(0),
  88         num_stream_frames(0),
  89         fec_group(0) {
  90   }
  91
  92   size_t num_ack_frames;
  93   size_t num_connection_close_frames;
  94   size_t num_feedback_frames;
  95   size_t num_goaway_frames;
  96   size_t num_rst_stream_frames;
  97   size_t num_stop_waiting_frames;
  98   size_t num_stream_frames;
  99
 100   QuicFecGroupNumber fec_group;
 101 };
 102
 103 }  // namespace
 104
 105 class QuicPacketGeneratorTest : public ::testing::Test {
 106  protected:
 107   QuicPacketGeneratorTest()
 108       : framer_(QuicSupportedVersions(), QuicTime::Zero(), false),
 109         generator_(42, &framer_, &random_, &delegate_),
 110         creator_(QuicPacketGeneratorPeer::GetPacketCreator(&generator_)),
 111         packet_(0, PACKET_1BYTE_SEQUENCE_NUMBER, NULL, 0, NULL),
 112         packet2_(0, PACKET_1BYTE_SEQUENCE_NUMBER, NULL, 0, NULL),
 113         packet3_(0, PACKET_1BYTE_SEQUENCE_NUMBER, NULL, 0, NULL),
 114         packet4_(0, PACKET_1BYTE_SEQUENCE_NUMBER, NULL, 0, NULL),
 115         packet5_(0, PACKET_1BYTE_SEQUENCE_NUMBER, NULL, 0, NULL),
 116         packet6_(0, PACKET_1BYTE_SEQUENCE_NUMBER, NULL, 0, NULL),
 117         packet7_(0, PACKET_1BYTE_SEQUENCE_NUMBER, NULL, 0, NULL) {
 118   }
 119
 120   virtual ~QuicPacketGeneratorTest() OVERRIDE {
 121     delete packet_.packet;
 122     delete packet_.retransmittable_frames;
 123     delete packet2_.packet;
 124     delete packet2_.retransmittable_frames;
 125     delete packet3_.packet;
 126     delete packet3_.retransmittable_frames;
 127     delete packet4_.packet;
 128     delete packet4_.retransmittable_frames;
 129     delete packet5_.packet;
 130     delete packet5_.retransmittable_frames;
 131     delete packet6_.packet;
 132     delete packet6_.retransmittable_frames;
 133     delete packet7_.packet;
 134     delete packet7_.retransmittable_frames;
 135   }
 136
 137   QuicAckFrame* CreateAckFrame() {
 138     // TODO(rch): Initialize this so it can be verified later.
 139     return new QuicAckFrame(MakeAckFrame(0, 0));
 140   }
 141
 142   QuicCongestionFeedbackFrame* CreateFeedbackFrame() {
 143     QuicCongestionFeedbackFrame* frame = new QuicCongestionFeedbackFrame;
 144     frame->type = kFixRate;
 145     frame->fix_rate.bitrate = QuicBandwidth::FromBytesPerSecond(42);
 146     return frame;
 147   }
 148
 149   QuicStopWaitingFrame* CreateStopWaitingFrame() {
 150     QuicStopWaitingFrame* frame = new QuicStopWaitingFrame();
 151     frame->entropy_hash = 0;
 152     frame->least_unacked = 0;
 153     return frame;
 154   }
 155
 156   QuicRstStreamFrame* CreateRstStreamFrame() {
 157     return new QuicRstStreamFrame(1, QUIC_STREAM_NO_ERROR, 0);
 158   }
 159
 160   QuicGoAwayFrame* CreateGoAwayFrame() {
 161     return new QuicGoAwayFrame(QUIC_NO_ERROR, 1, string());
 162   }
 163
 164   void CheckPacketContains(const PacketContents& contents,
 165                            const SerializedPacket& packet) {
 166     size_t num_retransmittable_frames = contents.num_connection_close_frames +
 167         contents.num_goaway_frames + contents.num_rst_stream_frames +
 168         contents.num_stream_frames;
 169     size_t num_frames = contents.num_feedback_frames + contents.num_ack_frames +
 170         contents.num_stop_waiting_frames + num_retransmittable_frames;
 171
 172     if (num_retransmittable_frames == 0) {
 173       ASSERT_TRUE(packet.retransmittable_frames == NULL);
 174     } else {
 175       ASSERT_TRUE(packet.retransmittable_frames != NULL);
 176       EXPECT_EQ(num_retransmittable_frames,
 177                 packet.retransmittable_frames->frames().size());
 178     }
 179
 180     ASSERT_TRUE(packet.packet != NULL);
 181     ASSERT_TRUE(simple_framer_.ProcessPacket(*packet.packet));
 182     EXPECT_EQ(num_frames, simple_framer_.num_frames());
 183     EXPECT_EQ(contents.num_ack_frames, simple_framer_.ack_frames().size());
 184     EXPECT_EQ(contents.num_connection_close_frames,
 185               simple_framer_.connection_close_frames().size());
 186     EXPECT_EQ(contents.num_feedback_frames,
 187               simple_framer_.feedback_frames().size());
 188     EXPECT_EQ(contents.num_goaway_frames,
 189               simple_framer_.goaway_frames().size());
 190     EXPECT_EQ(contents.num_rst_stream_frames,
 191               simple_framer_.rst_stream_frames().size());
 192     EXPECT_EQ(contents.num_stream_frames,
 193               simple_framer_.stream_frames().size());
 194     EXPECT_EQ(contents.num_stop_waiting_frames,
 195               simple_framer_.stop_waiting_frames().size());
 196     EXPECT_EQ(contents.fec_group, simple_framer_.header().fec_group);
 197   }
 198
 199   void CheckPacketHasSingleStreamFrame(const SerializedPacket& packet) {
 200     ASSERT_TRUE(packet.retransmittable_frames != NULL);
 201     EXPECT_EQ(1u, packet.retransmittable_frames->frames().size());
 202     ASSERT_TRUE(packet.packet != NULL);
 203     ASSERT_TRUE(simple_framer_.ProcessPacket(*packet.packet));
 204     EXPECT_EQ(1u, simple_framer_.num_frames());
 205     EXPECT_EQ(1u, simple_framer_.stream_frames().size());
 206   }
 207
 208   void CheckPacketIsFec(const SerializedPacket& packet,
 209                         QuicPacketSequenceNumber fec_group) {
 210     ASSERT_TRUE(packet.retransmittable_frames == NULL);
 211     ASSERT_TRUE(packet.packet != NULL);
 212     ASSERT_TRUE(simple_framer_.ProcessPacket(*packet.packet));
 213     EXPECT_TRUE(simple_framer_.header().fec_flag);
 214     EXPECT_EQ(fec_group, simple_framer_.fec_data().fec_group);
 215   }
 216
 217   IOVector CreateData(size_t len) {
 218     data_array_.reset(new char[len]);
 219     memset(data_array_.get(), '?', len);
 220     IOVector data;
 221     data.Append(data_array_.get(), len);
 222     return data;
 223   }
 224
 225   QuicFramer framer_;
 226   MockRandom random_;
 227   StrictMock<MockDelegate> delegate_;
 228   QuicPacketGenerator generator_;
 229   QuicPacketCreator* creator_;
 230   SimpleQuicFramer simple_framer_;
 231   SerializedPacket packet_;
 232   SerializedPacket packet2_;
 233   SerializedPacket packet3_;
 234   SerializedPacket packet4_;
 235   SerializedPacket packet5_;
 236   SerializedPacket packet6_;
 237   SerializedPacket packet7_;
 238
 239  private:
 240   scoped_ptr<char[]> data_array_;
 241 };
 242
 243 class MockDebugDelegate : public QuicPacketGenerator::DebugDelegate {
 244  public:
 245   MOCK_METHOD1(OnFrameAddedToPacket,
 246                void(const QuicFrame&));
 247 };
 248
 249 TEST_F(QuicPacketGeneratorTest, ShouldSendAck_NotWritable) {
 250   delegate_.SetCanNotWrite();
 251
 252   generator_.SetShouldSendAck(false, false);
 253   EXPECT_TRUE(generator_.HasQueuedFrames());
 254 }
 255
 256 TEST_F(QuicPacketGeneratorTest, ShouldSendAck_WritableAndShouldNotFlush) {
 257   StrictMock<MockDebugDelegate> debug_delegate;
 258
 259   generator_.set_debug_delegate(&debug_delegate);
 260   delegate_.SetCanWriteOnlyNonRetransmittable();
 261   generator_.StartBatchOperations();
 262
 263   EXPECT_CALL(delegate_, CreateAckFrame()).WillOnce(Return(CreateAckFrame()));
 264   EXPECT_CALL(debug_delegate, OnFrameAddedToPacket(_)).Times(1);
 265
 266   generator_.SetShouldSendAck(false, false);
 267   EXPECT_TRUE(generator_.HasQueuedFrames());
 268 }
 269
 270 TEST_F(QuicPacketGeneratorTest, ShouldSendAck_WritableAndShouldFlush) {
 271   delegate_.SetCanWriteOnlyNonRetransmittable();
 272
 273   EXPECT_CALL(delegate_, CreateAckFrame()).WillOnce(Return(CreateAckFrame()));
 274   EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
 275       DoAll(SaveArg<0>(&packet_), Return(true)));
 276
 277   generator_.SetShouldSendAck(false, false);
 278   EXPECT_FALSE(generator_.HasQueuedFrames());
 279
 280   PacketContents contents;
 281   contents.num_ack_frames = 1;
 282   CheckPacketContains(contents, packet_);
 283 }
 284
 285 TEST_F(QuicPacketGeneratorTest,
 286        ShouldSendAckWithFeedback_WritableAndShouldNotFlush) {
 287   delegate_.SetCanWriteOnlyNonRetransmittable();
 288   generator_.StartBatchOperations();
 289
 290   EXPECT_CALL(delegate_, CreateAckFrame()).WillOnce(Return(CreateAckFrame()));
 291   EXPECT_CALL(delegate_, CreateFeedbackFrame()).WillOnce(
 292       Return(CreateFeedbackFrame()));
 293
 294   generator_.SetShouldSendAck(true, false);
 295   EXPECT_TRUE(generator_.HasQueuedFrames());
 296 }
 297
 298 TEST_F(QuicPacketGeneratorTest,
 299        ShouldSendAckWithFeedback_WritableAndShouldFlush) {
 300   delegate_.SetCanWriteOnlyNonRetransmittable();
 301
 302   EXPECT_CALL(delegate_, CreateAckFrame()).WillOnce(Return(CreateAckFrame()));
 303   EXPECT_CALL(delegate_, CreateFeedbackFrame()).WillOnce(
 304       Return(CreateFeedbackFrame()));
 305   EXPECT_CALL(delegate_, CreateStopWaitingFrame()).WillOnce(
 306       Return(CreateStopWaitingFrame()));
 307
 308   EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
 309       DoAll(SaveArg<0>(&packet_), Return(true)));
 310
 311   generator_.SetShouldSendAck(true, true);
 312   EXPECT_FALSE(generator_.HasQueuedFrames());
 313
 314   PacketContents contents;
 315   contents.num_ack_frames = 1;
 316   contents.num_feedback_frames = 1;
 317   contents.num_stop_waiting_frames = 1;
 318   CheckPacketContains(contents, packet_);
 319 }
 320
 321 TEST_F(QuicPacketGeneratorTest, AddControlFrame_NotWritable) {
 322   delegate_.SetCanNotWrite();
 323
 324   generator_.AddControlFrame(QuicFrame(CreateRstStreamFrame()));
 325   EXPECT_TRUE(generator_.HasQueuedFrames());
 326 }
 327
 328 TEST_F(QuicPacketGeneratorTest, AddControlFrame_OnlyAckWritable) {
 329   delegate_.SetCanWriteOnlyNonRetransmittable();
 330
 331   generator_.AddControlFrame(QuicFrame(CreateRstStreamFrame()));
 332   EXPECT_TRUE(generator_.HasQueuedFrames());
 333 }
 334
 335 TEST_F(QuicPacketGeneratorTest, AddControlFrame_WritableAndShouldNotFlush) {
 336   delegate_.SetCanWriteAnything();
 337   generator_.StartBatchOperations();
 338
 339   generator_.AddControlFrame(QuicFrame(CreateRstStreamFrame()));
 340   EXPECT_TRUE(generator_.HasQueuedFrames());
 341 }
 342
 343 TEST_F(QuicPacketGeneratorTest, AddControlFrame_NotWritableBatchThenFlush) {
 344   delegate_.SetCanNotWrite();
 345   generator_.StartBatchOperations();
 346
 347   generator_.AddControlFrame(QuicFrame(CreateRstStreamFrame()));
 348   EXPECT_TRUE(generator_.HasQueuedFrames());
 349   generator_.FinishBatchOperations();
 350   EXPECT_TRUE(generator_.HasQueuedFrames());
 351
 352   EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
 353       DoAll(SaveArg<0>(&packet_), Return(true)));
 354   generator_.FlushAllQueuedFrames();
 355   EXPECT_FALSE(generator_.HasQueuedFrames());
 356
 357   PacketContents contents;
 358   contents.num_rst_stream_frames = 1;
 359   CheckPacketContains(contents, packet_);
 360 }
 361
 362 TEST_F(QuicPacketGeneratorTest, AddControlFrame_WritableAndShouldFlush) {
 363   delegate_.SetCanWriteAnything();
 364
 365   EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
 366       DoAll(SaveArg<0>(&packet_), Return(true)));
 367
 368   generator_.AddControlFrame(QuicFrame(CreateRstStreamFrame()));
 369   EXPECT_FALSE(generator_.HasQueuedFrames());
 370
 371   PacketContents contents;
 372   contents.num_rst_stream_frames = 1;
 373   CheckPacketContains(contents, packet_);
 374 }
 375
 376 TEST_F(QuicPacketGeneratorTest, ConsumeData_NotWritable) {
 377   delegate_.SetCanNotWrite();
 378
 379   QuicConsumedData consumed = generator_.ConsumeData(
 380       kHeadersStreamId, MakeIOVector("foo"), 2, true, MAY_FEC_PROTECT, NULL);
 381   EXPECT_EQ(0u, consumed.bytes_consumed);
 382   EXPECT_FALSE(consumed.fin_consumed);
 383   EXPECT_FALSE(generator_.HasQueuedFrames());
 384 }
 385
 386 TEST_F(QuicPacketGeneratorTest, ConsumeData_WritableAndShouldNotFlush) {
 387   delegate_.SetCanWriteAnything();
 388   generator_.StartBatchOperations();
 389
 390   QuicConsumedData consumed = generator_.ConsumeData(
 391       kHeadersStreamId, MakeIOVector("foo"), 2, true, MAY_FEC_PROTECT, NULL);
 392   EXPECT_EQ(3u, consumed.bytes_consumed);
 393   EXPECT_TRUE(consumed.fin_consumed);
 394   EXPECT_TRUE(generator_.HasQueuedFrames());
 395 }
 396
 397 TEST_F(QuicPacketGeneratorTest, ConsumeData_WritableAndShouldFlush) {
 398   delegate_.SetCanWriteAnything();
 399
 400   EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
 401       DoAll(SaveArg<0>(&packet_), Return(true)));
 402   QuicConsumedData consumed = generator_.ConsumeData(
 403       kHeadersStreamId, MakeIOVector("foo"), 2, true, MAY_FEC_PROTECT, NULL);
 404   EXPECT_EQ(3u, consumed.bytes_consumed);
 405   EXPECT_TRUE(consumed.fin_consumed);
 406   EXPECT_FALSE(generator_.HasQueuedFrames());
 407
 408   PacketContents contents;
 409   contents.num_stream_frames = 1;
 410   CheckPacketContains(contents, packet_);
 411 }
 412
 413 TEST_F(QuicPacketGeneratorTest,
 414        ConsumeDataMultipleTimes_WritableAndShouldNotFlush) {
 415   delegate_.SetCanWriteAnything();
 416   generator_.StartBatchOperations();
 417
 418   generator_.ConsumeData(kHeadersStreamId, MakeIOVector("foo"), 2, true,
 419                          MAY_FEC_PROTECT, NULL);
 420   QuicConsumedData consumed = generator_.ConsumeData(
 421       3, MakeIOVector("quux"), 7, false, MAY_FEC_PROTECT, NULL);
 422   EXPECT_EQ(4u, consumed.bytes_consumed);
 423   EXPECT_FALSE(consumed.fin_consumed);
 424   EXPECT_TRUE(generator_.HasQueuedFrames());
 425 }
 426
 427 TEST_F(QuicPacketGeneratorTest, ConsumeData_BatchOperations) {
 428   delegate_.SetCanWriteAnything();
 429   generator_.StartBatchOperations();
 430
 431   generator_.ConsumeData(kHeadersStreamId, MakeIOVector("foo"), 2, true,
 432                          MAY_FEC_PROTECT, NULL);
 433   QuicConsumedData consumed = generator_.ConsumeData(
 434       3, MakeIOVector("quux"), 7, false, MAY_FEC_PROTECT, NULL);
 435   EXPECT_EQ(4u, consumed.bytes_consumed);
 436   EXPECT_FALSE(consumed.fin_consumed);
 437   EXPECT_TRUE(generator_.HasQueuedFrames());
 438
 439   // Now both frames will be flushed out.
 440   EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
 441       DoAll(SaveArg<0>(&packet_), Return(true)));
 442   generator_.FinishBatchOperations();
 443   EXPECT_FALSE(generator_.HasQueuedFrames());
 444
 445   PacketContents contents;
 446   contents.num_stream_frames = 2;
 447   CheckPacketContains(contents, packet_);
 448 }
 449
 450 TEST_F(QuicPacketGeneratorTest, ConsumeDataFEC) {
 451   delegate_.SetCanWriteAnything();
 452
 453   // Send FEC every two packets.
 454   creator_->set_max_packets_per_fec_group(2);
 455
 456   {
 457     InSequence dummy;
 458     EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
 459         DoAll(SaveArg<0>(&packet_), Return(true)));
 460     EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
 461         DoAll(SaveArg<0>(&packet2_), Return(true)));
 462     EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
 463         DoAll(SaveArg<0>(&packet3_), Return(true)));
 464     EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
 465         DoAll(SaveArg<0>(&packet4_), Return(true)));
 466     EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
 467         DoAll(SaveArg<0>(&packet5_), Return(true)));
 468   }
 469
 470   // Send enough data to create 3 packets: two full and one partial. Send
 471   // with MUST_FEC_PROTECT flag.
 472   size_t data_len = 2 * kDefaultMaxPacketSize + 100;
 473   QuicConsumedData consumed =
 474       generator_.ConsumeData(3, CreateData(data_len), 0, true,
 475                              MUST_FEC_PROTECT, NULL);
 476   EXPECT_EQ(data_len, consumed.bytes_consumed);
 477   EXPECT_TRUE(consumed.fin_consumed);
 478   EXPECT_FALSE(generator_.HasQueuedFrames());
 479
 480   CheckPacketHasSingleStreamFrame(packet_);
 481   CheckPacketHasSingleStreamFrame(packet2_);
 482   CheckPacketIsFec(packet3_, 1);
 483
 484   CheckPacketHasSingleStreamFrame(packet4_);
 485   CheckPacketIsFec(packet5_, 4);
 486 }
 487
 488 TEST_F(QuicPacketGeneratorTest, ConsumeDataSendsFecAtEnd) {
 489   delegate_.SetCanWriteAnything();
 490
 491   // Enable FEC.
 492   creator_->set_max_packets_per_fec_group(6);
 493   {
 494     InSequence dummy;
 495     EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
 496         DoAll(SaveArg<0>(&packet_), Return(true)));
 497     EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
 498         DoAll(SaveArg<0>(&packet2_), Return(true)));
 499     EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
 500         DoAll(SaveArg<0>(&packet3_), Return(true)));
 501   }
 502
 503   // Send enough data to create 2 packets: one full and one partial. Send
 504   // with MUST_FEC_PROTECT flag.
 505   size_t data_len = 1 * kDefaultMaxPacketSize + 100;
 506   QuicConsumedData consumed =
 507       generator_.ConsumeData(3, CreateData(data_len), 0, true,
 508                              MUST_FEC_PROTECT, NULL);
 509   EXPECT_EQ(data_len, consumed.bytes_consumed);
 510   EXPECT_TRUE(consumed.fin_consumed);
 511   EXPECT_FALSE(generator_.HasQueuedFrames());
 512
 513   CheckPacketHasSingleStreamFrame(packet_);
 514   CheckPacketHasSingleStreamFrame(packet2_);
 515   CheckPacketIsFec(packet3_, 1);
 516 }
 517
 518 TEST_F(QuicPacketGeneratorTest, ConsumeData_FramesPreviouslyQueued) {
 519   // Set the packet size be enough for two stream frames with 0 stream offset,
 520   // but not enough for a stream frame of 0 offset and one with non-zero offset.
 521   size_t length =
 522       NullEncrypter().GetCiphertextSize(0) +
 523       GetPacketHeaderSize(creator_->connection_id_length(),
 524                           true,
 525                           creator_->next_sequence_number_length(),
 526                           NOT_IN_FEC_GROUP) +
 527       // Add an extra 3 bytes for the payload and 1 byte so BytesFree is larger
 528       // than the GetMinStreamFrameSize.
 529       QuicFramer::GetMinStreamFrameSize(framer_.version(), 1, 0, false,
 530                                         NOT_IN_FEC_GROUP) + 3 +
 531       QuicFramer::GetMinStreamFrameSize(framer_.version(), 1, 0, true,
 532                                         NOT_IN_FEC_GROUP) + 1;
 533   creator_->set_max_packet_length(length);
 534   delegate_.SetCanWriteAnything();
 535   {
 536      InSequence dummy;
 537      EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
 538          DoAll(SaveArg<0>(&packet_), Return(true)));
 539      EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
 540          DoAll(SaveArg<0>(&packet2_), Return(true)));
 541   }
 542   generator_.StartBatchOperations();
 543   // Queue enough data to prevent a stream frame with a non-zero offset from
 544   // fitting.
 545   QuicConsumedData consumed = generator_.ConsumeData(
 546       kHeadersStreamId, MakeIOVector("foo"), 0, false, MAY_FEC_PROTECT, NULL);
 547   EXPECT_EQ(3u, consumed.bytes_consumed);
 548   EXPECT_FALSE(consumed.fin_consumed);
 549   EXPECT_TRUE(generator_.HasQueuedFrames());
 550
 551   // This frame will not fit with the existing frame, causing the queued frame
 552   // to be serialized, and it will not fit with another frame like it, so it is
 553   // serialized by itself.
 554   consumed = generator_.ConsumeData(kHeadersStreamId, MakeIOVector("bar"), 3,
 555                                     true, MAY_FEC_PROTECT, NULL);
 556   EXPECT_EQ(3u, consumed.bytes_consumed);
 557   EXPECT_TRUE(consumed.fin_consumed);
 558   EXPECT_FALSE(generator_.HasQueuedFrames());
 559
 560   PacketContents contents;
 561   contents.num_stream_frames = 1;
 562   CheckPacketContains(contents, packet_);
 563   CheckPacketContains(contents, packet2_);
 564 }
 565
 566 TEST_F(QuicPacketGeneratorTest, SwitchFecOnOff) {
 567   delegate_.SetCanWriteAnything();
 568   // Enable FEC.
 569   creator_->set_max_packets_per_fec_group(2);
 570   EXPECT_FALSE(creator_->IsFecProtected());
 571
 572   // Send one unprotected data packet.
 573   EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
 574         DoAll(SaveArg<0>(&packet_), Return(true)));
 575   QuicConsumedData consumed =
 576       generator_.ConsumeData(5, CreateData(1u), 0, true, MAY_FEC_PROTECT,
 577                              NULL);
 578   EXPECT_EQ(1u, consumed.bytes_consumed);
 579   EXPECT_FALSE(generator_.HasQueuedFrames());
 580   EXPECT_FALSE(creator_->IsFecProtected());
 581   // Verify that one data packet was sent.
 582   PacketContents contents;
 583   contents.num_stream_frames = 1;
 584   CheckPacketContains(contents, packet_);
 585
 586   {
 587     InSequence dummy;
 588     EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
 589         DoAll(SaveArg<0>(&packet2_), Return(true)));
 590     EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
 591         DoAll(SaveArg<0>(&packet3_), Return(true)));
 592     EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
 593         DoAll(SaveArg<0>(&packet4_), Return(true)));
 594     EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
 595         DoAll(SaveArg<0>(&packet5_), Return(true)));
 596     EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
 597         DoAll(SaveArg<0>(&packet6_), Return(true)));
 598   }
 599   // Send enough data to create 3 packets with MUST_FEC_PROTECT flag.
 600   size_t data_len = 2 * kDefaultMaxPacketSize + 100;
 601   consumed = generator_.ConsumeData(7, CreateData(data_len), 0, true,
 602                                     MUST_FEC_PROTECT, NULL);
 603   EXPECT_EQ(data_len, consumed.bytes_consumed);
 604   EXPECT_FALSE(generator_.HasQueuedFrames());
 605
 606   // Verify that two FEC packets were sent.
 607   CheckPacketHasSingleStreamFrame(packet2_);
 608   CheckPacketHasSingleStreamFrame(packet3_);
 609   CheckPacketIsFec(packet4_, /*fec_group=*/2u);
 610   CheckPacketHasSingleStreamFrame(packet5_);
 611   CheckPacketIsFec(packet6_, /*fec_group=*/5u);  // Sent at the end of stream.
 612
 613   // Send one unprotected data packet.
 614   EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
 615         DoAll(SaveArg<0>(&packet7_), Return(true)));
 616   consumed = generator_.ConsumeData(7, CreateData(1u), 0, true,
 617                                     MAY_FEC_PROTECT, NULL);
 618   EXPECT_EQ(1u, consumed.bytes_consumed);
 619   EXPECT_FALSE(generator_.HasQueuedFrames());
 620   EXPECT_FALSE(creator_->IsFecProtected());
 621   // Verify that one unprotected data packet was sent.
 622   CheckPacketContains(contents, packet7_);
 623 }
 624
 625 TEST_F(QuicPacketGeneratorTest, SwitchFecOnWithPendingFrameInCreator) {
 626   delegate_.SetCanWriteAnything();
 627   // Enable FEC.
 628   creator_->set_max_packets_per_fec_group(2);
 629
 630   generator_.StartBatchOperations();
 631   // Queue enough data to prevent a stream frame with a non-zero offset from
 632   // fitting.
 633   QuicConsumedData consumed = generator_.ConsumeData(
 634       7, CreateData(1u), 0, true, MAY_FEC_PROTECT, NULL);
 635   EXPECT_EQ(1u, consumed.bytes_consumed);
 636   EXPECT_TRUE(creator_->HasPendingFrames());
 637
 638   // Queue protected data for sending. Should cause queued frames to be flushed.
 639   EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
 640       DoAll(SaveArg<0>(&packet_), Return(true)));
 641   EXPECT_FALSE(creator_->IsFecProtected());
 642   consumed = generator_.ConsumeData(7, CreateData(1u), 0, true,
 643                                     MUST_FEC_PROTECT, NULL);
 644   EXPECT_EQ(1u, consumed.bytes_consumed);
 645   PacketContents contents;
 646   contents.num_stream_frames = 1;
 647   // Transmitted packet was not FEC protected.
 648   CheckPacketContains(contents, packet_);
 649   EXPECT_TRUE(creator_->IsFecProtected());
 650   EXPECT_TRUE(creator_->HasPendingFrames());
 651 }
 652
 653 TEST_F(QuicPacketGeneratorTest, SwitchFecOnWithPendingFramesInGenerator) {
 654   // Enable FEC.
 655   creator_->set_max_packets_per_fec_group(2);
 656
 657   // Queue control frames in generator.
 658   delegate_.SetCanNotWrite();
 659   generator_.SetShouldSendAck(true, true);
 660   delegate_.SetCanWriteAnything();
 661   generator_.StartBatchOperations();
 662
 663   // Set up frames to write into the creator when control frames are written.
 664   EXPECT_CALL(delegate_, CreateAckFrame()).WillOnce(Return(CreateAckFrame()));
 665   EXPECT_CALL(delegate_, CreateFeedbackFrame()).WillOnce(
 666       Return(CreateFeedbackFrame()));
 667   EXPECT_CALL(delegate_, CreateStopWaitingFrame()).WillOnce(
 668       Return(CreateStopWaitingFrame()));
 669
 670   // Generator should have queued control frames, and creator should be empty.
 671   EXPECT_TRUE(generator_.HasQueuedFrames());
 672   EXPECT_FALSE(creator_->HasPendingFrames());
 673   EXPECT_FALSE(creator_->IsFecProtected());
 674
 675   // Queue protected data for sending. Should cause queued frames to be flushed.
 676   EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
 677       DoAll(SaveArg<0>(&packet_), Return(true)));
 678   QuicConsumedData consumed = generator_.ConsumeData(7, CreateData(1u), 0, true,
 679                                                      MUST_FEC_PROTECT, NULL);
 680   EXPECT_EQ(1u, consumed.bytes_consumed);
 681   PacketContents contents;
 682   contents.num_ack_frames = 1;
 683   contents.num_feedback_frames = 1;
 684   contents.num_stop_waiting_frames = 1;
 685   CheckPacketContains(contents, packet_);
 686
 687   // FEC protection should be on in creator.
 688   EXPECT_TRUE(creator_->IsFecProtected());
 689 }
 690
 691 TEST_F(QuicPacketGeneratorTest, SwitchFecOnOffWithSubsequentFramesProtected) {
 692   delegate_.SetCanWriteAnything();
 693
 694   // Enable FEC.
 695   creator_->set_max_packets_per_fec_group(2);
 696   EXPECT_FALSE(creator_->IsFecProtected());
 697
 698   // Queue stream frame to be protected in creator.
 699   generator_.StartBatchOperations();
 700   QuicConsumedData consumed = generator_.ConsumeData(5, CreateData(1u), 0, true,
 701                                                      MUST_FEC_PROTECT, NULL);
 702   EXPECT_EQ(1u, consumed.bytes_consumed);
 703   // Creator has a pending protected frame.
 704   EXPECT_TRUE(creator_->HasPendingFrames());
 705   EXPECT_TRUE(creator_->IsFecProtected());
 706
 707   // Add enough unprotected data to exceed size of current packet, so that
 708   // current packet is sent. Both frames will be sent out in a single packet.
 709   EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
 710       DoAll(SaveArg<0>(&packet_), Return(true)));
 711   size_t data_len = kDefaultMaxPacketSize;
 712   consumed = generator_.ConsumeData(5, CreateData(data_len), 0, true,
 713                                     MAY_FEC_PROTECT, NULL);
 714   EXPECT_EQ(data_len, consumed.bytes_consumed);
 715   PacketContents contents;
 716   contents.num_stream_frames = 2u;
 717   contents.fec_group = 1u;
 718   CheckPacketContains(contents, packet_);
 719   // FEC protection should still be on in creator.
 720   EXPECT_TRUE(creator_->IsFecProtected());
 721 }
 722
 723 TEST_F(QuicPacketGeneratorTest, SwitchFecOnOffWithSubsequentPacketsProtected) {
 724   delegate_.SetCanWriteAnything();
 725
 726   // Enable FEC.
 727   creator_->set_max_packets_per_fec_group(2);
 728   EXPECT_FALSE(creator_->IsFecProtected());
 729
 730   generator_.StartBatchOperations();
 731   // Send first packet, FEC protected.
 732   EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
 733       DoAll(SaveArg<0>(&packet_), Return(true)));
 734   // Write enough data to cause a packet to be emitted.
 735   size_t data_len = kDefaultMaxPacketSize;
 736   QuicConsumedData consumed = generator_.ConsumeData(
 737       5, CreateData(data_len), 0, true, MUST_FEC_PROTECT, NULL);
 738   EXPECT_EQ(data_len, consumed.bytes_consumed);
 739   PacketContents contents;
 740   contents.num_stream_frames = 1u;
 741   contents.fec_group = 1u;
 742   CheckPacketContains(contents, packet_);
 743
 744   // FEC should still be on in creator.
 745   EXPECT_TRUE(creator_->IsFecProtected());
 746
 747   // Send enough unprotected data to cause second packet to be sent, which gets
 748   // protected because it happens to fall within an open FEC group. Data packet
 749   // will be followed by FEC packet.
 750   {
 751     InSequence dummy;
 752     EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
 753         DoAll(SaveArg<0>(&packet2_), Return(true)));
 754     EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
 755         DoAll(SaveArg<0>(&packet3_), Return(true)));
 756   }
 757   consumed = generator_.ConsumeData(5, CreateData(data_len), 0, true,
 758                                     MAY_FEC_PROTECT, NULL);
 759   EXPECT_EQ(data_len, consumed.bytes_consumed);
 760   contents.num_stream_frames = 2u;
 761   CheckPacketContains(contents, packet2_);
 762   CheckPacketIsFec(packet3_, /*fec_group=*/1u);
 763
 764   // FEC protection should be off in creator.
 765   EXPECT_FALSE(creator_->IsFecProtected());
 766 }
 767
 768 TEST_F(QuicPacketGeneratorTest, SwitchFecOnOffThenOnWithCreatorProtectionOn) {
 769   delegate_.SetCanWriteAnything();
 770   generator_.StartBatchOperations();
 771
 772   // Enable FEC.
 773   creator_->set_max_packets_per_fec_group(2);
 774   EXPECT_FALSE(creator_->IsFecProtected());
 775
 776   // Queue one byte of FEC protected data.
 777   QuicConsumedData consumed = generator_.ConsumeData(5, CreateData(1u), 0, true,
 778                                                      MUST_FEC_PROTECT, NULL);
 779   EXPECT_TRUE(creator_->HasPendingFrames());
 780
 781   // Add more unprotected data causing first packet to be sent, FEC protected.
 782   EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
 783       DoAll(SaveArg<0>(&packet_), Return(true)));
 784   size_t data_len = kDefaultMaxPacketSize;
 785   consumed = generator_.ConsumeData(5, CreateData(data_len), 0, true,
 786                                     MAY_FEC_PROTECT, NULL);
 787   EXPECT_EQ(data_len, consumed.bytes_consumed);
 788   PacketContents contents;
 789   contents.num_stream_frames = 2u;
 790   contents.fec_group = 1u;
 791   CheckPacketContains(contents, packet_);
 792
 793   // FEC group is still open in creator.
 794   EXPECT_TRUE(creator_->IsFecProtected());
 795
 796   // Add data that should be protected, large enough to cause second packet to
 797   // be sent. Data packet should be followed by FEC packet.
 798   {
 799     InSequence dummy;
 800     EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
 801         DoAll(SaveArg<0>(&packet2_), Return(true)));
 802     EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
 803         DoAll(SaveArg<0>(&packet3_), Return(true)));
 804   }
 805   consumed = generator_.ConsumeData(5, CreateData(data_len), 0, true,
 806                                     MUST_FEC_PROTECT, NULL);
 807   EXPECT_EQ(data_len, consumed.bytes_consumed);
 808   CheckPacketContains(contents, packet2_);
 809   CheckPacketIsFec(packet3_, /*fec_group=*/1u);
 810
 811   // FEC protection should remain on in creator.
 812   EXPECT_TRUE(creator_->IsFecProtected());
 813 }
 814
 815 TEST_F(QuicPacketGeneratorTest, NotWritableThenBatchOperations) {
 816   delegate_.SetCanNotWrite();
 817
 818   generator_.SetShouldSendAck(true, false);
 819   generator_.AddControlFrame(QuicFrame(CreateRstStreamFrame()));
 820   EXPECT_TRUE(generator_.HasQueuedFrames());
 821
 822   delegate_.SetCanWriteAnything();
 823
 824   generator_.StartBatchOperations();
 825
 826   // When the first write operation is invoked, the ack and feedback
 827   // frames will be returned.
 828   EXPECT_CALL(delegate_, CreateAckFrame()).WillOnce(Return(CreateAckFrame()));
 829   EXPECT_CALL(delegate_, CreateFeedbackFrame()).WillOnce(
 830       Return(CreateFeedbackFrame()));
 831
 832   // Send some data and a control frame
 833   generator_.ConsumeData(3, MakeIOVector("quux"), 7, false,
 834                          MAY_FEC_PROTECT, NULL);
 835   generator_.AddControlFrame(QuicFrame(CreateGoAwayFrame()));
 836
 837   // All five frames will be flushed out in a single packet.
 838   EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
 839       DoAll(SaveArg<0>(&packet_), Return(true)));
 840   generator_.FinishBatchOperations();
 841   EXPECT_FALSE(generator_.HasQueuedFrames());
 842
 843   PacketContents contents;
 844   contents.num_ack_frames = 1;
 845   contents.num_goaway_frames = 1;
 846   contents.num_feedback_frames = 1;
 847   contents.num_rst_stream_frames = 1;
 848   contents.num_stream_frames = 1;
 849   CheckPacketContains(contents, packet_);
 850 }
 851
 852 TEST_F(QuicPacketGeneratorTest, NotWritableThenBatchOperations2) {
 853   delegate_.SetCanNotWrite();
 854
 855   generator_.SetShouldSendAck(true, false);
 856   generator_.AddControlFrame(QuicFrame(CreateRstStreamFrame()));
 857   EXPECT_TRUE(generator_.HasQueuedFrames());
 858
 859   delegate_.SetCanWriteAnything();
 860
 861   generator_.StartBatchOperations();
 862
 863   // When the first write operation is invoked, the ack and feedback
 864   // frames will be returned.
 865   EXPECT_CALL(delegate_, CreateAckFrame()).WillOnce(Return(CreateAckFrame()));
 866   EXPECT_CALL(delegate_, CreateFeedbackFrame()).WillOnce(
 867       Return(CreateFeedbackFrame()));
 868
 869   {
 870     InSequence dummy;
 871   // All five frames will be flushed out in a single packet
 872   EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
 873       DoAll(SaveArg<0>(&packet_), Return(true)));
 874   EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
 875       DoAll(SaveArg<0>(&packet2_), Return(true)));
 876   }
 877
 878   // Send enough data to exceed one packet
 879   size_t data_len = kDefaultMaxPacketSize + 100;
 880   QuicConsumedData consumed =
 881       generator_.ConsumeData(3, CreateData(data_len), 0, true,
 882                              MAY_FEC_PROTECT, NULL);
 883   EXPECT_EQ(data_len, consumed.bytes_consumed);
 884   EXPECT_TRUE(consumed.fin_consumed);
 885   generator_.AddControlFrame(QuicFrame(CreateGoAwayFrame()));
 886
 887   generator_.FinishBatchOperations();
 888   EXPECT_FALSE(generator_.HasQueuedFrames());
 889
 890   // The first packet should have the queued data and part of the stream data.
 891   PacketContents contents;
 892   contents.num_ack_frames = 1;
 893   contents.num_feedback_frames = 1;
 894   contents.num_rst_stream_frames = 1;
 895   contents.num_stream_frames = 1;
 896   CheckPacketContains(contents, packet_);
 897
 898   // The second should have the remainder of the stream data.
 899   PacketContents contents2;
 900   contents2.num_goaway_frames = 1;
 901   contents2.num_stream_frames = 1;
 902   CheckPacketContains(contents2, packet2_);
 903 }
 904
 905 }  // namespace test
 906 }  // namespace net