Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(180)

Side by Side Diff: net/quic/quic_packet_creator_test.cc

Issue 288313003: Land Recent QUIC Changes. (Closed) Base URL: https://chromium.googlesource.com/chromium/src
Patch Set: implemented rch's comments Created 6 years, 7 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. 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 2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file. 3 // found in the LICENSE file.
4 4
5 #include "net/quic/quic_packet_creator.h" 5 #include "net/quic/quic_packet_creator.h"
6 6
7 #include "base/stl_util.h" 7 #include "base/stl_util.h"
8 #include "net/quic/crypto/null_encrypter.h" 8 #include "net/quic/crypto/null_encrypter.h"
9 #include "net/quic/crypto/quic_decrypter.h" 9 #include "net/quic/crypto/quic_decrypter.h"
10 #include "net/quic/crypto/quic_encrypter.h" 10 #include "net/quic/crypto/quic_encrypter.h"
(...skipping 101 matching lines...) Expand 10 before | Expand all | Expand 10 after
112 client_framer_.GetMaxPlaintextSize( 112 client_framer_.GetMaxPlaintextSize(
113 creator_.options()->max_packet_length); 113 creator_.options()->max_packet_length);
114 } 114 }
115 115
116 // Returns the number of bytes consumed by the non-data fields of a stream 116 // Returns the number of bytes consumed by the non-data fields of a stream
117 // frame, assuming it is the last frame in the packet 117 // frame, assuming it is the last frame in the packet
118 size_t GetStreamFrameOverhead(InFecGroup is_in_fec_group) { 118 size_t GetStreamFrameOverhead(InFecGroup is_in_fec_group) {
119 return QuicFramer::GetMinStreamFrameSize( 119 return QuicFramer::GetMinStreamFrameSize(
120 client_framer_.version(), kStreamId, kOffset, true, is_in_fec_group); 120 client_framer_.version(), kStreamId, kOffset, true, is_in_fec_group);
121 } 121 }
122
123 static const QuicStreamId kStreamId = 1u; 122 static const QuicStreamId kStreamId = 1u;
124 static const QuicStreamOffset kOffset = 1u; 123 static const QuicStreamOffset kOffset = 1u;
125 124
126 QuicFrames frames_; 125 QuicFrames frames_;
127 QuicFramer server_framer_; 126 QuicFramer server_framer_;
128 QuicFramer client_framer_; 127 QuicFramer client_framer_;
129 testing::StrictMock<MockFramerVisitor> framer_visitor_; 128 testing::StrictMock<MockFramerVisitor> framer_visitor_;
130 QuicPacketSequenceNumber sequence_number_; 129 QuicPacketSequenceNumber sequence_number_;
131 QuicConnectionId connection_id_; 130 QuicConnectionId connection_id_;
132 string data_; 131 string data_;
133 MockRandom mock_random_; 132 MockRandom mock_random_;
134 QuicPacketCreator creator_; 133 QuicPacketCreator creator_;
135 }; 134 };
136 135
137 // Run all packet creator tests with all supported versions of QUIC, and with 136 // Run all packet creator tests with all supported versions of QUIC, and with
138 // and without version in the packet header. 137 // and without version in the packet header.
139 INSTANTIATE_TEST_CASE_P(QuicPacketCreatorTests, 138 INSTANTIATE_TEST_CASE_P(QuicPacketCreatorTests,
140 QuicPacketCreatorTest, 139 QuicPacketCreatorTest,
141 ::testing::ValuesIn(GetTestParams())); 140 ::testing::ValuesIn(GetTestParams()));
142 141
143
144 TEST_P(QuicPacketCreatorTest, SerializeFrames) { 142 TEST_P(QuicPacketCreatorTest, SerializeFrames) {
145 frames_.push_back(QuicFrame(new QuicAckFrame(MakeAckFrame(0u, 0u)))); 143 frames_.push_back(QuicFrame(new QuicAckFrame(MakeAckFrame(0u, 0u))));
146 frames_.push_back(QuicFrame(new QuicStreamFrame(0u, false, 0u, IOVector()))); 144 frames_.push_back(QuicFrame(new QuicStreamFrame(0u, false, 0u, IOVector())));
147 frames_.push_back(QuicFrame(new QuicStreamFrame(0u, true, 0u, IOVector()))); 145 frames_.push_back(QuicFrame(new QuicStreamFrame(0u, true, 0u, IOVector())));
148 SerializedPacket serialized = creator_.SerializeAllFrames(frames_); 146 SerializedPacket serialized = creator_.SerializeAllFrames(frames_);
149 delete frames_[0].ack_frame; 147 delete frames_[0].ack_frame;
150 delete frames_[1].stream_frame; 148 delete frames_[1].stream_frame;
151 delete frames_[2].stream_frame; 149 delete frames_[2].stream_frame;
152 150
153 { 151 {
154 InSequence s; 152 InSequence s;
155 EXPECT_CALL(framer_visitor_, OnPacket()); 153 EXPECT_CALL(framer_visitor_, OnPacket());
156 EXPECT_CALL(framer_visitor_, OnUnauthenticatedPublicHeader(_)); 154 EXPECT_CALL(framer_visitor_, OnUnauthenticatedPublicHeader(_));
157 EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_)); 155 EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_));
158 EXPECT_CALL(framer_visitor_, OnDecryptedPacket(_)); 156 EXPECT_CALL(framer_visitor_, OnDecryptedPacket(_));
159 EXPECT_CALL(framer_visitor_, OnPacketHeader(_)); 157 EXPECT_CALL(framer_visitor_, OnPacketHeader(_));
160 EXPECT_CALL(framer_visitor_, OnAckFrame(_)); 158 EXPECT_CALL(framer_visitor_, OnAckFrame(_));
161 EXPECT_CALL(framer_visitor_, OnStreamFrame(_)); 159 EXPECT_CALL(framer_visitor_, OnStreamFrame(_));
162 EXPECT_CALL(framer_visitor_, OnStreamFrame(_)); 160 EXPECT_CALL(framer_visitor_, OnStreamFrame(_));
163 EXPECT_CALL(framer_visitor_, OnPacketComplete()); 161 EXPECT_CALL(framer_visitor_, OnPacketComplete());
164 } 162 }
165 ProcessPacket(serialized.packet); 163 ProcessPacket(serialized.packet);
166 delete serialized.packet; 164 delete serialized.packet;
167 } 165 }
168 166
169 TEST_P(QuicPacketCreatorTest, SerializeWithFEC) { 167 TEST_P(QuicPacketCreatorTest, SerializeWithFEC) {
170 creator_.options()->max_packets_per_fec_group = 6; 168 // Enable FEC protection, and send FEC packet every 6 packets.
169 EXPECT_TRUE(QuicPacketCreatorPeer::SwitchFecProtectionOn(&creator_, 6));
171 // Should return false since we do not have enough packets in the FEC group to 170 // Should return false since we do not have enough packets in the FEC group to
172 // trigger an FEC packet. 171 // trigger an FEC packet.
173 ASSERT_FALSE(creator_.ShouldSendFec(/*force_close=*/false)); 172 ASSERT_FALSE(creator_.ShouldSendFec(/*force_close=*/false));
174 173
175 frames_.push_back(QuicFrame(new QuicStreamFrame(0u, false, 0u, IOVector()))); 174 frames_.push_back(QuicFrame(new QuicStreamFrame(0u, false, 0u, IOVector())));
176 SerializedPacket serialized = creator_.SerializeAllFrames(frames_); 175 SerializedPacket serialized = creator_.SerializeAllFrames(frames_);
177 delete frames_[0].stream_frame; 176 delete frames_[0].stream_frame;
178 177
179 { 178 {
180 InSequence s; 179 InSequence s;
(...skipping 71 matching lines...) Expand 10 before | Expand all | Expand 10 after
252 } 251 }
253 ProcessPacket(serialized.packet); 252 ProcessPacket(serialized.packet);
254 delete serialized.packet; 253 delete serialized.packet;
255 } 254 }
256 255
257 TEST_P(QuicPacketCreatorTest, SerializeWithFECChangingSequenceNumberLength) { 256 TEST_P(QuicPacketCreatorTest, SerializeWithFECChangingSequenceNumberLength) {
258 // Test goal is to test the following sequence (P1 => generate Packet 1): 257 // Test goal is to test the following sequence (P1 => generate Packet 1):
259 // P1 <change seq num length> P2 FEC, 258 // P1 <change seq num length> P2 FEC,
260 // and we expect that sequence number length should not change until the end 259 // and we expect that sequence number length should not change until the end
261 // of the open FEC group. 260 // of the open FEC group.
262 creator_.options()->max_packets_per_fec_group = 6; 261
262 // Enable FEC protection, and send FEC packet every 6 packets.
263 EXPECT_TRUE(QuicPacketCreatorPeer::SwitchFecProtectionOn(&creator_, 6));
263 // Should return false since we do not have enough packets in the FEC group to 264 // Should return false since we do not have enough packets in the FEC group to
264 // trigger an FEC packet. 265 // trigger an FEC packet.
265 ASSERT_FALSE(creator_.ShouldSendFec(/*force_close=*/false)); 266 ASSERT_FALSE(creator_.ShouldSendFec(/*force_close=*/false));
266 frames_.push_back(QuicFrame(new QuicAckFrame(MakeAckFrame(0u, 0u)))); 267 frames_.push_back(QuicFrame(new QuicAckFrame(MakeAckFrame(0u, 0u))));
267 268
268 // Generate Packet 1. 269 // Generate Packet 1.
269 creator_.AddSavedFrame(frames_[0]); 270 creator_.AddSavedFrame(frames_[0]);
270 // Change the sequence number length mid-FEC group and it should not change. 271 // Change the sequence number length mid-FEC group and it should not change.
271 creator_.options()->send_sequence_number_length = 272 creator_.options()->send_sequence_number_length =
272 PACKET_4BYTE_SEQUENCE_NUMBER; 273 PACKET_4BYTE_SEQUENCE_NUMBER;
(...skipping 111 matching lines...) Expand 10 before | Expand all | Expand 10 after
384 EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_)); 385 EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_));
385 EXPECT_CALL(framer_visitor_, OnDecryptedPacket(_)); 386 EXPECT_CALL(framer_visitor_, OnDecryptedPacket(_));
386 EXPECT_CALL(framer_visitor_, OnPacketHeader(_)); 387 EXPECT_CALL(framer_visitor_, OnPacketHeader(_));
387 EXPECT_CALL(framer_visitor_, OnConnectionCloseFrame(_)); 388 EXPECT_CALL(framer_visitor_, OnConnectionCloseFrame(_));
388 EXPECT_CALL(framer_visitor_, OnPacketComplete()); 389 EXPECT_CALL(framer_visitor_, OnPacketComplete());
389 390
390 ProcessPacket(serialized.packet); 391 ProcessPacket(serialized.packet);
391 delete serialized.packet; 392 delete serialized.packet;
392 } 393 }
393 394
395 TEST_P(QuicPacketCreatorTest, SwitchFecOnOffWithNoGroup) {
396 // Enable FEC protection.
397 creator_.set_max_packets_per_fec_group(6);
398 EXPECT_TRUE(creator_.IsFecEnabled());
399 EXPECT_FALSE(creator_.IsFecProtected());
400
401 // Turn on FEC protection.
402 creator_.StartFecProtectingPackets();
403 EXPECT_TRUE(creator_.IsFecProtected());
404 // We have no packets in the FEC group, so no FEC packet can be created.
405 EXPECT_FALSE(creator_.ShouldSendFec(/*force_close=*/true));
406 // Since no packets are in FEC group yet, we should be able to turn FEC
407 // off with no trouble.
408 creator_.StopFecProtectingPackets();
409 EXPECT_FALSE(creator_.IsFecProtected());
410 }
411
412 TEST_P(QuicPacketCreatorTest, SwitchFecOnOffWithGroupInProgress) {
413 // Enable FEC protection, and send FEC packet every 6 packets.
414 EXPECT_TRUE(QuicPacketCreatorPeer::SwitchFecProtectionOn(&creator_, 6));
415 frames_.push_back(QuicFrame(new QuicStreamFrame(0u, false, 0u, IOVector())));
416 SerializedPacket serialized = creator_.SerializeAllFrames(frames_);
417 delete frames_[0].stream_frame;
418 delete serialized.packet;
419
420 EXPECT_TRUE(creator_.IsFecProtected());
421 // We do not have enough packets in the FEC group to trigger an FEC packet.
422 EXPECT_FALSE(creator_.ShouldSendFec(/*force_close=*/false));
423 // Should return true since there are packets in the FEC group.
424 EXPECT_TRUE(creator_.ShouldSendFec(/*force_close=*/true));
425
426 // Switching FEC off should not change creator state, since there is an
427 // FEC packet under construction.
428 EXPECT_DFATAL(creator_.StopFecProtectingPackets(),
429 "Cannot stop FEC protection with open FEC group.");
430 EXPECT_TRUE(creator_.IsFecProtected());
431 // Confirm that FEC packet is still under construction.
432 EXPECT_TRUE(creator_.ShouldSendFec(/*force_close=*/true));
433
434 serialized = creator_.SerializeFec();
435 delete serialized.packet;
436
437 // Switching FEC on/off should work now.
438 creator_.StopFecProtectingPackets();
439 EXPECT_FALSE(creator_.IsFecProtected());
440 creator_.StartFecProtectingPackets();
441 EXPECT_TRUE(creator_.IsFecProtected());
442 }
443
444 TEST_P(QuicPacketCreatorTest, SwitchFecOnWithStreamFrameQueued) {
445 // Add a stream frame to the creator.
446 QuicFrame frame;
447 size_t consumed = creator_.CreateStreamFrame(
448 1u, MakeIOVector("test"), 0u, false, &frame);
449 EXPECT_EQ(4u, consumed);
450 ASSERT_TRUE(frame.stream_frame);
451 EXPECT_TRUE(creator_.AddSavedFrame(frame));
452 EXPECT_TRUE(creator_.HasPendingFrames());
453
454 // Enable FEC protection, and send FEC packet every 6 packets.
455 creator_.set_max_packets_per_fec_group(6);
456 EXPECT_TRUE(creator_.IsFecEnabled());
457 EXPECT_DFATAL(creator_.StartFecProtectingPackets(),
458 "Cannot start FEC protection with pending frames.");
459 EXPECT_FALSE(creator_.IsFecProtected());
460
461 // Serialize packet for transmission.
462 SerializedPacket serialized = creator_.SerializePacket();
463 delete serialized.packet;
464 delete serialized.retransmittable_frames;
465 EXPECT_FALSE(creator_.HasPendingFrames());
466
467 // Since all pending frames have been serialized, turning FEC on should work.
468 creator_.StartFecProtectingPackets();
469 EXPECT_TRUE(creator_.IsFecProtected());
470 }
471
394 TEST_P(QuicPacketCreatorTest, CreateStreamFrame) { 472 TEST_P(QuicPacketCreatorTest, CreateStreamFrame) {
395 QuicFrame frame; 473 QuicFrame frame;
396 size_t consumed = creator_.CreateStreamFrame(1u, MakeIOVector("test"), 0u, 474 size_t consumed = creator_.CreateStreamFrame(1u, MakeIOVector("test"), 0u,
397 false, &frame); 475 false, &frame);
398 EXPECT_EQ(4u, consumed); 476 EXPECT_EQ(4u, consumed);
399 CheckStreamFrame(frame, 1u, "test", 0u, false); 477 CheckStreamFrame(frame, 1u, "test", 0u, false);
400 delete frame.stream_frame; 478 delete frame.stream_frame;
401 } 479 }
402 480
403 TEST_P(QuicPacketCreatorTest, CreateStreamFrameFin) { 481 TEST_P(QuicPacketCreatorTest, CreateStreamFrameFin) {
(...skipping 58 matching lines...) Expand 10 before | Expand all | Expand 10 after
462 size_t expected_bytes_free = bytes_free < 3 ? 0 : bytes_free - 2; 540 size_t expected_bytes_free = bytes_free < 3 ? 0 : bytes_free - 2;
463 EXPECT_EQ(expected_bytes_free, creator_.BytesFree()) << "delta: " << delta; 541 EXPECT_EQ(expected_bytes_free, creator_.BytesFree()) << "delta: " << delta;
464 SerializedPacket serialized_packet = creator_.SerializePacket(); 542 SerializedPacket serialized_packet = creator_.SerializePacket();
465 ASSERT_TRUE(serialized_packet.packet); 543 ASSERT_TRUE(serialized_packet.packet);
466 delete serialized_packet.packet; 544 delete serialized_packet.packet;
467 delete serialized_packet.retransmittable_frames; 545 delete serialized_packet.retransmittable_frames;
468 } 546 }
469 } 547 }
470 548
471 TEST_P(QuicPacketCreatorTest, StreamFrameConsumptionWithFec) { 549 TEST_P(QuicPacketCreatorTest, StreamFrameConsumptionWithFec) {
472 // Turn on FEC protection. 550 // Enable FEC protection, and send FEC packet every 6 packets.
473 creator_.options()->max_packets_per_fec_group = 6; 551 EXPECT_TRUE(QuicPacketCreatorPeer::SwitchFecProtectionOn(&creator_, 6));
474 // Compute the total overhead for a single frame in packet. 552 // Compute the total overhead for a single frame in packet.
475 const size_t overhead = GetPacketHeaderOverhead(IN_FEC_GROUP) 553 const size_t overhead = GetPacketHeaderOverhead(IN_FEC_GROUP)
476 + GetEncryptionOverhead() + GetStreamFrameOverhead(IN_FEC_GROUP); 554 + GetEncryptionOverhead() + GetStreamFrameOverhead(IN_FEC_GROUP);
477 size_t capacity = kDefaultMaxPacketSize - overhead; 555 size_t capacity = kDefaultMaxPacketSize - overhead;
478 // Now, test various sizes around this size. 556 // Now, test various sizes around this size.
479 for (int delta = -5; delta <= 5; ++delta) { 557 for (int delta = -5; delta <= 5; ++delta) {
480 string data(capacity + delta, 'A'); 558 string data(capacity + delta, 'A');
481 size_t bytes_free = delta > 0 ? 0 : 0 - delta; 559 size_t bytes_free = delta > 0 ? 0 : 0 - delta;
482 QuicFrame frame; 560 QuicFrame frame;
483 size_t bytes_consumed = creator_.CreateStreamFrame( 561 size_t bytes_consumed = creator_.CreateStreamFrame(
(...skipping 281 matching lines...) Expand 10 before | Expand all | Expand 10 after
765 // After 64 calls, BoolSource will refresh the bucket - make sure it does. 843 // After 64 calls, BoolSource will refresh the bucket - make sure it does.
766 mock_random_.ChangeValue(); 844 mock_random_.ChangeValue();
767 } 845 }
768 846
769 delete frames_[0].stream_frame; 847 delete frames_[0].stream_frame;
770 } 848 }
771 849
772 } // namespace 850 } // namespace
773 } // namespace test 851 } // namespace test
774 } // namespace net 852 } // namespace net
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698