1 // Copyright 2019 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/uber_received_packet_manager.h"
6 
7 #include <utility>
8 
9 #include "quiche/quic/core/congestion_control/rtt_stats.h"
10 #include "quiche/quic/core/crypto/crypto_protocol.h"
11 #include "quiche/quic/core/quic_connection_stats.h"
12 #include "quiche/quic/core/quic_utils.h"
13 #include "quiche/quic/platform/api/quic_test.h"
14 #include "quiche/quic/test_tools/mock_clock.h"
15 
16 namespace quic {
17 namespace test {
18 
19 class UberReceivedPacketManagerPeer {
20  public:
SetAckDecimationDelay(UberReceivedPacketManager * manager,float ack_decimation_delay)21   static void SetAckDecimationDelay(UberReceivedPacketManager* manager,
22                                     float ack_decimation_delay) {
23     for (auto& received_packet_manager : manager->received_packet_managers_) {
24       received_packet_manager.ack_decimation_delay_ = ack_decimation_delay;
25     }
26   }
27 };
28 
29 namespace {
30 
31 const bool kInstigateAck = true;
32 const QuicTime::Delta kMinRttMs = QuicTime::Delta::FromMilliseconds(40);
33 const QuicTime::Delta kDelayedAckTime =
34     QuicTime::Delta::FromMilliseconds(kDefaultDelayedAckTimeMs);
35 
GetEncryptionLevel(PacketNumberSpace packet_number_space)36 EncryptionLevel GetEncryptionLevel(PacketNumberSpace packet_number_space) {
37   switch (packet_number_space) {
38     case INITIAL_DATA:
39       return ENCRYPTION_INITIAL;
40     case HANDSHAKE_DATA:
41       return ENCRYPTION_HANDSHAKE;
42     case APPLICATION_DATA:
43       return ENCRYPTION_FORWARD_SECURE;
44     default:
45       QUICHE_DCHECK(false);
46       return NUM_ENCRYPTION_LEVELS;
47   }
48 }
49 
50 class UberReceivedPacketManagerTest : public QuicTest {
51  protected:
UberReceivedPacketManagerTest()52   UberReceivedPacketManagerTest() {
53     manager_ = std::make_unique<UberReceivedPacketManager>(&stats_);
54     clock_.AdvanceTime(QuicTime::Delta::FromSeconds(1));
55     rtt_stats_.UpdateRtt(kMinRttMs, QuicTime::Delta::Zero(), QuicTime::Zero());
56     manager_->set_save_timestamps(true);
57   }
58 
RecordPacketReceipt(uint64_t packet_number)59   void RecordPacketReceipt(uint64_t packet_number) {
60     RecordPacketReceipt(ENCRYPTION_FORWARD_SECURE, packet_number);
61   }
62 
RecordPacketReceipt(uint64_t packet_number,QuicTime receipt_time)63   void RecordPacketReceipt(uint64_t packet_number, QuicTime receipt_time) {
64     RecordPacketReceipt(ENCRYPTION_FORWARD_SECURE, packet_number, receipt_time);
65   }
66 
RecordPacketReceipt(EncryptionLevel decrypted_packet_level,uint64_t packet_number)67   void RecordPacketReceipt(EncryptionLevel decrypted_packet_level,
68                            uint64_t packet_number) {
69     RecordPacketReceipt(decrypted_packet_level, packet_number,
70                         QuicTime::Zero());
71   }
72 
RecordPacketReceipt(EncryptionLevel decrypted_packet_level,uint64_t packet_number,QuicTime receipt_time)73   void RecordPacketReceipt(EncryptionLevel decrypted_packet_level,
74                            uint64_t packet_number, QuicTime receipt_time) {
75     QuicPacketHeader header;
76     header.packet_number = QuicPacketNumber(packet_number);
77     manager_->RecordPacketReceived(decrypted_packet_level, header, receipt_time,
78                                    ECN_NOT_ECT);
79   }
80 
HasPendingAck()81   bool HasPendingAck() {
82     if (!manager_->supports_multiple_packet_number_spaces()) {
83       return manager_->GetAckTimeout(APPLICATION_DATA).IsInitialized();
84     }
85     return manager_->GetEarliestAckTimeout().IsInitialized();
86   }
87 
MaybeUpdateAckTimeout(bool should_last_packet_instigate_acks,uint64_t last_received_packet_number)88   void MaybeUpdateAckTimeout(bool should_last_packet_instigate_acks,
89                              uint64_t last_received_packet_number) {
90     MaybeUpdateAckTimeout(should_last_packet_instigate_acks,
91                           ENCRYPTION_FORWARD_SECURE,
92                           last_received_packet_number);
93   }
94 
MaybeUpdateAckTimeout(bool should_last_packet_instigate_acks,EncryptionLevel decrypted_packet_level,uint64_t last_received_packet_number)95   void MaybeUpdateAckTimeout(bool should_last_packet_instigate_acks,
96                              EncryptionLevel decrypted_packet_level,
97                              uint64_t last_received_packet_number) {
98     manager_->MaybeUpdateAckTimeout(
99         should_last_packet_instigate_acks, decrypted_packet_level,
100         QuicPacketNumber(last_received_packet_number), clock_.ApproximateNow(),
101         clock_.ApproximateNow(), &rtt_stats_);
102   }
103 
CheckAckTimeout(QuicTime time)104   void CheckAckTimeout(QuicTime time) {
105     QUICHE_DCHECK(HasPendingAck());
106     if (!manager_->supports_multiple_packet_number_spaces()) {
107       QUICHE_DCHECK(manager_->GetAckTimeout(APPLICATION_DATA) == time);
108       if (time <= clock_.ApproximateNow()) {
109         // ACK timeout expires, send an ACK.
110         manager_->ResetAckStates(ENCRYPTION_FORWARD_SECURE);
111         QUICHE_DCHECK(!HasPendingAck());
112       }
113       return;
114     }
115     QUICHE_DCHECK(manager_->GetEarliestAckTimeout() == time);
116     // Send all expired ACKs.
117     for (int8_t i = INITIAL_DATA; i < NUM_PACKET_NUMBER_SPACES; ++i) {
118       const QuicTime ack_timeout =
119           manager_->GetAckTimeout(static_cast<PacketNumberSpace>(i));
120       if (!ack_timeout.IsInitialized() ||
121           ack_timeout > clock_.ApproximateNow()) {
122         continue;
123       }
124       manager_->ResetAckStates(
125           GetEncryptionLevel(static_cast<PacketNumberSpace>(i)));
126     }
127   }
128 
129   MockClock clock_;
130   RttStats rtt_stats_;
131   QuicConnectionStats stats_;
132   std::unique_ptr<UberReceivedPacketManager> manager_;
133 };
134 
TEST_F(UberReceivedPacketManagerTest,DontWaitForPacketsBefore)135 TEST_F(UberReceivedPacketManagerTest, DontWaitForPacketsBefore) {
136   EXPECT_TRUE(manager_->IsAckFrameEmpty(APPLICATION_DATA));
137   RecordPacketReceipt(2);
138   EXPECT_FALSE(manager_->IsAckFrameEmpty(APPLICATION_DATA));
139   RecordPacketReceipt(7);
140   EXPECT_TRUE(manager_->IsAwaitingPacket(ENCRYPTION_FORWARD_SECURE,
141                                          QuicPacketNumber(3u)));
142   EXPECT_TRUE(manager_->IsAwaitingPacket(ENCRYPTION_FORWARD_SECURE,
143                                          QuicPacketNumber(6u)));
144   manager_->DontWaitForPacketsBefore(ENCRYPTION_FORWARD_SECURE,
145                                      QuicPacketNumber(4));
146   EXPECT_FALSE(manager_->IsAwaitingPacket(ENCRYPTION_FORWARD_SECURE,
147                                           QuicPacketNumber(3u)));
148   EXPECT_TRUE(manager_->IsAwaitingPacket(ENCRYPTION_FORWARD_SECURE,
149                                          QuicPacketNumber(6u)));
150 }
151 
TEST_F(UberReceivedPacketManagerTest,GetUpdatedAckFrame)152 TEST_F(UberReceivedPacketManagerTest, GetUpdatedAckFrame) {
153   QuicTime two_ms = QuicTime::Zero() + QuicTime::Delta::FromMilliseconds(2);
154   EXPECT_FALSE(manager_->IsAckFrameUpdated());
155   RecordPacketReceipt(2, two_ms);
156   EXPECT_TRUE(manager_->IsAckFrameUpdated());
157 
158   QuicFrame ack =
159       manager_->GetUpdatedAckFrame(APPLICATION_DATA, QuicTime::Zero());
160   manager_->ResetAckStates(ENCRYPTION_FORWARD_SECURE);
161   EXPECT_FALSE(manager_->IsAckFrameUpdated());
162   // When UpdateReceivedPacketInfo with a time earlier than the time of the
163   // largest observed packet, make sure that the delta is 0, not negative.
164   EXPECT_EQ(QuicTime::Delta::Zero(), ack.ack_frame->ack_delay_time);
165   EXPECT_EQ(1u, ack.ack_frame->received_packet_times.size());
166 
167   QuicTime four_ms = QuicTime::Zero() + QuicTime::Delta::FromMilliseconds(4);
168   ack = manager_->GetUpdatedAckFrame(APPLICATION_DATA, four_ms);
169   manager_->ResetAckStates(ENCRYPTION_FORWARD_SECURE);
170   EXPECT_FALSE(manager_->IsAckFrameUpdated());
171   // When UpdateReceivedPacketInfo after not having received a new packet,
172   // the delta should still be accurate.
173   EXPECT_EQ(QuicTime::Delta::FromMilliseconds(2),
174             ack.ack_frame->ack_delay_time);
175   // And received packet times won't have change.
176   EXPECT_EQ(1u, ack.ack_frame->received_packet_times.size());
177 
178   RecordPacketReceipt(999, two_ms);
179   RecordPacketReceipt(4, two_ms);
180   RecordPacketReceipt(1000, two_ms);
181   EXPECT_TRUE(manager_->IsAckFrameUpdated());
182   ack = manager_->GetUpdatedAckFrame(APPLICATION_DATA, two_ms);
183   manager_->ResetAckStates(ENCRYPTION_FORWARD_SECURE);
184   EXPECT_FALSE(manager_->IsAckFrameUpdated());
185   // UpdateReceivedPacketInfo should discard any times which can't be
186   // expressed on the wire.
187   EXPECT_EQ(2u, ack.ack_frame->received_packet_times.size());
188 }
189 
TEST_F(UberReceivedPacketManagerTest,UpdateReceivedConnectionStats)190 TEST_F(UberReceivedPacketManagerTest, UpdateReceivedConnectionStats) {
191   EXPECT_FALSE(manager_->IsAckFrameUpdated());
192   RecordPacketReceipt(1);
193   EXPECT_TRUE(manager_->IsAckFrameUpdated());
194   RecordPacketReceipt(6);
195   RecordPacketReceipt(2,
196                       QuicTime::Zero() + QuicTime::Delta::FromMilliseconds(1));
197 
198   EXPECT_EQ(4u, stats_.max_sequence_reordering);
199   EXPECT_EQ(1000, stats_.max_time_reordering_us);
200   EXPECT_EQ(1u, stats_.packets_reordered);
201 }
202 
TEST_F(UberReceivedPacketManagerTest,LimitAckRanges)203 TEST_F(UberReceivedPacketManagerTest, LimitAckRanges) {
204   manager_->set_max_ack_ranges(10);
205   EXPECT_FALSE(manager_->IsAckFrameUpdated());
206   for (int i = 0; i < 100; ++i) {
207     RecordPacketReceipt(1 + 2 * i);
208     EXPECT_TRUE(manager_->IsAckFrameUpdated());
209     manager_->GetUpdatedAckFrame(APPLICATION_DATA, QuicTime::Zero());
210     EXPECT_GE(10u, manager_->ack_frame().packets.NumIntervals());
211     EXPECT_EQ(QuicPacketNumber(1u + 2 * i),
212               manager_->ack_frame().packets.Max());
213     for (int j = 0; j < std::min(10, i + 1); ++j) {
214       ASSERT_GE(i, j);
215       EXPECT_TRUE(manager_->ack_frame().packets.Contains(
216           QuicPacketNumber(1 + (i - j) * 2)));
217       if (i > j) {
218         EXPECT_FALSE(manager_->ack_frame().packets.Contains(
219             QuicPacketNumber((i - j) * 2)));
220       }
221     }
222   }
223 }
224 
TEST_F(UberReceivedPacketManagerTest,IgnoreOutOfOrderTimestamps)225 TEST_F(UberReceivedPacketManagerTest, IgnoreOutOfOrderTimestamps) {
226   EXPECT_FALSE(manager_->IsAckFrameUpdated());
227   RecordPacketReceipt(1, QuicTime::Zero());
228   EXPECT_TRUE(manager_->IsAckFrameUpdated());
229   EXPECT_EQ(1u, manager_->ack_frame().received_packet_times.size());
230   RecordPacketReceipt(2,
231                       QuicTime::Zero() + QuicTime::Delta::FromMilliseconds(1));
232   EXPECT_EQ(2u, manager_->ack_frame().received_packet_times.size());
233   RecordPacketReceipt(3, QuicTime::Zero());
234   EXPECT_EQ(2u, manager_->ack_frame().received_packet_times.size());
235 }
236 
TEST_F(UberReceivedPacketManagerTest,OutOfOrderReceiptCausesAckSent)237 TEST_F(UberReceivedPacketManagerTest, OutOfOrderReceiptCausesAckSent) {
238   EXPECT_FALSE(HasPendingAck());
239 
240   RecordPacketReceipt(3, clock_.ApproximateNow());
241   MaybeUpdateAckTimeout(kInstigateAck, 3);
242   // Delayed ack is scheduled.
243   CheckAckTimeout(clock_.ApproximateNow() + kDelayedAckTime);
244 
245   RecordPacketReceipt(2, clock_.ApproximateNow());
246   MaybeUpdateAckTimeout(kInstigateAck, 2);
247   CheckAckTimeout(clock_.ApproximateNow());
248 
249   RecordPacketReceipt(1, clock_.ApproximateNow());
250   MaybeUpdateAckTimeout(kInstigateAck, 1);
251   // Should ack immediately, since this fills the last hole.
252   CheckAckTimeout(clock_.ApproximateNow());
253 
254   RecordPacketReceipt(4, clock_.ApproximateNow());
255   MaybeUpdateAckTimeout(kInstigateAck, 4);
256   // Delayed ack is scheduled.
257   CheckAckTimeout(clock_.ApproximateNow() + kDelayedAckTime);
258 }
259 
TEST_F(UberReceivedPacketManagerTest,OutOfOrderAckReceiptCausesNoAck)260 TEST_F(UberReceivedPacketManagerTest, OutOfOrderAckReceiptCausesNoAck) {
261   EXPECT_FALSE(HasPendingAck());
262 
263   RecordPacketReceipt(2, clock_.ApproximateNow());
264   MaybeUpdateAckTimeout(!kInstigateAck, 2);
265   EXPECT_FALSE(HasPendingAck());
266 
267   RecordPacketReceipt(1, clock_.ApproximateNow());
268   MaybeUpdateAckTimeout(!kInstigateAck, 1);
269   EXPECT_FALSE(HasPendingAck());
270 }
271 
TEST_F(UberReceivedPacketManagerTest,AckReceiptCausesAckSend)272 TEST_F(UberReceivedPacketManagerTest, AckReceiptCausesAckSend) {
273   EXPECT_FALSE(HasPendingAck());
274 
275   RecordPacketReceipt(1, clock_.ApproximateNow());
276   MaybeUpdateAckTimeout(!kInstigateAck, 1);
277   EXPECT_FALSE(HasPendingAck());
278 
279   RecordPacketReceipt(2, clock_.ApproximateNow());
280   MaybeUpdateAckTimeout(!kInstigateAck, 2);
281   EXPECT_FALSE(HasPendingAck());
282 
283   RecordPacketReceipt(3, clock_.ApproximateNow());
284   MaybeUpdateAckTimeout(kInstigateAck, 3);
285   // Delayed ack is scheduled.
286   CheckAckTimeout(clock_.ApproximateNow() + kDelayedAckTime);
287   clock_.AdvanceTime(kDelayedAckTime);
288   CheckAckTimeout(clock_.ApproximateNow());
289 
290   RecordPacketReceipt(4, clock_.ApproximateNow());
291   MaybeUpdateAckTimeout(!kInstigateAck, 4);
292   EXPECT_FALSE(HasPendingAck());
293 
294   RecordPacketReceipt(5, clock_.ApproximateNow());
295   MaybeUpdateAckTimeout(!kInstigateAck, 5);
296   EXPECT_FALSE(HasPendingAck());
297 }
298 
TEST_F(UberReceivedPacketManagerTest,AckSentEveryNthPacket)299 TEST_F(UberReceivedPacketManagerTest, AckSentEveryNthPacket) {
300   EXPECT_FALSE(HasPendingAck());
301   manager_->set_ack_frequency(3);
302 
303   // Receives packets 1 - 39.
304   for (size_t i = 1; i <= 39; ++i) {
305     RecordPacketReceipt(i, clock_.ApproximateNow());
306     MaybeUpdateAckTimeout(kInstigateAck, i);
307     if (i % 3 == 0) {
308       CheckAckTimeout(clock_.ApproximateNow());
309     } else {
310       CheckAckTimeout(clock_.ApproximateNow() + kDelayedAckTime);
311     }
312   }
313 }
314 
TEST_F(UberReceivedPacketManagerTest,AckDecimationReducesAcks)315 TEST_F(UberReceivedPacketManagerTest, AckDecimationReducesAcks) {
316   EXPECT_FALSE(HasPendingAck());
317 
318   // Start ack decimation from 10th packet.
319   manager_->set_min_received_before_ack_decimation(10);
320 
321   // Receives packets 1 - 29.
322   for (size_t i = 1; i <= 29; ++i) {
323     RecordPacketReceipt(i, clock_.ApproximateNow());
324     MaybeUpdateAckTimeout(kInstigateAck, i);
325     if (i <= 10) {
326       // For packets 1-10, ack every 2 packets.
327       if (i % 2 == 0) {
328         CheckAckTimeout(clock_.ApproximateNow());
329       } else {
330         CheckAckTimeout(clock_.ApproximateNow() + kDelayedAckTime);
331       }
332       continue;
333     }
334     // ack at 20.
335     if (i == 20) {
336       CheckAckTimeout(clock_.ApproximateNow());
337     } else {
338       CheckAckTimeout(clock_.ApproximateNow() + kMinRttMs * 0.25);
339     }
340   }
341 
342   // We now receive the 30th packet, and so we send an ack.
343   RecordPacketReceipt(30, clock_.ApproximateNow());
344   MaybeUpdateAckTimeout(kInstigateAck, 30);
345   CheckAckTimeout(clock_.ApproximateNow());
346 }
347 
TEST_F(UberReceivedPacketManagerTest,SendDelayedAckDecimation)348 TEST_F(UberReceivedPacketManagerTest, SendDelayedAckDecimation) {
349   EXPECT_FALSE(HasPendingAck());
350   // The ack time should be based on min_rtt * 1/4, since it's less than the
351   // default delayed ack time.
352   QuicTime ack_time = clock_.ApproximateNow() + kMinRttMs * 0.25;
353 
354   // Process all the packets in order so there aren't missing packets.
355   uint64_t kFirstDecimatedPacket = 101;
356   for (uint64_t i = 1; i < kFirstDecimatedPacket; ++i) {
357     RecordPacketReceipt(i, clock_.ApproximateNow());
358     MaybeUpdateAckTimeout(kInstigateAck, i);
359     if (i % 2 == 0) {
360       // Ack every 2 packets by default.
361       CheckAckTimeout(clock_.ApproximateNow());
362     } else {
363       CheckAckTimeout(clock_.ApproximateNow() + kDelayedAckTime);
364     }
365   }
366 
367   RecordPacketReceipt(kFirstDecimatedPacket, clock_.ApproximateNow());
368   MaybeUpdateAckTimeout(kInstigateAck, kFirstDecimatedPacket);
369   CheckAckTimeout(ack_time);
370 
371   // The 10th received packet causes an ack to be sent.
372   for (uint64_t i = 1; i < 10; ++i) {
373     RecordPacketReceipt(kFirstDecimatedPacket + i, clock_.ApproximateNow());
374     MaybeUpdateAckTimeout(kInstigateAck, kFirstDecimatedPacket + i);
375   }
376   CheckAckTimeout(clock_.ApproximateNow());
377 }
378 
TEST_F(UberReceivedPacketManagerTest,SendDelayedAckDecimationUnlimitedAggregation)379 TEST_F(UberReceivedPacketManagerTest,
380        SendDelayedAckDecimationUnlimitedAggregation) {
381   EXPECT_FALSE(HasPendingAck());
382   QuicConfig config;
383   QuicTagVector connection_options;
384   // No limit on the number of packets received before sending an ack.
385   connection_options.push_back(kAKDU);
386   config.SetConnectionOptionsToSend(connection_options);
387   manager_->SetFromConfig(config, Perspective::IS_CLIENT);
388 
389   // The ack time should be based on min_rtt/4, since it's less than the
390   // default delayed ack time.
391   QuicTime ack_time = clock_.ApproximateNow() + kMinRttMs * 0.25;
392 
393   // Process all the initial packets in order so there aren't missing packets.
394   uint64_t kFirstDecimatedPacket = 101;
395   for (uint64_t i = 1; i < kFirstDecimatedPacket; ++i) {
396     RecordPacketReceipt(i, clock_.ApproximateNow());
397     MaybeUpdateAckTimeout(kInstigateAck, i);
398     if (i % 2 == 0) {
399       // Ack every 2 packets by default.
400       CheckAckTimeout(clock_.ApproximateNow());
401     } else {
402       CheckAckTimeout(clock_.ApproximateNow() + kDelayedAckTime);
403     }
404   }
405 
406   RecordPacketReceipt(kFirstDecimatedPacket, clock_.ApproximateNow());
407   MaybeUpdateAckTimeout(kInstigateAck, kFirstDecimatedPacket);
408   CheckAckTimeout(ack_time);
409 
410   // 18 packets will not cause an ack to be sent.  19 will because when
411   // stop waiting frames are in use, we ack every 20 packets no matter what.
412   for (int i = 1; i <= 18; ++i) {
413     RecordPacketReceipt(kFirstDecimatedPacket + i, clock_.ApproximateNow());
414     MaybeUpdateAckTimeout(kInstigateAck, kFirstDecimatedPacket + i);
415   }
416   CheckAckTimeout(ack_time);
417 }
418 
TEST_F(UberReceivedPacketManagerTest,SendDelayedAckDecimationEighthRtt)419 TEST_F(UberReceivedPacketManagerTest, SendDelayedAckDecimationEighthRtt) {
420   EXPECT_FALSE(HasPendingAck());
421   UberReceivedPacketManagerPeer::SetAckDecimationDelay(manager_.get(), 0.125);
422 
423   // The ack time should be based on min_rtt/8, since it's less than the
424   // default delayed ack time.
425   QuicTime ack_time = clock_.ApproximateNow() + kMinRttMs * 0.125;
426 
427   // Process all the packets in order so there aren't missing packets.
428   uint64_t kFirstDecimatedPacket = 101;
429   for (uint64_t i = 1; i < kFirstDecimatedPacket; ++i) {
430     RecordPacketReceipt(i, clock_.ApproximateNow());
431     MaybeUpdateAckTimeout(kInstigateAck, i);
432     if (i % 2 == 0) {
433       // Ack every 2 packets by default.
434       CheckAckTimeout(clock_.ApproximateNow());
435     } else {
436       CheckAckTimeout(clock_.ApproximateNow() + kDelayedAckTime);
437     }
438   }
439 
440   RecordPacketReceipt(kFirstDecimatedPacket, clock_.ApproximateNow());
441   MaybeUpdateAckTimeout(kInstigateAck, kFirstDecimatedPacket);
442   CheckAckTimeout(ack_time);
443 
444   // The 10th received packet causes an ack to be sent.
445   for (uint64_t i = 1; i < 10; ++i) {
446     RecordPacketReceipt(kFirstDecimatedPacket + i, clock_.ApproximateNow());
447     MaybeUpdateAckTimeout(kInstigateAck, kFirstDecimatedPacket + i);
448   }
449   CheckAckTimeout(clock_.ApproximateNow());
450 }
451 
TEST_F(UberReceivedPacketManagerTest,DontWaitForPacketsBeforeMultiplePacketNumberSpaces)452 TEST_F(UberReceivedPacketManagerTest,
453        DontWaitForPacketsBeforeMultiplePacketNumberSpaces) {
454   manager_->EnableMultiplePacketNumberSpacesSupport(Perspective::IS_CLIENT);
455   EXPECT_FALSE(
456       manager_->GetLargestObserved(ENCRYPTION_HANDSHAKE).IsInitialized());
457   EXPECT_FALSE(
458       manager_->GetLargestObserved(ENCRYPTION_FORWARD_SECURE).IsInitialized());
459   RecordPacketReceipt(ENCRYPTION_HANDSHAKE, 2);
460   RecordPacketReceipt(ENCRYPTION_HANDSHAKE, 4);
461   RecordPacketReceipt(ENCRYPTION_FORWARD_SECURE, 3);
462   RecordPacketReceipt(ENCRYPTION_FORWARD_SECURE, 7);
463   EXPECT_EQ(QuicPacketNumber(4),
464             manager_->GetLargestObserved(ENCRYPTION_HANDSHAKE));
465   EXPECT_EQ(QuicPacketNumber(7),
466             manager_->GetLargestObserved(ENCRYPTION_FORWARD_SECURE));
467 
468   EXPECT_TRUE(
469       manager_->IsAwaitingPacket(ENCRYPTION_HANDSHAKE, QuicPacketNumber(3)));
470   EXPECT_FALSE(manager_->IsAwaitingPacket(ENCRYPTION_FORWARD_SECURE,
471                                           QuicPacketNumber(3)));
472   EXPECT_TRUE(manager_->IsAwaitingPacket(ENCRYPTION_FORWARD_SECURE,
473                                          QuicPacketNumber(4)));
474 
475   manager_->DontWaitForPacketsBefore(ENCRYPTION_FORWARD_SECURE,
476                                      QuicPacketNumber(5));
477   EXPECT_TRUE(
478       manager_->IsAwaitingPacket(ENCRYPTION_HANDSHAKE, QuicPacketNumber(3)));
479   EXPECT_FALSE(manager_->IsAwaitingPacket(ENCRYPTION_FORWARD_SECURE,
480                                           QuicPacketNumber(4)));
481 }
482 
TEST_F(UberReceivedPacketManagerTest,AckSendingDifferentPacketNumberSpaces)483 TEST_F(UberReceivedPacketManagerTest, AckSendingDifferentPacketNumberSpaces) {
484   manager_->EnableMultiplePacketNumberSpacesSupport(Perspective::IS_SERVER);
485   EXPECT_FALSE(HasPendingAck());
486   EXPECT_FALSE(manager_->IsAckFrameUpdated());
487 
488   RecordPacketReceipt(ENCRYPTION_INITIAL, 3);
489   EXPECT_TRUE(manager_->IsAckFrameUpdated());
490   MaybeUpdateAckTimeout(kInstigateAck, ENCRYPTION_INITIAL, 3);
491   EXPECT_TRUE(HasPendingAck());
492   // Delayed ack is scheduled.
493   CheckAckTimeout(clock_.ApproximateNow() +
494                   QuicTime::Delta::FromMilliseconds(25));
495   // Send delayed handshake data ACK.
496   clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(25));
497   CheckAckTimeout(clock_.ApproximateNow());
498   EXPECT_FALSE(HasPendingAck());
499 
500   // Second delayed ack should have a shorter delay.
501   RecordPacketReceipt(ENCRYPTION_INITIAL, 4);
502   EXPECT_TRUE(manager_->IsAckFrameUpdated());
503   MaybeUpdateAckTimeout(kInstigateAck, ENCRYPTION_INITIAL, 4);
504   EXPECT_TRUE(HasPendingAck());
505   // Delayed ack is scheduled.
506   CheckAckTimeout(clock_.ApproximateNow() +
507                   QuicTime::Delta::FromMilliseconds(1));
508   // Send delayed handshake data ACK.
509   clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(1));
510   CheckAckTimeout(clock_.ApproximateNow());
511   EXPECT_FALSE(HasPendingAck());
512 
513   RecordPacketReceipt(ENCRYPTION_HANDSHAKE, 3);
514   EXPECT_TRUE(manager_->IsAckFrameUpdated());
515   MaybeUpdateAckTimeout(kInstigateAck, ENCRYPTION_HANDSHAKE, 3);
516   EXPECT_TRUE(HasPendingAck());
517   // Delayed ack is scheduled.
518   CheckAckTimeout(clock_.ApproximateNow() +
519                   QuicTime::Delta::FromMilliseconds(1));
520   // Send delayed handshake data ACK.
521   clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(1));
522   CheckAckTimeout(clock_.ApproximateNow());
523   EXPECT_FALSE(HasPendingAck());
524 
525   RecordPacketReceipt(ENCRYPTION_FORWARD_SECURE, 3);
526   MaybeUpdateAckTimeout(kInstigateAck, ENCRYPTION_FORWARD_SECURE, 3);
527   EXPECT_TRUE(HasPendingAck());
528   // Delayed ack is scheduled.
529   CheckAckTimeout(clock_.ApproximateNow() + kDelayedAckTime);
530 
531   RecordPacketReceipt(ENCRYPTION_FORWARD_SECURE, 2);
532   MaybeUpdateAckTimeout(kInstigateAck, ENCRYPTION_FORWARD_SECURE, 2);
533   // Application data ACK should be sent immediately.
534   CheckAckTimeout(clock_.ApproximateNow());
535   EXPECT_FALSE(HasPendingAck());
536 }
537 
TEST_F(UberReceivedPacketManagerTest,AckTimeoutForPreviouslyUndecryptablePackets)538 TEST_F(UberReceivedPacketManagerTest,
539        AckTimeoutForPreviouslyUndecryptablePackets) {
540   manager_->EnableMultiplePacketNumberSpacesSupport(Perspective::IS_SERVER);
541   EXPECT_FALSE(HasPendingAck());
542   EXPECT_FALSE(manager_->IsAckFrameUpdated());
543 
544   // Received undecryptable 1-RTT packet 4.
545   const QuicTime packet_receipt_time4 = clock_.ApproximateNow();
546   // 1-RTT keys become available after 10ms because HANDSHAKE 5 gets received.
547   clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(10));
548   RecordPacketReceipt(ENCRYPTION_HANDSHAKE, 5);
549   MaybeUpdateAckTimeout(kInstigateAck, ENCRYPTION_HANDSHAKE, 5);
550   EXPECT_TRUE(HasPendingAck());
551   RecordPacketReceipt(ENCRYPTION_FORWARD_SECURE, 4);
552   manager_->MaybeUpdateAckTimeout(kInstigateAck, ENCRYPTION_FORWARD_SECURE,
553                                   QuicPacketNumber(4), packet_receipt_time4,
554                                   clock_.ApproximateNow(), &rtt_stats_);
555 
556   // Send delayed handshake ACK.
557   clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(1));
558   CheckAckTimeout(clock_.ApproximateNow());
559 
560   EXPECT_TRUE(HasPendingAck());
561   // Verify ACK delay is based on packet receipt time.
562   CheckAckTimeout(clock_.ApproximateNow() -
563                   QuicTime::Delta::FromMilliseconds(11) + kDelayedAckTime);
564 }
565 
566 }  // namespace
567 }  // namespace test
568 }  // namespace quic
569