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