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 "quiche/quic/core/quic_packet_creator.h"
6
7 #include <cstdint>
8 #include <limits>
9 #include <memory>
10 #include <ostream>
11 #include <string>
12 #include <utility>
13
14 #include "absl/base/macros.h"
15 #include "absl/strings/str_cat.h"
16 #include "absl/strings/string_view.h"
17 #include "quiche/quic/core/crypto/quic_decrypter.h"
18 #include "quiche/quic/core/crypto/quic_encrypter.h"
19 #include "quiche/quic/core/frames/quic_frame.h"
20 #include "quiche/quic/core/frames/quic_stream_frame.h"
21 #include "quiche/quic/core/quic_connection_id.h"
22 #include "quiche/quic/core/quic_data_writer.h"
23 #include "quiche/quic/core/quic_types.h"
24 #include "quiche/quic/core/quic_utils.h"
25 #include "quiche/quic/platform/api/quic_expect_bug.h"
26 #include "quiche/quic/platform/api/quic_flags.h"
27 #include "quiche/quic/platform/api/quic_socket_address.h"
28 #include "quiche/quic/platform/api/quic_test.h"
29 #include "quiche/quic/test_tools/quic_framer_peer.h"
30 #include "quiche/quic/test_tools/quic_packet_creator_peer.h"
31 #include "quiche/quic/test_tools/quic_test_utils.h"
32 #include "quiche/quic/test_tools/simple_data_producer.h"
33 #include "quiche/quic/test_tools/simple_quic_framer.h"
34 #include "quiche/common/simple_buffer_allocator.h"
35 #include "quiche/common/test_tools/quiche_test_utils.h"
36
37 using ::testing::_;
38 using ::testing::AtLeast;
39 using ::testing::DoAll;
40 using ::testing::InSequence;
41 using ::testing::Invoke;
42 using ::testing::Return;
43 using ::testing::SaveArg;
44 using ::testing::StrictMock;
45
46 namespace quic {
47 namespace test {
48 namespace {
49
50 const QuicPacketNumber kPacketNumber = QuicPacketNumber(UINT64_C(0x12345678));
51 // Use fields in which each byte is distinct to ensure that every byte is
52 // framed correctly. The values are otherwise arbitrary.
CreateTestConnectionId()53 QuicConnectionId CreateTestConnectionId() {
54 return TestConnectionId(UINT64_C(0xFEDCBA9876543210));
55 }
56
57 // Run tests with combinations of {ParsedQuicVersion,
58 // ToggleVersionSerialization}.
59 struct TestParams {
TestParamsquic::test::__anon1c4b7b270111::TestParams60 TestParams(ParsedQuicVersion version, bool version_serialization)
61 : version(version), version_serialization(version_serialization) {}
62
63 ParsedQuicVersion version;
64 bool version_serialization;
65 };
66
67 // Used by ::testing::PrintToStringParamName().
PrintToString(const TestParams & p)68 std::string PrintToString(const TestParams& p) {
69 return absl::StrCat(ParsedQuicVersionToString(p.version), "_",
70 (p.version_serialization ? "Include" : "No"), "Version");
71 }
72
73 // Constructs various test permutations.
GetTestParams()74 std::vector<TestParams> GetTestParams() {
75 std::vector<TestParams> params;
76 ParsedQuicVersionVector all_supported_versions = AllSupportedVersions();
77 for (size_t i = 0; i < all_supported_versions.size(); ++i) {
78 params.push_back(TestParams(all_supported_versions[i], true));
79 params.push_back(TestParams(all_supported_versions[i], false));
80 }
81 return params;
82 }
83
84 class MockDebugDelegate : public QuicPacketCreator::DebugDelegate {
85 public:
86 ~MockDebugDelegate() override = default;
87
88 MOCK_METHOD(void, OnFrameAddedToPacket, (const QuicFrame& frame), (override));
89
90 MOCK_METHOD(void, OnStreamFrameCoalesced, (const QuicStreamFrame& frame),
91 (override));
92 };
93
94 class TestPacketCreator : public QuicPacketCreator {
95 public:
TestPacketCreator(QuicConnectionId connection_id,QuicFramer * framer,DelegateInterface * delegate,SimpleDataProducer * producer)96 TestPacketCreator(QuicConnectionId connection_id, QuicFramer* framer,
97 DelegateInterface* delegate, SimpleDataProducer* producer)
98 : QuicPacketCreator(connection_id, framer, delegate),
99 producer_(producer),
100 version_(framer->version()) {}
101
ConsumeDataToFillCurrentPacket(QuicStreamId id,absl::string_view data,QuicStreamOffset offset,bool fin,bool needs_full_padding,TransmissionType transmission_type,QuicFrame * frame)102 bool ConsumeDataToFillCurrentPacket(QuicStreamId id, absl::string_view data,
103 QuicStreamOffset offset, bool fin,
104 bool needs_full_padding,
105 TransmissionType transmission_type,
106 QuicFrame* frame) {
107 // Save data before data is consumed.
108 if (!data.empty()) {
109 producer_->SaveStreamData(id, data);
110 }
111 return QuicPacketCreator::ConsumeDataToFillCurrentPacket(
112 id, data.length(), offset, fin, needs_full_padding, transmission_type,
113 frame);
114 }
115
StopSendingVersion()116 void StopSendingVersion() { set_encryption_level(ENCRYPTION_FORWARD_SECURE); }
117
118 SimpleDataProducer* producer_;
119 ParsedQuicVersion version_;
120 };
121
122 class QuicPacketCreatorTest : public QuicTestWithParam<TestParams> {
123 public:
ClearSerializedPacketForTests(SerializedPacket)124 void ClearSerializedPacketForTests(SerializedPacket /*serialized_packet*/) {
125 // serialized packet self-clears on destruction.
126 }
127
SaveSerializedPacket(SerializedPacket serialized_packet)128 void SaveSerializedPacket(SerializedPacket serialized_packet) {
129 serialized_packet_.reset(CopySerializedPacket(
130 serialized_packet, &allocator_, /*copy_buffer=*/true));
131 }
132
DeleteSerializedPacket()133 void DeleteSerializedPacket() { serialized_packet_ = nullptr; }
134
135 protected:
QuicPacketCreatorTest()136 QuicPacketCreatorTest()
137 : connection_id_(TestConnectionId(2)),
138 server_framer_(SupportedVersions(GetParam().version), QuicTime::Zero(),
139 Perspective::IS_SERVER, connection_id_.length()),
140 client_framer_(SupportedVersions(GetParam().version), QuicTime::Zero(),
141 Perspective::IS_CLIENT, connection_id_.length()),
142 data_("foo"),
143 creator_(connection_id_, &client_framer_, &delegate_, &producer_) {
144 EXPECT_CALL(delegate_, GetPacketBuffer())
145 .WillRepeatedly(Return(QuicPacketBuffer()));
146 EXPECT_CALL(delegate_, GetSerializedPacketFate(_, _))
147 .WillRepeatedly(Return(SEND_TO_WRITER));
148 creator_.SetEncrypter(
149 ENCRYPTION_INITIAL,
150 std::make_unique<TaggingEncrypter>(ENCRYPTION_INITIAL));
151 creator_.SetEncrypter(
152 ENCRYPTION_HANDSHAKE,
153 std::make_unique<TaggingEncrypter>(ENCRYPTION_HANDSHAKE));
154 creator_.SetEncrypter(
155 ENCRYPTION_ZERO_RTT,
156 std::make_unique<TaggingEncrypter>(ENCRYPTION_ZERO_RTT));
157 creator_.SetEncrypter(
158 ENCRYPTION_FORWARD_SECURE,
159 std::make_unique<TaggingEncrypter>(ENCRYPTION_FORWARD_SECURE));
160 client_framer_.set_visitor(&framer_visitor_);
161 server_framer_.set_visitor(&framer_visitor_);
162 client_framer_.set_data_producer(&producer_);
163 if (server_framer_.version().KnowsWhichDecrypterToUse()) {
164 server_framer_.InstallDecrypter(ENCRYPTION_INITIAL,
165 std::make_unique<TaggingDecrypter>());
166 server_framer_.InstallDecrypter(ENCRYPTION_ZERO_RTT,
167 std::make_unique<TaggingDecrypter>());
168 server_framer_.InstallDecrypter(ENCRYPTION_HANDSHAKE,
169 std::make_unique<TaggingDecrypter>());
170 server_framer_.InstallDecrypter(ENCRYPTION_FORWARD_SECURE,
171 std::make_unique<TaggingDecrypter>());
172 } else {
173 server_framer_.SetDecrypter(ENCRYPTION_INITIAL,
174 std::make_unique<TaggingDecrypter>());
175 server_framer_.SetAlternativeDecrypter(
176 ENCRYPTION_FORWARD_SECURE, std::make_unique<TaggingDecrypter>(),
177 false);
178 }
179 }
180
~QuicPacketCreatorTest()181 ~QuicPacketCreatorTest() override {}
182
SerializeAllFrames(const QuicFrames & frames)183 SerializedPacket SerializeAllFrames(const QuicFrames& frames) {
184 SerializedPacket packet = QuicPacketCreatorPeer::SerializeAllFrames(
185 &creator_, frames, buffer_, kMaxOutgoingPacketSize);
186 EXPECT_EQ(QuicPacketCreatorPeer::GetEncryptionLevel(&creator_),
187 packet.encryption_level);
188 return packet;
189 }
190
ProcessPacket(const SerializedPacket & packet)191 void ProcessPacket(const SerializedPacket& packet) {
192 QuicEncryptedPacket encrypted_packet(packet.encrypted_buffer,
193 packet.encrypted_length);
194 server_framer_.ProcessPacket(encrypted_packet);
195 }
196
CheckStreamFrame(const QuicFrame & frame,QuicStreamId stream_id,const std::string & data,QuicStreamOffset offset,bool fin)197 void CheckStreamFrame(const QuicFrame& frame, QuicStreamId stream_id,
198 const std::string& data, QuicStreamOffset offset,
199 bool fin) {
200 EXPECT_EQ(STREAM_FRAME, frame.type);
201 EXPECT_EQ(stream_id, frame.stream_frame.stream_id);
202 char buf[kMaxOutgoingPacketSize];
203 QuicDataWriter writer(kMaxOutgoingPacketSize, buf, quiche::HOST_BYTE_ORDER);
204 if (frame.stream_frame.data_length > 0) {
205 producer_.WriteStreamData(stream_id, frame.stream_frame.offset,
206 frame.stream_frame.data_length, &writer);
207 }
208 EXPECT_EQ(data, absl::string_view(buf, frame.stream_frame.data_length));
209 EXPECT_EQ(offset, frame.stream_frame.offset);
210 EXPECT_EQ(fin, frame.stream_frame.fin);
211 }
212
213 // Returns the number of bytes consumed by the header of packet, including
214 // the version.
GetPacketHeaderOverhead(QuicTransportVersion version)215 size_t GetPacketHeaderOverhead(QuicTransportVersion version) {
216 return GetPacketHeaderSize(
217 version, creator_.GetDestinationConnectionIdLength(),
218 creator_.GetSourceConnectionIdLength(),
219 QuicPacketCreatorPeer::SendVersionInPacket(&creator_),
220 !kIncludeDiversificationNonce,
221 QuicPacketCreatorPeer::GetPacketNumberLength(&creator_),
222 QuicPacketCreatorPeer::GetRetryTokenLengthLength(&creator_), 0,
223 QuicPacketCreatorPeer::GetLengthLength(&creator_));
224 }
225
226 // Returns the number of bytes of overhead that will be added to a packet
227 // of maximum length.
GetEncryptionOverhead()228 size_t GetEncryptionOverhead() {
229 return creator_.max_packet_length() -
230 client_framer_.GetMaxPlaintextSize(creator_.max_packet_length());
231 }
232
233 // Returns the number of bytes consumed by the non-data fields of a stream
234 // frame, assuming it is the last frame in the packet
GetStreamFrameOverhead(QuicTransportVersion version)235 size_t GetStreamFrameOverhead(QuicTransportVersion version) {
236 return QuicFramer::GetMinStreamFrameSize(
237 version, GetNthClientInitiatedStreamId(1), kOffset, true,
238 /* data_length= */ 0);
239 }
240
IsDefaultTestConfiguration()241 bool IsDefaultTestConfiguration() {
242 TestParams p = GetParam();
243 return p.version == AllSupportedVersions()[0] && p.version_serialization;
244 }
245
GetNthClientInitiatedStreamId(int n) const246 QuicStreamId GetNthClientInitiatedStreamId(int n) const {
247 return QuicUtils::GetFirstBidirectionalStreamId(
248 creator_.transport_version(), Perspective::IS_CLIENT) +
249 n * 2;
250 }
251
252 void TestChaosProtection(bool enabled);
253
254 static constexpr QuicStreamOffset kOffset = 0u;
255
256 char buffer_[kMaxOutgoingPacketSize];
257 QuicConnectionId connection_id_;
258 QuicFrames frames_;
259 QuicFramer server_framer_;
260 QuicFramer client_framer_;
261 StrictMock<MockFramerVisitor> framer_visitor_;
262 StrictMock<MockPacketCreatorDelegate> delegate_;
263 std::string data_;
264 TestPacketCreator creator_;
265 std::unique_ptr<SerializedPacket> serialized_packet_;
266 SimpleDataProducer producer_;
267 quiche::SimpleBufferAllocator allocator_;
268 };
269
270 // Run all packet creator tests with all supported versions of QUIC, and with
271 // and without version in the packet header, as well as doing a run for each
272 // length of truncated connection id.
273 INSTANTIATE_TEST_SUITE_P(QuicPacketCreatorTests, QuicPacketCreatorTest,
274 ::testing::ValuesIn(GetTestParams()),
275 ::testing::PrintToStringParamName());
276
TEST_P(QuicPacketCreatorTest,SerializeFrames)277 TEST_P(QuicPacketCreatorTest, SerializeFrames) {
278 ParsedQuicVersion version = client_framer_.version();
279 for (int i = ENCRYPTION_INITIAL; i < NUM_ENCRYPTION_LEVELS; ++i) {
280 EncryptionLevel level = static_cast<EncryptionLevel>(i);
281 bool has_ack = false, has_stream = false;
282 creator_.set_encryption_level(level);
283 size_t payload_len = 0;
284 if (level != ENCRYPTION_ZERO_RTT) {
285 frames_.push_back(QuicFrame(new QuicAckFrame(InitAckFrame(1))));
286 has_ack = true;
287 payload_len += version.UsesTls() ? 12 : 6;
288 }
289 if (level != ENCRYPTION_INITIAL && level != ENCRYPTION_HANDSHAKE) {
290 QuicStreamId stream_id = QuicUtils::GetFirstBidirectionalStreamId(
291 client_framer_.transport_version(), Perspective::IS_CLIENT);
292 frames_.push_back(QuicFrame(
293 QuicStreamFrame(stream_id, false, 0u, absl::string_view())));
294 has_stream = true;
295 payload_len += 2;
296 }
297 SerializedPacket serialized = SerializeAllFrames(frames_);
298 EXPECT_EQ(level, serialized.encryption_level);
299 if (level != ENCRYPTION_ZERO_RTT) {
300 delete frames_[0].ack_frame;
301 }
302 frames_.clear();
303 ASSERT_GT(payload_len, 0); // Must have a frame!
304 size_t min_payload = version.UsesTls() ? 3 : 7;
305 bool need_padding =
306 (version.HasHeaderProtection() && (payload_len < min_payload));
307 {
308 InSequence s;
309 EXPECT_CALL(framer_visitor_, OnPacket());
310 EXPECT_CALL(framer_visitor_, OnUnauthenticatedPublicHeader(_));
311 EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_));
312 EXPECT_CALL(framer_visitor_, OnDecryptedPacket(_, _));
313 EXPECT_CALL(framer_visitor_, OnPacketHeader(_));
314 if (need_padding) {
315 EXPECT_CALL(framer_visitor_, OnPaddingFrame(_));
316 }
317 if (has_ack) {
318 EXPECT_CALL(framer_visitor_, OnAckFrameStart(_, _))
319 .WillOnce(Return(true));
320 EXPECT_CALL(framer_visitor_,
321 OnAckRange(QuicPacketNumber(1), QuicPacketNumber(2)))
322 .WillOnce(Return(true));
323 EXPECT_CALL(framer_visitor_, OnAckFrameEnd(QuicPacketNumber(1), _))
324 .WillOnce(Return(true));
325 }
326 if (has_stream) {
327 EXPECT_CALL(framer_visitor_, OnStreamFrame(_));
328 }
329 EXPECT_CALL(framer_visitor_, OnPacketComplete());
330 }
331 ProcessPacket(serialized);
332 }
333 }
334
TEST_P(QuicPacketCreatorTest,SerializeConnectionClose)335 TEST_P(QuicPacketCreatorTest, SerializeConnectionClose) {
336 QuicConnectionCloseFrame* frame = new QuicConnectionCloseFrame(
337 creator_.transport_version(), QUIC_NO_ERROR, NO_IETF_QUIC_ERROR, "error",
338 /*transport_close_frame_type=*/0);
339
340 QuicFrames frames;
341 frames.push_back(QuicFrame(frame));
342 SerializedPacket serialized = SerializeAllFrames(frames);
343 EXPECT_EQ(ENCRYPTION_INITIAL, serialized.encryption_level);
344 ASSERT_EQ(QuicPacketNumber(1u), serialized.packet_number);
345 ASSERT_EQ(QuicPacketNumber(1u), creator_.packet_number());
346
347 InSequence s;
348 EXPECT_CALL(framer_visitor_, OnPacket());
349 EXPECT_CALL(framer_visitor_, OnUnauthenticatedPublicHeader(_));
350 EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_));
351 EXPECT_CALL(framer_visitor_, OnDecryptedPacket(_, _));
352 EXPECT_CALL(framer_visitor_, OnPacketHeader(_));
353 EXPECT_CALL(framer_visitor_, OnConnectionCloseFrame(_));
354 EXPECT_CALL(framer_visitor_, OnPacketComplete());
355
356 ProcessPacket(serialized);
357 }
358
TEST_P(QuicPacketCreatorTest,SerializePacketWithPadding)359 TEST_P(QuicPacketCreatorTest, SerializePacketWithPadding) {
360 creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
361
362 creator_.AddFrame(QuicFrame(QuicWindowUpdateFrame()), NOT_RETRANSMISSION);
363 creator_.AddFrame(QuicFrame(QuicPaddingFrame()), NOT_RETRANSMISSION);
364 EXPECT_CALL(delegate_, OnSerializedPacket(_))
365 .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
366 creator_.FlushCurrentPacket();
367 ASSERT_TRUE(serialized_packet_->encrypted_buffer);
368
369 EXPECT_EQ(kDefaultMaxPacketSize, serialized_packet_->encrypted_length);
370
371 DeleteSerializedPacket();
372 }
373
TEST_P(QuicPacketCreatorTest,SerializeLargerPacketWithPadding)374 TEST_P(QuicPacketCreatorTest, SerializeLargerPacketWithPadding) {
375 creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
376 const QuicByteCount packet_size = 100 + kDefaultMaxPacketSize;
377 creator_.SetMaxPacketLength(packet_size);
378
379 creator_.AddFrame(QuicFrame(QuicWindowUpdateFrame()), NOT_RETRANSMISSION);
380 creator_.AddFrame(QuicFrame(QuicPaddingFrame()), NOT_RETRANSMISSION);
381 EXPECT_CALL(delegate_, OnSerializedPacket(_))
382 .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
383 creator_.FlushCurrentPacket();
384 ASSERT_TRUE(serialized_packet_->encrypted_buffer);
385
386 EXPECT_EQ(packet_size, serialized_packet_->encrypted_length);
387
388 DeleteSerializedPacket();
389 }
390
TEST_P(QuicPacketCreatorTest,IncreaseMaxPacketLengthWithFramesPending)391 TEST_P(QuicPacketCreatorTest, IncreaseMaxPacketLengthWithFramesPending) {
392 creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
393 const QuicByteCount packet_size = 100 + kDefaultMaxPacketSize;
394
395 // Since the creator has a frame queued, the packet size will not change.
396 creator_.AddFrame(QuicFrame(QuicWindowUpdateFrame()), NOT_RETRANSMISSION);
397 creator_.SetMaxPacketLength(packet_size);
398 creator_.AddFrame(QuicFrame(QuicPaddingFrame()), NOT_RETRANSMISSION);
399 EXPECT_CALL(delegate_, OnSerializedPacket(_))
400 .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
401 creator_.FlushCurrentPacket();
402 ASSERT_TRUE(serialized_packet_->encrypted_buffer);
403
404 EXPECT_EQ(kDefaultMaxPacketSize, serialized_packet_->encrypted_length);
405
406 DeleteSerializedPacket();
407
408 // Now that the previous packet was generated, the next on will use
409 // the new larger size.
410 creator_.AddFrame(QuicFrame(QuicWindowUpdateFrame()), NOT_RETRANSMISSION);
411 creator_.AddFrame(QuicFrame(QuicPaddingFrame()), NOT_RETRANSMISSION);
412 EXPECT_CALL(delegate_, OnSerializedPacket(_))
413 .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
414 creator_.FlushCurrentPacket();
415 ASSERT_TRUE(serialized_packet_->encrypted_buffer);
416 EXPECT_EQ(packet_size, serialized_packet_->encrypted_length);
417
418 EXPECT_EQ(packet_size, serialized_packet_->encrypted_length);
419
420 DeleteSerializedPacket();
421 }
422
TEST_P(QuicPacketCreatorTest,ConsumeCryptoDataToFillCurrentPacket)423 TEST_P(QuicPacketCreatorTest, ConsumeCryptoDataToFillCurrentPacket) {
424 std::string data = "crypto data";
425 QuicFrame frame;
426 ASSERT_TRUE(creator_.ConsumeCryptoDataToFillCurrentPacket(
427 ENCRYPTION_INITIAL, data.length(), 0,
428 /*needs_full_padding=*/true, NOT_RETRANSMISSION, &frame));
429 EXPECT_EQ(frame.crypto_frame->data_length, data.length());
430 EXPECT_TRUE(creator_.HasPendingFrames());
431 }
432
TEST_P(QuicPacketCreatorTest,ConsumeDataToFillCurrentPacket)433 TEST_P(QuicPacketCreatorTest, ConsumeDataToFillCurrentPacket) {
434 creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
435 QuicFrame frame;
436 QuicStreamId stream_id = QuicUtils::GetFirstBidirectionalStreamId(
437 client_framer_.transport_version(), Perspective::IS_CLIENT);
438 const std::string data("test");
439 ASSERT_TRUE(creator_.ConsumeDataToFillCurrentPacket(
440 stream_id, data, 0u, false, false, NOT_RETRANSMISSION, &frame));
441 size_t consumed = frame.stream_frame.data_length;
442 EXPECT_EQ(4u, consumed);
443 CheckStreamFrame(frame, stream_id, "test", 0u, false);
444 EXPECT_TRUE(creator_.HasPendingFrames());
445 }
446
TEST_P(QuicPacketCreatorTest,ConsumeDataFin)447 TEST_P(QuicPacketCreatorTest, ConsumeDataFin) {
448 creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
449 QuicFrame frame;
450 QuicStreamId stream_id = QuicUtils::GetFirstBidirectionalStreamId(
451 client_framer_.transport_version(), Perspective::IS_CLIENT);
452 const std::string data("test");
453 ASSERT_TRUE(creator_.ConsumeDataToFillCurrentPacket(
454 stream_id, data, 0u, true, false, NOT_RETRANSMISSION, &frame));
455 size_t consumed = frame.stream_frame.data_length;
456 EXPECT_EQ(4u, consumed);
457 CheckStreamFrame(frame, stream_id, "test", 0u, true);
458 EXPECT_TRUE(creator_.HasPendingFrames());
459 }
460
TEST_P(QuicPacketCreatorTest,ConsumeDataFinOnly)461 TEST_P(QuicPacketCreatorTest, ConsumeDataFinOnly) {
462 creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
463 QuicFrame frame;
464 QuicStreamId stream_id = QuicUtils::GetFirstBidirectionalStreamId(
465 client_framer_.transport_version(), Perspective::IS_CLIENT);
466 ASSERT_TRUE(creator_.ConsumeDataToFillCurrentPacket(
467 stream_id, {}, 0u, true, false, NOT_RETRANSMISSION, &frame));
468 size_t consumed = frame.stream_frame.data_length;
469 EXPECT_EQ(0u, consumed);
470 CheckStreamFrame(frame, stream_id, std::string(), 0u, true);
471 EXPECT_TRUE(creator_.HasPendingFrames());
472 EXPECT_TRUE(absl::StartsWith(creator_.GetPendingFramesInfo(),
473 "type { STREAM_FRAME }"));
474 }
475
TEST_P(QuicPacketCreatorTest,CreateAllFreeBytesForStreamFrames)476 TEST_P(QuicPacketCreatorTest, CreateAllFreeBytesForStreamFrames) {
477 creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
478 const size_t overhead =
479 GetPacketHeaderOverhead(client_framer_.transport_version()) +
480 GetEncryptionOverhead();
481 for (size_t i = overhead +
482 QuicPacketCreator::MinPlaintextPacketSize(
483 client_framer_.version(),
484 QuicPacketCreatorPeer::GetPacketNumberLength(&creator_));
485 i < overhead + 100; ++i) {
486 SCOPED_TRACE(i);
487 creator_.SetMaxPacketLength(i);
488 const bool should_have_room =
489 i >
490 overhead + GetStreamFrameOverhead(client_framer_.transport_version());
491 ASSERT_EQ(should_have_room,
492 creator_.HasRoomForStreamFrame(GetNthClientInitiatedStreamId(1),
493 kOffset, /* data_size=*/0xffff));
494 if (should_have_room) {
495 QuicFrame frame;
496 const std::string data("testdata");
497 EXPECT_CALL(delegate_, OnSerializedPacket(_))
498 .WillRepeatedly(Invoke(
499 this, &QuicPacketCreatorTest::ClearSerializedPacketForTests));
500 ASSERT_TRUE(creator_.ConsumeDataToFillCurrentPacket(
501 GetNthClientInitiatedStreamId(1), data, kOffset, false, false,
502 NOT_RETRANSMISSION, &frame));
503 size_t bytes_consumed = frame.stream_frame.data_length;
504 EXPECT_LT(0u, bytes_consumed);
505 creator_.FlushCurrentPacket();
506 }
507 }
508 }
509
TEST_P(QuicPacketCreatorTest,StreamFrameConsumption)510 TEST_P(QuicPacketCreatorTest, StreamFrameConsumption) {
511 creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
512 // Compute the total overhead for a single frame in packet.
513 const size_t overhead =
514 GetPacketHeaderOverhead(client_framer_.transport_version()) +
515 GetEncryptionOverhead() +
516 GetStreamFrameOverhead(client_framer_.transport_version());
517 size_t capacity = kDefaultMaxPacketSize - overhead;
518 // Now, test various sizes around this size.
519 for (int delta = -5; delta <= 5; ++delta) {
520 std::string data(capacity + delta, 'A');
521 size_t bytes_free = delta > 0 ? 0 : 0 - delta;
522 QuicFrame frame;
523 ASSERT_TRUE(creator_.ConsumeDataToFillCurrentPacket(
524 GetNthClientInitiatedStreamId(1), data, kOffset, false, false,
525 NOT_RETRANSMISSION, &frame));
526
527 // BytesFree() returns bytes available for the next frame, which will
528 // be two bytes smaller since the stream frame would need to be grown.
529 EXPECT_EQ(2u, creator_.ExpansionOnNewFrame());
530 size_t expected_bytes_free = bytes_free < 3 ? 0 : bytes_free - 2;
531 EXPECT_EQ(expected_bytes_free, creator_.BytesFree()) << "delta: " << delta;
532 EXPECT_CALL(delegate_, OnSerializedPacket(_))
533 .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
534 creator_.FlushCurrentPacket();
535 ASSERT_TRUE(serialized_packet_->encrypted_buffer);
536 DeleteSerializedPacket();
537 }
538 }
539
TEST_P(QuicPacketCreatorTest,CryptoStreamFramePacketPadding)540 TEST_P(QuicPacketCreatorTest, CryptoStreamFramePacketPadding) {
541 // This test serializes crypto payloads slightly larger than a packet, which
542 // Causes the multi-packet ClientHello check to fail.
543 SetQuicFlag(quic_enforce_single_packet_chlo, false);
544 // Compute the total overhead for a single frame in packet.
545 size_t overhead =
546 GetPacketHeaderOverhead(client_framer_.transport_version()) +
547 GetEncryptionOverhead();
548 if (QuicVersionUsesCryptoFrames(client_framer_.transport_version())) {
549 overhead +=
550 QuicFramer::GetMinCryptoFrameSize(kOffset, kMaxOutgoingPacketSize);
551 } else {
552 overhead += QuicFramer::GetMinStreamFrameSize(
553 client_framer_.transport_version(), GetNthClientInitiatedStreamId(1),
554 kOffset, false, 0);
555 }
556 ASSERT_GT(kMaxOutgoingPacketSize, overhead);
557 size_t capacity = kDefaultMaxPacketSize - overhead;
558 // Now, test various sizes around this size.
559 for (int delta = -5; delta <= 5; ++delta) {
560 SCOPED_TRACE(delta);
561 std::string data(capacity + delta, 'A');
562 size_t bytes_free = delta > 0 ? 0 : 0 - delta;
563
564 QuicFrame frame;
565 EXPECT_CALL(delegate_, OnSerializedPacket(_))
566 .WillRepeatedly(
567 Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
568 if (client_framer_.version().CanSendCoalescedPackets()) {
569 EXPECT_CALL(delegate_, GetSerializedPacketFate(_, _))
570 .WillRepeatedly(Return(COALESCE));
571 }
572 if (!QuicVersionUsesCryptoFrames(client_framer_.transport_version())) {
573 ASSERT_TRUE(creator_.ConsumeDataToFillCurrentPacket(
574 QuicUtils::GetCryptoStreamId(client_framer_.transport_version()),
575 data, kOffset, false, true, NOT_RETRANSMISSION, &frame));
576 size_t bytes_consumed = frame.stream_frame.data_length;
577 EXPECT_LT(0u, bytes_consumed);
578 } else {
579 producer_.SaveCryptoData(ENCRYPTION_INITIAL, kOffset, data);
580 ASSERT_TRUE(creator_.ConsumeCryptoDataToFillCurrentPacket(
581 ENCRYPTION_INITIAL, data.length(), kOffset,
582 /*needs_full_padding=*/true, NOT_RETRANSMISSION, &frame));
583 size_t bytes_consumed = frame.crypto_frame->data_length;
584 EXPECT_LT(0u, bytes_consumed);
585 }
586 creator_.FlushCurrentPacket();
587 ASSERT_TRUE(serialized_packet_->encrypted_buffer);
588 // If there is not enough space in the packet to fit a padding frame
589 // (1 byte) and to expand the stream frame (another 2 bytes) the packet
590 // will not be padded.
591 // Padding is skipped when we try to send coalesced packets.
592 if (client_framer_.version().CanSendCoalescedPackets()) {
593 EXPECT_EQ(kDefaultMaxPacketSize - bytes_free,
594 serialized_packet_->encrypted_length);
595 } else {
596 EXPECT_EQ(kDefaultMaxPacketSize, serialized_packet_->encrypted_length);
597 }
598 DeleteSerializedPacket();
599 }
600 }
601
TEST_P(QuicPacketCreatorTest,NonCryptoStreamFramePacketNonPadding)602 TEST_P(QuicPacketCreatorTest, NonCryptoStreamFramePacketNonPadding) {
603 creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
604 // Compute the total overhead for a single frame in packet.
605 const size_t overhead =
606 GetPacketHeaderOverhead(client_framer_.transport_version()) +
607 GetEncryptionOverhead() +
608 GetStreamFrameOverhead(client_framer_.transport_version());
609 ASSERT_GT(kDefaultMaxPacketSize, overhead);
610 size_t capacity = kDefaultMaxPacketSize - overhead;
611 // Now, test various sizes around this size.
612 for (int delta = -5; delta <= 5; ++delta) {
613 std::string data(capacity + delta, 'A');
614 size_t bytes_free = delta > 0 ? 0 : 0 - delta;
615
616 QuicFrame frame;
617 EXPECT_CALL(delegate_, OnSerializedPacket(_))
618 .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
619 ASSERT_TRUE(creator_.ConsumeDataToFillCurrentPacket(
620 GetNthClientInitiatedStreamId(1), data, kOffset, false, false,
621 NOT_RETRANSMISSION, &frame));
622 size_t bytes_consumed = frame.stream_frame.data_length;
623 EXPECT_LT(0u, bytes_consumed);
624 creator_.FlushCurrentPacket();
625 ASSERT_TRUE(serialized_packet_->encrypted_buffer);
626 if (bytes_free > 0) {
627 EXPECT_EQ(kDefaultMaxPacketSize - bytes_free,
628 serialized_packet_->encrypted_length);
629 } else {
630 EXPECT_EQ(kDefaultMaxPacketSize, serialized_packet_->encrypted_length);
631 }
632 DeleteSerializedPacket();
633 }
634 }
635
636 // Test that the path challenge connectivity probing packet is serialized
637 // correctly as a padded PATH CHALLENGE packet.
TEST_P(QuicPacketCreatorTest,BuildPathChallengePacket)638 TEST_P(QuicPacketCreatorTest, BuildPathChallengePacket) {
639 if (!VersionHasIetfQuicFrames(creator_.transport_version())) {
640 // This frame is only for IETF QUIC.
641 return;
642 }
643
644 QuicPacketHeader header;
645 header.destination_connection_id = CreateTestConnectionId();
646 header.reset_flag = false;
647 header.version_flag = false;
648 header.packet_number = kPacketNumber;
649 MockRandom randomizer;
650 QuicPathFrameBuffer payload;
651 randomizer.RandBytes(payload.data(), payload.size());
652
653 // clang-format off
654 unsigned char packet[] = {
655 // type (short header, 4 byte packet number)
656 0x43,
657 // connection_id
658 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
659 // packet number
660 0x12, 0x34, 0x56, 0x78,
661
662 // Path Challenge Frame type (IETF_PATH_CHALLENGE)
663 0x1a,
664 // 8 "random" bytes, MockRandom makes lots of r's
665 'r', 'r', 'r', 'r', 'r', 'r', 'r', 'r',
666 // frame type (padding frame)
667 0x00,
668 0x00, 0x00, 0x00, 0x00
669 };
670 // clang-format on
671
672 std::unique_ptr<char[]> buffer(new char[kMaxOutgoingPacketSize]);
673
674 size_t length = creator_.BuildPaddedPathChallengePacket(
675 header, buffer.get(), ABSL_ARRAYSIZE(packet), payload,
676 ENCRYPTION_INITIAL);
677 EXPECT_EQ(length, ABSL_ARRAYSIZE(packet));
678
679 // Payload has the random bytes that were generated. Copy them into packet,
680 // above, before checking that the generated packet is correct.
681 EXPECT_EQ(kQuicPathFrameBufferSize, payload.size());
682
683 QuicPacket data(creator_.transport_version(), buffer.release(), length, true,
684 header);
685
686 quiche::test::CompareCharArraysWithHexError(
687 "constructed packet", data.data(), data.length(),
688 reinterpret_cast<char*>(packet), ABSL_ARRAYSIZE(packet));
689 }
690
TEST_P(QuicPacketCreatorTest,BuildConnectivityProbingPacket)691 TEST_P(QuicPacketCreatorTest, BuildConnectivityProbingPacket) {
692 QuicPacketHeader header;
693 header.destination_connection_id = CreateTestConnectionId();
694 header.reset_flag = false;
695 header.version_flag = false;
696 header.packet_number = kPacketNumber;
697
698 // clang-format off
699 unsigned char packet[] = {
700 // type (short header, 4 byte packet number)
701 0x43,
702 // connection_id
703 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
704 // packet number
705 0x12, 0x34, 0x56, 0x78,
706
707 // frame type
708 0x07,
709 // frame type (padding frame)
710 0x00,
711 0x00, 0x00, 0x00, 0x00
712 };
713
714 unsigned char packet99[] = {
715 // type (short header, 4 byte packet number)
716 0x43,
717 // connection_id
718 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
719 // packet number
720 0x12, 0x34, 0x56, 0x78,
721
722 // frame type (IETF_PING frame)
723 0x01,
724 // frame type (padding frame)
725 0x00,
726 0x00, 0x00, 0x00, 0x00
727 };
728 // clang-format on
729
730 unsigned char* p = packet;
731 size_t packet_size = ABSL_ARRAYSIZE(packet);
732 if (creator_.version().HasIetfQuicFrames()) {
733 p = packet99;
734 packet_size = ABSL_ARRAYSIZE(packet99);
735 }
736
737 std::unique_ptr<char[]> buffer(new char[kMaxOutgoingPacketSize]);
738
739 size_t length = creator_.BuildConnectivityProbingPacket(
740 header, buffer.get(), packet_size, ENCRYPTION_INITIAL);
741
742 EXPECT_NE(0u, length);
743 QuicPacket data(creator_.transport_version(), buffer.release(), length, true,
744 header);
745
746 quiche::test::CompareCharArraysWithHexError(
747 "constructed packet", data.data(), data.length(),
748 reinterpret_cast<char*>(p), packet_size);
749 }
750
751 // Several tests that the path response connectivity probing packet is
752 // serialized correctly as either a padded and unpadded PATH RESPONSE
753 // packet. Also generates packets with 1 and 3 PATH_RESPONSES in them to
754 // exercised the single- and multiple- payload cases.
TEST_P(QuicPacketCreatorTest,BuildPathResponsePacket1ResponseUnpadded)755 TEST_P(QuicPacketCreatorTest, BuildPathResponsePacket1ResponseUnpadded) {
756 if (!VersionHasIetfQuicFrames(creator_.transport_version())) {
757 // This frame is only for IETF QUIC.
758 return;
759 }
760
761 QuicPacketHeader header;
762 header.destination_connection_id = CreateTestConnectionId();
763 header.reset_flag = false;
764 header.version_flag = false;
765 header.packet_number = kPacketNumber;
766 QuicPathFrameBuffer payload0 = {
767 {0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08}};
768
769 // Build 1 PATH RESPONSE, not padded
770 // clang-format off
771 unsigned char packet[] = {
772 // type (short header, 4 byte packet number)
773 0x43,
774 // connection_id
775 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
776 // packet number
777 0x12, 0x34, 0x56, 0x78,
778
779 // Path Response Frame type (IETF_PATH_RESPONSE)
780 0x1b,
781 // 8 "random" bytes
782 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
783 };
784 // clang-format on
785 std::unique_ptr<char[]> buffer(new char[kMaxOutgoingPacketSize]);
786 quiche::QuicheCircularDeque<QuicPathFrameBuffer> payloads;
787 payloads.push_back(payload0);
788 size_t length = creator_.BuildPathResponsePacket(
789 header, buffer.get(), ABSL_ARRAYSIZE(packet), payloads,
790 /*is_padded=*/false, ENCRYPTION_INITIAL);
791 EXPECT_EQ(length, ABSL_ARRAYSIZE(packet));
792 QuicPacket data(creator_.transport_version(), buffer.release(), length, true,
793 header);
794
795 quiche::test::CompareCharArraysWithHexError(
796 "constructed packet", data.data(), data.length(),
797 reinterpret_cast<char*>(packet), ABSL_ARRAYSIZE(packet));
798 }
799
TEST_P(QuicPacketCreatorTest,BuildPathResponsePacket1ResponsePadded)800 TEST_P(QuicPacketCreatorTest, BuildPathResponsePacket1ResponsePadded) {
801 if (!VersionHasIetfQuicFrames(creator_.transport_version())) {
802 // This frame is only for IETF QUIC.
803 return;
804 }
805
806 QuicPacketHeader header;
807 header.destination_connection_id = CreateTestConnectionId();
808 header.reset_flag = false;
809 header.version_flag = false;
810 header.packet_number = kPacketNumber;
811 QuicPathFrameBuffer payload0 = {
812 {0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08}};
813
814 // Build 1 PATH RESPONSE, padded
815 // clang-format off
816 unsigned char packet[] = {
817 // type (short header, 4 byte packet number)
818 0x43,
819 // connection_id
820 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
821 // packet number
822 0x12, 0x34, 0x56, 0x78,
823
824 // Path Response Frame type (IETF_PATH_RESPONSE)
825 0x1b,
826 // 8 "random" bytes
827 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
828 // Padding type and pad
829 0x00, 0x00, 0x00, 0x00, 0x00
830 };
831 // clang-format on
832 std::unique_ptr<char[]> buffer(new char[kMaxOutgoingPacketSize]);
833 quiche::QuicheCircularDeque<QuicPathFrameBuffer> payloads;
834 payloads.push_back(payload0);
835 size_t length = creator_.BuildPathResponsePacket(
836 header, buffer.get(), ABSL_ARRAYSIZE(packet), payloads,
837 /*is_padded=*/true, ENCRYPTION_INITIAL);
838 EXPECT_EQ(length, ABSL_ARRAYSIZE(packet));
839 QuicPacket data(creator_.transport_version(), buffer.release(), length, true,
840 header);
841
842 quiche::test::CompareCharArraysWithHexError(
843 "constructed packet", data.data(), data.length(),
844 reinterpret_cast<char*>(packet), ABSL_ARRAYSIZE(packet));
845 }
846
TEST_P(QuicPacketCreatorTest,BuildPathResponsePacket3ResponsesUnpadded)847 TEST_P(QuicPacketCreatorTest, BuildPathResponsePacket3ResponsesUnpadded) {
848 if (!VersionHasIetfQuicFrames(creator_.transport_version())) {
849 // This frame is only for IETF QUIC.
850 return;
851 }
852
853 QuicPacketHeader header;
854 header.destination_connection_id = CreateTestConnectionId();
855 header.reset_flag = false;
856 header.version_flag = false;
857 header.packet_number = kPacketNumber;
858 QuicPathFrameBuffer payload0 = {
859 {0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08}};
860 QuicPathFrameBuffer payload1 = {
861 {0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18}};
862 QuicPathFrameBuffer payload2 = {
863 {0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28}};
864
865 // Build one packet with 3 PATH RESPONSES, no padding
866 // clang-format off
867 unsigned char packet[] = {
868 // type (short header, 4 byte packet number)
869 0x43,
870 // connection_id
871 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
872 // packet number
873 0x12, 0x34, 0x56, 0x78,
874
875 // 3 path response frames (IETF_PATH_RESPONSE type byte and payload)
876 0x1b, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
877 0x1b, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18,
878 0x1b, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
879 };
880 // clang-format on
881
882 std::unique_ptr<char[]> buffer(new char[kMaxOutgoingPacketSize]);
883 quiche::QuicheCircularDeque<QuicPathFrameBuffer> payloads;
884 payloads.push_back(payload0);
885 payloads.push_back(payload1);
886 payloads.push_back(payload2);
887 size_t length = creator_.BuildPathResponsePacket(
888 header, buffer.get(), ABSL_ARRAYSIZE(packet), payloads,
889 /*is_padded=*/false, ENCRYPTION_INITIAL);
890 EXPECT_EQ(length, ABSL_ARRAYSIZE(packet));
891 QuicPacket data(creator_.transport_version(), buffer.release(), length, true,
892 header);
893
894 quiche::test::CompareCharArraysWithHexError(
895 "constructed packet", data.data(), data.length(),
896 reinterpret_cast<char*>(packet), ABSL_ARRAYSIZE(packet));
897 }
898
TEST_P(QuicPacketCreatorTest,BuildPathResponsePacket3ResponsesPadded)899 TEST_P(QuicPacketCreatorTest, BuildPathResponsePacket3ResponsesPadded) {
900 if (!VersionHasIetfQuicFrames(creator_.transport_version())) {
901 // This frame is only for IETF QUIC.
902 return;
903 }
904
905 QuicPacketHeader header;
906 header.destination_connection_id = CreateTestConnectionId();
907 header.reset_flag = false;
908 header.version_flag = false;
909 header.packet_number = kPacketNumber;
910 QuicPathFrameBuffer payload0 = {
911 {0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08}};
912 QuicPathFrameBuffer payload1 = {
913 {0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18}};
914 QuicPathFrameBuffer payload2 = {
915 {0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28}};
916
917 // Build one packet with 3 PATH RESPONSES, with padding
918 // clang-format off
919 unsigned char packet[] = {
920 // type (short header, 4 byte packet number)
921 0x43,
922 // connection_id
923 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
924 // packet number
925 0x12, 0x34, 0x56, 0x78,
926
927 // 3 path response frames (IETF_PATH_RESPONSE byte and payload)
928 0x1b, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
929 0x1b, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18,
930 0x1b, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
931 // Padding
932 0x00, 0x00, 0x00, 0x00, 0x00
933 };
934 // clang-format on
935
936 std::unique_ptr<char[]> buffer(new char[kMaxOutgoingPacketSize]);
937 quiche::QuicheCircularDeque<QuicPathFrameBuffer> payloads;
938 payloads.push_back(payload0);
939 payloads.push_back(payload1);
940 payloads.push_back(payload2);
941 size_t length = creator_.BuildPathResponsePacket(
942 header, buffer.get(), ABSL_ARRAYSIZE(packet), payloads,
943 /*is_padded=*/true, ENCRYPTION_INITIAL);
944 EXPECT_EQ(length, ABSL_ARRAYSIZE(packet));
945 QuicPacket data(creator_.transport_version(), buffer.release(), length, true,
946 header);
947
948 quiche::test::CompareCharArraysWithHexError(
949 "constructed packet", data.data(), data.length(),
950 reinterpret_cast<char*>(packet), ABSL_ARRAYSIZE(packet));
951 }
952
TEST_P(QuicPacketCreatorTest,SerializeConnectivityProbingPacket)953 TEST_P(QuicPacketCreatorTest, SerializeConnectivityProbingPacket) {
954 creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
955
956 std::unique_ptr<SerializedPacket> encrypted;
957 if (VersionHasIetfQuicFrames(creator_.transport_version())) {
958 QuicPathFrameBuffer payload = {
959 {0xde, 0xad, 0xbe, 0xef, 0xba, 0xdc, 0x0f, 0xfe}};
960 encrypted =
961 creator_.SerializePathChallengeConnectivityProbingPacket(payload);
962 } else {
963 encrypted = creator_.SerializeConnectivityProbingPacket();
964 }
965 {
966 InSequence s;
967 EXPECT_CALL(framer_visitor_, OnPacket());
968 EXPECT_CALL(framer_visitor_, OnUnauthenticatedPublicHeader(_));
969 EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_));
970 EXPECT_CALL(framer_visitor_, OnDecryptedPacket(_, _));
971 EXPECT_CALL(framer_visitor_, OnPacketHeader(_));
972 if (VersionHasIetfQuicFrames(creator_.transport_version())) {
973 EXPECT_CALL(framer_visitor_, OnPathChallengeFrame(_));
974 EXPECT_CALL(framer_visitor_, OnPaddingFrame(_));
975 } else {
976 EXPECT_CALL(framer_visitor_, OnPingFrame(_));
977 EXPECT_CALL(framer_visitor_, OnPaddingFrame(_));
978 }
979 EXPECT_CALL(framer_visitor_, OnPacketComplete());
980 }
981 // QuicFramerPeer::SetPerspective(&client_framer_, Perspective::IS_SERVER);
982 server_framer_.ProcessPacket(QuicEncryptedPacket(
983 encrypted->encrypted_buffer, encrypted->encrypted_length));
984 }
985
TEST_P(QuicPacketCreatorTest,SerializePathChallengeProbePacket)986 TEST_P(QuicPacketCreatorTest, SerializePathChallengeProbePacket) {
987 if (!VersionHasIetfQuicFrames(creator_.transport_version())) {
988 return;
989 }
990 QuicPathFrameBuffer payload = {
991 {0xde, 0xad, 0xbe, 0xef, 0xba, 0xdc, 0x0f, 0xee}};
992
993 creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
994
995 std::unique_ptr<SerializedPacket> encrypted(
996 creator_.SerializePathChallengeConnectivityProbingPacket(payload));
997 {
998 InSequence s;
999 EXPECT_CALL(framer_visitor_, OnPacket());
1000 EXPECT_CALL(framer_visitor_, OnUnauthenticatedPublicHeader(_));
1001 EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_));
1002 EXPECT_CALL(framer_visitor_, OnDecryptedPacket(_, _));
1003 EXPECT_CALL(framer_visitor_, OnPacketHeader(_));
1004 EXPECT_CALL(framer_visitor_, OnPathChallengeFrame(_));
1005 EXPECT_CALL(framer_visitor_, OnPaddingFrame(_));
1006 EXPECT_CALL(framer_visitor_, OnPacketComplete());
1007 }
1008 // QuicFramerPeer::SetPerspective(&client_framer_, Perspective::IS_SERVER);
1009 server_framer_.ProcessPacket(QuicEncryptedPacket(
1010 encrypted->encrypted_buffer, encrypted->encrypted_length));
1011 }
1012
TEST_P(QuicPacketCreatorTest,SerializePathResponseProbePacket1PayloadPadded)1013 TEST_P(QuicPacketCreatorTest, SerializePathResponseProbePacket1PayloadPadded) {
1014 if (!VersionHasIetfQuicFrames(creator_.transport_version())) {
1015 return;
1016 }
1017 QuicPathFrameBuffer payload0 = {
1018 {0xde, 0xad, 0xbe, 0xef, 0xba, 0xdc, 0x0f, 0xee}};
1019
1020 creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
1021
1022 quiche::QuicheCircularDeque<QuicPathFrameBuffer> payloads;
1023 payloads.push_back(payload0);
1024
1025 std::unique_ptr<SerializedPacket> encrypted(
1026 creator_.SerializePathResponseConnectivityProbingPacket(payloads, true));
1027 {
1028 InSequence s;
1029 EXPECT_CALL(framer_visitor_, OnPacket());
1030 EXPECT_CALL(framer_visitor_, OnUnauthenticatedPublicHeader(_));
1031 EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_));
1032 EXPECT_CALL(framer_visitor_, OnDecryptedPacket(_, _));
1033 EXPECT_CALL(framer_visitor_, OnPacketHeader(_));
1034 EXPECT_CALL(framer_visitor_, OnPathResponseFrame(_));
1035 EXPECT_CALL(framer_visitor_, OnPaddingFrame(_));
1036 EXPECT_CALL(framer_visitor_, OnPacketComplete());
1037 }
1038 server_framer_.ProcessPacket(QuicEncryptedPacket(
1039 encrypted->encrypted_buffer, encrypted->encrypted_length));
1040 }
1041
TEST_P(QuicPacketCreatorTest,SerializePathResponseProbePacket1PayloadUnPadded)1042 TEST_P(QuicPacketCreatorTest,
1043 SerializePathResponseProbePacket1PayloadUnPadded) {
1044 if (!VersionHasIetfQuicFrames(creator_.transport_version())) {
1045 return;
1046 }
1047 QuicPathFrameBuffer payload0 = {
1048 {0xde, 0xad, 0xbe, 0xef, 0xba, 0xdc, 0x0f, 0xee}};
1049
1050 creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
1051
1052 quiche::QuicheCircularDeque<QuicPathFrameBuffer> payloads;
1053 payloads.push_back(payload0);
1054
1055 std::unique_ptr<SerializedPacket> encrypted(
1056 creator_.SerializePathResponseConnectivityProbingPacket(payloads, false));
1057 {
1058 InSequence s;
1059 EXPECT_CALL(framer_visitor_, OnPacket());
1060 EXPECT_CALL(framer_visitor_, OnUnauthenticatedPublicHeader(_));
1061 EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_));
1062 EXPECT_CALL(framer_visitor_, OnDecryptedPacket(_, _));
1063 EXPECT_CALL(framer_visitor_, OnPacketHeader(_));
1064 EXPECT_CALL(framer_visitor_, OnPathResponseFrame(_));
1065 EXPECT_CALL(framer_visitor_, OnPacketComplete());
1066 }
1067 server_framer_.ProcessPacket(QuicEncryptedPacket(
1068 encrypted->encrypted_buffer, encrypted->encrypted_length));
1069 }
1070
TEST_P(QuicPacketCreatorTest,SerializePathResponseProbePacket2PayloadsPadded)1071 TEST_P(QuicPacketCreatorTest, SerializePathResponseProbePacket2PayloadsPadded) {
1072 if (!VersionHasIetfQuicFrames(creator_.transport_version())) {
1073 return;
1074 }
1075 QuicPathFrameBuffer payload0 = {
1076 {0xde, 0xad, 0xbe, 0xef, 0xba, 0xdc, 0x0f, 0xee}};
1077 QuicPathFrameBuffer payload1 = {
1078 {0xad, 0xbe, 0xef, 0xba, 0xdc, 0x0f, 0xee, 0xde}};
1079
1080 creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
1081
1082 quiche::QuicheCircularDeque<QuicPathFrameBuffer> payloads;
1083 payloads.push_back(payload0);
1084 payloads.push_back(payload1);
1085
1086 std::unique_ptr<SerializedPacket> encrypted(
1087 creator_.SerializePathResponseConnectivityProbingPacket(payloads, true));
1088 {
1089 InSequence s;
1090 EXPECT_CALL(framer_visitor_, OnPacket());
1091 EXPECT_CALL(framer_visitor_, OnUnauthenticatedPublicHeader(_));
1092 EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_));
1093 EXPECT_CALL(framer_visitor_, OnDecryptedPacket(_, _));
1094 EXPECT_CALL(framer_visitor_, OnPacketHeader(_));
1095 EXPECT_CALL(framer_visitor_, OnPathResponseFrame(_)).Times(2);
1096 EXPECT_CALL(framer_visitor_, OnPaddingFrame(_));
1097 EXPECT_CALL(framer_visitor_, OnPacketComplete());
1098 }
1099 server_framer_.ProcessPacket(QuicEncryptedPacket(
1100 encrypted->encrypted_buffer, encrypted->encrypted_length));
1101 }
1102
TEST_P(QuicPacketCreatorTest,SerializePathResponseProbePacket2PayloadsUnPadded)1103 TEST_P(QuicPacketCreatorTest,
1104 SerializePathResponseProbePacket2PayloadsUnPadded) {
1105 if (!VersionHasIetfQuicFrames(creator_.transport_version())) {
1106 return;
1107 }
1108 QuicPathFrameBuffer payload0 = {
1109 {0xde, 0xad, 0xbe, 0xef, 0xba, 0xdc, 0x0f, 0xee}};
1110 QuicPathFrameBuffer payload1 = {
1111 {0xad, 0xbe, 0xef, 0xba, 0xdc, 0x0f, 0xee, 0xde}};
1112
1113 creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
1114
1115 quiche::QuicheCircularDeque<QuicPathFrameBuffer> payloads;
1116 payloads.push_back(payload0);
1117 payloads.push_back(payload1);
1118
1119 std::unique_ptr<SerializedPacket> encrypted(
1120 creator_.SerializePathResponseConnectivityProbingPacket(payloads, false));
1121 {
1122 InSequence s;
1123 EXPECT_CALL(framer_visitor_, OnPacket());
1124 EXPECT_CALL(framer_visitor_, OnUnauthenticatedPublicHeader(_));
1125 EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_));
1126 EXPECT_CALL(framer_visitor_, OnDecryptedPacket(_, _));
1127 EXPECT_CALL(framer_visitor_, OnPacketHeader(_));
1128 EXPECT_CALL(framer_visitor_, OnPathResponseFrame(_)).Times(2);
1129 EXPECT_CALL(framer_visitor_, OnPacketComplete());
1130 }
1131 server_framer_.ProcessPacket(QuicEncryptedPacket(
1132 encrypted->encrypted_buffer, encrypted->encrypted_length));
1133 }
1134
TEST_P(QuicPacketCreatorTest,SerializePathResponseProbePacket3PayloadsPadded)1135 TEST_P(QuicPacketCreatorTest, SerializePathResponseProbePacket3PayloadsPadded) {
1136 if (!VersionHasIetfQuicFrames(creator_.transport_version())) {
1137 return;
1138 }
1139 QuicPathFrameBuffer payload0 = {
1140 {0xde, 0xad, 0xbe, 0xef, 0xba, 0xdc, 0x0f, 0xee}};
1141 QuicPathFrameBuffer payload1 = {
1142 {0xad, 0xbe, 0xef, 0xba, 0xdc, 0x0f, 0xee, 0xde}};
1143 QuicPathFrameBuffer payload2 = {
1144 {0xbe, 0xef, 0xba, 0xdc, 0x0f, 0xee, 0xde, 0xad}};
1145
1146 creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
1147
1148 quiche::QuicheCircularDeque<QuicPathFrameBuffer> payloads;
1149 payloads.push_back(payload0);
1150 payloads.push_back(payload1);
1151 payloads.push_back(payload2);
1152
1153 std::unique_ptr<SerializedPacket> encrypted(
1154 creator_.SerializePathResponseConnectivityProbingPacket(payloads, true));
1155 {
1156 InSequence s;
1157 EXPECT_CALL(framer_visitor_, OnPacket());
1158 EXPECT_CALL(framer_visitor_, OnUnauthenticatedPublicHeader(_));
1159 EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_));
1160 EXPECT_CALL(framer_visitor_, OnDecryptedPacket(_, _));
1161 EXPECT_CALL(framer_visitor_, OnPacketHeader(_));
1162 EXPECT_CALL(framer_visitor_, OnPathResponseFrame(_)).Times(3);
1163 EXPECT_CALL(framer_visitor_, OnPaddingFrame(_));
1164 EXPECT_CALL(framer_visitor_, OnPacketComplete());
1165 }
1166 server_framer_.ProcessPacket(QuicEncryptedPacket(
1167 encrypted->encrypted_buffer, encrypted->encrypted_length));
1168 }
1169
TEST_P(QuicPacketCreatorTest,SerializePathResponseProbePacket3PayloadsUnpadded)1170 TEST_P(QuicPacketCreatorTest,
1171 SerializePathResponseProbePacket3PayloadsUnpadded) {
1172 if (!VersionHasIetfQuicFrames(creator_.transport_version())) {
1173 return;
1174 }
1175 QuicPathFrameBuffer payload0 = {
1176 {0xde, 0xad, 0xbe, 0xef, 0xba, 0xdc, 0x0f, 0xee}};
1177 QuicPathFrameBuffer payload1 = {
1178 {0xad, 0xbe, 0xef, 0xba, 0xdc, 0x0f, 0xee, 0xde}};
1179 QuicPathFrameBuffer payload2 = {
1180 {0xbe, 0xef, 0xba, 0xdc, 0x0f, 0xee, 0xde, 0xad}};
1181
1182 creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
1183
1184 quiche::QuicheCircularDeque<QuicPathFrameBuffer> payloads;
1185 payloads.push_back(payload0);
1186 payloads.push_back(payload1);
1187 payloads.push_back(payload2);
1188
1189 std::unique_ptr<SerializedPacket> encrypted(
1190 creator_.SerializePathResponseConnectivityProbingPacket(payloads, false));
1191 InSequence s;
1192 EXPECT_CALL(framer_visitor_, OnPacket());
1193 EXPECT_CALL(framer_visitor_, OnUnauthenticatedPublicHeader(_));
1194 EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_));
1195 EXPECT_CALL(framer_visitor_, OnDecryptedPacket(_, _));
1196 EXPECT_CALL(framer_visitor_, OnPacketHeader(_));
1197 EXPECT_CALL(framer_visitor_, OnPathResponseFrame(_)).Times(3);
1198 EXPECT_CALL(framer_visitor_, OnPacketComplete());
1199
1200 server_framer_.ProcessPacket(QuicEncryptedPacket(
1201 encrypted->encrypted_buffer, encrypted->encrypted_length));
1202 }
1203
TEST_P(QuicPacketCreatorTest,UpdatePacketSequenceNumberLengthLeastAwaiting)1204 TEST_P(QuicPacketCreatorTest, UpdatePacketSequenceNumberLengthLeastAwaiting) {
1205 if (!GetParam().version.SendsVariableLengthPacketNumberInLongHeader()) {
1206 EXPECT_EQ(PACKET_4BYTE_PACKET_NUMBER,
1207 QuicPacketCreatorPeer::GetPacketNumberLength(&creator_));
1208 creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
1209 } else {
1210 EXPECT_EQ(PACKET_1BYTE_PACKET_NUMBER,
1211 QuicPacketCreatorPeer::GetPacketNumberLength(&creator_));
1212 }
1213
1214 QuicPacketCreatorPeer::SetPacketNumber(&creator_, 64);
1215 creator_.UpdatePacketNumberLength(QuicPacketNumber(2),
1216 10000 / kDefaultMaxPacketSize);
1217 EXPECT_EQ(PACKET_1BYTE_PACKET_NUMBER,
1218 QuicPacketCreatorPeer::GetPacketNumberLength(&creator_));
1219
1220 QuicPacketCreatorPeer::SetPacketNumber(&creator_, 64 * 256);
1221 creator_.UpdatePacketNumberLength(QuicPacketNumber(2),
1222 10000 / kDefaultMaxPacketSize);
1223 EXPECT_EQ(PACKET_2BYTE_PACKET_NUMBER,
1224 QuicPacketCreatorPeer::GetPacketNumberLength(&creator_));
1225
1226 QuicPacketCreatorPeer::SetPacketNumber(&creator_, 64 * 256 * 256);
1227 creator_.UpdatePacketNumberLength(QuicPacketNumber(2),
1228 10000 / kDefaultMaxPacketSize);
1229 EXPECT_EQ(PACKET_4BYTE_PACKET_NUMBER,
1230 QuicPacketCreatorPeer::GetPacketNumberLength(&creator_));
1231
1232 QuicPacketCreatorPeer::SetPacketNumber(&creator_,
1233 UINT64_C(64) * 256 * 256 * 256 * 256);
1234 creator_.UpdatePacketNumberLength(QuicPacketNumber(2),
1235 10000 / kDefaultMaxPacketSize);
1236 EXPECT_EQ(PACKET_6BYTE_PACKET_NUMBER,
1237 QuicPacketCreatorPeer::GetPacketNumberLength(&creator_));
1238 }
1239
TEST_P(QuicPacketCreatorTest,UpdatePacketSequenceNumberLengthCwnd)1240 TEST_P(QuicPacketCreatorTest, UpdatePacketSequenceNumberLengthCwnd) {
1241 QuicPacketCreatorPeer::SetPacketNumber(&creator_, 1);
1242 if (!GetParam().version.SendsVariableLengthPacketNumberInLongHeader()) {
1243 EXPECT_EQ(PACKET_4BYTE_PACKET_NUMBER,
1244 QuicPacketCreatorPeer::GetPacketNumberLength(&creator_));
1245 creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
1246 } else {
1247 EXPECT_EQ(PACKET_1BYTE_PACKET_NUMBER,
1248 QuicPacketCreatorPeer::GetPacketNumberLength(&creator_));
1249 }
1250
1251 creator_.UpdatePacketNumberLength(QuicPacketNumber(1),
1252 10000 / kDefaultMaxPacketSize);
1253 EXPECT_EQ(PACKET_1BYTE_PACKET_NUMBER,
1254 QuicPacketCreatorPeer::GetPacketNumberLength(&creator_));
1255
1256 creator_.UpdatePacketNumberLength(QuicPacketNumber(1),
1257 10000 * 256 / kDefaultMaxPacketSize);
1258 EXPECT_EQ(PACKET_2BYTE_PACKET_NUMBER,
1259 QuicPacketCreatorPeer::GetPacketNumberLength(&creator_));
1260
1261 creator_.UpdatePacketNumberLength(QuicPacketNumber(1),
1262 10000 * 256 * 256 / kDefaultMaxPacketSize);
1263 EXPECT_EQ(PACKET_4BYTE_PACKET_NUMBER,
1264 QuicPacketCreatorPeer::GetPacketNumberLength(&creator_));
1265
1266 creator_.UpdatePacketNumberLength(
1267 QuicPacketNumber(1),
1268 UINT64_C(1000) * 256 * 256 * 256 * 256 / kDefaultMaxPacketSize);
1269 EXPECT_EQ(PACKET_6BYTE_PACKET_NUMBER,
1270 QuicPacketCreatorPeer::GetPacketNumberLength(&creator_));
1271 }
1272
TEST_P(QuicPacketCreatorTest,SkipNPacketNumbers)1273 TEST_P(QuicPacketCreatorTest, SkipNPacketNumbers) {
1274 QuicPacketCreatorPeer::SetPacketNumber(&creator_, 1);
1275 if (!GetParam().version.SendsVariableLengthPacketNumberInLongHeader()) {
1276 EXPECT_EQ(PACKET_4BYTE_PACKET_NUMBER,
1277 QuicPacketCreatorPeer::GetPacketNumberLength(&creator_));
1278 creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
1279 } else {
1280 EXPECT_EQ(PACKET_1BYTE_PACKET_NUMBER,
1281 QuicPacketCreatorPeer::GetPacketNumberLength(&creator_));
1282 }
1283 creator_.SkipNPacketNumbers(63, QuicPacketNumber(2),
1284 10000 / kDefaultMaxPacketSize);
1285 EXPECT_EQ(QuicPacketNumber(64), creator_.packet_number());
1286 EXPECT_EQ(PACKET_1BYTE_PACKET_NUMBER,
1287 QuicPacketCreatorPeer::GetPacketNumberLength(&creator_));
1288
1289 creator_.SkipNPacketNumbers(64 * 255, QuicPacketNumber(2),
1290 10000 / kDefaultMaxPacketSize);
1291 EXPECT_EQ(QuicPacketNumber(64 * 256), creator_.packet_number());
1292 EXPECT_EQ(PACKET_2BYTE_PACKET_NUMBER,
1293 QuicPacketCreatorPeer::GetPacketNumberLength(&creator_));
1294
1295 creator_.SkipNPacketNumbers(64 * 256 * 255, QuicPacketNumber(2),
1296 10000 / kDefaultMaxPacketSize);
1297 EXPECT_EQ(QuicPacketNumber(64 * 256 * 256), creator_.packet_number());
1298 EXPECT_EQ(PACKET_4BYTE_PACKET_NUMBER,
1299 QuicPacketCreatorPeer::GetPacketNumberLength(&creator_));
1300 }
1301
TEST_P(QuicPacketCreatorTest,SerializeFrame)1302 TEST_P(QuicPacketCreatorTest, SerializeFrame) {
1303 if (!GetParam().version_serialization) {
1304 creator_.StopSendingVersion();
1305 }
1306 std::string data("test data");
1307 if (!QuicVersionUsesCryptoFrames(client_framer_.transport_version())) {
1308 QuicStreamFrame stream_frame(
1309 QuicUtils::GetCryptoStreamId(client_framer_.transport_version()),
1310 /*fin=*/false, 0u, absl::string_view());
1311 frames_.push_back(QuicFrame(stream_frame));
1312 } else {
1313 producer_.SaveCryptoData(ENCRYPTION_INITIAL, 0, data);
1314 frames_.push_back(
1315 QuicFrame(new QuicCryptoFrame(ENCRYPTION_INITIAL, 0, data.length())));
1316 }
1317 SerializedPacket serialized = SerializeAllFrames(frames_);
1318
1319 QuicPacketHeader header;
1320 {
1321 InSequence s;
1322 EXPECT_CALL(framer_visitor_, OnPacket());
1323 EXPECT_CALL(framer_visitor_, OnUnauthenticatedPublicHeader(_));
1324 EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_));
1325 EXPECT_CALL(framer_visitor_, OnDecryptedPacket(_, _));
1326 EXPECT_CALL(framer_visitor_, OnPacketHeader(_))
1327 .WillOnce(DoAll(SaveArg<0>(&header), Return(true)));
1328 if (QuicVersionUsesCryptoFrames(client_framer_.transport_version())) {
1329 EXPECT_CALL(framer_visitor_, OnCryptoFrame(_));
1330 } else {
1331 EXPECT_CALL(framer_visitor_, OnStreamFrame(_));
1332 }
1333 EXPECT_CALL(framer_visitor_, OnPacketComplete());
1334 }
1335 ProcessPacket(serialized);
1336 EXPECT_EQ(GetParam().version_serialization, header.version_flag);
1337 }
1338
TEST_P(QuicPacketCreatorTest,SerializeFrameShortData)1339 TEST_P(QuicPacketCreatorTest, SerializeFrameShortData) {
1340 if (!GetParam().version_serialization) {
1341 creator_.StopSendingVersion();
1342 }
1343 std::string data("Hello World!");
1344 if (!QuicVersionUsesCryptoFrames(client_framer_.transport_version())) {
1345 QuicStreamFrame stream_frame(
1346 QuicUtils::GetCryptoStreamId(client_framer_.transport_version()),
1347 /*fin=*/false, 0u, absl::string_view());
1348 frames_.push_back(QuicFrame(stream_frame));
1349 } else {
1350 producer_.SaveCryptoData(ENCRYPTION_INITIAL, 0, data);
1351 frames_.push_back(
1352 QuicFrame(new QuicCryptoFrame(ENCRYPTION_INITIAL, 0, data.length())));
1353 }
1354 SerializedPacket serialized = SerializeAllFrames(frames_);
1355
1356 QuicPacketHeader header;
1357 {
1358 InSequence s;
1359 EXPECT_CALL(framer_visitor_, OnPacket());
1360 EXPECT_CALL(framer_visitor_, OnUnauthenticatedPublicHeader(_));
1361 EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_));
1362 EXPECT_CALL(framer_visitor_, OnDecryptedPacket(_, _));
1363 EXPECT_CALL(framer_visitor_, OnPacketHeader(_))
1364 .WillOnce(DoAll(SaveArg<0>(&header), Return(true)));
1365 if (QuicVersionUsesCryptoFrames(client_framer_.transport_version())) {
1366 EXPECT_CALL(framer_visitor_, OnCryptoFrame(_));
1367 } else {
1368 EXPECT_CALL(framer_visitor_, OnStreamFrame(_));
1369 }
1370 EXPECT_CALL(framer_visitor_, OnPacketComplete());
1371 }
1372 ProcessPacket(serialized);
1373 EXPECT_EQ(GetParam().version_serialization, header.version_flag);
1374 }
1375
TestChaosProtection(bool enabled)1376 void QuicPacketCreatorTest::TestChaosProtection(bool enabled) {
1377 if (!GetParam().version.UsesCryptoFrames()) {
1378 return;
1379 }
1380 MockRandom mock_random(2);
1381 QuicPacketCreatorPeer::SetRandom(&creator_, &mock_random);
1382 std::string data("ChAoS_ThEoRy!");
1383 producer_.SaveCryptoData(ENCRYPTION_INITIAL, 0, data);
1384 frames_.push_back(
1385 QuicFrame(new QuicCryptoFrame(ENCRYPTION_INITIAL, 0, data.length())));
1386 frames_.push_back(QuicFrame(QuicPaddingFrame(33)));
1387 SerializedPacket serialized = SerializeAllFrames(frames_);
1388 EXPECT_CALL(framer_visitor_, OnPacket());
1389 EXPECT_CALL(framer_visitor_, OnUnauthenticatedPublicHeader(_));
1390 EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_));
1391 EXPECT_CALL(framer_visitor_, OnDecryptedPacket(_, _));
1392 EXPECT_CALL(framer_visitor_, OnPacketHeader(_));
1393 if (enabled) {
1394 EXPECT_CALL(framer_visitor_, OnCryptoFrame(_)).Times(AtLeast(2));
1395 EXPECT_CALL(framer_visitor_, OnPaddingFrame(_)).Times(AtLeast(2));
1396 EXPECT_CALL(framer_visitor_, OnPingFrame(_)).Times(AtLeast(1));
1397 } else {
1398 EXPECT_CALL(framer_visitor_, OnCryptoFrame(_)).Times(1);
1399 EXPECT_CALL(framer_visitor_, OnPaddingFrame(_)).Times(1);
1400 EXPECT_CALL(framer_visitor_, OnPingFrame(_)).Times(0);
1401 }
1402 EXPECT_CALL(framer_visitor_, OnPacketComplete());
1403 ProcessPacket(serialized);
1404 }
1405
TEST_P(QuicPacketCreatorTest,ChaosProtectionEnabled)1406 TEST_P(QuicPacketCreatorTest, ChaosProtectionEnabled) {
1407 TestChaosProtection(true);
1408 }
1409
TEST_P(QuicPacketCreatorTest,ChaosProtectionDisabled)1410 TEST_P(QuicPacketCreatorTest, ChaosProtectionDisabled) {
1411 SetQuicFlag(quic_enable_chaos_protection, false);
1412 TestChaosProtection(false);
1413 }
1414
TEST_P(QuicPacketCreatorTest,ConsumeDataLargerThanOneStreamFrame)1415 TEST_P(QuicPacketCreatorTest, ConsumeDataLargerThanOneStreamFrame) {
1416 if (!GetParam().version_serialization) {
1417 creator_.StopSendingVersion();
1418 }
1419 creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
1420 // A string larger than fits into a frame.
1421 QuicFrame frame;
1422 size_t payload_length = creator_.max_packet_length();
1423 const std::string too_long_payload(payload_length, 'a');
1424 EXPECT_CALL(delegate_, OnSerializedPacket(_))
1425 .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
1426 QuicStreamId stream_id = QuicUtils::GetFirstBidirectionalStreamId(
1427 client_framer_.transport_version(), Perspective::IS_CLIENT);
1428 ASSERT_TRUE(creator_.ConsumeDataToFillCurrentPacket(
1429 stream_id, too_long_payload, 0u, true, false, NOT_RETRANSMISSION,
1430 &frame));
1431 size_t consumed = frame.stream_frame.data_length;
1432 // The entire payload could not be consumed.
1433 EXPECT_GT(payload_length, consumed);
1434 creator_.FlushCurrentPacket();
1435 DeleteSerializedPacket();
1436 }
1437
TEST_P(QuicPacketCreatorTest,AddFrameAndFlush)1438 TEST_P(QuicPacketCreatorTest, AddFrameAndFlush) {
1439 if (!GetParam().version_serialization) {
1440 creator_.StopSendingVersion();
1441 }
1442 const size_t max_plaintext_size =
1443 client_framer_.GetMaxPlaintextSize(creator_.max_packet_length());
1444 EXPECT_FALSE(creator_.HasPendingFrames());
1445 creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
1446 QuicStreamId stream_id = QuicUtils::GetFirstBidirectionalStreamId(
1447 client_framer_.transport_version(), Perspective::IS_CLIENT);
1448 if (!QuicVersionUsesCryptoFrames(client_framer_.transport_version())) {
1449 stream_id =
1450 QuicUtils::GetCryptoStreamId(client_framer_.transport_version());
1451 }
1452 EXPECT_FALSE(creator_.HasPendingStreamFramesOfStream(stream_id));
1453 EXPECT_EQ(max_plaintext_size -
1454 GetPacketHeaderSize(
1455 client_framer_.transport_version(),
1456 creator_.GetDestinationConnectionIdLength(),
1457 creator_.GetSourceConnectionIdLength(),
1458 QuicPacketCreatorPeer::SendVersionInPacket(&creator_),
1459 !kIncludeDiversificationNonce,
1460 QuicPacketCreatorPeer::GetPacketNumberLength(&creator_),
1461 QuicPacketCreatorPeer::GetRetryTokenLengthLength(&creator_),
1462 0, QuicPacketCreatorPeer::GetLengthLength(&creator_)),
1463 creator_.BytesFree());
1464 StrictMock<MockDebugDelegate> debug;
1465 creator_.set_debug_delegate(&debug);
1466
1467 // Add a variety of frame types and then a padding frame.
1468 QuicAckFrame ack_frame(InitAckFrame(10u));
1469 EXPECT_CALL(debug, OnFrameAddedToPacket(_));
1470 EXPECT_TRUE(creator_.AddFrame(QuicFrame(&ack_frame), NOT_RETRANSMISSION));
1471 EXPECT_TRUE(creator_.HasPendingFrames());
1472 EXPECT_FALSE(creator_.HasPendingStreamFramesOfStream(stream_id));
1473
1474 QuicFrame frame;
1475 const std::string data("test");
1476 EXPECT_CALL(debug, OnFrameAddedToPacket(_));
1477 ASSERT_TRUE(creator_.ConsumeDataToFillCurrentPacket(
1478 stream_id, data, 0u, false, false, NOT_RETRANSMISSION, &frame));
1479 size_t consumed = frame.stream_frame.data_length;
1480 EXPECT_EQ(4u, consumed);
1481 EXPECT_TRUE(creator_.HasPendingFrames());
1482 EXPECT_TRUE(creator_.HasPendingStreamFramesOfStream(stream_id));
1483
1484 QuicPaddingFrame padding_frame;
1485 EXPECT_CALL(debug, OnFrameAddedToPacket(_));
1486 EXPECT_TRUE(creator_.AddFrame(QuicFrame(padding_frame), NOT_RETRANSMISSION));
1487 EXPECT_TRUE(creator_.HasPendingFrames());
1488 EXPECT_EQ(0u, creator_.BytesFree());
1489
1490 // Packet is full. Creator will flush.
1491 EXPECT_CALL(delegate_, OnSerializedPacket(_))
1492 .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
1493 EXPECT_FALSE(creator_.AddFrame(QuicFrame(&ack_frame), NOT_RETRANSMISSION));
1494
1495 // Ensure the packet is successfully created.
1496 ASSERT_TRUE(serialized_packet_->encrypted_buffer);
1497 ASSERT_FALSE(serialized_packet_->retransmittable_frames.empty());
1498 const QuicFrames& retransmittable =
1499 serialized_packet_->retransmittable_frames;
1500 ASSERT_EQ(1u, retransmittable.size());
1501 EXPECT_EQ(STREAM_FRAME, retransmittable[0].type);
1502 EXPECT_TRUE(serialized_packet_->has_ack);
1503 EXPECT_EQ(QuicPacketNumber(10u), serialized_packet_->largest_acked);
1504 DeleteSerializedPacket();
1505
1506 EXPECT_FALSE(creator_.HasPendingFrames());
1507 EXPECT_FALSE(creator_.HasPendingStreamFramesOfStream(stream_id));
1508 EXPECT_EQ(max_plaintext_size -
1509 GetPacketHeaderSize(
1510 client_framer_.transport_version(),
1511 creator_.GetDestinationConnectionIdLength(),
1512 creator_.GetSourceConnectionIdLength(),
1513 QuicPacketCreatorPeer::SendVersionInPacket(&creator_),
1514 !kIncludeDiversificationNonce,
1515 QuicPacketCreatorPeer::GetPacketNumberLength(&creator_),
1516 QuicPacketCreatorPeer::GetRetryTokenLengthLength(&creator_),
1517 0, QuicPacketCreatorPeer::GetLengthLength(&creator_)),
1518 creator_.BytesFree());
1519 }
1520
TEST_P(QuicPacketCreatorTest,SerializeAndSendStreamFrame)1521 TEST_P(QuicPacketCreatorTest, SerializeAndSendStreamFrame) {
1522 creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
1523 if (!GetParam().version_serialization) {
1524 creator_.StopSendingVersion();
1525 }
1526 EXPECT_FALSE(creator_.HasPendingFrames());
1527
1528 const std::string data("test");
1529 producer_.SaveStreamData(GetNthClientInitiatedStreamId(0), data);
1530 EXPECT_CALL(delegate_, OnSerializedPacket(_))
1531 .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
1532 size_t num_bytes_consumed;
1533 StrictMock<MockDebugDelegate> debug;
1534 creator_.set_debug_delegate(&debug);
1535 EXPECT_CALL(debug, OnFrameAddedToPacket(_));
1536 creator_.CreateAndSerializeStreamFrame(
1537 GetNthClientInitiatedStreamId(0), data.length(), 0, 0, true,
1538 NOT_RETRANSMISSION, &num_bytes_consumed);
1539 EXPECT_EQ(4u, num_bytes_consumed);
1540
1541 // Ensure the packet is successfully created.
1542 ASSERT_TRUE(serialized_packet_->encrypted_buffer);
1543 ASSERT_FALSE(serialized_packet_->retransmittable_frames.empty());
1544 const QuicFrames& retransmittable =
1545 serialized_packet_->retransmittable_frames;
1546 ASSERT_EQ(1u, retransmittable.size());
1547 EXPECT_EQ(STREAM_FRAME, retransmittable[0].type);
1548 DeleteSerializedPacket();
1549
1550 EXPECT_FALSE(creator_.HasPendingFrames());
1551 }
1552
TEST_P(QuicPacketCreatorTest,SerializeStreamFrameWithPadding)1553 TEST_P(QuicPacketCreatorTest, SerializeStreamFrameWithPadding) {
1554 // Regression test to check that CreateAndSerializeStreamFrame uses a
1555 // correctly formatted stream frame header when appending padding.
1556
1557 creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
1558 if (!GetParam().version_serialization) {
1559 creator_.StopSendingVersion();
1560 }
1561 EXPECT_FALSE(creator_.HasPendingFrames());
1562
1563 // Send zero bytes of stream data. This requires padding.
1564 EXPECT_CALL(delegate_, OnSerializedPacket(_))
1565 .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
1566 size_t num_bytes_consumed;
1567 creator_.CreateAndSerializeStreamFrame(GetNthClientInitiatedStreamId(0), 0, 0,
1568 0, true, NOT_RETRANSMISSION,
1569 &num_bytes_consumed);
1570 EXPECT_EQ(0u, num_bytes_consumed);
1571
1572 // Check that a packet is created.
1573 ASSERT_TRUE(serialized_packet_->encrypted_buffer);
1574 ASSERT_FALSE(serialized_packet_->retransmittable_frames.empty());
1575 ASSERT_EQ(serialized_packet_->packet_number_length,
1576 PACKET_1BYTE_PACKET_NUMBER);
1577 {
1578 InSequence s;
1579 EXPECT_CALL(framer_visitor_, OnPacket());
1580 EXPECT_CALL(framer_visitor_, OnUnauthenticatedPublicHeader(_));
1581 EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_));
1582 EXPECT_CALL(framer_visitor_, OnDecryptedPacket(_, _));
1583 EXPECT_CALL(framer_visitor_, OnPacketHeader(_));
1584 if (client_framer_.version().HasHeaderProtection()) {
1585 EXPECT_CALL(framer_visitor_, OnPaddingFrame(_));
1586 EXPECT_CALL(framer_visitor_, OnStreamFrame(_));
1587 } else {
1588 EXPECT_CALL(framer_visitor_, OnStreamFrame(_));
1589 }
1590 EXPECT_CALL(framer_visitor_, OnPacketComplete());
1591 }
1592 ProcessPacket(*serialized_packet_);
1593 }
1594
TEST_P(QuicPacketCreatorTest,AddUnencryptedStreamDataClosesConnection)1595 TEST_P(QuicPacketCreatorTest, AddUnencryptedStreamDataClosesConnection) {
1596 // EXPECT_QUIC_BUG tests are expensive so only run one instance of them.
1597 if (!IsDefaultTestConfiguration()) {
1598 return;
1599 }
1600
1601 creator_.set_encryption_level(ENCRYPTION_INITIAL);
1602 QuicStreamFrame stream_frame(GetNthClientInitiatedStreamId(0),
1603 /*fin=*/false, 0u, absl::string_view());
1604 EXPECT_QUIC_BUG(
1605 {
1606 EXPECT_CALL(delegate_, OnUnrecoverableError(_, _));
1607 creator_.AddFrame(QuicFrame(stream_frame), NOT_RETRANSMISSION);
1608 },
1609 "Cannot send stream data with level: ENCRYPTION_INITIAL");
1610 }
1611
TEST_P(QuicPacketCreatorTest,SendStreamDataWithEncryptionHandshake)1612 TEST_P(QuicPacketCreatorTest, SendStreamDataWithEncryptionHandshake) {
1613 // EXPECT_QUIC_BUG tests are expensive so only run one instance of them.
1614 if (!IsDefaultTestConfiguration()) {
1615 return;
1616 }
1617
1618 creator_.set_encryption_level(ENCRYPTION_HANDSHAKE);
1619 QuicStreamFrame stream_frame(GetNthClientInitiatedStreamId(0),
1620 /*fin=*/false, 0u, absl::string_view());
1621 EXPECT_QUIC_BUG(
1622 {
1623 EXPECT_CALL(delegate_, OnUnrecoverableError(_, _));
1624 creator_.AddFrame(QuicFrame(stream_frame), NOT_RETRANSMISSION);
1625 },
1626 "Cannot send stream data with level: ENCRYPTION_HANDSHAKE");
1627 }
1628
TEST_P(QuicPacketCreatorTest,ChloTooLarge)1629 TEST_P(QuicPacketCreatorTest, ChloTooLarge) {
1630 // EXPECT_QUIC_BUG tests are expensive so only run one instance of them.
1631 if (!IsDefaultTestConfiguration()) {
1632 return;
1633 }
1634
1635 // This test only matters when the crypto handshake is sent in stream frames.
1636 // TODO(b/128596274): Re-enable when this check is supported for CRYPTO
1637 // frames.
1638 if (QuicVersionUsesCryptoFrames(client_framer_.transport_version())) {
1639 return;
1640 }
1641
1642 CryptoHandshakeMessage message;
1643 message.set_tag(kCHLO);
1644 message.set_minimum_size(kMaxOutgoingPacketSize);
1645 CryptoFramer framer;
1646 std::unique_ptr<QuicData> message_data;
1647 message_data = framer.ConstructHandshakeMessage(message);
1648
1649 QuicFrame frame;
1650 EXPECT_CALL(delegate_, OnUnrecoverableError(QUIC_CRYPTO_CHLO_TOO_LARGE, _));
1651 EXPECT_QUIC_BUG(
1652 creator_.ConsumeDataToFillCurrentPacket(
1653 QuicUtils::GetCryptoStreamId(client_framer_.transport_version()),
1654 absl::string_view(message_data->data(), message_data->length()), 0u,
1655 false, false, NOT_RETRANSMISSION, &frame),
1656 "Client hello won't fit in a single packet.");
1657 }
1658
TEST_P(QuicPacketCreatorTest,PendingPadding)1659 TEST_P(QuicPacketCreatorTest, PendingPadding) {
1660 EXPECT_EQ(0u, creator_.pending_padding_bytes());
1661 creator_.AddPendingPadding(kMaxNumRandomPaddingBytes * 10);
1662 EXPECT_EQ(kMaxNumRandomPaddingBytes * 10, creator_.pending_padding_bytes());
1663
1664 EXPECT_CALL(delegate_, OnSerializedPacket(_))
1665 .WillRepeatedly(
1666 Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
1667 // Flush all paddings.
1668 while (creator_.pending_padding_bytes() > 0) {
1669 creator_.FlushCurrentPacket();
1670 {
1671 InSequence s;
1672 EXPECT_CALL(framer_visitor_, OnPacket());
1673 EXPECT_CALL(framer_visitor_, OnUnauthenticatedPublicHeader(_));
1674 EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_));
1675 EXPECT_CALL(framer_visitor_, OnDecryptedPacket(_, _));
1676 EXPECT_CALL(framer_visitor_, OnPacketHeader(_));
1677 EXPECT_CALL(framer_visitor_, OnPaddingFrame(_));
1678 EXPECT_CALL(framer_visitor_, OnPacketComplete());
1679 }
1680 // Packet only contains padding.
1681 ProcessPacket(*serialized_packet_);
1682 }
1683 EXPECT_EQ(0u, creator_.pending_padding_bytes());
1684 }
1685
TEST_P(QuicPacketCreatorTest,FullPaddingDoesNotConsumePendingPadding)1686 TEST_P(QuicPacketCreatorTest, FullPaddingDoesNotConsumePendingPadding) {
1687 creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
1688 creator_.AddPendingPadding(kMaxNumRandomPaddingBytes);
1689 QuicFrame frame;
1690 QuicStreamId stream_id = QuicUtils::GetFirstBidirectionalStreamId(
1691 client_framer_.transport_version(), Perspective::IS_CLIENT);
1692 const std::string data("test");
1693 ASSERT_TRUE(creator_.ConsumeDataToFillCurrentPacket(
1694 stream_id, data, 0u, false,
1695 /*needs_full_padding=*/true, NOT_RETRANSMISSION, &frame));
1696 EXPECT_CALL(delegate_, OnSerializedPacket(_))
1697 .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
1698 creator_.FlushCurrentPacket();
1699 EXPECT_EQ(kMaxNumRandomPaddingBytes, creator_.pending_padding_bytes());
1700 }
1701
TEST_P(QuicPacketCreatorTest,ConsumeDataAndRandomPadding)1702 TEST_P(QuicPacketCreatorTest, ConsumeDataAndRandomPadding) {
1703 creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
1704 const QuicByteCount kStreamFramePayloadSize = 100u;
1705 // Set the packet size be enough for one stream frame with 0 stream offset +
1706 // 1.
1707 QuicStreamId stream_id = QuicUtils::GetFirstBidirectionalStreamId(
1708 client_framer_.transport_version(), Perspective::IS_CLIENT);
1709 size_t length =
1710 GetPacketHeaderOverhead(client_framer_.transport_version()) +
1711 GetEncryptionOverhead() +
1712 QuicFramer::GetMinStreamFrameSize(
1713 client_framer_.transport_version(), stream_id, 0,
1714 /*last_frame_in_packet=*/true, kStreamFramePayloadSize + 1) +
1715 kStreamFramePayloadSize + 1;
1716 creator_.SetMaxPacketLength(length);
1717 creator_.AddPendingPadding(kMaxNumRandomPaddingBytes);
1718 QuicByteCount pending_padding_bytes = creator_.pending_padding_bytes();
1719 QuicFrame frame;
1720 char buf[kStreamFramePayloadSize + 1] = {};
1721 EXPECT_CALL(delegate_, OnSerializedPacket(_))
1722 .WillRepeatedly(
1723 Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
1724 // Send stream frame of size kStreamFramePayloadSize.
1725 creator_.ConsumeDataToFillCurrentPacket(
1726 stream_id, absl::string_view(buf, kStreamFramePayloadSize), 0u, false,
1727 false, NOT_RETRANSMISSION, &frame);
1728 creator_.FlushCurrentPacket();
1729 // 1 byte padding is sent.
1730 EXPECT_EQ(pending_padding_bytes - 1, creator_.pending_padding_bytes());
1731 // Send stream frame of size kStreamFramePayloadSize + 1.
1732 creator_.ConsumeDataToFillCurrentPacket(
1733 stream_id, absl::string_view(buf, kStreamFramePayloadSize + 1),
1734 kStreamFramePayloadSize, false, false, NOT_RETRANSMISSION, &frame);
1735 // No padding is sent.
1736 creator_.FlushCurrentPacket();
1737 EXPECT_EQ(pending_padding_bytes - 1, creator_.pending_padding_bytes());
1738 // Flush all paddings.
1739 while (creator_.pending_padding_bytes() > 0) {
1740 creator_.FlushCurrentPacket();
1741 }
1742 EXPECT_EQ(0u, creator_.pending_padding_bytes());
1743 }
1744
TEST_P(QuicPacketCreatorTest,FlushWithExternalBuffer)1745 TEST_P(QuicPacketCreatorTest, FlushWithExternalBuffer) {
1746 creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
1747 char* buffer = new char[kMaxOutgoingPacketSize];
1748 QuicPacketBuffer external_buffer = {buffer,
1749 [](const char* p) { delete[] p; }};
1750 EXPECT_CALL(delegate_, GetPacketBuffer()).WillOnce(Return(external_buffer));
1751
1752 QuicFrame frame;
1753 QuicStreamId stream_id = QuicUtils::GetFirstBidirectionalStreamId(
1754 client_framer_.transport_version(), Perspective::IS_CLIENT);
1755 const std::string data("test");
1756 ASSERT_TRUE(creator_.ConsumeDataToFillCurrentPacket(
1757 stream_id, data, 0u, false,
1758 /*needs_full_padding=*/true, NOT_RETRANSMISSION, &frame));
1759
1760 EXPECT_CALL(delegate_, OnSerializedPacket(_))
1761 .WillOnce(Invoke([&external_buffer](SerializedPacket serialized_packet) {
1762 EXPECT_EQ(external_buffer.buffer, serialized_packet.encrypted_buffer);
1763 }));
1764 creator_.FlushCurrentPacket();
1765 }
1766
1767 // Test for error found in
1768 // https://bugs.chromium.org/p/chromium/issues/detail?id=859949 where a gap
1769 // length that crosses an IETF VarInt length boundary would cause a
1770 // failure. While this test is not applicable to versions other than version 99,
1771 // it should still work. Hence, it is not made version-specific.
TEST_P(QuicPacketCreatorTest,IetfAckGapErrorRegression)1772 TEST_P(QuicPacketCreatorTest, IetfAckGapErrorRegression) {
1773 QuicAckFrame ack_frame =
1774 InitAckFrame({{QuicPacketNumber(60), QuicPacketNumber(61)},
1775 {QuicPacketNumber(125), QuicPacketNumber(126)}});
1776 frames_.push_back(QuicFrame(&ack_frame));
1777 SerializeAllFrames(frames_);
1778 }
1779
TEST_P(QuicPacketCreatorTest,AddMessageFrame)1780 TEST_P(QuicPacketCreatorTest, AddMessageFrame) {
1781 if (client_framer_.version().UsesTls()) {
1782 creator_.SetMaxDatagramFrameSize(kMaxAcceptedDatagramFrameSize);
1783 }
1784 creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
1785 EXPECT_CALL(delegate_, OnSerializedPacket(_))
1786 .Times(3)
1787 .WillRepeatedly(
1788 Invoke(this, &QuicPacketCreatorTest::ClearSerializedPacketForTests));
1789 // Verify that there is enough room for the largest message payload.
1790 EXPECT_TRUE(creator_.HasRoomForMessageFrame(
1791 creator_.GetCurrentLargestMessagePayload()));
1792 std::string large_message(creator_.GetCurrentLargestMessagePayload(), 'a');
1793 QuicMessageFrame* message_frame =
1794 new QuicMessageFrame(1, MemSliceFromString(large_message));
1795 EXPECT_TRUE(creator_.AddFrame(QuicFrame(message_frame), NOT_RETRANSMISSION));
1796 EXPECT_TRUE(creator_.HasPendingFrames());
1797 creator_.FlushCurrentPacket();
1798
1799 QuicMessageFrame* frame2 =
1800 new QuicMessageFrame(2, MemSliceFromString("message"));
1801 EXPECT_TRUE(creator_.AddFrame(QuicFrame(frame2), NOT_RETRANSMISSION));
1802 EXPECT_TRUE(creator_.HasPendingFrames());
1803 // Verify if a new frame is added, 1 byte message length will be added.
1804 EXPECT_EQ(1u, creator_.ExpansionOnNewFrame());
1805 QuicMessageFrame* frame3 =
1806 new QuicMessageFrame(3, MemSliceFromString("message2"));
1807 EXPECT_TRUE(creator_.AddFrame(QuicFrame(frame3), NOT_RETRANSMISSION));
1808 EXPECT_EQ(1u, creator_.ExpansionOnNewFrame());
1809 creator_.FlushCurrentPacket();
1810
1811 QuicFrame frame;
1812 QuicStreamId stream_id = QuicUtils::GetFirstBidirectionalStreamId(
1813 client_framer_.transport_version(), Perspective::IS_CLIENT);
1814 const std::string data("test");
1815 EXPECT_TRUE(creator_.ConsumeDataToFillCurrentPacket(
1816 stream_id, data, 0u, false, false, NOT_RETRANSMISSION, &frame));
1817 QuicMessageFrame* frame4 =
1818 new QuicMessageFrame(4, MemSliceFromString("message"));
1819 EXPECT_TRUE(creator_.AddFrame(QuicFrame(frame4), NOT_RETRANSMISSION));
1820 EXPECT_TRUE(creator_.HasPendingFrames());
1821 // Verify there is not enough room for largest payload.
1822 EXPECT_FALSE(creator_.HasRoomForMessageFrame(
1823 creator_.GetCurrentLargestMessagePayload()));
1824 // Add largest message will causes the flush of the stream frame.
1825 QuicMessageFrame frame5(5, MemSliceFromString(large_message));
1826 EXPECT_FALSE(creator_.AddFrame(QuicFrame(&frame5), NOT_RETRANSMISSION));
1827 EXPECT_FALSE(creator_.HasPendingFrames());
1828 }
1829
TEST_P(QuicPacketCreatorTest,MessageFrameConsumption)1830 TEST_P(QuicPacketCreatorTest, MessageFrameConsumption) {
1831 if (client_framer_.version().UsesTls()) {
1832 creator_.SetMaxDatagramFrameSize(kMaxAcceptedDatagramFrameSize);
1833 }
1834 std::string message_data(kDefaultMaxPacketSize, 'a');
1835 // Test all possible encryption levels of message frames.
1836 for (EncryptionLevel level :
1837 {ENCRYPTION_ZERO_RTT, ENCRYPTION_FORWARD_SECURE}) {
1838 creator_.set_encryption_level(level);
1839 // Test all possible sizes of message frames.
1840 for (size_t message_size = 0;
1841 message_size <= creator_.GetCurrentLargestMessagePayload();
1842 ++message_size) {
1843 QuicMessageFrame* frame =
1844 new QuicMessageFrame(0, MemSliceFromString(absl::string_view(
1845 message_data.data(), message_size)));
1846 EXPECT_TRUE(creator_.AddFrame(QuicFrame(frame), NOT_RETRANSMISSION));
1847 EXPECT_TRUE(creator_.HasPendingFrames());
1848
1849 size_t expansion_bytes = message_size >= 64 ? 2 : 1;
1850 EXPECT_EQ(expansion_bytes, creator_.ExpansionOnNewFrame());
1851 // Verify BytesFree returns bytes available for the next frame, which
1852 // should subtract the message length.
1853 size_t expected_bytes_free =
1854 creator_.GetCurrentLargestMessagePayload() - message_size <
1855 expansion_bytes
1856 ? 0
1857 : creator_.GetCurrentLargestMessagePayload() - expansion_bytes -
1858 message_size;
1859 EXPECT_EQ(expected_bytes_free, creator_.BytesFree());
1860 EXPECT_LE(creator_.GetGuaranteedLargestMessagePayload(),
1861 creator_.GetCurrentLargestMessagePayload());
1862 EXPECT_CALL(delegate_, OnSerializedPacket(_))
1863 .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
1864 creator_.FlushCurrentPacket();
1865 ASSERT_TRUE(serialized_packet_->encrypted_buffer);
1866 DeleteSerializedPacket();
1867 }
1868 }
1869 }
1870
TEST_P(QuicPacketCreatorTest,GetGuaranteedLargestMessagePayload)1871 TEST_P(QuicPacketCreatorTest, GetGuaranteedLargestMessagePayload) {
1872 ParsedQuicVersion version = GetParam().version;
1873 if (version.UsesTls()) {
1874 creator_.SetMaxDatagramFrameSize(kMaxAcceptedDatagramFrameSize);
1875 }
1876 QuicPacketLength expected_largest_payload = 1215;
1877 if (version.HasLongHeaderLengths()) {
1878 expected_largest_payload -= 2;
1879 }
1880 if (version.HasLengthPrefixedConnectionIds()) {
1881 expected_largest_payload -= 1;
1882 }
1883 EXPECT_EQ(expected_largest_payload,
1884 creator_.GetGuaranteedLargestMessagePayload());
1885 EXPECT_TRUE(creator_.HasRoomForMessageFrame(
1886 creator_.GetGuaranteedLargestMessagePayload()));
1887
1888 // Now test whether SetMaxDatagramFrameSize works.
1889 creator_.SetMaxDatagramFrameSize(expected_largest_payload + 1 +
1890 kQuicFrameTypeSize);
1891 EXPECT_EQ(expected_largest_payload,
1892 creator_.GetGuaranteedLargestMessagePayload());
1893 EXPECT_TRUE(creator_.HasRoomForMessageFrame(
1894 creator_.GetGuaranteedLargestMessagePayload()));
1895
1896 creator_.SetMaxDatagramFrameSize(expected_largest_payload +
1897 kQuicFrameTypeSize);
1898 EXPECT_EQ(expected_largest_payload,
1899 creator_.GetGuaranteedLargestMessagePayload());
1900 EXPECT_TRUE(creator_.HasRoomForMessageFrame(
1901 creator_.GetGuaranteedLargestMessagePayload()));
1902
1903 creator_.SetMaxDatagramFrameSize(expected_largest_payload - 1 +
1904 kQuicFrameTypeSize);
1905 EXPECT_EQ(expected_largest_payload - 1,
1906 creator_.GetGuaranteedLargestMessagePayload());
1907 EXPECT_TRUE(creator_.HasRoomForMessageFrame(
1908 creator_.GetGuaranteedLargestMessagePayload()));
1909
1910 constexpr QuicPacketLength kFrameSizeLimit = 1000;
1911 constexpr QuicPacketLength kPayloadSizeLimit =
1912 kFrameSizeLimit - kQuicFrameTypeSize;
1913 creator_.SetMaxDatagramFrameSize(kFrameSizeLimit);
1914 EXPECT_EQ(creator_.GetGuaranteedLargestMessagePayload(), kPayloadSizeLimit);
1915 EXPECT_TRUE(creator_.HasRoomForMessageFrame(kPayloadSizeLimit));
1916 EXPECT_FALSE(creator_.HasRoomForMessageFrame(kPayloadSizeLimit + 1));
1917 }
1918
TEST_P(QuicPacketCreatorTest,GetCurrentLargestMessagePayload)1919 TEST_P(QuicPacketCreatorTest, GetCurrentLargestMessagePayload) {
1920 ParsedQuicVersion version = GetParam().version;
1921 if (version.UsesTls()) {
1922 creator_.SetMaxDatagramFrameSize(kMaxAcceptedDatagramFrameSize);
1923 }
1924 QuicPacketLength expected_largest_payload = 1215;
1925 if (version.SendsVariableLengthPacketNumberInLongHeader()) {
1926 expected_largest_payload += 3;
1927 }
1928 if (version.HasLongHeaderLengths()) {
1929 expected_largest_payload -= 2;
1930 }
1931 if (version.HasLengthPrefixedConnectionIds()) {
1932 expected_largest_payload -= 1;
1933 }
1934 EXPECT_EQ(expected_largest_payload,
1935 creator_.GetCurrentLargestMessagePayload());
1936
1937 // Now test whether SetMaxDatagramFrameSize works.
1938 creator_.SetMaxDatagramFrameSize(expected_largest_payload + 1 +
1939 kQuicFrameTypeSize);
1940 EXPECT_EQ(expected_largest_payload,
1941 creator_.GetCurrentLargestMessagePayload());
1942
1943 creator_.SetMaxDatagramFrameSize(expected_largest_payload +
1944 kQuicFrameTypeSize);
1945 EXPECT_EQ(expected_largest_payload,
1946 creator_.GetCurrentLargestMessagePayload());
1947
1948 creator_.SetMaxDatagramFrameSize(expected_largest_payload - 1 +
1949 kQuicFrameTypeSize);
1950 EXPECT_EQ(expected_largest_payload - 1,
1951 creator_.GetCurrentLargestMessagePayload());
1952 }
1953
TEST_P(QuicPacketCreatorTest,PacketTransmissionType)1954 TEST_P(QuicPacketCreatorTest, PacketTransmissionType) {
1955 creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
1956
1957 QuicAckFrame temp_ack_frame = InitAckFrame(1);
1958 QuicFrame ack_frame(&temp_ack_frame);
1959 ASSERT_FALSE(QuicUtils::IsRetransmittableFrame(ack_frame.type));
1960
1961 QuicStreamId stream_id = QuicUtils::GetFirstBidirectionalStreamId(
1962 client_framer_.transport_version(), Perspective::IS_CLIENT);
1963 QuicFrame stream_frame(QuicStreamFrame(stream_id,
1964 /*fin=*/false, 0u,
1965 absl::string_view()));
1966 ASSERT_TRUE(QuicUtils::IsRetransmittableFrame(stream_frame.type));
1967
1968 QuicFrame stream_frame_2(QuicStreamFrame(stream_id,
1969 /*fin=*/false, 1u,
1970 absl::string_view()));
1971
1972 QuicFrame padding_frame{QuicPaddingFrame()};
1973 ASSERT_FALSE(QuicUtils::IsRetransmittableFrame(padding_frame.type));
1974
1975 EXPECT_CALL(delegate_, OnSerializedPacket(_))
1976 .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
1977
1978 EXPECT_TRUE(creator_.AddFrame(ack_frame, LOSS_RETRANSMISSION));
1979 ASSERT_EQ(serialized_packet_, nullptr);
1980
1981 EXPECT_TRUE(creator_.AddFrame(stream_frame, PTO_RETRANSMISSION));
1982 ASSERT_EQ(serialized_packet_, nullptr);
1983
1984 EXPECT_TRUE(creator_.AddFrame(stream_frame_2, PATH_RETRANSMISSION));
1985 ASSERT_EQ(serialized_packet_, nullptr);
1986
1987 EXPECT_TRUE(creator_.AddFrame(padding_frame, PTO_RETRANSMISSION));
1988 creator_.FlushCurrentPacket();
1989 ASSERT_TRUE(serialized_packet_->encrypted_buffer);
1990
1991 // The last retransmittable frame on packet is a stream frame, the packet's
1992 // transmission type should be the same as the stream frame's.
1993 EXPECT_EQ(serialized_packet_->transmission_type, PATH_RETRANSMISSION);
1994 DeleteSerializedPacket();
1995 }
1996
TEST_P(QuicPacketCreatorTest,PacketBytesRetransmitted_AddFrame_Retransmission)1997 TEST_P(QuicPacketCreatorTest,
1998 PacketBytesRetransmitted_AddFrame_Retransmission) {
1999 creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
2000
2001 QuicAckFrame temp_ack_frame = InitAckFrame(1);
2002 QuicFrame ack_frame(&temp_ack_frame);
2003 EXPECT_TRUE(creator_.AddFrame(ack_frame, LOSS_RETRANSMISSION));
2004
2005 QuicStreamId stream_id = QuicUtils::GetFirstBidirectionalStreamId(
2006 client_framer_.transport_version(), Perspective::IS_CLIENT);
2007
2008 QuicFrame stream_frame;
2009 const std::string data("data");
2010 // ConsumeDataToFillCurrentPacket calls AddFrame
2011 ASSERT_TRUE(creator_.ConsumeDataToFillCurrentPacket(
2012 stream_id, data, 0u, false, false, PTO_RETRANSMISSION, &stream_frame));
2013 EXPECT_EQ(4u, stream_frame.stream_frame.data_length);
2014
2015 EXPECT_CALL(delegate_, OnSerializedPacket(_))
2016 .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
2017
2018 creator_.FlushCurrentPacket();
2019 ASSERT_TRUE(serialized_packet_->encrypted_buffer);
2020 ASSERT_FALSE(serialized_packet_->bytes_not_retransmitted.has_value());
2021
2022 DeleteSerializedPacket();
2023 }
2024
TEST_P(QuicPacketCreatorTest,PacketBytesRetransmitted_AddFrame_NotRetransmission)2025 TEST_P(QuicPacketCreatorTest,
2026 PacketBytesRetransmitted_AddFrame_NotRetransmission) {
2027 creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
2028
2029 QuicAckFrame temp_ack_frame = InitAckFrame(1);
2030 QuicFrame ack_frame(&temp_ack_frame);
2031 EXPECT_TRUE(creator_.AddFrame(ack_frame, NOT_RETRANSMISSION));
2032
2033 QuicStreamId stream_id = QuicUtils::GetFirstBidirectionalStreamId(
2034 client_framer_.transport_version(), Perspective::IS_CLIENT);
2035
2036 QuicFrame stream_frame;
2037 const std::string data("data");
2038 // ConsumeDataToFillCurrentPacket calls AddFrame
2039 ASSERT_TRUE(creator_.ConsumeDataToFillCurrentPacket(
2040 stream_id, data, 0u, false, false, NOT_RETRANSMISSION, &stream_frame));
2041 EXPECT_EQ(4u, stream_frame.stream_frame.data_length);
2042
2043 EXPECT_CALL(delegate_, OnSerializedPacket(_))
2044 .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
2045
2046 creator_.FlushCurrentPacket();
2047 ASSERT_TRUE(serialized_packet_->encrypted_buffer);
2048 ASSERT_FALSE(serialized_packet_->bytes_not_retransmitted.has_value());
2049
2050 DeleteSerializedPacket();
2051 }
2052
TEST_P(QuicPacketCreatorTest,PacketBytesRetransmitted_AddFrame_MixedFrames)2053 TEST_P(QuicPacketCreatorTest, PacketBytesRetransmitted_AddFrame_MixedFrames) {
2054 creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
2055
2056 QuicAckFrame temp_ack_frame = InitAckFrame(1);
2057 QuicFrame ack_frame(&temp_ack_frame);
2058 EXPECT_TRUE(creator_.AddFrame(ack_frame, NOT_RETRANSMISSION));
2059
2060 QuicStreamId stream_id = QuicUtils::GetFirstBidirectionalStreamId(
2061 client_framer_.transport_version(), Perspective::IS_CLIENT);
2062
2063 QuicFrame stream_frame;
2064 const std::string data("data");
2065 // ConsumeDataToFillCurrentPacket calls AddFrame
2066 ASSERT_TRUE(creator_.ConsumeDataToFillCurrentPacket(
2067 stream_id, data, 0u, false, false, NOT_RETRANSMISSION, &stream_frame));
2068 EXPECT_EQ(4u, stream_frame.stream_frame.data_length);
2069
2070 QuicFrame stream_frame2;
2071 // ConsumeDataToFillCurrentPacket calls AddFrame
2072 ASSERT_TRUE(creator_.ConsumeDataToFillCurrentPacket(
2073 stream_id, data, 0u, false, false, LOSS_RETRANSMISSION, &stream_frame2));
2074 EXPECT_EQ(4u, stream_frame2.stream_frame.data_length);
2075
2076 EXPECT_CALL(delegate_, OnSerializedPacket(_))
2077 .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
2078
2079 creator_.FlushCurrentPacket();
2080 ASSERT_TRUE(serialized_packet_->encrypted_buffer);
2081 ASSERT_TRUE(serialized_packet_->bytes_not_retransmitted.has_value());
2082 ASSERT_GE(serialized_packet_->bytes_not_retransmitted.value(), 4u);
2083
2084 DeleteSerializedPacket();
2085 }
2086
TEST_P(QuicPacketCreatorTest,PacketBytesRetransmitted_CreateAndSerializeStreamFrame_Retransmission)2087 TEST_P(QuicPacketCreatorTest,
2088 PacketBytesRetransmitted_CreateAndSerializeStreamFrame_Retransmission) {
2089 creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
2090
2091 const std::string data("test");
2092 producer_.SaveStreamData(GetNthClientInitiatedStreamId(0), data);
2093 EXPECT_CALL(delegate_, OnSerializedPacket(_))
2094 .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
2095 size_t num_bytes_consumed;
2096 // Retransmission frame adds to packet's bytes_retransmitted
2097 creator_.CreateAndSerializeStreamFrame(
2098 GetNthClientInitiatedStreamId(0), data.length(), 0, 0, true,
2099 LOSS_RETRANSMISSION, &num_bytes_consumed);
2100 EXPECT_EQ(4u, num_bytes_consumed);
2101
2102 ASSERT_TRUE(serialized_packet_->encrypted_buffer);
2103 ASSERT_FALSE(serialized_packet_->bytes_not_retransmitted.has_value());
2104 DeleteSerializedPacket();
2105
2106 EXPECT_FALSE(creator_.HasPendingFrames());
2107 }
2108
TEST_P(QuicPacketCreatorTest,PacketBytesRetransmitted_CreateAndSerializeStreamFrame_NotRetransmission)2109 TEST_P(
2110 QuicPacketCreatorTest,
2111 PacketBytesRetransmitted_CreateAndSerializeStreamFrame_NotRetransmission) {
2112 creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
2113
2114 const std::string data("test");
2115 producer_.SaveStreamData(GetNthClientInitiatedStreamId(0), data);
2116 EXPECT_CALL(delegate_, OnSerializedPacket(_))
2117 .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
2118 size_t num_bytes_consumed;
2119 // Non-retransmission frame does not add to packet's bytes_retransmitted
2120 creator_.CreateAndSerializeStreamFrame(
2121 GetNthClientInitiatedStreamId(0), data.length(), 0, 0, true,
2122 NOT_RETRANSMISSION, &num_bytes_consumed);
2123 EXPECT_EQ(4u, num_bytes_consumed);
2124
2125 ASSERT_TRUE(serialized_packet_->encrypted_buffer);
2126 ASSERT_FALSE(serialized_packet_->bytes_not_retransmitted.has_value());
2127 DeleteSerializedPacket();
2128
2129 EXPECT_FALSE(creator_.HasPendingFrames());
2130 }
2131
TEST_P(QuicPacketCreatorTest,RetryToken)2132 TEST_P(QuicPacketCreatorTest, RetryToken) {
2133 if (!GetParam().version_serialization ||
2134 !QuicVersionHasLongHeaderLengths(client_framer_.transport_version())) {
2135 return;
2136 }
2137
2138 char retry_token_bytes[] = {1, 2, 3, 4, 5, 6, 7, 8,
2139 9, 10, 11, 12, 13, 14, 15, 16};
2140
2141 creator_.SetRetryToken(
2142 std::string(retry_token_bytes, sizeof(retry_token_bytes)));
2143
2144 frames_.push_back(QuicFrame(QuicPingFrame()));
2145 SerializedPacket serialized = SerializeAllFrames(frames_);
2146
2147 QuicPacketHeader header;
2148 {
2149 InSequence s;
2150 EXPECT_CALL(framer_visitor_, OnPacket());
2151 EXPECT_CALL(framer_visitor_, OnUnauthenticatedPublicHeader(_));
2152 EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_));
2153 EXPECT_CALL(framer_visitor_, OnDecryptedPacket(_, _));
2154 EXPECT_CALL(framer_visitor_, OnPacketHeader(_))
2155 .WillOnce(DoAll(SaveArg<0>(&header), Return(true)));
2156 if (client_framer_.version().HasHeaderProtection()) {
2157 EXPECT_CALL(framer_visitor_, OnPaddingFrame(_));
2158 }
2159 EXPECT_CALL(framer_visitor_, OnPingFrame(_));
2160 EXPECT_CALL(framer_visitor_, OnPacketComplete());
2161 }
2162 ProcessPacket(serialized);
2163 ASSERT_TRUE(header.version_flag);
2164 ASSERT_EQ(header.long_packet_type, INITIAL);
2165 ASSERT_EQ(header.retry_token.length(), sizeof(retry_token_bytes));
2166 quiche::test::CompareCharArraysWithHexError(
2167 "retry token", header.retry_token.data(), header.retry_token.length(),
2168 retry_token_bytes, sizeof(retry_token_bytes));
2169 }
2170
TEST_P(QuicPacketCreatorTest,GetConnectionId)2171 TEST_P(QuicPacketCreatorTest, GetConnectionId) {
2172 EXPECT_EQ(TestConnectionId(2), creator_.GetDestinationConnectionId());
2173 EXPECT_EQ(EmptyQuicConnectionId(), creator_.GetSourceConnectionId());
2174 }
2175
TEST_P(QuicPacketCreatorTest,ClientConnectionId)2176 TEST_P(QuicPacketCreatorTest, ClientConnectionId) {
2177 if (!client_framer_.version().SupportsClientConnectionIds()) {
2178 return;
2179 }
2180 EXPECT_EQ(TestConnectionId(2), creator_.GetDestinationConnectionId());
2181 EXPECT_EQ(EmptyQuicConnectionId(), creator_.GetSourceConnectionId());
2182 creator_.SetClientConnectionId(TestConnectionId(0x33));
2183 EXPECT_EQ(TestConnectionId(2), creator_.GetDestinationConnectionId());
2184 EXPECT_EQ(TestConnectionId(0x33), creator_.GetSourceConnectionId());
2185 }
2186
TEST_P(QuicPacketCreatorTest,CoalesceStreamFrames)2187 TEST_P(QuicPacketCreatorTest, CoalesceStreamFrames) {
2188 InSequence s;
2189 if (!GetParam().version_serialization) {
2190 creator_.StopSendingVersion();
2191 }
2192 const size_t max_plaintext_size =
2193 client_framer_.GetMaxPlaintextSize(creator_.max_packet_length());
2194 EXPECT_FALSE(creator_.HasPendingFrames());
2195 creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
2196 QuicStreamId stream_id1 = QuicUtils::GetFirstBidirectionalStreamId(
2197 client_framer_.transport_version(), Perspective::IS_CLIENT);
2198 QuicStreamId stream_id2 = GetNthClientInitiatedStreamId(1);
2199 EXPECT_FALSE(creator_.HasPendingStreamFramesOfStream(stream_id1));
2200 EXPECT_EQ(max_plaintext_size -
2201 GetPacketHeaderSize(
2202 client_framer_.transport_version(),
2203 creator_.GetDestinationConnectionIdLength(),
2204 creator_.GetSourceConnectionIdLength(),
2205 QuicPacketCreatorPeer::SendVersionInPacket(&creator_),
2206 !kIncludeDiversificationNonce,
2207 QuicPacketCreatorPeer::GetPacketNumberLength(&creator_),
2208 QuicPacketCreatorPeer::GetRetryTokenLengthLength(&creator_),
2209 0, QuicPacketCreatorPeer::GetLengthLength(&creator_)),
2210 creator_.BytesFree());
2211 StrictMock<MockDebugDelegate> debug;
2212 creator_.set_debug_delegate(&debug);
2213
2214 QuicFrame frame;
2215 const std::string data1("test");
2216 EXPECT_CALL(debug, OnFrameAddedToPacket(_));
2217 ASSERT_TRUE(creator_.ConsumeDataToFillCurrentPacket(
2218 stream_id1, data1, 0u, false, false, NOT_RETRANSMISSION, &frame));
2219 EXPECT_TRUE(creator_.HasPendingFrames());
2220 EXPECT_TRUE(creator_.HasPendingStreamFramesOfStream(stream_id1));
2221
2222 const std::string data2("coalesce");
2223 // frame will be coalesced with the first frame.
2224 const auto previous_size = creator_.PacketSize();
2225 QuicStreamFrame target(stream_id1, true, 0, data1.length() + data2.length());
2226 EXPECT_CALL(debug, OnStreamFrameCoalesced(target));
2227 ASSERT_TRUE(creator_.ConsumeDataToFillCurrentPacket(
2228 stream_id1, data2, 4u, true, false, NOT_RETRANSMISSION, &frame));
2229 EXPECT_EQ(frame.stream_frame.data_length,
2230 creator_.PacketSize() - previous_size);
2231
2232 // frame is for another stream, so it won't be coalesced.
2233 const auto length = creator_.BytesFree() - 10u;
2234 const std::string data3(length, 'x');
2235 EXPECT_CALL(debug, OnFrameAddedToPacket(_));
2236 ASSERT_TRUE(creator_.ConsumeDataToFillCurrentPacket(
2237 stream_id2, data3, 0u, false, false, NOT_RETRANSMISSION, &frame));
2238 EXPECT_TRUE(creator_.HasPendingStreamFramesOfStream(stream_id2));
2239
2240 // The packet doesn't have enough free bytes for all data, but will still be
2241 // able to consume and coalesce part of them.
2242 EXPECT_CALL(debug, OnStreamFrameCoalesced(_));
2243 const std::string data4("somerandomdata");
2244 ASSERT_TRUE(creator_.ConsumeDataToFillCurrentPacket(
2245 stream_id2, data4, length, false, false, NOT_RETRANSMISSION, &frame));
2246
2247 EXPECT_CALL(delegate_, OnSerializedPacket(_))
2248 .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
2249 creator_.FlushCurrentPacket();
2250 EXPECT_CALL(framer_visitor_, OnPacket());
2251 EXPECT_CALL(framer_visitor_, OnUnauthenticatedPublicHeader(_));
2252 EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_));
2253 EXPECT_CALL(framer_visitor_, OnDecryptedPacket(_, _));
2254 EXPECT_CALL(framer_visitor_, OnPacketHeader(_));
2255 // The packet should only have 2 stream frames.
2256 EXPECT_CALL(framer_visitor_, OnStreamFrame(_));
2257 EXPECT_CALL(framer_visitor_, OnStreamFrame(_));
2258 EXPECT_CALL(framer_visitor_, OnPacketComplete());
2259 ProcessPacket(*serialized_packet_);
2260 }
2261
TEST_P(QuicPacketCreatorTest,SaveNonRetransmittableFrames)2262 TEST_P(QuicPacketCreatorTest, SaveNonRetransmittableFrames) {
2263 QuicAckFrame ack_frame(InitAckFrame(1));
2264 frames_.push_back(QuicFrame(&ack_frame));
2265 frames_.push_back(QuicFrame(QuicPaddingFrame(-1)));
2266 SerializedPacket serialized = SerializeAllFrames(frames_);
2267 ASSERT_EQ(2u, serialized.nonretransmittable_frames.size());
2268 EXPECT_EQ(ACK_FRAME, serialized.nonretransmittable_frames[0].type);
2269 EXPECT_EQ(PADDING_FRAME, serialized.nonretransmittable_frames[1].type);
2270 // Verify full padding frame is translated to a padding frame with actual
2271 // bytes of padding.
2272 EXPECT_LT(
2273 0,
2274 serialized.nonretransmittable_frames[1].padding_frame.num_padding_bytes);
2275 frames_.clear();
2276
2277 // Serialize another packet with the same frames.
2278 SerializedPacket packet = QuicPacketCreatorPeer::SerializeAllFrames(
2279 &creator_, serialized.nonretransmittable_frames, buffer_,
2280 kMaxOutgoingPacketSize);
2281 // Verify the packet length of both packets are equal.
2282 EXPECT_EQ(serialized.encrypted_length, packet.encrypted_length);
2283 }
2284
TEST_P(QuicPacketCreatorTest,SerializeCoalescedPacket)2285 TEST_P(QuicPacketCreatorTest, SerializeCoalescedPacket) {
2286 QuicCoalescedPacket coalesced;
2287 quiche::SimpleBufferAllocator allocator;
2288 QuicSocketAddress self_address(QuicIpAddress::Loopback4(), 1);
2289 QuicSocketAddress peer_address(QuicIpAddress::Loopback4(), 2);
2290 for (size_t i = ENCRYPTION_INITIAL; i < NUM_ENCRYPTION_LEVELS; ++i) {
2291 EncryptionLevel level = static_cast<EncryptionLevel>(i);
2292 creator_.set_encryption_level(level);
2293 QuicAckFrame ack_frame(InitAckFrame(1));
2294 if (level != ENCRYPTION_ZERO_RTT) {
2295 frames_.push_back(QuicFrame(&ack_frame));
2296 }
2297 if (level != ENCRYPTION_INITIAL && level != ENCRYPTION_HANDSHAKE) {
2298 frames_.push_back(
2299 QuicFrame(QuicStreamFrame(1, false, 0u, absl::string_view())));
2300 }
2301 SerializedPacket serialized = SerializeAllFrames(frames_);
2302 EXPECT_EQ(level, serialized.encryption_level);
2303 frames_.clear();
2304 ASSERT_TRUE(coalesced.MaybeCoalescePacket(
2305 serialized, self_address, peer_address, &allocator,
2306 creator_.max_packet_length(), ECN_NOT_ECT));
2307 }
2308 char buffer[kMaxOutgoingPacketSize];
2309 size_t coalesced_length = creator_.SerializeCoalescedPacket(
2310 coalesced, buffer, kMaxOutgoingPacketSize);
2311 // Verify packet is padded to full.
2312 ASSERT_EQ(coalesced.max_packet_length(), coalesced_length);
2313 if (!QuicVersionHasLongHeaderLengths(server_framer_.transport_version())) {
2314 return;
2315 }
2316 // Verify packet process.
2317 std::unique_ptr<QuicEncryptedPacket> packets[NUM_ENCRYPTION_LEVELS];
2318 packets[ENCRYPTION_INITIAL] =
2319 std::make_unique<QuicEncryptedPacket>(buffer, coalesced_length);
2320 for (size_t i = ENCRYPTION_INITIAL; i < NUM_ENCRYPTION_LEVELS; ++i) {
2321 InSequence s;
2322 EXPECT_CALL(framer_visitor_, OnPacket());
2323 EXPECT_CALL(framer_visitor_, OnUnauthenticatedPublicHeader(_));
2324 if (i < ENCRYPTION_FORWARD_SECURE) {
2325 // Save coalesced packet.
2326 EXPECT_CALL(framer_visitor_, OnCoalescedPacket(_))
2327 .WillOnce(Invoke([i, &packets](const QuicEncryptedPacket& packet) {
2328 packets[i + 1] = packet.Clone();
2329 }));
2330 }
2331 EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_));
2332 EXPECT_CALL(framer_visitor_, OnDecryptedPacket(_, _));
2333 EXPECT_CALL(framer_visitor_, OnPacketHeader(_));
2334 if (i != ENCRYPTION_ZERO_RTT) {
2335 if (i != ENCRYPTION_INITIAL) {
2336 EXPECT_CALL(framer_visitor_, OnPaddingFrame(_))
2337 .Times(testing::AtMost(1));
2338 }
2339 EXPECT_CALL(framer_visitor_, OnAckFrameStart(_, _))
2340 .WillOnce(Return(true));
2341 EXPECT_CALL(framer_visitor_,
2342 OnAckRange(QuicPacketNumber(1), QuicPacketNumber(2)))
2343 .WillOnce(Return(true));
2344 EXPECT_CALL(framer_visitor_, OnAckFrameEnd(_, _)).WillOnce(Return(true));
2345 }
2346 if (i == ENCRYPTION_INITIAL) {
2347 // Verify padding is added.
2348 EXPECT_CALL(framer_visitor_, OnPaddingFrame(_));
2349 }
2350 if (i == ENCRYPTION_ZERO_RTT) {
2351 EXPECT_CALL(framer_visitor_, OnPaddingFrame(_));
2352 }
2353 if (i != ENCRYPTION_INITIAL && i != ENCRYPTION_HANDSHAKE) {
2354 EXPECT_CALL(framer_visitor_, OnStreamFrame(_));
2355 }
2356 EXPECT_CALL(framer_visitor_, OnPacketComplete());
2357 server_framer_.ProcessPacket(*packets[i]);
2358 }
2359 }
2360
TEST_P(QuicPacketCreatorTest,SoftMaxPacketLength)2361 TEST_P(QuicPacketCreatorTest, SoftMaxPacketLength) {
2362 creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
2363 QuicByteCount previous_max_packet_length = creator_.max_packet_length();
2364 const size_t overhead =
2365 GetPacketHeaderOverhead(client_framer_.transport_version()) +
2366 QuicPacketCreator::MinPlaintextPacketSize(
2367 client_framer_.version(),
2368 QuicPacketCreatorPeer::GetPacketNumberLength(&creator_)) +
2369 GetEncryptionOverhead();
2370 // Make sure a length which cannot accommodate header (includes header
2371 // protection minimal length) gets rejected.
2372 creator_.SetSoftMaxPacketLength(overhead - 1);
2373 EXPECT_EQ(previous_max_packet_length, creator_.max_packet_length());
2374
2375 creator_.SetSoftMaxPacketLength(overhead);
2376 EXPECT_EQ(overhead, creator_.max_packet_length());
2377
2378 // Verify creator has room for stream frame because max_packet_length_ gets
2379 // restored.
2380 ASSERT_TRUE(creator_.HasRoomForStreamFrame(
2381 GetNthClientInitiatedStreamId(1), kMaxIetfVarInt,
2382 std::numeric_limits<uint32_t>::max()));
2383 EXPECT_EQ(previous_max_packet_length, creator_.max_packet_length());
2384
2385 // Same for message frame.
2386 creator_.SetSoftMaxPacketLength(overhead);
2387 if (client_framer_.version().UsesTls()) {
2388 creator_.SetMaxDatagramFrameSize(kMaxAcceptedDatagramFrameSize);
2389 }
2390 // Verify GetCurrentLargestMessagePayload is based on the actual
2391 // max_packet_length.
2392 EXPECT_LT(1u, creator_.GetCurrentLargestMessagePayload());
2393 EXPECT_EQ(overhead, creator_.max_packet_length());
2394 ASSERT_TRUE(creator_.HasRoomForMessageFrame(
2395 creator_.GetCurrentLargestMessagePayload()));
2396 EXPECT_EQ(previous_max_packet_length, creator_.max_packet_length());
2397
2398 // Verify creator can consume crypto data because max_packet_length_ gets
2399 // restored.
2400 creator_.SetSoftMaxPacketLength(overhead);
2401 EXPECT_EQ(overhead, creator_.max_packet_length());
2402 const std::string data = "crypto data";
2403 QuicFrame frame;
2404 if (!QuicVersionUsesCryptoFrames(client_framer_.transport_version())) {
2405 ASSERT_TRUE(creator_.ConsumeDataToFillCurrentPacket(
2406 QuicUtils::GetCryptoStreamId(client_framer_.transport_version()), data,
2407 kOffset, false, true, NOT_RETRANSMISSION, &frame));
2408 size_t bytes_consumed = frame.stream_frame.data_length;
2409 EXPECT_LT(0u, bytes_consumed);
2410 } else {
2411 producer_.SaveCryptoData(ENCRYPTION_INITIAL, kOffset, data);
2412 ASSERT_TRUE(creator_.ConsumeCryptoDataToFillCurrentPacket(
2413 ENCRYPTION_INITIAL, data.length(), kOffset,
2414 /*needs_full_padding=*/true, NOT_RETRANSMISSION, &frame));
2415 size_t bytes_consumed = frame.crypto_frame->data_length;
2416 EXPECT_LT(0u, bytes_consumed);
2417 }
2418 EXPECT_TRUE(creator_.HasPendingFrames());
2419 EXPECT_CALL(delegate_, OnSerializedPacket(_))
2420 .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
2421 creator_.FlushCurrentPacket();
2422
2423 // Verify ACK frame can be consumed.
2424 creator_.SetSoftMaxPacketLength(overhead);
2425 EXPECT_EQ(overhead, creator_.max_packet_length());
2426 QuicAckFrame ack_frame(InitAckFrame(10u));
2427 EXPECT_TRUE(creator_.AddFrame(QuicFrame(&ack_frame), NOT_RETRANSMISSION));
2428 EXPECT_TRUE(creator_.HasPendingFrames());
2429 }
2430
TEST_P(QuicPacketCreatorTest,ChangingEncryptionLevelRemovesSoftMaxPacketLength)2431 TEST_P(QuicPacketCreatorTest,
2432 ChangingEncryptionLevelRemovesSoftMaxPacketLength) {
2433 if (!client_framer_.version().CanSendCoalescedPackets()) {
2434 return;
2435 }
2436 // First set encryption level to forward secure which has the shortest header.
2437 creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
2438 const QuicByteCount previous_max_packet_length = creator_.max_packet_length();
2439 const size_t min_acceptable_packet_size =
2440 GetPacketHeaderOverhead(client_framer_.transport_version()) +
2441 QuicPacketCreator::MinPlaintextPacketSize(
2442 client_framer_.version(),
2443 QuicPacketCreatorPeer::GetPacketNumberLength(&creator_)) +
2444 GetEncryptionOverhead();
2445 // Then set the soft max packet length to the lowest allowed value.
2446 creator_.SetSoftMaxPacketLength(min_acceptable_packet_size);
2447 // Make sure that the low value was accepted.
2448 EXPECT_EQ(creator_.max_packet_length(), min_acceptable_packet_size);
2449 // Now set the encryption level to handshake which increases the header size.
2450 creator_.set_encryption_level(ENCRYPTION_HANDSHAKE);
2451 // Make sure that adding a frame removes the the soft max packet length.
2452 QuicAckFrame ack_frame(InitAckFrame(1));
2453 frames_.push_back(QuicFrame(&ack_frame));
2454 SerializedPacket serialized = SerializeAllFrames(frames_);
2455 EXPECT_EQ(serialized.encryption_level, ENCRYPTION_HANDSHAKE);
2456 EXPECT_EQ(creator_.max_packet_length(), previous_max_packet_length);
2457 }
2458
TEST_P(QuicPacketCreatorTest,MinPayloadLength)2459 TEST_P(QuicPacketCreatorTest, MinPayloadLength) {
2460 ParsedQuicVersion version = client_framer_.version();
2461 for (QuicPacketNumberLength pn_length :
2462 {PACKET_1BYTE_PACKET_NUMBER, PACKET_2BYTE_PACKET_NUMBER,
2463 PACKET_3BYTE_PACKET_NUMBER, PACKET_4BYTE_PACKET_NUMBER}) {
2464 if (!version.HasHeaderProtection()) {
2465 EXPECT_EQ(creator_.MinPlaintextPacketSize(version, pn_length), 0);
2466 } else {
2467 EXPECT_EQ(creator_.MinPlaintextPacketSize(version, pn_length),
2468 (version.UsesTls() ? 4 : 8) - pn_length);
2469 }
2470 }
2471 }
2472
2473 // A variant of StreamFrameConsumption that tests when expansion of the stream
2474 // frame puts it at or over the max length, but the packet is supposed to be
2475 // padded to max length.
TEST_P(QuicPacketCreatorTest,PadWhenAlmostMaxLength)2476 TEST_P(QuicPacketCreatorTest, PadWhenAlmostMaxLength) {
2477 creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
2478 // Compute the total overhead for a single frame in packet.
2479 const size_t overhead =
2480 GetPacketHeaderOverhead(client_framer_.transport_version()) +
2481 GetEncryptionOverhead() +
2482 GetStreamFrameOverhead(client_framer_.transport_version());
2483 size_t capacity = kDefaultMaxPacketSize - overhead;
2484 for (size_t bytes_free = 1; bytes_free <= 2; bytes_free++) {
2485 std::string data(capacity - bytes_free, 'A');
2486
2487 QuicFrame frame;
2488 ASSERT_TRUE(creator_.ConsumeDataToFillCurrentPacket(
2489 GetNthClientInitiatedStreamId(1), data, kOffset, false,
2490 /*needs_full_padding=*/true, NOT_RETRANSMISSION, &frame));
2491
2492 // BytesFree() returns bytes available for the next frame, which will
2493 // be two bytes smaller since the stream frame would need to be grown.
2494 EXPECT_EQ(2u, creator_.ExpansionOnNewFrame());
2495 EXPECT_EQ(0u, creator_.BytesFree());
2496 EXPECT_CALL(delegate_, OnSerializedPacket(_))
2497 .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
2498 creator_.FlushCurrentPacket();
2499 EXPECT_EQ(serialized_packet_->encrypted_length, kDefaultMaxPacketSize);
2500 DeleteSerializedPacket();
2501 }
2502 }
2503
TEST_P(QuicPacketCreatorTest,MorePendingPaddingThanBytesFree)2504 TEST_P(QuicPacketCreatorTest, MorePendingPaddingThanBytesFree) {
2505 creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
2506 // Compute the total overhead for a single frame in packet.
2507 const size_t overhead =
2508 GetPacketHeaderOverhead(client_framer_.transport_version()) +
2509 GetEncryptionOverhead() +
2510 GetStreamFrameOverhead(client_framer_.transport_version());
2511 size_t capacity = kDefaultMaxPacketSize - overhead;
2512 const size_t pending_padding = 10;
2513 std::string data(capacity - pending_padding, 'A');
2514 QuicFrame frame;
2515 // The stream frame means that BytesFree() will be less than the
2516 // available space, because of the frame length field.
2517 ASSERT_TRUE(creator_.ConsumeDataToFillCurrentPacket(
2518 GetNthClientInitiatedStreamId(1), data, kOffset, false,
2519 /*needs_full_padding=*/false, NOT_RETRANSMISSION, &frame));
2520 creator_.AddPendingPadding(pending_padding);
2521 EXPECT_EQ(2u, creator_.ExpansionOnNewFrame());
2522 // BytesFree() does not know about pending_padding because that's added
2523 // when flushed.
2524 EXPECT_EQ(pending_padding - 2u, creator_.BytesFree());
2525 EXPECT_CALL(delegate_, OnSerializedPacket(_))
2526 .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
2527 creator_.FlushCurrentPacket();
2528 /* Without the fix, the packet is not full-length. */
2529 EXPECT_EQ(serialized_packet_->encrypted_length, kDefaultMaxPacketSize);
2530 DeleteSerializedPacket();
2531 }
2532
2533 class MockDelegate : public QuicPacketCreator::DelegateInterface {
2534 public:
MockDelegate()2535 MockDelegate() {}
2536 MockDelegate(const MockDelegate&) = delete;
2537 MockDelegate& operator=(const MockDelegate&) = delete;
~MockDelegate()2538 ~MockDelegate() override {}
2539
2540 MOCK_METHOD(bool, ShouldGeneratePacket,
2541 (HasRetransmittableData retransmittable, IsHandshake handshake),
2542 (override));
2543 MOCK_METHOD(void, MaybeBundleOpportunistically,
2544 (TransmissionType transmission_type), (override));
2545 MOCK_METHOD(QuicByteCount, GetFlowControlSendWindowSize, (QuicStreamId),
2546 (override));
2547 MOCK_METHOD(QuicPacketBuffer, GetPacketBuffer, (), (override));
2548 MOCK_METHOD(void, OnSerializedPacket, (SerializedPacket), (override));
2549 MOCK_METHOD(void, OnUnrecoverableError, (QuicErrorCode, const std::string&),
2550 (override));
2551 MOCK_METHOD(SerializedPacketFate, GetSerializedPacketFate,
2552 (bool, EncryptionLevel), (override));
2553
SetCanWriteAnything()2554 void SetCanWriteAnything() {
2555 EXPECT_CALL(*this, ShouldGeneratePacket(_, _)).WillRepeatedly(Return(true));
2556 EXPECT_CALL(*this, ShouldGeneratePacket(NO_RETRANSMITTABLE_DATA, _))
2557 .WillRepeatedly(Return(true));
2558 }
2559
SetCanNotWrite()2560 void SetCanNotWrite() {
2561 EXPECT_CALL(*this, ShouldGeneratePacket(_, _))
2562 .WillRepeatedly(Return(false));
2563 EXPECT_CALL(*this, ShouldGeneratePacket(NO_RETRANSMITTABLE_DATA, _))
2564 .WillRepeatedly(Return(false));
2565 }
2566
2567 // Use this when only ack frames should be allowed to be written.
SetCanWriteOnlyNonRetransmittable()2568 void SetCanWriteOnlyNonRetransmittable() {
2569 EXPECT_CALL(*this, ShouldGeneratePacket(_, _))
2570 .WillRepeatedly(Return(false));
2571 EXPECT_CALL(*this, ShouldGeneratePacket(NO_RETRANSMITTABLE_DATA, _))
2572 .WillRepeatedly(Return(true));
2573 }
2574 };
2575
2576 // Simple struct for describing the contents of a packet.
2577 // Useful in conjunction with a SimpleQuicFrame for validating that a packet
2578 // contains the expected frames.
2579 struct PacketContents {
PacketContentsquic::test::__anon1c4b7b270111::PacketContents2580 PacketContents()
2581 : num_ack_frames(0),
2582 num_connection_close_frames(0),
2583 num_goaway_frames(0),
2584 num_rst_stream_frames(0),
2585 num_stop_waiting_frames(0),
2586 num_stream_frames(0),
2587 num_crypto_frames(0),
2588 num_ping_frames(0),
2589 num_mtu_discovery_frames(0),
2590 num_padding_frames(0) {}
2591
2592 size_t num_ack_frames;
2593 size_t num_connection_close_frames;
2594 size_t num_goaway_frames;
2595 size_t num_rst_stream_frames;
2596 size_t num_stop_waiting_frames;
2597 size_t num_stream_frames;
2598 size_t num_crypto_frames;
2599 size_t num_ping_frames;
2600 size_t num_mtu_discovery_frames;
2601 size_t num_padding_frames;
2602 };
2603
2604 class MultiplePacketsTestPacketCreator : public QuicPacketCreator {
2605 public:
MultiplePacketsTestPacketCreator(QuicConnectionId connection_id,QuicFramer * framer,QuicRandom * random_generator,QuicPacketCreator::DelegateInterface * delegate,SimpleDataProducer * producer)2606 MultiplePacketsTestPacketCreator(
2607 QuicConnectionId connection_id, QuicFramer* framer,
2608 QuicRandom* random_generator,
2609 QuicPacketCreator::DelegateInterface* delegate,
2610 SimpleDataProducer* producer)
2611 : QuicPacketCreator(connection_id, framer, random_generator, delegate),
2612 ack_frame_(InitAckFrame(1)),
2613 delegate_(static_cast<MockDelegate*>(delegate)),
2614 producer_(producer) {}
2615
ConsumeRetransmittableControlFrame(const QuicFrame & frame,bool bundle_ack)2616 bool ConsumeRetransmittableControlFrame(const QuicFrame& frame,
2617 bool bundle_ack) {
2618 QuicFrames frames;
2619 if (bundle_ack) {
2620 frames.push_back(QuicFrame(&ack_frame_));
2621 }
2622 EXPECT_CALL(*delegate_, MaybeBundleOpportunistically(_))
2623 .WillOnce(Invoke([this, frames = std::move(frames)] {
2624 FlushAckFrame(frames);
2625 return QuicFrames();
2626 }));
2627 return QuicPacketCreator::ConsumeRetransmittableControlFrame(frame);
2628 }
2629
ConsumeDataFastPath(QuicStreamId id,absl::string_view data)2630 QuicConsumedData ConsumeDataFastPath(QuicStreamId id,
2631 absl::string_view data) {
2632 // Save data before data is consumed.
2633 if (!data.empty()) {
2634 producer_->SaveStreamData(id, data);
2635 }
2636 return QuicPacketCreator::ConsumeDataFastPath(id, data.length(),
2637 /* offset = */ 0,
2638 /* fin = */ true, 0);
2639 }
2640
ConsumeData(QuicStreamId id,absl::string_view data,QuicStreamOffset offset,StreamSendingState state)2641 QuicConsumedData ConsumeData(QuicStreamId id, absl::string_view data,
2642 QuicStreamOffset offset,
2643 StreamSendingState state) {
2644 // Save data before data is consumed.
2645 if (!data.empty()) {
2646 producer_->SaveStreamData(id, data);
2647 }
2648 EXPECT_CALL(*delegate_, MaybeBundleOpportunistically(_)).Times(1);
2649 return QuicPacketCreator::ConsumeData(id, data.length(), offset, state);
2650 }
2651
AddMessageFrame(QuicMessageId message_id,quiche::QuicheMemSlice message)2652 MessageStatus AddMessageFrame(QuicMessageId message_id,
2653 quiche::QuicheMemSlice message) {
2654 if (!has_ack() && delegate_->ShouldGeneratePacket(NO_RETRANSMITTABLE_DATA,
2655 NOT_HANDSHAKE)) {
2656 EXPECT_CALL(*delegate_, MaybeBundleOpportunistically(_)).Times(1);
2657 }
2658 return QuicPacketCreator::AddMessageFrame(message_id,
2659 absl::MakeSpan(&message, 1));
2660 }
2661
ConsumeCryptoData(EncryptionLevel level,absl::string_view data,QuicStreamOffset offset)2662 size_t ConsumeCryptoData(EncryptionLevel level, absl::string_view data,
2663 QuicStreamOffset offset) {
2664 producer_->SaveCryptoData(level, offset, data);
2665 EXPECT_CALL(*delegate_, MaybeBundleOpportunistically(_)).Times(1);
2666 return QuicPacketCreator::ConsumeCryptoData(level, data.length(), offset);
2667 }
2668
2669 QuicAckFrame ack_frame_;
2670 MockDelegate* delegate_;
2671 SimpleDataProducer* producer_;
2672 };
2673
2674 class QuicPacketCreatorMultiplePacketsTest : public QuicTest {
2675 public:
QuicPacketCreatorMultiplePacketsTest()2676 QuicPacketCreatorMultiplePacketsTest()
2677 : framer_(AllSupportedVersions(), QuicTime::Zero(),
2678 Perspective::IS_CLIENT, kQuicDefaultConnectionIdLength),
2679 creator_(TestConnectionId(), &framer_, &random_creator_, &delegate_,
2680 &producer_),
2681 ack_frame_(InitAckFrame(1)) {
2682 EXPECT_CALL(delegate_, GetPacketBuffer())
2683 .WillRepeatedly(Return(QuicPacketBuffer()));
2684 EXPECT_CALL(delegate_, GetSerializedPacketFate(_, _))
2685 .WillRepeatedly(Return(SEND_TO_WRITER));
2686 EXPECT_CALL(delegate_, GetFlowControlSendWindowSize(_))
2687 .WillRepeatedly(Return(std::numeric_limits<QuicByteCount>::max()));
2688 creator_.SetEncrypter(
2689 ENCRYPTION_FORWARD_SECURE,
2690 std::make_unique<TaggingEncrypter>(ENCRYPTION_FORWARD_SECURE));
2691 creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
2692 framer_.set_data_producer(&producer_);
2693 if (simple_framer_.framer()->version().KnowsWhichDecrypterToUse()) {
2694 simple_framer_.framer()->InstallDecrypter(
2695 ENCRYPTION_FORWARD_SECURE, std::make_unique<TaggingDecrypter>());
2696 }
2697 creator_.AttachPacketFlusher();
2698 }
2699
~QuicPacketCreatorMultiplePacketsTest()2700 ~QuicPacketCreatorMultiplePacketsTest() override {}
2701
SavePacket(SerializedPacket packet)2702 void SavePacket(SerializedPacket packet) {
2703 QUICHE_DCHECK(packet.release_encrypted_buffer == nullptr);
2704 packet.encrypted_buffer = CopyBuffer(packet);
2705 packet.release_encrypted_buffer = [](const char* p) { delete[] p; };
2706 packets_.push_back(std::move(packet));
2707 }
2708
2709 protected:
CreateRstStreamFrame()2710 QuicRstStreamFrame* CreateRstStreamFrame() {
2711 return new QuicRstStreamFrame(1, 1, QUIC_STREAM_NO_ERROR, 0);
2712 }
2713
CreateGoAwayFrame()2714 QuicGoAwayFrame* CreateGoAwayFrame() {
2715 return new QuicGoAwayFrame(2, QUIC_NO_ERROR, 1, std::string());
2716 }
2717
CheckPacketContains(const PacketContents & contents,size_t packet_index)2718 void CheckPacketContains(const PacketContents& contents,
2719 size_t packet_index) {
2720 ASSERT_GT(packets_.size(), packet_index);
2721 const SerializedPacket& packet = packets_[packet_index];
2722 size_t num_retransmittable_frames =
2723 contents.num_connection_close_frames + contents.num_goaway_frames +
2724 contents.num_rst_stream_frames + contents.num_stream_frames +
2725 contents.num_crypto_frames + contents.num_ping_frames;
2726 size_t num_frames =
2727 contents.num_ack_frames + contents.num_stop_waiting_frames +
2728 contents.num_mtu_discovery_frames + contents.num_padding_frames +
2729 num_retransmittable_frames;
2730
2731 if (num_retransmittable_frames == 0) {
2732 ASSERT_TRUE(packet.retransmittable_frames.empty());
2733 } else {
2734 EXPECT_EQ(num_retransmittable_frames,
2735 packet.retransmittable_frames.size());
2736 }
2737
2738 ASSERT_TRUE(packet.encrypted_buffer != nullptr);
2739 ASSERT_TRUE(simple_framer_.ProcessPacket(
2740 QuicEncryptedPacket(packet.encrypted_buffer, packet.encrypted_length)));
2741 size_t num_padding_frames = 0;
2742 if (contents.num_padding_frames == 0) {
2743 num_padding_frames = simple_framer_.padding_frames().size();
2744 }
2745 EXPECT_EQ(num_frames + num_padding_frames, simple_framer_.num_frames());
2746 EXPECT_EQ(contents.num_ack_frames, simple_framer_.ack_frames().size());
2747 EXPECT_EQ(contents.num_connection_close_frames,
2748 simple_framer_.connection_close_frames().size());
2749 EXPECT_EQ(contents.num_goaway_frames,
2750 simple_framer_.goaway_frames().size());
2751 EXPECT_EQ(contents.num_rst_stream_frames,
2752 simple_framer_.rst_stream_frames().size());
2753 EXPECT_EQ(contents.num_stream_frames,
2754 simple_framer_.stream_frames().size());
2755 EXPECT_EQ(contents.num_crypto_frames,
2756 simple_framer_.crypto_frames().size());
2757 EXPECT_EQ(contents.num_stop_waiting_frames,
2758 simple_framer_.stop_waiting_frames().size());
2759 if (contents.num_padding_frames != 0) {
2760 EXPECT_EQ(contents.num_padding_frames,
2761 simple_framer_.padding_frames().size());
2762 }
2763
2764 // From the receiver's perspective, MTU discovery frames are ping frames.
2765 EXPECT_EQ(contents.num_ping_frames + contents.num_mtu_discovery_frames,
2766 simple_framer_.ping_frames().size());
2767 }
2768
CheckPacketHasSingleStreamFrame(size_t packet_index)2769 void CheckPacketHasSingleStreamFrame(size_t packet_index) {
2770 ASSERT_GT(packets_.size(), packet_index);
2771 const SerializedPacket& packet = packets_[packet_index];
2772 ASSERT_FALSE(packet.retransmittable_frames.empty());
2773 EXPECT_EQ(1u, packet.retransmittable_frames.size());
2774 ASSERT_TRUE(packet.encrypted_buffer != nullptr);
2775 ASSERT_TRUE(simple_framer_.ProcessPacket(
2776 QuicEncryptedPacket(packet.encrypted_buffer, packet.encrypted_length)));
2777 EXPECT_EQ(1u, simple_framer_.num_frames());
2778 EXPECT_EQ(1u, simple_framer_.stream_frames().size());
2779 }
2780
CheckAllPacketsHaveSingleStreamFrame()2781 void CheckAllPacketsHaveSingleStreamFrame() {
2782 for (size_t i = 0; i < packets_.size(); i++) {
2783 CheckPacketHasSingleStreamFrame(i);
2784 }
2785 }
2786
2787 QuicFramer framer_;
2788 MockRandom random_creator_;
2789 StrictMock<MockDelegate> delegate_;
2790 MultiplePacketsTestPacketCreator creator_;
2791 SimpleQuicFramer simple_framer_;
2792 std::vector<SerializedPacket> packets_;
2793 QuicAckFrame ack_frame_;
2794 struct iovec iov_;
2795 quiche::SimpleBufferAllocator allocator_;
2796
2797 private:
2798 std::unique_ptr<char[]> data_array_;
2799 SimpleDataProducer producer_;
2800 };
2801
TEST_F(QuicPacketCreatorMultiplePacketsTest,AddControlFrame_NotWritable)2802 TEST_F(QuicPacketCreatorMultiplePacketsTest, AddControlFrame_NotWritable) {
2803 delegate_.SetCanNotWrite();
2804
2805 QuicRstStreamFrame* rst_frame = CreateRstStreamFrame();
2806 const bool consumed =
2807 creator_.ConsumeRetransmittableControlFrame(QuicFrame(rst_frame),
2808 /*bundle_ack=*/false);
2809 EXPECT_FALSE(consumed);
2810 EXPECT_FALSE(creator_.HasPendingFrames());
2811 EXPECT_FALSE(creator_.HasPendingRetransmittableFrames());
2812 delete rst_frame;
2813 }
2814
TEST_F(QuicPacketCreatorMultiplePacketsTest,WrongEncryptionLevelForStreamDataFastPath)2815 TEST_F(QuicPacketCreatorMultiplePacketsTest,
2816 WrongEncryptionLevelForStreamDataFastPath) {
2817 creator_.set_encryption_level(ENCRYPTION_HANDSHAKE);
2818 delegate_.SetCanWriteAnything();
2819 const std::string data(10000, '?');
2820 EXPECT_CALL(delegate_, OnSerializedPacket(_)).Times(0);
2821 EXPECT_QUIC_BUG(
2822 {
2823 EXPECT_CALL(delegate_, OnUnrecoverableError(_, _));
2824 creator_.ConsumeDataFastPath(
2825 QuicUtils::GetFirstBidirectionalStreamId(
2826 framer_.transport_version(), Perspective::IS_CLIENT),
2827 data);
2828 },
2829 "");
2830 }
2831
TEST_F(QuicPacketCreatorMultiplePacketsTest,AddControlFrame_OnlyAckWritable)2832 TEST_F(QuicPacketCreatorMultiplePacketsTest, AddControlFrame_OnlyAckWritable) {
2833 delegate_.SetCanWriteOnlyNonRetransmittable();
2834
2835 QuicRstStreamFrame* rst_frame = CreateRstStreamFrame();
2836 const bool consumed =
2837 creator_.ConsumeRetransmittableControlFrame(QuicFrame(rst_frame),
2838 /*bundle_ack=*/false);
2839 EXPECT_FALSE(consumed);
2840 EXPECT_FALSE(creator_.HasPendingFrames());
2841 EXPECT_FALSE(creator_.HasPendingRetransmittableFrames());
2842 delete rst_frame;
2843 }
2844
TEST_F(QuicPacketCreatorMultiplePacketsTest,AddControlFrame_WritableAndShouldNotFlush)2845 TEST_F(QuicPacketCreatorMultiplePacketsTest,
2846 AddControlFrame_WritableAndShouldNotFlush) {
2847 delegate_.SetCanWriteAnything();
2848
2849 creator_.ConsumeRetransmittableControlFrame(QuicFrame(CreateRstStreamFrame()),
2850 /*bundle_ack=*/false);
2851 EXPECT_TRUE(creator_.HasPendingFrames());
2852 EXPECT_TRUE(creator_.HasPendingRetransmittableFrames());
2853 }
2854
TEST_F(QuicPacketCreatorMultiplePacketsTest,AddControlFrame_NotWritableBatchThenFlush)2855 TEST_F(QuicPacketCreatorMultiplePacketsTest,
2856 AddControlFrame_NotWritableBatchThenFlush) {
2857 delegate_.SetCanNotWrite();
2858
2859 QuicRstStreamFrame* rst_frame = CreateRstStreamFrame();
2860 const bool consumed =
2861 creator_.ConsumeRetransmittableControlFrame(QuicFrame(rst_frame),
2862 /*bundle_ack=*/false);
2863 EXPECT_FALSE(consumed);
2864 EXPECT_FALSE(creator_.HasPendingFrames());
2865 EXPECT_FALSE(creator_.HasPendingRetransmittableFrames());
2866 delete rst_frame;
2867 }
2868
TEST_F(QuicPacketCreatorMultiplePacketsTest,AddControlFrame_WritableAndShouldFlush)2869 TEST_F(QuicPacketCreatorMultiplePacketsTest,
2870 AddControlFrame_WritableAndShouldFlush) {
2871 delegate_.SetCanWriteAnything();
2872
2873 EXPECT_CALL(delegate_, OnSerializedPacket(_))
2874 .WillOnce(
2875 Invoke(this, &QuicPacketCreatorMultiplePacketsTest::SavePacket));
2876
2877 creator_.ConsumeRetransmittableControlFrame(QuicFrame(CreateRstStreamFrame()),
2878 /*bundle_ack=*/false);
2879 creator_.Flush();
2880 EXPECT_FALSE(creator_.HasPendingFrames());
2881 EXPECT_FALSE(creator_.HasPendingRetransmittableFrames());
2882
2883 PacketContents contents;
2884 contents.num_rst_stream_frames = 1;
2885 CheckPacketContains(contents, 0);
2886 }
2887
TEST_F(QuicPacketCreatorMultiplePacketsTest,ConsumeCryptoData)2888 TEST_F(QuicPacketCreatorMultiplePacketsTest, ConsumeCryptoData) {
2889 delegate_.SetCanWriteAnything();
2890
2891 EXPECT_CALL(delegate_, OnSerializedPacket(_))
2892 .WillOnce(
2893 Invoke(this, &QuicPacketCreatorMultiplePacketsTest::SavePacket));
2894 std::string data = "crypto data";
2895 size_t consumed_bytes =
2896 creator_.ConsumeCryptoData(ENCRYPTION_INITIAL, data, 0);
2897 creator_.Flush();
2898 EXPECT_EQ(data.length(), consumed_bytes);
2899 EXPECT_FALSE(creator_.HasPendingFrames());
2900 EXPECT_FALSE(creator_.HasPendingRetransmittableFrames());
2901
2902 PacketContents contents;
2903 contents.num_crypto_frames = 1;
2904 contents.num_padding_frames = 1;
2905 CheckPacketContains(contents, 0);
2906 }
2907
TEST_F(QuicPacketCreatorMultiplePacketsTest,ConsumeCryptoDataCheckShouldGeneratePacket)2908 TEST_F(QuicPacketCreatorMultiplePacketsTest,
2909 ConsumeCryptoDataCheckShouldGeneratePacket) {
2910 delegate_.SetCanNotWrite();
2911
2912 EXPECT_CALL(delegate_, OnSerializedPacket(_)).Times(0);
2913 std::string data = "crypto data";
2914 size_t consumed_bytes =
2915 creator_.ConsumeCryptoData(ENCRYPTION_INITIAL, data, 0);
2916 creator_.Flush();
2917 EXPECT_EQ(0u, consumed_bytes);
2918 EXPECT_FALSE(creator_.HasPendingFrames());
2919 EXPECT_FALSE(creator_.HasPendingRetransmittableFrames());
2920 }
2921
2922 // Tests the case that after bundling data, send window reduced to be shorter
2923 // than data.
TEST_F(QuicPacketCreatorMultiplePacketsTest,ConsumeDataAdjustWriteLengthAfterBundledData)2924 TEST_F(QuicPacketCreatorMultiplePacketsTest,
2925 ConsumeDataAdjustWriteLengthAfterBundledData) {
2926 creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
2927 creator_.SetTransmissionType(NOT_RETRANSMISSION);
2928 delegate_.SetCanWriteAnything();
2929
2930 const std::string data(1000, 'D');
2931 QuicStreamId stream_id = QuicUtils::GetFirstBidirectionalStreamId(
2932 framer_.transport_version(), Perspective::IS_CLIENT);
2933
2934 if (GetQuicRestartFlag(quic_opport_bundle_qpack_decoder_data4)) {
2935 EXPECT_CALL(delegate_, GetFlowControlSendWindowSize(stream_id))
2936 .WillOnce(Return(data.length() - 1));
2937 } else {
2938 EXPECT_CALL(delegate_, GetFlowControlSendWindowSize(_)).Times(0);
2939 }
2940
2941 QuicConsumedData consumed = creator_.ConsumeData(stream_id, data, 0u, FIN);
2942
2943 if (GetQuicRestartFlag(quic_opport_bundle_qpack_decoder_data4)) {
2944 EXPECT_EQ(consumed.bytes_consumed, data.length() - 1);
2945 EXPECT_FALSE(consumed.fin_consumed);
2946 } else {
2947 EXPECT_EQ(consumed.bytes_consumed, data.length());
2948 EXPECT_TRUE(consumed.fin_consumed);
2949 }
2950 }
2951
2952 // Tests the case that after bundling data, send window is exactly as big as
2953 // data length.
TEST_F(QuicPacketCreatorMultiplePacketsTest,ConsumeDataDoesNotAdjustWriteLengthAfterBundledData)2954 TEST_F(QuicPacketCreatorMultiplePacketsTest,
2955 ConsumeDataDoesNotAdjustWriteLengthAfterBundledData) {
2956 creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
2957 creator_.SetTransmissionType(NOT_RETRANSMISSION);
2958 delegate_.SetCanWriteAnything();
2959
2960 const std::string data(1000, 'D');
2961 QuicStreamId stream_id = QuicUtils::GetFirstBidirectionalStreamId(
2962 framer_.transport_version(), Perspective::IS_CLIENT);
2963
2964 if (GetQuicRestartFlag(quic_opport_bundle_qpack_decoder_data4)) {
2965 EXPECT_CALL(delegate_, GetFlowControlSendWindowSize(stream_id))
2966 .WillOnce(Return(data.length()));
2967 } else {
2968 EXPECT_CALL(delegate_, GetFlowControlSendWindowSize(_)).Times(0);
2969 }
2970
2971 QuicConsumedData consumed = creator_.ConsumeData(stream_id, data, 0u, FIN);
2972
2973 EXPECT_EQ(consumed.bytes_consumed, data.length());
2974 EXPECT_TRUE(consumed.fin_consumed);
2975 }
2976
TEST_F(QuicPacketCreatorMultiplePacketsTest,ConsumeData_NotWritable)2977 TEST_F(QuicPacketCreatorMultiplePacketsTest, ConsumeData_NotWritable) {
2978 delegate_.SetCanNotWrite();
2979
2980 QuicConsumedData consumed = creator_.ConsumeData(
2981 QuicUtils::GetFirstBidirectionalStreamId(framer_.transport_version(),
2982 Perspective::IS_CLIENT),
2983 "foo", 0, FIN);
2984 EXPECT_EQ(0u, consumed.bytes_consumed);
2985 EXPECT_FALSE(consumed.fin_consumed);
2986 EXPECT_FALSE(creator_.HasPendingFrames());
2987 EXPECT_FALSE(creator_.HasPendingRetransmittableFrames());
2988 }
2989
TEST_F(QuicPacketCreatorMultiplePacketsTest,ConsumeData_WritableAndShouldNotFlush)2990 TEST_F(QuicPacketCreatorMultiplePacketsTest,
2991 ConsumeData_WritableAndShouldNotFlush) {
2992 delegate_.SetCanWriteAnything();
2993
2994 QuicConsumedData consumed = creator_.ConsumeData(
2995 QuicUtils::GetFirstBidirectionalStreamId(framer_.transport_version(),
2996 Perspective::IS_CLIENT),
2997 "foo", 0, FIN);
2998 EXPECT_EQ(3u, consumed.bytes_consumed);
2999 EXPECT_TRUE(consumed.fin_consumed);
3000 EXPECT_TRUE(creator_.HasPendingFrames());
3001 EXPECT_TRUE(creator_.HasPendingRetransmittableFrames());
3002 }
3003
TEST_F(QuicPacketCreatorMultiplePacketsTest,ConsumeData_WritableAndShouldFlush)3004 TEST_F(QuicPacketCreatorMultiplePacketsTest,
3005 ConsumeData_WritableAndShouldFlush) {
3006 delegate_.SetCanWriteAnything();
3007
3008 EXPECT_CALL(delegate_, OnSerializedPacket(_))
3009 .WillOnce(
3010 Invoke(this, &QuicPacketCreatorMultiplePacketsTest::SavePacket));
3011 QuicConsumedData consumed = creator_.ConsumeData(
3012 QuicUtils::GetFirstBidirectionalStreamId(framer_.transport_version(),
3013 Perspective::IS_CLIENT),
3014 "foo", 0, FIN);
3015 creator_.Flush();
3016 EXPECT_EQ(3u, consumed.bytes_consumed);
3017 EXPECT_TRUE(consumed.fin_consumed);
3018 EXPECT_FALSE(creator_.HasPendingFrames());
3019 EXPECT_FALSE(creator_.HasPendingRetransmittableFrames());
3020
3021 PacketContents contents;
3022 contents.num_stream_frames = 1;
3023 CheckPacketContains(contents, 0);
3024 }
3025
3026 // Test the behavior of ConsumeData when the data consumed is for the crypto
3027 // handshake stream. Ensure that the packet is always sent and padded even if
3028 // the creator operates in batch mode.
TEST_F(QuicPacketCreatorMultiplePacketsTest,ConsumeData_Handshake)3029 TEST_F(QuicPacketCreatorMultiplePacketsTest, ConsumeData_Handshake) {
3030 delegate_.SetCanWriteAnything();
3031
3032 EXPECT_CALL(delegate_, OnSerializedPacket(_))
3033 .WillOnce(
3034 Invoke(this, &QuicPacketCreatorMultiplePacketsTest::SavePacket));
3035 const std::string data = "foo bar";
3036 size_t consumed_bytes = 0;
3037 if (QuicVersionUsesCryptoFrames(framer_.transport_version())) {
3038 consumed_bytes = creator_.ConsumeCryptoData(ENCRYPTION_INITIAL, data, 0);
3039 } else {
3040 consumed_bytes =
3041 creator_
3042 .ConsumeData(
3043 QuicUtils::GetCryptoStreamId(framer_.transport_version()), data,
3044 0, NO_FIN)
3045 .bytes_consumed;
3046 }
3047 EXPECT_EQ(7u, consumed_bytes);
3048 EXPECT_FALSE(creator_.HasPendingFrames());
3049 EXPECT_FALSE(creator_.HasPendingRetransmittableFrames());
3050
3051 PacketContents contents;
3052 if (QuicVersionUsesCryptoFrames(framer_.transport_version())) {
3053 contents.num_crypto_frames = 1;
3054 } else {
3055 contents.num_stream_frames = 1;
3056 }
3057 contents.num_padding_frames = 1;
3058 CheckPacketContains(contents, 0);
3059
3060 ASSERT_EQ(1u, packets_.size());
3061 ASSERT_EQ(kDefaultMaxPacketSize, creator_.max_packet_length());
3062 EXPECT_EQ(kDefaultMaxPacketSize, packets_[0].encrypted_length);
3063 }
3064
3065 // Test the behavior of ConsumeData when the data is for the crypto handshake
3066 // stream, but padding is disabled.
TEST_F(QuicPacketCreatorMultiplePacketsTest,ConsumeData_Handshake_PaddingDisabled)3067 TEST_F(QuicPacketCreatorMultiplePacketsTest,
3068 ConsumeData_Handshake_PaddingDisabled) {
3069 creator_.set_fully_pad_crypto_handshake_packets(false);
3070
3071 delegate_.SetCanWriteAnything();
3072
3073 EXPECT_CALL(delegate_, OnSerializedPacket(_))
3074 .WillOnce(
3075 Invoke(this, &QuicPacketCreatorMultiplePacketsTest::SavePacket));
3076 const std::string data = "foo";
3077 size_t bytes_consumed = 0;
3078 if (QuicVersionUsesCryptoFrames(framer_.transport_version())) {
3079 bytes_consumed = creator_.ConsumeCryptoData(ENCRYPTION_INITIAL, data, 0);
3080 } else {
3081 bytes_consumed =
3082 creator_
3083 .ConsumeData(
3084 QuicUtils::GetCryptoStreamId(framer_.transport_version()), data,
3085 0, NO_FIN)
3086 .bytes_consumed;
3087 }
3088 EXPECT_EQ(3u, bytes_consumed);
3089 EXPECT_FALSE(creator_.HasPendingFrames());
3090 EXPECT_FALSE(creator_.HasPendingRetransmittableFrames());
3091
3092 PacketContents contents;
3093 if (QuicVersionUsesCryptoFrames(framer_.transport_version())) {
3094 contents.num_crypto_frames = 1;
3095 } else {
3096 contents.num_stream_frames = 1;
3097 }
3098 contents.num_padding_frames = 0;
3099 CheckPacketContains(contents, 0);
3100
3101 ASSERT_EQ(1u, packets_.size());
3102
3103 // Packet is not fully padded, but we want to future packets to be larger.
3104 ASSERT_EQ(kDefaultMaxPacketSize, creator_.max_packet_length());
3105 size_t expected_packet_length = 31;
3106 if (QuicVersionUsesCryptoFrames(framer_.transport_version())) {
3107 // The framing of CRYPTO frames is slightly different than that of stream
3108 // frames, so the expected packet length differs slightly.
3109 expected_packet_length = 32;
3110 }
3111 EXPECT_EQ(expected_packet_length, packets_[0].encrypted_length);
3112 }
3113
TEST_F(QuicPacketCreatorMultiplePacketsTest,ConsumeData_EmptyData)3114 TEST_F(QuicPacketCreatorMultiplePacketsTest, ConsumeData_EmptyData) {
3115 delegate_.SetCanWriteAnything();
3116
3117 EXPECT_QUIC_BUG(creator_.ConsumeData(
3118 QuicUtils::QuicUtils::GetFirstBidirectionalStreamId(
3119 framer_.transport_version(), Perspective::IS_CLIENT),
3120 {}, 0, NO_FIN),
3121 "Attempt to consume empty data without FIN.");
3122 }
3123
TEST_F(QuicPacketCreatorMultiplePacketsTest,ConsumeDataMultipleTimes_WritableAndShouldNotFlush)3124 TEST_F(QuicPacketCreatorMultiplePacketsTest,
3125 ConsumeDataMultipleTimes_WritableAndShouldNotFlush) {
3126 delegate_.SetCanWriteAnything();
3127
3128 creator_.ConsumeData(QuicUtils::GetFirstBidirectionalStreamId(
3129 framer_.transport_version(), Perspective::IS_CLIENT),
3130 "foo", 0, FIN);
3131 QuicConsumedData consumed = creator_.ConsumeData(3, "quux", 3, NO_FIN);
3132 EXPECT_EQ(4u, consumed.bytes_consumed);
3133 EXPECT_FALSE(consumed.fin_consumed);
3134 EXPECT_TRUE(creator_.HasPendingFrames());
3135 EXPECT_TRUE(creator_.HasPendingRetransmittableFrames());
3136 }
3137
TEST_F(QuicPacketCreatorMultiplePacketsTest,ConsumeData_BatchOperations)3138 TEST_F(QuicPacketCreatorMultiplePacketsTest, ConsumeData_BatchOperations) {
3139 delegate_.SetCanWriteAnything();
3140
3141 creator_.ConsumeData(QuicUtils::GetFirstBidirectionalStreamId(
3142 framer_.transport_version(), Perspective::IS_CLIENT),
3143 "foo", 0, NO_FIN);
3144 QuicConsumedData consumed = creator_.ConsumeData(
3145 QuicUtils::GetFirstBidirectionalStreamId(framer_.transport_version(),
3146 Perspective::IS_CLIENT),
3147 "quux", 3, FIN);
3148 EXPECT_EQ(4u, consumed.bytes_consumed);
3149 EXPECT_TRUE(consumed.fin_consumed);
3150 EXPECT_TRUE(creator_.HasPendingFrames());
3151 EXPECT_TRUE(creator_.HasPendingRetransmittableFrames());
3152
3153 // Now both frames will be flushed out.
3154 EXPECT_CALL(delegate_, OnSerializedPacket(_))
3155 .WillOnce(
3156 Invoke(this, &QuicPacketCreatorMultiplePacketsTest::SavePacket));
3157 creator_.Flush();
3158 EXPECT_FALSE(creator_.HasPendingFrames());
3159 EXPECT_FALSE(creator_.HasPendingRetransmittableFrames());
3160
3161 PacketContents contents;
3162 contents.num_stream_frames = 1;
3163 CheckPacketContains(contents, 0);
3164 }
3165
TEST_F(QuicPacketCreatorMultiplePacketsTest,ConsumeData_FramesPreviouslyQueued)3166 TEST_F(QuicPacketCreatorMultiplePacketsTest,
3167 ConsumeData_FramesPreviouslyQueued) {
3168 // Set the packet size be enough for two stream frames with 0 stream offset,
3169 // but not enough for a stream frame of 0 offset and one with non-zero offset.
3170 size_t length =
3171 TaggingEncrypter(0x00).GetCiphertextSize(0) +
3172 GetPacketHeaderSize(
3173 framer_.transport_version(),
3174 creator_.GetDestinationConnectionIdLength(),
3175 creator_.GetSourceConnectionIdLength(),
3176 QuicPacketCreatorPeer::SendVersionInPacket(&creator_),
3177 !kIncludeDiversificationNonce,
3178 QuicPacketCreatorPeer::GetPacketNumberLength(&creator_),
3179 QuicPacketCreatorPeer::GetRetryTokenLengthLength(&creator_), 0,
3180 QuicPacketCreatorPeer::GetLengthLength(&creator_)) +
3181 // Add an extra 3 bytes for the payload and 1 byte so
3182 // BytesFree is larger than the GetMinStreamFrameSize.
3183 QuicFramer::GetMinStreamFrameSize(framer_.transport_version(), 1, 0,
3184 false, 3) +
3185 3 +
3186 QuicFramer::GetMinStreamFrameSize(framer_.transport_version(), 1, 0, true,
3187 1) +
3188 1;
3189 creator_.SetMaxPacketLength(length);
3190 delegate_.SetCanWriteAnything();
3191 {
3192 InSequence dummy;
3193 EXPECT_CALL(delegate_, OnSerializedPacket(_))
3194 .WillOnce(
3195 Invoke(this, &QuicPacketCreatorMultiplePacketsTest::SavePacket));
3196 EXPECT_CALL(delegate_, OnSerializedPacket(_))
3197 .WillOnce(
3198 Invoke(this, &QuicPacketCreatorMultiplePacketsTest::SavePacket));
3199 }
3200 // Queue enough data to prevent a stream frame with a non-zero offset from
3201 // fitting.
3202 QuicConsumedData consumed = creator_.ConsumeData(
3203 QuicUtils::GetFirstBidirectionalStreamId(framer_.transport_version(),
3204 Perspective::IS_CLIENT),
3205 "foo", 0, NO_FIN);
3206 EXPECT_EQ(3u, consumed.bytes_consumed);
3207 EXPECT_FALSE(consumed.fin_consumed);
3208 EXPECT_TRUE(creator_.HasPendingFrames());
3209 EXPECT_TRUE(creator_.HasPendingRetransmittableFrames());
3210
3211 // This frame will not fit with the existing frame, causing the queued frame
3212 // to be serialized, and it will be added to a new open packet.
3213 consumed = creator_.ConsumeData(
3214 QuicUtils::GetFirstBidirectionalStreamId(framer_.transport_version(),
3215 Perspective::IS_CLIENT),
3216 "bar", 3, FIN);
3217 EXPECT_EQ(3u, consumed.bytes_consumed);
3218 EXPECT_TRUE(consumed.fin_consumed);
3219 EXPECT_TRUE(creator_.HasPendingFrames());
3220 EXPECT_TRUE(creator_.HasPendingRetransmittableFrames());
3221
3222 creator_.FlushCurrentPacket();
3223 EXPECT_FALSE(creator_.HasPendingFrames());
3224 EXPECT_FALSE(creator_.HasPendingRetransmittableFrames());
3225
3226 PacketContents contents;
3227 contents.num_stream_frames = 1;
3228 CheckPacketContains(contents, 0);
3229 CheckPacketContains(contents, 1);
3230 }
3231
TEST_F(QuicPacketCreatorMultiplePacketsTest,ConsumeDataFastPath)3232 TEST_F(QuicPacketCreatorMultiplePacketsTest, ConsumeDataFastPath) {
3233 delegate_.SetCanWriteAnything();
3234 creator_.SetTransmissionType(LOSS_RETRANSMISSION);
3235
3236 const std::string data(10000, '?');
3237 EXPECT_CALL(delegate_, OnSerializedPacket(_))
3238 .WillRepeatedly(
3239 Invoke(this, &QuicPacketCreatorMultiplePacketsTest::SavePacket));
3240 QuicConsumedData consumed = creator_.ConsumeDataFastPath(
3241 QuicUtils::GetFirstBidirectionalStreamId(framer_.transport_version(),
3242 Perspective::IS_CLIENT),
3243 data);
3244 EXPECT_EQ(10000u, consumed.bytes_consumed);
3245 EXPECT_TRUE(consumed.fin_consumed);
3246 EXPECT_FALSE(creator_.HasPendingFrames());
3247 EXPECT_FALSE(creator_.HasPendingRetransmittableFrames());
3248
3249 PacketContents contents;
3250 contents.num_stream_frames = 1;
3251 CheckPacketContains(contents, 0);
3252 EXPECT_FALSE(packets_.empty());
3253 SerializedPacket& packet = packets_.back();
3254 EXPECT_TRUE(!packet.retransmittable_frames.empty());
3255 EXPECT_EQ(LOSS_RETRANSMISSION, packet.transmission_type);
3256 EXPECT_EQ(STREAM_FRAME, packet.retransmittable_frames.front().type);
3257 const QuicStreamFrame& stream_frame =
3258 packet.retransmittable_frames.front().stream_frame;
3259 EXPECT_EQ(10000u, stream_frame.data_length + stream_frame.offset);
3260 }
3261
TEST_F(QuicPacketCreatorMultiplePacketsTest,ConsumeDataLarge)3262 TEST_F(QuicPacketCreatorMultiplePacketsTest, ConsumeDataLarge) {
3263 delegate_.SetCanWriteAnything();
3264
3265 const std::string data(10000, '?');
3266 EXPECT_CALL(delegate_, OnSerializedPacket(_))
3267 .WillRepeatedly(
3268 Invoke(this, &QuicPacketCreatorMultiplePacketsTest::SavePacket));
3269 QuicConsumedData consumed = creator_.ConsumeData(
3270 QuicUtils::GetFirstBidirectionalStreamId(framer_.transport_version(),
3271 Perspective::IS_CLIENT),
3272 data, 0, FIN);
3273 EXPECT_EQ(10000u, consumed.bytes_consumed);
3274 EXPECT_TRUE(consumed.fin_consumed);
3275 EXPECT_FALSE(creator_.HasPendingFrames());
3276 EXPECT_FALSE(creator_.HasPendingRetransmittableFrames());
3277
3278 PacketContents contents;
3279 contents.num_stream_frames = 1;
3280 CheckPacketContains(contents, 0);
3281 EXPECT_FALSE(packets_.empty());
3282 SerializedPacket& packet = packets_.back();
3283 EXPECT_TRUE(!packet.retransmittable_frames.empty());
3284 EXPECT_EQ(STREAM_FRAME, packet.retransmittable_frames.front().type);
3285 const QuicStreamFrame& stream_frame =
3286 packet.retransmittable_frames.front().stream_frame;
3287 EXPECT_EQ(10000u, stream_frame.data_length + stream_frame.offset);
3288 }
3289
TEST_F(QuicPacketCreatorMultiplePacketsTest,ConsumeDataLargeSendAckFalse)3290 TEST_F(QuicPacketCreatorMultiplePacketsTest, ConsumeDataLargeSendAckFalse) {
3291 delegate_.SetCanNotWrite();
3292
3293 QuicRstStreamFrame* rst_frame = CreateRstStreamFrame();
3294 const bool success =
3295 creator_.ConsumeRetransmittableControlFrame(QuicFrame(rst_frame),
3296 /*bundle_ack=*/true);
3297 EXPECT_FALSE(success);
3298 EXPECT_FALSE(creator_.HasPendingFrames());
3299 EXPECT_FALSE(creator_.HasPendingRetransmittableFrames());
3300
3301 delegate_.SetCanWriteAnything();
3302
3303 creator_.ConsumeRetransmittableControlFrame(QuicFrame(rst_frame),
3304 /*bundle_ack=*/false);
3305
3306 const std::string data(10000, '?');
3307 EXPECT_CALL(delegate_, OnSerializedPacket(_))
3308 .WillRepeatedly(
3309 Invoke(this, &QuicPacketCreatorMultiplePacketsTest::SavePacket));
3310 creator_.ConsumeRetransmittableControlFrame(QuicFrame(CreateRstStreamFrame()),
3311 /*bundle_ack=*/true);
3312 QuicConsumedData consumed = creator_.ConsumeData(
3313 QuicUtils::GetFirstBidirectionalStreamId(framer_.transport_version(),
3314 Perspective::IS_CLIENT),
3315 data, 0, FIN);
3316 creator_.Flush();
3317
3318 EXPECT_EQ(10000u, consumed.bytes_consumed);
3319 EXPECT_TRUE(consumed.fin_consumed);
3320 EXPECT_FALSE(creator_.HasPendingFrames());
3321 EXPECT_FALSE(creator_.HasPendingRetransmittableFrames());
3322
3323 EXPECT_FALSE(packets_.empty());
3324 SerializedPacket& packet = packets_.back();
3325 EXPECT_TRUE(!packet.retransmittable_frames.empty());
3326 EXPECT_EQ(STREAM_FRAME, packet.retransmittable_frames.front().type);
3327 const QuicStreamFrame& stream_frame =
3328 packet.retransmittable_frames.front().stream_frame;
3329 EXPECT_EQ(10000u, stream_frame.data_length + stream_frame.offset);
3330 }
3331
TEST_F(QuicPacketCreatorMultiplePacketsTest,ConsumeDataLargeSendAckTrue)3332 TEST_F(QuicPacketCreatorMultiplePacketsTest, ConsumeDataLargeSendAckTrue) {
3333 delegate_.SetCanNotWrite();
3334 delegate_.SetCanWriteAnything();
3335
3336 const std::string data(10000, '?');
3337 EXPECT_CALL(delegate_, OnSerializedPacket(_))
3338 .WillRepeatedly(
3339 Invoke(this, &QuicPacketCreatorMultiplePacketsTest::SavePacket));
3340 QuicConsumedData consumed = creator_.ConsumeData(
3341 QuicUtils::GetFirstBidirectionalStreamId(framer_.transport_version(),
3342 Perspective::IS_CLIENT),
3343 data, 0, FIN);
3344 creator_.Flush();
3345
3346 EXPECT_EQ(10000u, consumed.bytes_consumed);
3347 EXPECT_TRUE(consumed.fin_consumed);
3348 EXPECT_FALSE(creator_.HasPendingFrames());
3349 EXPECT_FALSE(creator_.HasPendingRetransmittableFrames());
3350
3351 EXPECT_FALSE(packets_.empty());
3352 SerializedPacket& packet = packets_.back();
3353 EXPECT_TRUE(!packet.retransmittable_frames.empty());
3354 EXPECT_EQ(STREAM_FRAME, packet.retransmittable_frames.front().type);
3355 const QuicStreamFrame& stream_frame =
3356 packet.retransmittable_frames.front().stream_frame;
3357 EXPECT_EQ(10000u, stream_frame.data_length + stream_frame.offset);
3358 }
3359
TEST_F(QuicPacketCreatorMultiplePacketsTest,NotWritableThenBatchOperations)3360 TEST_F(QuicPacketCreatorMultiplePacketsTest, NotWritableThenBatchOperations) {
3361 delegate_.SetCanNotWrite();
3362
3363 QuicRstStreamFrame* rst_frame = CreateRstStreamFrame();
3364 const bool consumed =
3365 creator_.ConsumeRetransmittableControlFrame(QuicFrame(rst_frame),
3366 /*bundle_ack=*/true);
3367 EXPECT_FALSE(consumed);
3368 EXPECT_FALSE(creator_.HasPendingFrames());
3369 EXPECT_FALSE(creator_.HasPendingRetransmittableFrames());
3370 EXPECT_FALSE(creator_.HasPendingStreamFramesOfStream(3));
3371
3372 delegate_.SetCanWriteAnything();
3373
3374 EXPECT_TRUE(
3375 creator_.ConsumeRetransmittableControlFrame(QuicFrame(rst_frame),
3376 /*bundle_ack=*/false));
3377 // Send some data and a control frame
3378 creator_.ConsumeData(3, "quux", 0, NO_FIN);
3379 if (!VersionHasIetfQuicFrames(framer_.transport_version())) {
3380 creator_.ConsumeRetransmittableControlFrame(QuicFrame(CreateGoAwayFrame()),
3381 /*bundle_ack=*/false);
3382 }
3383 EXPECT_TRUE(creator_.HasPendingStreamFramesOfStream(3));
3384
3385 // All five frames will be flushed out in a single packet.
3386 EXPECT_CALL(delegate_, OnSerializedPacket(_))
3387 .WillOnce(
3388 Invoke(this, &QuicPacketCreatorMultiplePacketsTest::SavePacket));
3389 creator_.Flush();
3390 EXPECT_FALSE(creator_.HasPendingFrames());
3391 EXPECT_FALSE(creator_.HasPendingRetransmittableFrames());
3392 EXPECT_FALSE(creator_.HasPendingStreamFramesOfStream(3));
3393
3394 PacketContents contents;
3395 // ACK will be flushed by connection.
3396 contents.num_ack_frames = 0;
3397 if (!VersionHasIetfQuicFrames(framer_.transport_version())) {
3398 contents.num_goaway_frames = 1;
3399 } else {
3400 contents.num_goaway_frames = 0;
3401 }
3402 contents.num_rst_stream_frames = 1;
3403 contents.num_stream_frames = 1;
3404 CheckPacketContains(contents, 0);
3405 }
3406
TEST_F(QuicPacketCreatorMultiplePacketsTest,NotWritableThenBatchOperations2)3407 TEST_F(QuicPacketCreatorMultiplePacketsTest, NotWritableThenBatchOperations2) {
3408 delegate_.SetCanNotWrite();
3409
3410 QuicRstStreamFrame* rst_frame = CreateRstStreamFrame();
3411 const bool success =
3412 creator_.ConsumeRetransmittableControlFrame(QuicFrame(rst_frame),
3413 /*bundle_ack=*/true);
3414 EXPECT_FALSE(success);
3415 EXPECT_FALSE(creator_.HasPendingFrames());
3416 EXPECT_FALSE(creator_.HasPendingRetransmittableFrames());
3417
3418 delegate_.SetCanWriteAnything();
3419
3420 {
3421 InSequence dummy;
3422 // All five frames will be flushed out in a single packet
3423 EXPECT_CALL(delegate_, OnSerializedPacket(_))
3424 .WillOnce(
3425 Invoke(this, &QuicPacketCreatorMultiplePacketsTest::SavePacket));
3426 EXPECT_CALL(delegate_, OnSerializedPacket(_))
3427 .WillOnce(
3428 Invoke(this, &QuicPacketCreatorMultiplePacketsTest::SavePacket));
3429 }
3430 EXPECT_TRUE(
3431 creator_.ConsumeRetransmittableControlFrame(QuicFrame(rst_frame),
3432 /*bundle_ack=*/false));
3433 // Send enough data to exceed one packet
3434 size_t data_len = kDefaultMaxPacketSize + 100;
3435 const std::string data(data_len, '?');
3436 QuicConsumedData consumed = creator_.ConsumeData(3, data, 0, FIN);
3437 EXPECT_EQ(data_len, consumed.bytes_consumed);
3438 EXPECT_TRUE(consumed.fin_consumed);
3439 if (!VersionHasIetfQuicFrames(framer_.transport_version())) {
3440 creator_.ConsumeRetransmittableControlFrame(QuicFrame(CreateGoAwayFrame()),
3441 /*bundle_ack=*/false);
3442 }
3443
3444 creator_.Flush();
3445 EXPECT_FALSE(creator_.HasPendingFrames());
3446 EXPECT_FALSE(creator_.HasPendingRetransmittableFrames());
3447
3448 // The first packet should have the queued data and part of the stream data.
3449 PacketContents contents;
3450 // ACK will be sent by connection.
3451 contents.num_ack_frames = 0;
3452 contents.num_rst_stream_frames = 1;
3453 contents.num_stream_frames = 1;
3454 CheckPacketContains(contents, 0);
3455
3456 // The second should have the remainder of the stream data.
3457 PacketContents contents2;
3458 if (!VersionHasIetfQuicFrames(framer_.transport_version())) {
3459 contents2.num_goaway_frames = 1;
3460 } else {
3461 contents2.num_goaway_frames = 0;
3462 }
3463 contents2.num_stream_frames = 1;
3464 CheckPacketContains(contents2, 1);
3465 }
3466
3467 // Regression test of b/120493795.
TEST_F(QuicPacketCreatorMultiplePacketsTest,PacketTransmissionType)3468 TEST_F(QuicPacketCreatorMultiplePacketsTest, PacketTransmissionType) {
3469 delegate_.SetCanWriteAnything();
3470
3471 // The first ConsumeData will fill the packet without flush.
3472 creator_.SetTransmissionType(LOSS_RETRANSMISSION);
3473
3474 size_t data_len = 1220;
3475 const std::string data(data_len, '?');
3476 QuicStreamId stream1_id = QuicUtils::GetFirstBidirectionalStreamId(
3477 framer_.transport_version(), Perspective::IS_CLIENT);
3478 QuicConsumedData consumed = creator_.ConsumeData(stream1_id, data, 0, NO_FIN);
3479 EXPECT_EQ(data_len, consumed.bytes_consumed);
3480 ASSERT_EQ(0u, creator_.BytesFree())
3481 << "Test setup failed: Please increase data_len to "
3482 << data_len + creator_.BytesFree() << " bytes.";
3483
3484 // The second ConsumeData can not be added to the packet and will flush.
3485 creator_.SetTransmissionType(NOT_RETRANSMISSION);
3486
3487 EXPECT_CALL(delegate_, OnSerializedPacket(_))
3488 .WillOnce(
3489 Invoke(this, &QuicPacketCreatorMultiplePacketsTest::SavePacket));
3490
3491 QuicStreamId stream2_id = stream1_id + 4;
3492
3493 consumed = creator_.ConsumeData(stream2_id, data, 0, NO_FIN);
3494 EXPECT_EQ(data_len, consumed.bytes_consumed);
3495
3496 // Ensure the packet is successfully created.
3497 ASSERT_EQ(1u, packets_.size());
3498 ASSERT_TRUE(packets_[0].encrypted_buffer);
3499 ASSERT_EQ(1u, packets_[0].retransmittable_frames.size());
3500 EXPECT_EQ(stream1_id,
3501 packets_[0].retransmittable_frames[0].stream_frame.stream_id);
3502
3503 // Since the second frame was not added, the packet's transmission type
3504 // should be the first frame's type.
3505 EXPECT_EQ(packets_[0].transmission_type, LOSS_RETRANSMISSION);
3506 }
3507
TEST_F(QuicPacketCreatorMultiplePacketsTest,TestConnectionIdLength)3508 TEST_F(QuicPacketCreatorMultiplePacketsTest, TestConnectionIdLength) {
3509 QuicFramerPeer::SetPerspective(&framer_, Perspective::IS_SERVER);
3510 creator_.SetServerConnectionIdLength(0);
3511 EXPECT_EQ(0, creator_.GetDestinationConnectionIdLength());
3512
3513 for (size_t i = 1; i < 10; i++) {
3514 creator_.SetServerConnectionIdLength(i);
3515 EXPECT_EQ(0, creator_.GetDestinationConnectionIdLength());
3516 }
3517 }
3518
3519 // Test whether SetMaxPacketLength() works in the situation when the queue is
3520 // empty, and we send three packets worth of data.
TEST_F(QuicPacketCreatorMultiplePacketsTest,SetMaxPacketLength_Initial)3521 TEST_F(QuicPacketCreatorMultiplePacketsTest, SetMaxPacketLength_Initial) {
3522 delegate_.SetCanWriteAnything();
3523
3524 // Send enough data for three packets.
3525 size_t data_len = 3 * kDefaultMaxPacketSize + 1;
3526 size_t packet_len = kDefaultMaxPacketSize + 100;
3527 ASSERT_LE(packet_len, kMaxOutgoingPacketSize);
3528 creator_.SetMaxPacketLength(packet_len);
3529 EXPECT_EQ(packet_len, creator_.max_packet_length());
3530
3531 EXPECT_CALL(delegate_, OnSerializedPacket(_))
3532 .Times(3)
3533 .WillRepeatedly(
3534 Invoke(this, &QuicPacketCreatorMultiplePacketsTest::SavePacket));
3535 const std::string data(data_len, '?');
3536 QuicConsumedData consumed = creator_.ConsumeData(
3537 QuicUtils::GetFirstBidirectionalStreamId(framer_.transport_version(),
3538 Perspective::IS_CLIENT),
3539 data,
3540 /*offset=*/0, FIN);
3541 EXPECT_EQ(data_len, consumed.bytes_consumed);
3542 EXPECT_TRUE(consumed.fin_consumed);
3543 EXPECT_FALSE(creator_.HasPendingFrames());
3544 EXPECT_FALSE(creator_.HasPendingRetransmittableFrames());
3545
3546 // We expect three packets, and first two of them have to be of packet_len
3547 // size. We check multiple packets (instead of just one) because we want to
3548 // ensure that |max_packet_length_| does not get changed incorrectly by the
3549 // creator after first packet is serialized.
3550 ASSERT_EQ(3u, packets_.size());
3551 EXPECT_EQ(packet_len, packets_[0].encrypted_length);
3552 EXPECT_EQ(packet_len, packets_[1].encrypted_length);
3553 CheckAllPacketsHaveSingleStreamFrame();
3554 }
3555
3556 // Test whether SetMaxPacketLength() works in the situation when we first write
3557 // data, then change packet size, then write data again.
TEST_F(QuicPacketCreatorMultiplePacketsTest,SetMaxPacketLength_Middle)3558 TEST_F(QuicPacketCreatorMultiplePacketsTest, SetMaxPacketLength_Middle) {
3559 delegate_.SetCanWriteAnything();
3560
3561 // We send enough data to overflow default packet length, but not the altered
3562 // one.
3563 size_t data_len = kDefaultMaxPacketSize;
3564 size_t packet_len = kDefaultMaxPacketSize + 100;
3565 ASSERT_LE(packet_len, kMaxOutgoingPacketSize);
3566
3567 // We expect to see three packets in total.
3568 EXPECT_CALL(delegate_, OnSerializedPacket(_))
3569 .Times(3)
3570 .WillRepeatedly(
3571 Invoke(this, &QuicPacketCreatorMultiplePacketsTest::SavePacket));
3572
3573 // Send two packets before packet size change.
3574 const std::string data(data_len, '?');
3575 QuicConsumedData consumed = creator_.ConsumeData(
3576 QuicUtils::GetFirstBidirectionalStreamId(framer_.transport_version(),
3577 Perspective::IS_CLIENT),
3578 data,
3579 /*offset=*/0, NO_FIN);
3580 creator_.Flush();
3581 EXPECT_EQ(data_len, consumed.bytes_consumed);
3582 EXPECT_FALSE(consumed.fin_consumed);
3583 EXPECT_FALSE(creator_.HasPendingFrames());
3584 EXPECT_FALSE(creator_.HasPendingRetransmittableFrames());
3585
3586 // Make sure we already have two packets.
3587 ASSERT_EQ(2u, packets_.size());
3588
3589 // Increase packet size.
3590 creator_.SetMaxPacketLength(packet_len);
3591 EXPECT_EQ(packet_len, creator_.max_packet_length());
3592
3593 // Send a packet after packet size change.
3594 creator_.AttachPacketFlusher();
3595 consumed = creator_.ConsumeData(
3596 QuicUtils::GetFirstBidirectionalStreamId(framer_.transport_version(),
3597 Perspective::IS_CLIENT),
3598 data, data_len, FIN);
3599 creator_.Flush();
3600 EXPECT_EQ(data_len, consumed.bytes_consumed);
3601 EXPECT_TRUE(consumed.fin_consumed);
3602 EXPECT_FALSE(creator_.HasPendingFrames());
3603 EXPECT_FALSE(creator_.HasPendingRetransmittableFrames());
3604
3605 // We expect first data chunk to get fragmented, but the second one to fit
3606 // into a single packet.
3607 ASSERT_EQ(3u, packets_.size());
3608 EXPECT_EQ(kDefaultMaxPacketSize, packets_[0].encrypted_length);
3609 EXPECT_LE(kDefaultMaxPacketSize, packets_[2].encrypted_length);
3610 CheckAllPacketsHaveSingleStreamFrame();
3611 }
3612
3613 // Test whether SetMaxPacketLength() works correctly when we force the change of
3614 // the packet size in the middle of the batched packet.
TEST_F(QuicPacketCreatorMultiplePacketsTest,SetMaxPacketLength_MidpacketFlush)3615 TEST_F(QuicPacketCreatorMultiplePacketsTest,
3616 SetMaxPacketLength_MidpacketFlush) {
3617 delegate_.SetCanWriteAnything();
3618
3619 size_t first_write_len = kDefaultMaxPacketSize / 2;
3620 size_t packet_len = kDefaultMaxPacketSize + 100;
3621 size_t second_write_len = packet_len + 1;
3622 ASSERT_LE(packet_len, kMaxOutgoingPacketSize);
3623
3624 // First send half of the packet worth of data. We are in the batch mode, so
3625 // should not cause packet serialization.
3626 const std::string first_write(first_write_len, '?');
3627 QuicConsumedData consumed = creator_.ConsumeData(
3628 QuicUtils::GetFirstBidirectionalStreamId(framer_.transport_version(),
3629 Perspective::IS_CLIENT),
3630 first_write,
3631 /*offset=*/0, NO_FIN);
3632 EXPECT_EQ(first_write_len, consumed.bytes_consumed);
3633 EXPECT_FALSE(consumed.fin_consumed);
3634 EXPECT_TRUE(creator_.HasPendingFrames());
3635 EXPECT_TRUE(creator_.HasPendingRetransmittableFrames());
3636
3637 // Make sure we have no packets so far.
3638 ASSERT_EQ(0u, packets_.size());
3639
3640 // Expect a packet to be flushed.
3641 EXPECT_CALL(delegate_, OnSerializedPacket(_))
3642 .WillOnce(
3643 Invoke(this, &QuicPacketCreatorMultiplePacketsTest::SavePacket));
3644
3645 // Increase packet size after flushing all frames.
3646 // Ensure it's immediately enacted.
3647 creator_.FlushCurrentPacket();
3648 creator_.SetMaxPacketLength(packet_len);
3649 EXPECT_EQ(packet_len, creator_.max_packet_length());
3650 EXPECT_FALSE(creator_.HasPendingFrames());
3651 EXPECT_FALSE(creator_.HasPendingRetransmittableFrames());
3652
3653 // We expect to see exactly one packet serialized after that, because we send
3654 // a value somewhat exceeding new max packet size, and the tail data does not
3655 // get serialized because we are still in the batch mode.
3656 EXPECT_CALL(delegate_, OnSerializedPacket(_))
3657 .WillOnce(
3658 Invoke(this, &QuicPacketCreatorMultiplePacketsTest::SavePacket));
3659
3660 // Send a more than a packet worth of data to the same stream. This should
3661 // trigger serialization of one packet, and queue another one.
3662 const std::string second_write(second_write_len, '?');
3663 consumed = creator_.ConsumeData(
3664 QuicUtils::GetFirstBidirectionalStreamId(framer_.transport_version(),
3665 Perspective::IS_CLIENT),
3666 second_write,
3667 /*offset=*/first_write_len, FIN);
3668 EXPECT_EQ(second_write_len, consumed.bytes_consumed);
3669 EXPECT_TRUE(consumed.fin_consumed);
3670 EXPECT_TRUE(creator_.HasPendingFrames());
3671 EXPECT_TRUE(creator_.HasPendingRetransmittableFrames());
3672
3673 // We expect the first packet to be underfilled, and the second packet be up
3674 // to the new max packet size.
3675 ASSERT_EQ(2u, packets_.size());
3676 EXPECT_GT(kDefaultMaxPacketSize, packets_[0].encrypted_length);
3677 EXPECT_EQ(packet_len, packets_[1].encrypted_length);
3678
3679 CheckAllPacketsHaveSingleStreamFrame();
3680 }
3681
3682 // Test sending a connectivity probing packet.
TEST_F(QuicPacketCreatorMultiplePacketsTest,GenerateConnectivityProbingPacket)3683 TEST_F(QuicPacketCreatorMultiplePacketsTest,
3684 GenerateConnectivityProbingPacket) {
3685 delegate_.SetCanWriteAnything();
3686
3687 std::unique_ptr<SerializedPacket> probing_packet;
3688 if (VersionHasIetfQuicFrames(framer_.transport_version())) {
3689 QuicPathFrameBuffer payload = {
3690 {0xde, 0xad, 0xbe, 0xef, 0xba, 0xdc, 0x0f, 0xfe}};
3691 probing_packet =
3692 creator_.SerializePathChallengeConnectivityProbingPacket(payload);
3693 } else {
3694 probing_packet = creator_.SerializeConnectivityProbingPacket();
3695 }
3696
3697 ASSERT_TRUE(simple_framer_.ProcessPacket(QuicEncryptedPacket(
3698 probing_packet->encrypted_buffer, probing_packet->encrypted_length)));
3699
3700 EXPECT_EQ(2u, simple_framer_.num_frames());
3701 if (VersionHasIetfQuicFrames(framer_.transport_version())) {
3702 EXPECT_EQ(1u, simple_framer_.path_challenge_frames().size());
3703 } else {
3704 EXPECT_EQ(1u, simple_framer_.ping_frames().size());
3705 }
3706 EXPECT_EQ(1u, simple_framer_.padding_frames().size());
3707 }
3708
3709 // Test sending an MTU probe, without any surrounding data.
TEST_F(QuicPacketCreatorMultiplePacketsTest,GenerateMtuDiscoveryPacket_Simple)3710 TEST_F(QuicPacketCreatorMultiplePacketsTest,
3711 GenerateMtuDiscoveryPacket_Simple) {
3712 delegate_.SetCanWriteAnything();
3713
3714 const size_t target_mtu = kDefaultMaxPacketSize + 100;
3715 static_assert(target_mtu < kMaxOutgoingPacketSize,
3716 "The MTU probe used by the test exceeds maximum packet size");
3717
3718 EXPECT_CALL(delegate_, OnSerializedPacket(_))
3719 .WillOnce(
3720 Invoke(this, &QuicPacketCreatorMultiplePacketsTest::SavePacket));
3721
3722 creator_.GenerateMtuDiscoveryPacket(target_mtu);
3723
3724 EXPECT_FALSE(creator_.HasPendingFrames());
3725 EXPECT_FALSE(creator_.HasPendingRetransmittableFrames());
3726 ASSERT_EQ(1u, packets_.size());
3727 EXPECT_EQ(target_mtu, packets_[0].encrypted_length);
3728
3729 PacketContents contents;
3730 contents.num_mtu_discovery_frames = 1;
3731 contents.num_padding_frames = 1;
3732 CheckPacketContains(contents, 0);
3733 }
3734
3735 // Test sending an MTU probe. Surround it with data, to ensure that it resets
3736 // the MTU to the value before the probe was sent.
TEST_F(QuicPacketCreatorMultiplePacketsTest,GenerateMtuDiscoveryPacket_SurroundedByData)3737 TEST_F(QuicPacketCreatorMultiplePacketsTest,
3738 GenerateMtuDiscoveryPacket_SurroundedByData) {
3739 delegate_.SetCanWriteAnything();
3740
3741 const size_t target_mtu = kDefaultMaxPacketSize + 100;
3742 static_assert(target_mtu < kMaxOutgoingPacketSize,
3743 "The MTU probe used by the test exceeds maximum packet size");
3744
3745 // Send enough data so it would always cause two packets to be sent.
3746 const size_t data_len = target_mtu + 1;
3747
3748 // Send a total of five packets: two packets before the probe, the probe
3749 // itself, and two packets after the probe.
3750 EXPECT_CALL(delegate_, OnSerializedPacket(_))
3751 .Times(5)
3752 .WillRepeatedly(
3753 Invoke(this, &QuicPacketCreatorMultiplePacketsTest::SavePacket));
3754
3755 // Send data before the MTU probe.
3756 const std::string data(data_len, '?');
3757 QuicConsumedData consumed = creator_.ConsumeData(
3758 QuicUtils::GetFirstBidirectionalStreamId(framer_.transport_version(),
3759 Perspective::IS_CLIENT),
3760 data,
3761 /*offset=*/0, NO_FIN);
3762 creator_.Flush();
3763 EXPECT_EQ(data_len, consumed.bytes_consumed);
3764 EXPECT_FALSE(consumed.fin_consumed);
3765 EXPECT_FALSE(creator_.HasPendingFrames());
3766 EXPECT_FALSE(creator_.HasPendingRetransmittableFrames());
3767
3768 // Send the MTU probe.
3769 creator_.GenerateMtuDiscoveryPacket(target_mtu);
3770 EXPECT_FALSE(creator_.HasPendingFrames());
3771 EXPECT_FALSE(creator_.HasPendingRetransmittableFrames());
3772
3773 // Send data after the MTU probe.
3774 creator_.AttachPacketFlusher();
3775 consumed = creator_.ConsumeData(
3776 QuicUtils::GetFirstBidirectionalStreamId(framer_.transport_version(),
3777 Perspective::IS_CLIENT),
3778 data,
3779 /*offset=*/data_len, FIN);
3780 creator_.Flush();
3781 EXPECT_EQ(data_len, consumed.bytes_consumed);
3782 EXPECT_TRUE(consumed.fin_consumed);
3783 EXPECT_FALSE(creator_.HasPendingFrames());
3784 EXPECT_FALSE(creator_.HasPendingRetransmittableFrames());
3785
3786 ASSERT_EQ(5u, packets_.size());
3787 EXPECT_EQ(kDefaultMaxPacketSize, packets_[0].encrypted_length);
3788 EXPECT_EQ(target_mtu, packets_[2].encrypted_length);
3789 EXPECT_EQ(kDefaultMaxPacketSize, packets_[3].encrypted_length);
3790
3791 PacketContents probe_contents;
3792 probe_contents.num_mtu_discovery_frames = 1;
3793 probe_contents.num_padding_frames = 1;
3794
3795 CheckPacketHasSingleStreamFrame(0);
3796 CheckPacketHasSingleStreamFrame(1);
3797 CheckPacketContains(probe_contents, 2);
3798 CheckPacketHasSingleStreamFrame(3);
3799 CheckPacketHasSingleStreamFrame(4);
3800 }
3801
3802 // Regression test for b/31486443.
TEST_F(QuicPacketCreatorMultiplePacketsTest,ConnectionCloseFrameLargerThanPacketSize)3803 TEST_F(QuicPacketCreatorMultiplePacketsTest,
3804 ConnectionCloseFrameLargerThanPacketSize) {
3805 delegate_.SetCanWriteAnything();
3806 char buf[2000] = {};
3807 absl::string_view error_details(buf, 2000);
3808 const QuicErrorCode kQuicErrorCode = QUIC_PACKET_WRITE_ERROR;
3809
3810 QuicConnectionCloseFrame* frame = new QuicConnectionCloseFrame(
3811 framer_.transport_version(), kQuicErrorCode, NO_IETF_QUIC_ERROR,
3812 std::string(error_details),
3813 /*transport_close_frame_type=*/0);
3814 creator_.ConsumeRetransmittableControlFrame(QuicFrame(frame),
3815 /*bundle_ack=*/false);
3816 EXPECT_TRUE(creator_.HasPendingFrames());
3817 EXPECT_TRUE(creator_.HasPendingRetransmittableFrames());
3818 }
3819
TEST_F(QuicPacketCreatorMultiplePacketsTest,RandomPaddingAfterFinSingleStreamSinglePacket)3820 TEST_F(QuicPacketCreatorMultiplePacketsTest,
3821 RandomPaddingAfterFinSingleStreamSinglePacket) {
3822 const QuicByteCount kStreamFramePayloadSize = 100u;
3823 char buf[kStreamFramePayloadSize] = {};
3824 const QuicStreamId kDataStreamId = 5;
3825 // Set the packet size be enough for one stream frame with 0 stream offset and
3826 // max size of random padding.
3827 size_t length =
3828 TaggingEncrypter(0x00).GetCiphertextSize(0) +
3829 GetPacketHeaderSize(
3830 framer_.transport_version(),
3831 creator_.GetDestinationConnectionIdLength(),
3832 creator_.GetSourceConnectionIdLength(),
3833 QuicPacketCreatorPeer::SendVersionInPacket(&creator_),
3834 !kIncludeDiversificationNonce,
3835 QuicPacketCreatorPeer::GetPacketNumberLength(&creator_),
3836 QuicPacketCreatorPeer::GetRetryTokenLengthLength(&creator_), 0,
3837 QuicPacketCreatorPeer::GetLengthLength(&creator_)) +
3838 QuicFramer::GetMinStreamFrameSize(
3839 framer_.transport_version(), kDataStreamId, 0,
3840 /*last_frame_in_packet=*/false,
3841 kStreamFramePayloadSize + kMaxNumRandomPaddingBytes) +
3842 kStreamFramePayloadSize + kMaxNumRandomPaddingBytes;
3843 creator_.SetMaxPacketLength(length);
3844 delegate_.SetCanWriteAnything();
3845 EXPECT_CALL(delegate_, OnSerializedPacket(_))
3846 .WillOnce(
3847 Invoke(this, &QuicPacketCreatorMultiplePacketsTest::SavePacket));
3848 QuicConsumedData consumed = creator_.ConsumeData(
3849 kDataStreamId, absl::string_view(buf, kStreamFramePayloadSize), 0,
3850 FIN_AND_PADDING);
3851 creator_.Flush();
3852 EXPECT_EQ(kStreamFramePayloadSize, consumed.bytes_consumed);
3853 EXPECT_FALSE(creator_.HasPendingFrames());
3854 EXPECT_FALSE(creator_.HasPendingRetransmittableFrames());
3855
3856 EXPECT_EQ(1u, packets_.size());
3857 PacketContents contents;
3858 // The packet has both stream and padding frames.
3859 contents.num_padding_frames = 1;
3860 contents.num_stream_frames = 1;
3861 CheckPacketContains(contents, 0);
3862 }
3863
TEST_F(QuicPacketCreatorMultiplePacketsTest,RandomPaddingAfterFinSingleStreamMultiplePackets)3864 TEST_F(QuicPacketCreatorMultiplePacketsTest,
3865 RandomPaddingAfterFinSingleStreamMultiplePackets) {
3866 const QuicByteCount kStreamFramePayloadSize = 100u;
3867 char buf[kStreamFramePayloadSize] = {};
3868 const QuicStreamId kDataStreamId = 5;
3869 // Set the packet size be enough for one stream frame with 0 stream offset +
3870 // 1. One or more packets will accommodate.
3871 size_t length =
3872 TaggingEncrypter(0x00).GetCiphertextSize(0) +
3873 GetPacketHeaderSize(
3874 framer_.transport_version(),
3875 creator_.GetDestinationConnectionIdLength(),
3876 creator_.GetSourceConnectionIdLength(),
3877 QuicPacketCreatorPeer::SendVersionInPacket(&creator_),
3878 !kIncludeDiversificationNonce,
3879 QuicPacketCreatorPeer::GetPacketNumberLength(&creator_),
3880 QuicPacketCreatorPeer::GetRetryTokenLengthLength(&creator_), 0,
3881 QuicPacketCreatorPeer::GetLengthLength(&creator_)) +
3882 QuicFramer::GetMinStreamFrameSize(
3883 framer_.transport_version(), kDataStreamId, 0,
3884 /*last_frame_in_packet=*/false, kStreamFramePayloadSize + 1) +
3885 kStreamFramePayloadSize + 1;
3886 creator_.SetMaxPacketLength(length);
3887 delegate_.SetCanWriteAnything();
3888 EXPECT_CALL(delegate_, OnSerializedPacket(_))
3889 .WillRepeatedly(
3890 Invoke(this, &QuicPacketCreatorMultiplePacketsTest::SavePacket));
3891 QuicConsumedData consumed = creator_.ConsumeData(
3892 kDataStreamId, absl::string_view(buf, kStreamFramePayloadSize), 0,
3893 FIN_AND_PADDING);
3894 creator_.Flush();
3895 EXPECT_EQ(kStreamFramePayloadSize, consumed.bytes_consumed);
3896 EXPECT_FALSE(creator_.HasPendingFrames());
3897 EXPECT_FALSE(creator_.HasPendingRetransmittableFrames());
3898
3899 EXPECT_LE(1u, packets_.size());
3900 PacketContents contents;
3901 // The first packet has both stream and padding frames.
3902 contents.num_stream_frames = 1;
3903 contents.num_padding_frames = 1;
3904 CheckPacketContains(contents, 0);
3905
3906 for (size_t i = 1; i < packets_.size(); ++i) {
3907 // Following packets only have paddings.
3908 contents.num_stream_frames = 0;
3909 contents.num_padding_frames = 1;
3910 CheckPacketContains(contents, i);
3911 }
3912 }
3913
TEST_F(QuicPacketCreatorMultiplePacketsTest,RandomPaddingAfterFinMultipleStreamsMultiplePackets)3914 TEST_F(QuicPacketCreatorMultiplePacketsTest,
3915 RandomPaddingAfterFinMultipleStreamsMultiplePackets) {
3916 const QuicByteCount kStreamFramePayloadSize = 100u;
3917 char buf[kStreamFramePayloadSize] = {};
3918 const QuicStreamId kDataStreamId1 = 5;
3919 const QuicStreamId kDataStreamId2 = 6;
3920 // Set the packet size be enough for first frame with 0 stream offset + second
3921 // frame + 1 byte payload. two or more packets will accommodate.
3922 size_t length =
3923 TaggingEncrypter(0x00).GetCiphertextSize(0) +
3924 GetPacketHeaderSize(
3925 framer_.transport_version(),
3926 creator_.GetDestinationConnectionIdLength(),
3927 creator_.GetSourceConnectionIdLength(),
3928 QuicPacketCreatorPeer::SendVersionInPacket(&creator_),
3929 !kIncludeDiversificationNonce,
3930 QuicPacketCreatorPeer::GetPacketNumberLength(&creator_),
3931 QuicPacketCreatorPeer::GetRetryTokenLengthLength(&creator_), 0,
3932 QuicPacketCreatorPeer::GetLengthLength(&creator_)) +
3933 QuicFramer::GetMinStreamFrameSize(
3934 framer_.transport_version(), kDataStreamId1, 0,
3935 /*last_frame_in_packet=*/false, kStreamFramePayloadSize) +
3936 kStreamFramePayloadSize +
3937 QuicFramer::GetMinStreamFrameSize(framer_.transport_version(),
3938 kDataStreamId1, 0,
3939 /*last_frame_in_packet=*/false, 1) +
3940 1;
3941 creator_.SetMaxPacketLength(length);
3942 delegate_.SetCanWriteAnything();
3943 EXPECT_CALL(delegate_, OnSerializedPacket(_))
3944 .WillRepeatedly(
3945 Invoke(this, &QuicPacketCreatorMultiplePacketsTest::SavePacket));
3946 QuicConsumedData consumed = creator_.ConsumeData(
3947 kDataStreamId1, absl::string_view(buf, kStreamFramePayloadSize), 0,
3948 FIN_AND_PADDING);
3949 EXPECT_EQ(kStreamFramePayloadSize, consumed.bytes_consumed);
3950 consumed = creator_.ConsumeData(
3951 kDataStreamId2, absl::string_view(buf, kStreamFramePayloadSize), 0,
3952 FIN_AND_PADDING);
3953 EXPECT_EQ(kStreamFramePayloadSize, consumed.bytes_consumed);
3954 creator_.Flush();
3955 EXPECT_FALSE(creator_.HasPendingFrames());
3956 EXPECT_FALSE(creator_.HasPendingRetransmittableFrames());
3957
3958 EXPECT_LE(2u, packets_.size());
3959 PacketContents contents;
3960 // The first packet has two stream frames.
3961 contents.num_stream_frames = 2;
3962 CheckPacketContains(contents, 0);
3963
3964 // The second packet has one stream frame and padding frames.
3965 contents.num_stream_frames = 1;
3966 contents.num_padding_frames = 1;
3967 CheckPacketContains(contents, 1);
3968
3969 for (size_t i = 2; i < packets_.size(); ++i) {
3970 // Following packets only have paddings.
3971 contents.num_stream_frames = 0;
3972 contents.num_padding_frames = 1;
3973 CheckPacketContains(contents, i);
3974 }
3975 }
3976
TEST_F(QuicPacketCreatorMultiplePacketsTest,AddMessageFrame)3977 TEST_F(QuicPacketCreatorMultiplePacketsTest, AddMessageFrame) {
3978 if (framer_.version().UsesTls()) {
3979 creator_.SetMaxDatagramFrameSize(kMaxAcceptedDatagramFrameSize);
3980 }
3981 delegate_.SetCanWriteAnything();
3982 EXPECT_CALL(delegate_, OnSerializedPacket(_))
3983 .WillOnce(
3984 Invoke(this, &QuicPacketCreatorMultiplePacketsTest::SavePacket));
3985
3986 creator_.ConsumeData(QuicUtils::GetFirstBidirectionalStreamId(
3987 framer_.transport_version(), Perspective::IS_CLIENT),
3988 "foo", 0, FIN);
3989 EXPECT_EQ(MESSAGE_STATUS_SUCCESS,
3990 creator_.AddMessageFrame(1, MemSliceFromString("message")));
3991 EXPECT_TRUE(creator_.HasPendingFrames());
3992 EXPECT_TRUE(creator_.HasPendingRetransmittableFrames());
3993
3994 // Add a message which causes the flush of current packet.
3995 EXPECT_EQ(MESSAGE_STATUS_SUCCESS,
3996 creator_.AddMessageFrame(
3997 2, MemSliceFromString(std::string(
3998 creator_.GetCurrentLargestMessagePayload(), 'a'))));
3999 EXPECT_TRUE(creator_.HasPendingRetransmittableFrames());
4000
4001 // Failed to send messages which cannot fit into one packet.
4002 EXPECT_EQ(MESSAGE_STATUS_TOO_LARGE,
4003 creator_.AddMessageFrame(
4004 3, MemSliceFromString(std::string(
4005 creator_.GetCurrentLargestMessagePayload() + 10, 'a'))));
4006 }
4007
TEST_F(QuicPacketCreatorMultiplePacketsTest,ConnectionId)4008 TEST_F(QuicPacketCreatorMultiplePacketsTest, ConnectionId) {
4009 creator_.SetServerConnectionId(TestConnectionId(0x1337));
4010 EXPECT_EQ(TestConnectionId(0x1337), creator_.GetDestinationConnectionId());
4011 EXPECT_EQ(EmptyQuicConnectionId(), creator_.GetSourceConnectionId());
4012 if (!framer_.version().SupportsClientConnectionIds()) {
4013 return;
4014 }
4015 creator_.SetClientConnectionId(TestConnectionId(0x33));
4016 EXPECT_EQ(TestConnectionId(0x1337), creator_.GetDestinationConnectionId());
4017 EXPECT_EQ(TestConnectionId(0x33), creator_.GetSourceConnectionId());
4018 }
4019
4020 // Regresstion test for b/159812345.
TEST_F(QuicPacketCreatorMultiplePacketsTest,ExtraPaddingNeeded)4021 TEST_F(QuicPacketCreatorMultiplePacketsTest, ExtraPaddingNeeded) {
4022 if (!framer_.version().HasHeaderProtection()) {
4023 return;
4024 }
4025 delegate_.SetCanWriteAnything();
4026 // If the packet number length > 1, we won't get padding.
4027 EXPECT_EQ(QuicPacketCreatorPeer::GetPacketNumberLength(&creator_),
4028 PACKET_1BYTE_PACKET_NUMBER);
4029 EXPECT_CALL(delegate_, OnSerializedPacket(_))
4030 .WillOnce(
4031 Invoke(this, &QuicPacketCreatorMultiplePacketsTest::SavePacket));
4032 // with no data and no offset, this is a 2B STREAM frame.
4033 creator_.ConsumeData(QuicUtils::GetFirstBidirectionalStreamId(
4034 framer_.transport_version(), Perspective::IS_CLIENT),
4035 "", 0, FIN);
4036 creator_.Flush();
4037 ASSERT_FALSE(packets_[0].nonretransmittable_frames.empty());
4038 QuicFrame padding = packets_[0].nonretransmittable_frames[0];
4039 // Verify stream frame expansion is excluded.
4040 EXPECT_EQ(padding.padding_frame.num_padding_bytes, 1);
4041 }
4042
TEST_F(QuicPacketCreatorMultiplePacketsTest,PeerAddressContextWithSameAddress)4043 TEST_F(QuicPacketCreatorMultiplePacketsTest,
4044 PeerAddressContextWithSameAddress) {
4045 QuicConnectionId client_connection_id = TestConnectionId(1);
4046 QuicConnectionId server_connection_id = TestConnectionId(2);
4047 QuicSocketAddress peer_addr(QuicIpAddress::Any4(), 12345);
4048 creator_.SetDefaultPeerAddress(peer_addr);
4049 creator_.SetClientConnectionId(client_connection_id);
4050 creator_.SetServerConnectionId(server_connection_id);
4051 // Send some stream data.
4052 EXPECT_CALL(delegate_, ShouldGeneratePacket(_, _))
4053 .WillRepeatedly(Return(true));
4054 EXPECT_EQ(3u, creator_
4055 .ConsumeData(QuicUtils::GetFirstBidirectionalStreamId(
4056 creator_.transport_version(),
4057 Perspective::IS_CLIENT),
4058 "foo", 0, NO_FIN)
4059 .bytes_consumed);
4060 EXPECT_TRUE(creator_.HasPendingFrames());
4061 {
4062 // Set the same address via context which should not trigger flush.
4063 QuicPacketCreator::ScopedPeerAddressContext context(
4064 &creator_, peer_addr, client_connection_id, server_connection_id);
4065 ASSERT_EQ(client_connection_id, creator_.GetClientConnectionId());
4066 ASSERT_EQ(server_connection_id, creator_.GetServerConnectionId());
4067 EXPECT_TRUE(creator_.HasPendingFrames());
4068 // Queue another STREAM_FRAME.
4069 EXPECT_EQ(3u, creator_
4070 .ConsumeData(QuicUtils::GetFirstBidirectionalStreamId(
4071 creator_.transport_version(),
4072 Perspective::IS_CLIENT),
4073 "foo", 0, FIN)
4074 .bytes_consumed);
4075 }
4076 // After exiting the scope, the last queued frame should be flushed.
4077 EXPECT_TRUE(creator_.HasPendingFrames());
4078 EXPECT_CALL(delegate_, OnSerializedPacket(_))
4079 .WillOnce(Invoke([=](SerializedPacket packet) {
4080 EXPECT_EQ(peer_addr, packet.peer_address);
4081 ASSERT_EQ(2u, packet.retransmittable_frames.size());
4082 EXPECT_EQ(STREAM_FRAME, packet.retransmittable_frames.front().type);
4083 EXPECT_EQ(STREAM_FRAME, packet.retransmittable_frames.back().type);
4084 }));
4085 creator_.FlushCurrentPacket();
4086 }
4087
TEST_F(QuicPacketCreatorMultiplePacketsTest,PeerAddressContextWithDifferentAddress)4088 TEST_F(QuicPacketCreatorMultiplePacketsTest,
4089 PeerAddressContextWithDifferentAddress) {
4090 QuicSocketAddress peer_addr(QuicIpAddress::Any4(), 12345);
4091 creator_.SetDefaultPeerAddress(peer_addr);
4092 // Send some stream data.
4093 EXPECT_CALL(delegate_, ShouldGeneratePacket(_, _))
4094 .WillRepeatedly(Return(true));
4095 EXPECT_EQ(3u, creator_
4096 .ConsumeData(QuicUtils::GetFirstBidirectionalStreamId(
4097 creator_.transport_version(),
4098 Perspective::IS_CLIENT),
4099 "foo", 0, NO_FIN)
4100 .bytes_consumed);
4101
4102 QuicSocketAddress peer_addr1(QuicIpAddress::Any4(), 12346);
4103 EXPECT_CALL(delegate_, OnSerializedPacket(_))
4104 .WillOnce(Invoke([=](SerializedPacket packet) {
4105 EXPECT_EQ(peer_addr, packet.peer_address);
4106 ASSERT_EQ(1u, packet.retransmittable_frames.size());
4107 EXPECT_EQ(STREAM_FRAME, packet.retransmittable_frames.front().type);
4108 }))
4109 .WillOnce(Invoke([=](SerializedPacket packet) {
4110 EXPECT_EQ(peer_addr1, packet.peer_address);
4111 ASSERT_EQ(1u, packet.retransmittable_frames.size());
4112 EXPECT_EQ(STREAM_FRAME, packet.retransmittable_frames.front().type);
4113 }));
4114 EXPECT_TRUE(creator_.HasPendingFrames());
4115 {
4116 QuicConnectionId client_connection_id = TestConnectionId(1);
4117 QuicConnectionId server_connection_id = TestConnectionId(2);
4118 // Set a different address via context which should trigger flush.
4119 QuicPacketCreator::ScopedPeerAddressContext context(
4120 &creator_, peer_addr1, client_connection_id, server_connection_id);
4121 ASSERT_EQ(client_connection_id, creator_.GetClientConnectionId());
4122 ASSERT_EQ(server_connection_id, creator_.GetServerConnectionId());
4123 EXPECT_FALSE(creator_.HasPendingFrames());
4124 // Queue another STREAM_FRAME.
4125 EXPECT_EQ(3u, creator_
4126 .ConsumeData(QuicUtils::GetFirstBidirectionalStreamId(
4127 creator_.transport_version(),
4128 Perspective::IS_CLIENT),
4129 "foo", 0, FIN)
4130 .bytes_consumed);
4131 EXPECT_TRUE(creator_.HasPendingFrames());
4132 }
4133 // After exiting the scope, the last queued frame should be flushed.
4134 EXPECT_FALSE(creator_.HasPendingFrames());
4135 }
4136
TEST_F(QuicPacketCreatorMultiplePacketsTest,NestedPeerAddressContextWithDifferentAddress)4137 TEST_F(QuicPacketCreatorMultiplePacketsTest,
4138 NestedPeerAddressContextWithDifferentAddress) {
4139 QuicConnectionId client_connection_id1 = creator_.GetClientConnectionId();
4140 QuicConnectionId server_connection_id1 = creator_.GetServerConnectionId();
4141 QuicSocketAddress peer_addr(QuicIpAddress::Any4(), 12345);
4142 creator_.SetDefaultPeerAddress(peer_addr);
4143 QuicPacketCreator::ScopedPeerAddressContext context(
4144 &creator_, peer_addr, client_connection_id1, server_connection_id1);
4145 ASSERT_EQ(client_connection_id1, creator_.GetClientConnectionId());
4146 ASSERT_EQ(server_connection_id1, creator_.GetServerConnectionId());
4147
4148 // Send some stream data.
4149 EXPECT_CALL(delegate_, ShouldGeneratePacket(_, _))
4150 .WillRepeatedly(Return(true));
4151 EXPECT_EQ(3u, creator_
4152 .ConsumeData(QuicUtils::GetFirstBidirectionalStreamId(
4153 creator_.transport_version(),
4154 Perspective::IS_CLIENT),
4155 "foo", 0, NO_FIN)
4156 .bytes_consumed);
4157 EXPECT_TRUE(creator_.HasPendingFrames());
4158
4159 QuicSocketAddress peer_addr1(QuicIpAddress::Any4(), 12346);
4160 EXPECT_CALL(delegate_, OnSerializedPacket(_))
4161 .WillOnce(Invoke([=](SerializedPacket packet) {
4162 EXPECT_EQ(peer_addr, packet.peer_address);
4163 ASSERT_EQ(1u, packet.retransmittable_frames.size());
4164 EXPECT_EQ(STREAM_FRAME, packet.retransmittable_frames.front().type);
4165
4166 QuicConnectionId client_connection_id2 = TestConnectionId(3);
4167 QuicConnectionId server_connection_id2 = TestConnectionId(4);
4168 // Set up another context with a different address.
4169 QuicPacketCreator::ScopedPeerAddressContext context(
4170 &creator_, peer_addr1, client_connection_id2,
4171 server_connection_id2);
4172 ASSERT_EQ(client_connection_id2, creator_.GetClientConnectionId());
4173 ASSERT_EQ(server_connection_id2, creator_.GetServerConnectionId());
4174 EXPECT_CALL(delegate_, ShouldGeneratePacket(_, _))
4175 .WillRepeatedly(Return(true));
4176 EXPECT_EQ(3u, creator_
4177 .ConsumeData(QuicUtils::GetFirstBidirectionalStreamId(
4178 creator_.transport_version(),
4179 Perspective::IS_CLIENT),
4180 "foo", 0, NO_FIN)
4181 .bytes_consumed);
4182 EXPECT_TRUE(creator_.HasPendingFrames());
4183 // This should trigger another OnSerializedPacket() with the 2nd
4184 // address.
4185 creator_.FlushCurrentPacket();
4186 }))
4187 .WillOnce(Invoke([=](SerializedPacket packet) {
4188 EXPECT_EQ(peer_addr1, packet.peer_address);
4189 ASSERT_EQ(1u, packet.retransmittable_frames.size());
4190 EXPECT_EQ(STREAM_FRAME, packet.retransmittable_frames.front().type);
4191 }));
4192 creator_.FlushCurrentPacket();
4193 }
4194
4195 } // namespace
4196 } // namespace test
4197 } // namespace quic
4198