1 // Copyright (c) 2020 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "net/third_party/quiche/src/quic/core/quic_idle_network_detector.h"
6
7 #include "net/third_party/quiche/src/quic/core/quic_one_block_arena.h"
8 #include "net/third_party/quiche/src/quic/platform/api/quic_test.h"
9 #include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h"
10
11 namespace quic {
12 namespace test {
13
14 class QuicIdleNetworkDetectorTestPeer {
15 public:
GetAlarm(QuicIdleNetworkDetector * detector)16 static QuicAlarm* GetAlarm(QuicIdleNetworkDetector* detector) {
17 return detector->alarm_.get();
18 }
19 };
20
21 namespace {
22
23 class MockDelegate : public QuicIdleNetworkDetector::Delegate {
24 public:
25 MOCK_METHOD0(OnHandshakeTimeout, void());
26 MOCK_METHOD0(OnIdleNetworkDetected, void());
27 };
28
29 class QuicIdleNetworkDetectorTest : public QuicTest {
30 public:
QuicIdleNetworkDetectorTest()31 QuicIdleNetworkDetectorTest() {
32 clock_.AdvanceTime(QuicTime::Delta::FromSeconds(1));
33 detector_ = std::make_unique<QuicIdleNetworkDetector>(
34 &delegate_, clock_.Now(), &arena_, &alarm_factory_);
35 alarm_ = static_cast<MockAlarmFactory::TestAlarm*>(
36 QuicIdleNetworkDetectorTestPeer::GetAlarm(detector_.get()));
37 }
38
39 protected:
40 testing::StrictMock<MockDelegate> delegate_;
41 QuicConnectionArena arena_;
42 MockAlarmFactory alarm_factory_;
43
44 std::unique_ptr<QuicIdleNetworkDetector> detector_;
45
46 MockAlarmFactory::TestAlarm* alarm_;
47 MockClock clock_;
48 };
49
TEST_F(QuicIdleNetworkDetectorTest,IdleNetworkDetectedBeforeHandshakeCompletes)50 TEST_F(QuicIdleNetworkDetectorTest,
51 IdleNetworkDetectedBeforeHandshakeCompletes) {
52 EXPECT_FALSE(alarm_->IsSet());
53 detector_->SetTimeouts(
54 /*handshake_timeout=*/QuicTime::Delta::FromSeconds(30),
55 /*idle_network_timeout=*/QuicTime::Delta::FromSeconds(20));
56 EXPECT_TRUE(alarm_->IsSet());
57 EXPECT_EQ(clock_.Now() + QuicTime::Delta::FromSeconds(20),
58 alarm_->deadline());
59
60 // No network activity for 20s.
61 clock_.AdvanceTime(QuicTime::Delta::FromSeconds(20));
62 EXPECT_CALL(delegate_, OnIdleNetworkDetected());
63 alarm_->Fire();
64 }
65
TEST_F(QuicIdleNetworkDetectorTest,HandshakeTimeout)66 TEST_F(QuicIdleNetworkDetectorTest, HandshakeTimeout) {
67 EXPECT_FALSE(alarm_->IsSet());
68 detector_->SetTimeouts(
69 /*handshake_timeout=*/QuicTime::Delta::FromSeconds(30),
70 /*idle_network_timeout=*/QuicTime::Delta::FromSeconds(20));
71 EXPECT_TRUE(alarm_->IsSet());
72
73 // Has network activity after 15s.
74 clock_.AdvanceTime(QuicTime::Delta::FromSeconds(15));
75 detector_->OnPacketReceived(clock_.Now());
76 EXPECT_EQ(clock_.Now() + QuicTime::Delta::FromSeconds(15),
77 alarm_->deadline());
78 // Handshake does not complete for another 15s.
79 clock_.AdvanceTime(QuicTime::Delta::FromSeconds(15));
80 EXPECT_CALL(delegate_, OnHandshakeTimeout());
81 alarm_->Fire();
82 }
83
TEST_F(QuicIdleNetworkDetectorTest,IdleNetworkDetectedAfterHandshakeCompletes)84 TEST_F(QuicIdleNetworkDetectorTest,
85 IdleNetworkDetectedAfterHandshakeCompletes) {
86 EXPECT_FALSE(alarm_->IsSet());
87 detector_->SetTimeouts(
88 /*handshake_timeout=*/QuicTime::Delta::FromSeconds(30),
89 /*idle_network_timeout=*/QuicTime::Delta::FromSeconds(20));
90 EXPECT_TRUE(alarm_->IsSet());
91
92 // Handshake completes in 200ms.
93 clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(200));
94 detector_->OnPacketReceived(clock_.Now());
95 detector_->SetTimeouts(
96 /*handshake_timeout=*/QuicTime::Delta::Infinite(),
97 /*idle_network_timeout=*/QuicTime::Delta::FromSeconds(600));
98 EXPECT_EQ(clock_.Now() + QuicTime::Delta::FromSeconds(600),
99 alarm_->deadline());
100
101 // No network activity for 600s.
102 clock_.AdvanceTime(QuicTime::Delta::FromSeconds(600));
103 EXPECT_CALL(delegate_, OnIdleNetworkDetected());
104 alarm_->Fire();
105 }
106
TEST_F(QuicIdleNetworkDetectorTest,DoNotExtendIdleDeadlineOnConsecutiveSentPackets)107 TEST_F(QuicIdleNetworkDetectorTest,
108 DoNotExtendIdleDeadlineOnConsecutiveSentPackets) {
109 EXPECT_FALSE(alarm_->IsSet());
110 detector_->SetTimeouts(
111 /*handshake_timeout=*/QuicTime::Delta::FromSeconds(30),
112 /*idle_network_timeout=*/QuicTime::Delta::FromSeconds(20));
113 EXPECT_TRUE(alarm_->IsSet());
114
115 // Handshake completes in 200ms.
116 clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(200));
117 detector_->OnPacketReceived(clock_.Now());
118 detector_->SetTimeouts(
119 /*handshake_timeout=*/QuicTime::Delta::Infinite(),
120 /*idle_network_timeout=*/QuicTime::Delta::FromSeconds(600));
121 EXPECT_EQ(clock_.Now() + QuicTime::Delta::FromSeconds(600),
122 alarm_->deadline());
123
124 // Sent packets after 200ms.
125 clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(200));
126 detector_->OnPacketSent(clock_.Now());
127 const QuicTime packet_sent_time = clock_.Now();
128 EXPECT_EQ(packet_sent_time + QuicTime::Delta::FromSeconds(600),
129 alarm_->deadline());
130
131 // Sent another packet after 200ms
132 clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(200));
133 detector_->OnPacketSent(clock_.Now());
134 // Verify idle network deadline does not extend.
135 EXPECT_EQ(packet_sent_time + QuicTime::Delta::FromSeconds(600),
136 alarm_->deadline());
137
138 // No network activity for 600s.
139 clock_.AdvanceTime(QuicTime::Delta::FromSeconds(600) -
140 QuicTime::Delta::FromMilliseconds(200));
141 EXPECT_CALL(delegate_, OnIdleNetworkDetected());
142 alarm_->Fire();
143 }
144
145 } // namespace
146
147 } // namespace test
148 } // namespace quic
149