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