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, void(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)); 140 } 141 142 QuicCongestionFeedbackFrame* CreateFeedbackFrame() { 143 QuicCongestionFeedbackFrame* frame = new QuicCongestionFeedbackFrame; 144 frame->type = kTCP; 145 frame->tcp.receive_window = 0x4030; 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(SaveArg<0>(&packet_)); 275 276 generator_.SetShouldSendAck(false, false); 277 EXPECT_FALSE(generator_.HasQueuedFrames()); 278 279 PacketContents contents; 280 contents.num_ack_frames = 1; 281 CheckPacketContains(contents, packet_); 282 } 283 284 TEST_F(QuicPacketGeneratorTest, 285 ShouldSendAckWithFeedback_WritableAndShouldNotFlush) { 286 delegate_.SetCanWriteOnlyNonRetransmittable(); 287 generator_.StartBatchOperations(); 288 289 EXPECT_CALL(delegate_, CreateAckFrame()).WillOnce(Return(CreateAckFrame())); 290 EXPECT_CALL(delegate_, CreateFeedbackFrame()).WillOnce( 291 Return(CreateFeedbackFrame())); 292 293 generator_.SetShouldSendAck(true, false); 294 EXPECT_TRUE(generator_.HasQueuedFrames()); 295 } 296 297 TEST_F(QuicPacketGeneratorTest, 298 ShouldSendAckWithFeedback_WritableAndShouldFlush) { 299 delegate_.SetCanWriteOnlyNonRetransmittable(); 300 301 EXPECT_CALL(delegate_, CreateAckFrame()).WillOnce(Return(CreateAckFrame())); 302 EXPECT_CALL(delegate_, CreateFeedbackFrame()).WillOnce( 303 Return(CreateFeedbackFrame())); 304 EXPECT_CALL(delegate_, CreateStopWaitingFrame()).WillOnce( 305 Return(CreateStopWaitingFrame())); 306 307 EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(SaveArg<0>(&packet_)); 308 309 generator_.SetShouldSendAck(true, true); 310 EXPECT_FALSE(generator_.HasQueuedFrames()); 311 312 PacketContents contents; 313 contents.num_ack_frames = 1; 314 contents.num_feedback_frames = 1; 315 contents.num_stop_waiting_frames = 1; 316 CheckPacketContains(contents, packet_); 317 } 318 319 TEST_F(QuicPacketGeneratorTest, AddControlFrame_NotWritable) { 320 delegate_.SetCanNotWrite(); 321 322 generator_.AddControlFrame(QuicFrame(CreateRstStreamFrame())); 323 EXPECT_TRUE(generator_.HasQueuedFrames()); 324 } 325 326 TEST_F(QuicPacketGeneratorTest, AddControlFrame_OnlyAckWritable) { 327 delegate_.SetCanWriteOnlyNonRetransmittable(); 328 329 generator_.AddControlFrame(QuicFrame(CreateRstStreamFrame())); 330 EXPECT_TRUE(generator_.HasQueuedFrames()); 331 } 332 333 TEST_F(QuicPacketGeneratorTest, AddControlFrame_WritableAndShouldNotFlush) { 334 delegate_.SetCanWriteAnything(); 335 generator_.StartBatchOperations(); 336 337 generator_.AddControlFrame(QuicFrame(CreateRstStreamFrame())); 338 EXPECT_TRUE(generator_.HasQueuedFrames()); 339 } 340 341 TEST_F(QuicPacketGeneratorTest, AddControlFrame_NotWritableBatchThenFlush) { 342 delegate_.SetCanNotWrite(); 343 generator_.StartBatchOperations(); 344 345 generator_.AddControlFrame(QuicFrame(CreateRstStreamFrame())); 346 EXPECT_TRUE(generator_.HasQueuedFrames()); 347 generator_.FinishBatchOperations(); 348 EXPECT_TRUE(generator_.HasQueuedFrames()); 349 350 EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(SaveArg<0>(&packet_)); 351 generator_.FlushAllQueuedFrames(); 352 EXPECT_FALSE(generator_.HasQueuedFrames()); 353 354 PacketContents contents; 355 contents.num_rst_stream_frames = 1; 356 CheckPacketContains(contents, packet_); 357 } 358 359 TEST_F(QuicPacketGeneratorTest, AddControlFrame_WritableAndShouldFlush) { 360 delegate_.SetCanWriteAnything(); 361 362 EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(SaveArg<0>(&packet_)); 363 364 generator_.AddControlFrame(QuicFrame(CreateRstStreamFrame())); 365 EXPECT_FALSE(generator_.HasQueuedFrames()); 366 367 PacketContents contents; 368 contents.num_rst_stream_frames = 1; 369 CheckPacketContains(contents, packet_); 370 } 371 372 TEST_F(QuicPacketGeneratorTest, ConsumeData_NotWritable) { 373 delegate_.SetCanNotWrite(); 374 375 QuicConsumedData consumed = generator_.ConsumeData( 376 kHeadersStreamId, MakeIOVector("foo"), 2, true, MAY_FEC_PROTECT, NULL); 377 EXPECT_EQ(0u, consumed.bytes_consumed); 378 EXPECT_FALSE(consumed.fin_consumed); 379 EXPECT_FALSE(generator_.HasQueuedFrames()); 380 } 381 382 TEST_F(QuicPacketGeneratorTest, ConsumeData_WritableAndShouldNotFlush) { 383 delegate_.SetCanWriteAnything(); 384 generator_.StartBatchOperations(); 385 386 QuicConsumedData consumed = generator_.ConsumeData( 387 kHeadersStreamId, MakeIOVector("foo"), 2, true, MAY_FEC_PROTECT, NULL); 388 EXPECT_EQ(3u, consumed.bytes_consumed); 389 EXPECT_TRUE(consumed.fin_consumed); 390 EXPECT_TRUE(generator_.HasQueuedFrames()); 391 } 392 393 TEST_F(QuicPacketGeneratorTest, ConsumeData_WritableAndShouldFlush) { 394 delegate_.SetCanWriteAnything(); 395 396 EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(SaveArg<0>(&packet_)); 397 QuicConsumedData consumed = generator_.ConsumeData( 398 kHeadersStreamId, MakeIOVector("foo"), 2, true, MAY_FEC_PROTECT, NULL); 399 EXPECT_EQ(3u, consumed.bytes_consumed); 400 EXPECT_TRUE(consumed.fin_consumed); 401 EXPECT_FALSE(generator_.HasQueuedFrames()); 402 403 PacketContents contents; 404 contents.num_stream_frames = 1; 405 CheckPacketContains(contents, packet_); 406 } 407 408 TEST_F(QuicPacketGeneratorTest, 409 ConsumeDataMultipleTimes_WritableAndShouldNotFlush) { 410 delegate_.SetCanWriteAnything(); 411 generator_.StartBatchOperations(); 412 413 generator_.ConsumeData(kHeadersStreamId, MakeIOVector("foo"), 2, true, 414 MAY_FEC_PROTECT, NULL); 415 QuicConsumedData consumed = generator_.ConsumeData( 416 3, MakeIOVector("quux"), 7, false, MAY_FEC_PROTECT, NULL); 417 EXPECT_EQ(4u, consumed.bytes_consumed); 418 EXPECT_FALSE(consumed.fin_consumed); 419 EXPECT_TRUE(generator_.HasQueuedFrames()); 420 } 421 422 TEST_F(QuicPacketGeneratorTest, ConsumeData_BatchOperations) { 423 delegate_.SetCanWriteAnything(); 424 generator_.StartBatchOperations(); 425 426 generator_.ConsumeData(kHeadersStreamId, MakeIOVector("foo"), 2, true, 427 MAY_FEC_PROTECT, NULL); 428 QuicConsumedData consumed = generator_.ConsumeData( 429 3, MakeIOVector("quux"), 7, false, MAY_FEC_PROTECT, NULL); 430 EXPECT_EQ(4u, consumed.bytes_consumed); 431 EXPECT_FALSE(consumed.fin_consumed); 432 EXPECT_TRUE(generator_.HasQueuedFrames()); 433 434 // Now both frames will be flushed out. 435 EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(SaveArg<0>(&packet_)); 436 generator_.FinishBatchOperations(); 437 EXPECT_FALSE(generator_.HasQueuedFrames()); 438 439 PacketContents contents; 440 contents.num_stream_frames = 2; 441 CheckPacketContains(contents, packet_); 442 } 443 444 TEST_F(QuicPacketGeneratorTest, ConsumeDataFEC) { 445 delegate_.SetCanWriteAnything(); 446 447 // Send FEC every two packets. 448 creator_->set_max_packets_per_fec_group(2); 449 450 { 451 InSequence dummy; 452 EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce( 453 SaveArg<0>(&packet_)); 454 EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce( 455 SaveArg<0>(&packet2_)); 456 EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce( 457 SaveArg<0>(&packet3_)); 458 EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce( 459 SaveArg<0>(&packet4_)); 460 EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce( 461 SaveArg<0>(&packet5_)); 462 } 463 464 // Send enough data to create 3 packets: two full and one partial. Send 465 // with MUST_FEC_PROTECT flag. 466 size_t data_len = 2 * kDefaultMaxPacketSize + 100; 467 QuicConsumedData consumed = 468 generator_.ConsumeData(3, CreateData(data_len), 0, true, 469 MUST_FEC_PROTECT, NULL); 470 EXPECT_EQ(data_len, consumed.bytes_consumed); 471 EXPECT_TRUE(consumed.fin_consumed); 472 EXPECT_FALSE(generator_.HasQueuedFrames()); 473 474 CheckPacketHasSingleStreamFrame(packet_); 475 CheckPacketHasSingleStreamFrame(packet2_); 476 CheckPacketIsFec(packet3_, 1); 477 478 CheckPacketHasSingleStreamFrame(packet4_); 479 CheckPacketIsFec(packet5_, 4); 480 } 481 482 TEST_F(QuicPacketGeneratorTest, ConsumeDataSendsFecAtEnd) { 483 delegate_.SetCanWriteAnything(); 484 485 // Enable FEC. 486 creator_->set_max_packets_per_fec_group(6); 487 { 488 InSequence dummy; 489 EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce( 490 SaveArg<0>(&packet_)); 491 EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce( 492 SaveArg<0>(&packet2_)); 493 EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce( 494 SaveArg<0>(&packet3_)); 495 } 496 497 // Send enough data to create 2 packets: one full and one partial. Send 498 // with MUST_FEC_PROTECT flag. 499 size_t data_len = 1 * kDefaultMaxPacketSize + 100; 500 QuicConsumedData consumed = 501 generator_.ConsumeData(3, CreateData(data_len), 0, true, 502 MUST_FEC_PROTECT, NULL); 503 EXPECT_EQ(data_len, consumed.bytes_consumed); 504 EXPECT_TRUE(consumed.fin_consumed); 505 EXPECT_FALSE(generator_.HasQueuedFrames()); 506 507 CheckPacketHasSingleStreamFrame(packet_); 508 CheckPacketHasSingleStreamFrame(packet2_); 509 CheckPacketIsFec(packet3_, 1); 510 } 511 512 TEST_F(QuicPacketGeneratorTest, ConsumeData_FramesPreviouslyQueued) { 513 // Set the packet size be enough for two stream frames with 0 stream offset, 514 // but not enough for a stream frame of 0 offset and one with non-zero offset. 515 size_t length = 516 NullEncrypter().GetCiphertextSize(0) + 517 GetPacketHeaderSize(creator_->connection_id_length(), 518 true, 519 creator_->next_sequence_number_length(), 520 NOT_IN_FEC_GROUP) + 521 // Add an extra 3 bytes for the payload and 1 byte so BytesFree is larger 522 // than the GetMinStreamFrameSize. 523 QuicFramer::GetMinStreamFrameSize(1, 0, false, NOT_IN_FEC_GROUP) + 3 + 524 QuicFramer::GetMinStreamFrameSize(1, 0, true, NOT_IN_FEC_GROUP) + 1; 525 creator_->set_max_packet_length(length); 526 delegate_.SetCanWriteAnything(); 527 { 528 InSequence dummy; 529 EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce( 530 SaveArg<0>(&packet_)); 531 EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce( 532 SaveArg<0>(&packet2_)); 533 } 534 generator_.StartBatchOperations(); 535 // Queue enough data to prevent a stream frame with a non-zero offset from 536 // fitting. 537 QuicConsumedData consumed = generator_.ConsumeData( 538 kHeadersStreamId, MakeIOVector("foo"), 0, false, MAY_FEC_PROTECT, NULL); 539 EXPECT_EQ(3u, consumed.bytes_consumed); 540 EXPECT_FALSE(consumed.fin_consumed); 541 EXPECT_TRUE(generator_.HasQueuedFrames()); 542 543 // This frame will not fit with the existing frame, causing the queued frame 544 // to be serialized, and it will not fit with another frame like it, so it is 545 // serialized by itself. 546 consumed = generator_.ConsumeData(kHeadersStreamId, MakeIOVector("bar"), 3, 547 true, MAY_FEC_PROTECT, NULL); 548 EXPECT_EQ(3u, consumed.bytes_consumed); 549 EXPECT_TRUE(consumed.fin_consumed); 550 EXPECT_FALSE(generator_.HasQueuedFrames()); 551 552 PacketContents contents; 553 contents.num_stream_frames = 1; 554 CheckPacketContains(contents, packet_); 555 CheckPacketContains(contents, packet2_); 556 } 557 558 TEST_F(QuicPacketGeneratorTest, FecGroupSizeOnCongestionWindowChange) { 559 delegate_.SetCanWriteAnything(); 560 creator_->set_max_packets_per_fec_group(50); 561 EXPECT_EQ(50u, creator_->max_packets_per_fec_group()); 562 EXPECT_FALSE(creator_->IsFecGroupOpen()); 563 564 // On reduced cwnd. 565 generator_.OnCongestionWindowChange(7 * kDefaultTCPMSS); 566 EXPECT_EQ(3u, creator_->max_packets_per_fec_group()); 567 568 // On increased cwnd. 569 generator_.OnCongestionWindowChange(100 * kDefaultTCPMSS); 570 EXPECT_EQ(50u, creator_->max_packets_per_fec_group()); 571 572 // On collapsed cwnd. 573 generator_.OnCongestionWindowChange(1 * kDefaultTCPMSS); 574 EXPECT_EQ(2u, creator_->max_packets_per_fec_group()); 575 } 576 577 TEST_F(QuicPacketGeneratorTest, FecGroupSizeChangeWithOpenGroup) { 578 delegate_.SetCanWriteAnything(); 579 // TODO(jri): This starting of batch mode should not be required when 580 // FEC sending is separated from batching operations. 581 generator_.StartBatchOperations(); 582 creator_->set_max_packets_per_fec_group(50); 583 EXPECT_EQ(50u, creator_->max_packets_per_fec_group()); 584 EXPECT_FALSE(creator_->IsFecGroupOpen()); 585 586 // Send enough data to create 4 packets with MUST_FEC_PROTECT flag. 587 // 3 packets are sent, one is queued in the creator. 588 { 589 InSequence dummy; 590 EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce( 591 SaveArg<0>(&packet_)); 592 EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce( 593 SaveArg<0>(&packet2_)); 594 EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce( 595 SaveArg<0>(&packet3_)); 596 } 597 size_t data_len = 3 * kDefaultMaxPacketSize + 1; 598 QuicConsumedData consumed = generator_.ConsumeData( 599 7, CreateData(data_len), 0, true, MUST_FEC_PROTECT, NULL); 600 EXPECT_EQ(data_len, consumed.bytes_consumed); 601 EXPECT_TRUE(creator_->IsFecGroupOpen()); 602 603 // Change FEC groupsize. 604 generator_.OnCongestionWindowChange(2 * kDefaultTCPMSS); 605 EXPECT_EQ(2u, creator_->max_packets_per_fec_group()); 606 607 // Send enough data to trigger one unprotected data packet, 608 // causing the FEC packet to also be sent. 609 { 610 InSequence dummy; 611 EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce( 612 SaveArg<0>(&packet4_)); 613 EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce( 614 SaveArg<0>(&packet5_)); 615 } 616 consumed = generator_.ConsumeData(7, CreateData(kDefaultMaxPacketSize), 0, 617 true, MAY_FEC_PROTECT, NULL); 618 EXPECT_EQ(kDefaultMaxPacketSize, consumed.bytes_consumed); 619 // Verify that one FEC packet was sent. 620 CheckPacketIsFec(packet5_, /*fec_group=*/1u); 621 EXPECT_FALSE(creator_->IsFecGroupOpen()); 622 EXPECT_FALSE(creator_->IsFecProtected()); 623 } 624 625 TEST_F(QuicPacketGeneratorTest, SwitchFecOnOff) { 626 delegate_.SetCanWriteAnything(); 627 creator_->set_max_packets_per_fec_group(2); 628 EXPECT_FALSE(creator_->IsFecProtected()); 629 630 // Send one unprotected data packet. 631 EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce( 632 SaveArg<0>(&packet_)); 633 QuicConsumedData consumed = 634 generator_.ConsumeData(5, CreateData(1u), 0, true, MAY_FEC_PROTECT, 635 NULL); 636 EXPECT_EQ(1u, consumed.bytes_consumed); 637 EXPECT_FALSE(generator_.HasQueuedFrames()); 638 EXPECT_FALSE(creator_->IsFecProtected()); 639 // Verify that one data packet was sent. 640 PacketContents contents; 641 contents.num_stream_frames = 1; 642 CheckPacketContains(contents, packet_); 643 644 { 645 InSequence dummy; 646 EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce( 647 SaveArg<0>(&packet2_)); 648 EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce( 649 SaveArg<0>(&packet3_)); 650 EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce( 651 SaveArg<0>(&packet4_)); 652 EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce( 653 SaveArg<0>(&packet5_)); 654 EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce( 655 SaveArg<0>(&packet6_)); 656 } 657 // Send enough data to create 3 packets with MUST_FEC_PROTECT flag. 658 size_t data_len = 2 * kDefaultMaxPacketSize + 100; 659 consumed = generator_.ConsumeData(7, CreateData(data_len), 0, true, 660 MUST_FEC_PROTECT, NULL); 661 EXPECT_EQ(data_len, consumed.bytes_consumed); 662 EXPECT_FALSE(generator_.HasQueuedFrames()); 663 664 // Verify that two FEC packets were sent. 665 CheckPacketHasSingleStreamFrame(packet2_); 666 CheckPacketHasSingleStreamFrame(packet3_); 667 CheckPacketIsFec(packet4_, /*fec_group=*/2u); 668 CheckPacketHasSingleStreamFrame(packet5_); 669 CheckPacketIsFec(packet6_, /*fec_group=*/5u); // Sent at the end of stream. 670 671 // Send one unprotected data packet. 672 EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce( 673 SaveArg<0>(&packet7_)); 674 consumed = generator_.ConsumeData(7, CreateData(1u), 0, true, 675 MAY_FEC_PROTECT, NULL); 676 EXPECT_EQ(1u, consumed.bytes_consumed); 677 EXPECT_FALSE(generator_.HasQueuedFrames()); 678 EXPECT_FALSE(creator_->IsFecProtected()); 679 // Verify that one unprotected data packet was sent. 680 CheckPacketContains(contents, packet7_); 681 } 682 683 TEST_F(QuicPacketGeneratorTest, SwitchFecOnWithPendingFrameInCreator) { 684 delegate_.SetCanWriteAnything(); 685 // Enable FEC. 686 creator_->set_max_packets_per_fec_group(2); 687 688 generator_.StartBatchOperations(); 689 // Queue enough data to prevent a stream frame with a non-zero offset from 690 // fitting. 691 QuicConsumedData consumed = generator_.ConsumeData( 692 7, CreateData(1u), 0, true, MAY_FEC_PROTECT, NULL); 693 EXPECT_EQ(1u, consumed.bytes_consumed); 694 EXPECT_TRUE(creator_->HasPendingFrames()); 695 696 // Queue protected data for sending. Should cause queued frames to be flushed. 697 EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce( 698 SaveArg<0>(&packet_)); 699 EXPECT_FALSE(creator_->IsFecProtected()); 700 consumed = generator_.ConsumeData(7, CreateData(1u), 0, true, 701 MUST_FEC_PROTECT, NULL); 702 EXPECT_EQ(1u, consumed.bytes_consumed); 703 PacketContents contents; 704 contents.num_stream_frames = 1; 705 // Transmitted packet was not FEC protected. 706 CheckPacketContains(contents, packet_); 707 EXPECT_TRUE(creator_->IsFecProtected()); 708 EXPECT_TRUE(creator_->HasPendingFrames()); 709 } 710 711 TEST_F(QuicPacketGeneratorTest, SwitchFecOnWithPendingFramesInGenerator) { 712 // Enable FEC. 713 creator_->set_max_packets_per_fec_group(2); 714 715 // Queue control frames in generator. 716 delegate_.SetCanNotWrite(); 717 generator_.SetShouldSendAck(true, true); 718 delegate_.SetCanWriteAnything(); 719 generator_.StartBatchOperations(); 720 721 // Set up frames to write into the creator when control frames are written. 722 EXPECT_CALL(delegate_, CreateAckFrame()).WillOnce(Return(CreateAckFrame())); 723 EXPECT_CALL(delegate_, CreateFeedbackFrame()).WillOnce( 724 Return(CreateFeedbackFrame())); 725 EXPECT_CALL(delegate_, CreateStopWaitingFrame()).WillOnce( 726 Return(CreateStopWaitingFrame())); 727 728 // Generator should have queued control frames, and creator should be empty. 729 EXPECT_TRUE(generator_.HasQueuedFrames()); 730 EXPECT_FALSE(creator_->HasPendingFrames()); 731 EXPECT_FALSE(creator_->IsFecProtected()); 732 733 // Queue protected data for sending. Should cause queued frames to be flushed. 734 EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce( 735 SaveArg<0>(&packet_)); 736 QuicConsumedData consumed = generator_.ConsumeData(7, CreateData(1u), 0, true, 737 MUST_FEC_PROTECT, NULL); 738 EXPECT_EQ(1u, consumed.bytes_consumed); 739 PacketContents contents; 740 contents.num_ack_frames = 1; 741 contents.num_feedback_frames = 1; 742 contents.num_stop_waiting_frames = 1; 743 CheckPacketContains(contents, packet_); 744 745 // FEC protection should be on in creator. 746 EXPECT_TRUE(creator_->IsFecProtected()); 747 } 748 749 TEST_F(QuicPacketGeneratorTest, SwitchFecOnOffWithSubsequentFramesProtected) { 750 delegate_.SetCanWriteAnything(); 751 752 // Enable FEC. 753 creator_->set_max_packets_per_fec_group(2); 754 EXPECT_FALSE(creator_->IsFecProtected()); 755 756 // Queue stream frame to be protected in creator. 757 generator_.StartBatchOperations(); 758 QuicConsumedData consumed = generator_.ConsumeData(5, CreateData(1u), 0, true, 759 MUST_FEC_PROTECT, NULL); 760 EXPECT_EQ(1u, consumed.bytes_consumed); 761 // Creator has a pending protected frame. 762 EXPECT_TRUE(creator_->HasPendingFrames()); 763 EXPECT_TRUE(creator_->IsFecProtected()); 764 765 // Add enough unprotected data to exceed size of current packet, so that 766 // current packet is sent. Both frames will be sent out in a single packet. 767 EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(SaveArg<0>(&packet_)); 768 size_t data_len = kDefaultMaxPacketSize; 769 consumed = generator_.ConsumeData(5, CreateData(data_len), 0, true, 770 MAY_FEC_PROTECT, NULL); 771 EXPECT_EQ(data_len, consumed.bytes_consumed); 772 PacketContents contents; 773 contents.num_stream_frames = 2u; 774 contents.fec_group = 1u; 775 CheckPacketContains(contents, packet_); 776 // FEC protection should still be on in creator. 777 EXPECT_TRUE(creator_->IsFecProtected()); 778 } 779 780 TEST_F(QuicPacketGeneratorTest, SwitchFecOnOffWithSubsequentPacketsProtected) { 781 delegate_.SetCanWriteAnything(); 782 783 // Enable FEC. 784 creator_->set_max_packets_per_fec_group(2); 785 EXPECT_FALSE(creator_->IsFecProtected()); 786 787 generator_.StartBatchOperations(); 788 // Send first packet, FEC protected. 789 EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(SaveArg<0>(&packet_)); 790 // Write enough data to cause a packet to be emitted. 791 size_t data_len = kDefaultMaxPacketSize; 792 QuicConsumedData consumed = generator_.ConsumeData( 793 5, CreateData(data_len), 0, true, MUST_FEC_PROTECT, NULL); 794 EXPECT_EQ(data_len, consumed.bytes_consumed); 795 PacketContents contents; 796 contents.num_stream_frames = 1u; 797 contents.fec_group = 1u; 798 CheckPacketContains(contents, packet_); 799 800 // FEC should still be on in creator. 801 EXPECT_TRUE(creator_->IsFecProtected()); 802 803 // Send enough unprotected data to cause second packet to be sent, which gets 804 // protected because it happens to fall within an open FEC group. Data packet 805 // will be followed by FEC packet. 806 { 807 InSequence dummy; 808 EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce( 809 SaveArg<0>(&packet2_)); 810 EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce( 811 SaveArg<0>(&packet3_)); 812 } 813 consumed = generator_.ConsumeData(5, CreateData(data_len), 0, true, 814 MAY_FEC_PROTECT, NULL); 815 EXPECT_EQ(data_len, consumed.bytes_consumed); 816 contents.num_stream_frames = 2u; 817 CheckPacketContains(contents, packet2_); 818 CheckPacketIsFec(packet3_, /*fec_group=*/1u); 819 820 // FEC protection should be off in creator. 821 EXPECT_FALSE(creator_->IsFecProtected()); 822 } 823 824 TEST_F(QuicPacketGeneratorTest, SwitchFecOnOffThenOnWithCreatorProtectionOn) { 825 delegate_.SetCanWriteAnything(); 826 generator_.StartBatchOperations(); 827 828 // Enable FEC. 829 creator_->set_max_packets_per_fec_group(2); 830 EXPECT_FALSE(creator_->IsFecProtected()); 831 832 // Queue one byte of FEC protected data. 833 QuicConsumedData consumed = generator_.ConsumeData(5, CreateData(1u), 0, true, 834 MUST_FEC_PROTECT, NULL); 835 EXPECT_TRUE(creator_->HasPendingFrames()); 836 837 // Add more unprotected data causing first packet to be sent, FEC protected. 838 EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce( 839 SaveArg<0>(&packet_)); 840 size_t data_len = kDefaultMaxPacketSize; 841 consumed = generator_.ConsumeData(5, CreateData(data_len), 0, true, 842 MAY_FEC_PROTECT, NULL); 843 EXPECT_EQ(data_len, consumed.bytes_consumed); 844 PacketContents contents; 845 contents.num_stream_frames = 2u; 846 contents.fec_group = 1u; 847 CheckPacketContains(contents, packet_); 848 849 // FEC group is still open in creator. 850 EXPECT_TRUE(creator_->IsFecProtected()); 851 852 // Add data that should be protected, large enough to cause second packet to 853 // be sent. Data packet should be followed by FEC packet. 854 { 855 InSequence dummy; 856 EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce( 857 SaveArg<0>(&packet2_)); 858 EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce( 859 SaveArg<0>(&packet3_)); 860 } 861 consumed = generator_.ConsumeData(5, CreateData(data_len), 0, true, 862 MUST_FEC_PROTECT, NULL); 863 EXPECT_EQ(data_len, consumed.bytes_consumed); 864 CheckPacketContains(contents, packet2_); 865 CheckPacketIsFec(packet3_, /*fec_group=*/1u); 866 867 // FEC protection should remain on in creator. 868 EXPECT_TRUE(creator_->IsFecProtected()); 869 } 870 871 TEST_F(QuicPacketGeneratorTest, NotWritableThenBatchOperations) { 872 delegate_.SetCanNotWrite(); 873 874 generator_.SetShouldSendAck(true, false); 875 generator_.AddControlFrame(QuicFrame(CreateRstStreamFrame())); 876 EXPECT_TRUE(generator_.HasQueuedFrames()); 877 878 delegate_.SetCanWriteAnything(); 879 880 generator_.StartBatchOperations(); 881 882 // When the first write operation is invoked, the ack and feedback 883 // frames will be returned. 884 EXPECT_CALL(delegate_, CreateAckFrame()).WillOnce(Return(CreateAckFrame())); 885 EXPECT_CALL(delegate_, CreateFeedbackFrame()).WillOnce( 886 Return(CreateFeedbackFrame())); 887 888 // Send some data and a control frame 889 generator_.ConsumeData(3, MakeIOVector("quux"), 7, false, 890 MAY_FEC_PROTECT, NULL); 891 generator_.AddControlFrame(QuicFrame(CreateGoAwayFrame())); 892 893 // All five frames will be flushed out in a single packet. 894 EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(SaveArg<0>(&packet_)); 895 generator_.FinishBatchOperations(); 896 EXPECT_FALSE(generator_.HasQueuedFrames()); 897 898 PacketContents contents; 899 contents.num_ack_frames = 1; 900 contents.num_goaway_frames = 1; 901 contents.num_feedback_frames = 1; 902 contents.num_rst_stream_frames = 1; 903 contents.num_stream_frames = 1; 904 CheckPacketContains(contents, packet_); 905 } 906 907 TEST_F(QuicPacketGeneratorTest, NotWritableThenBatchOperations2) { 908 delegate_.SetCanNotWrite(); 909 910 generator_.SetShouldSendAck(true, false); 911 generator_.AddControlFrame(QuicFrame(CreateRstStreamFrame())); 912 EXPECT_TRUE(generator_.HasQueuedFrames()); 913 914 delegate_.SetCanWriteAnything(); 915 916 generator_.StartBatchOperations(); 917 918 // When the first write operation is invoked, the ack and feedback 919 // frames will be returned. 920 EXPECT_CALL(delegate_, CreateAckFrame()).WillOnce(Return(CreateAckFrame())); 921 EXPECT_CALL(delegate_, CreateFeedbackFrame()).WillOnce( 922 Return(CreateFeedbackFrame())); 923 924 { 925 InSequence dummy; 926 // All five frames will be flushed out in a single packet 927 EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce( 928 SaveArg<0>(&packet_)); 929 EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce( 930 SaveArg<0>(&packet2_)); 931 } 932 933 // Send enough data to exceed one packet 934 size_t data_len = kDefaultMaxPacketSize + 100; 935 QuicConsumedData consumed = 936 generator_.ConsumeData(3, CreateData(data_len), 0, true, 937 MAY_FEC_PROTECT, NULL); 938 EXPECT_EQ(data_len, consumed.bytes_consumed); 939 EXPECT_TRUE(consumed.fin_consumed); 940 generator_.AddControlFrame(QuicFrame(CreateGoAwayFrame())); 941 942 generator_.FinishBatchOperations(); 943 EXPECT_FALSE(generator_.HasQueuedFrames()); 944 945 // The first packet should have the queued data and part of the stream data. 946 PacketContents contents; 947 contents.num_ack_frames = 1; 948 contents.num_feedback_frames = 1; 949 contents.num_rst_stream_frames = 1; 950 contents.num_stream_frames = 1; 951 CheckPacketContains(contents, packet_); 952 953 // The second should have the remainder of the stream data. 954 PacketContents contents2; 955 contents2.num_goaway_frames = 1; 956 contents2.num_stream_frames = 1; 957 CheckPacketContains(contents2, packet2_); 958 } 959 960 } // namespace test 961 } // namespace net 962
