1 // Copyright (c) 2017 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_control_frame_manager.h"
6
7 #include <utility>
8
9 #include "net/third_party/quiche/src/quic/core/crypto/null_encrypter.h"
10 #include "net/third_party/quiche/src/quic/core/frames/quic_ack_frequency_frame.h"
11 #include "net/third_party/quiche/src/quic/core/quic_types.h"
12 #include "net/third_party/quiche/src/quic/platform/api/quic_expect_bug.h"
13 #include "net/third_party/quiche/src/quic/platform/api/quic_flags.h"
14 #include "net/third_party/quiche/src/quic/platform/api/quic_test.h"
15 #include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h"
16
17 using testing::_;
18 using testing::InSequence;
19 using testing::Invoke;
20 using testing::Return;
21 using testing::StrictMock;
22
23 namespace quic {
24 namespace test {
25
26 class QuicControlFrameManagerPeer {
27 public:
QueueSize(QuicControlFrameManager * manager)28 static size_t QueueSize(QuicControlFrameManager* manager) {
29 return manager->control_frames_.size();
30 }
31 };
32
33 namespace {
34
35 const QuicStreamId kTestStreamId = 5;
36 const QuicRstStreamErrorCode kTestStopSendingCode =
37 QUIC_STREAM_ENCODER_STREAM_ERROR;
38
39 class QuicControlFrameManagerTest : public QuicTest {
40 public:
SaveControlFrame(const QuicFrame & frame,TransmissionType)41 bool SaveControlFrame(const QuicFrame& frame, TransmissionType /*type*/) {
42 frame_ = frame;
43 return true;
44 }
45
46 protected:
47 // Pre-fills the control frame queue with the following frames:
48 // ID Type
49 // 1 RST_STREAM
50 // 2 GO_AWAY
51 // 3 WINDOW_UPDATE
52 // 4 BLOCKED
53 // 5 STOP_SENDING
54 // This is verified. The tests then perform manipulations on these.
Initialize()55 void Initialize() {
56 connection_ = new MockQuicConnection(&helper_, &alarm_factory_,
57 Perspective::IS_SERVER);
58 connection_->SetEncrypter(
59 ENCRYPTION_FORWARD_SECURE,
60 std::make_unique<NullEncrypter>(connection_->perspective()));
61 session_ = std::make_unique<StrictMock<MockQuicSession>>(connection_);
62 manager_ = std::make_unique<QuicControlFrameManager>(session_.get());
63 EXPECT_EQ(0u, QuicControlFrameManagerPeer::QueueSize(manager_.get()));
64 EXPECT_FALSE(manager_->HasPendingRetransmission());
65 EXPECT_FALSE(manager_->WillingToWrite());
66
67 EXPECT_CALL(*session_, WriteControlFrame(_, _)).WillOnce(Return(false));
68 manager_->WriteOrBufferRstStream(kTestStreamId, QUIC_STREAM_CANCELLED, 0);
69 manager_->WriteOrBufferGoAway(QUIC_PEER_GOING_AWAY, kTestStreamId,
70 "Going away.");
71 manager_->WriteOrBufferWindowUpdate(kTestStreamId, 100);
72 manager_->WriteOrBufferBlocked(kTestStreamId);
73 manager_->WriteOrBufferStopSending(kTestStopSendingCode, kTestStreamId);
74 number_of_frames_ = 5u;
75 ping_frame_id_ = 6u;
76 EXPECT_EQ(number_of_frames_,
77 QuicControlFrameManagerPeer::QueueSize(manager_.get()));
78 EXPECT_TRUE(manager_->IsControlFrameOutstanding(QuicFrame(&rst_stream_)));
79 EXPECT_TRUE(manager_->IsControlFrameOutstanding(QuicFrame(&goaway_)));
80 EXPECT_TRUE(
81 manager_->IsControlFrameOutstanding(QuicFrame(&window_update_)));
82 EXPECT_TRUE(manager_->IsControlFrameOutstanding(QuicFrame(&blocked_)));
83 EXPECT_TRUE(manager_->IsControlFrameOutstanding(QuicFrame(&stop_sending_)));
84 EXPECT_FALSE(manager_->IsControlFrameOutstanding(
85 QuicFrame(QuicPingFrame(ping_frame_id_))));
86
87 EXPECT_FALSE(manager_->HasPendingRetransmission());
88 EXPECT_TRUE(manager_->WillingToWrite());
89 }
90
91 QuicRstStreamFrame rst_stream_ = {1, kTestStreamId, QUIC_STREAM_CANCELLED, 0};
92 QuicGoAwayFrame goaway_ = {2, QUIC_PEER_GOING_AWAY, kTestStreamId,
93 "Going away."};
94 QuicWindowUpdateFrame window_update_ = {3, kTestStreamId, 100};
95 QuicBlockedFrame blocked_ = {4, kTestStreamId};
96 QuicStopSendingFrame stop_sending_ = {5, kTestStreamId, kTestStopSendingCode};
97 MockQuicConnectionHelper helper_;
98 MockAlarmFactory alarm_factory_;
99 MockQuicConnection* connection_;
100 std::unique_ptr<StrictMock<MockQuicSession>> session_;
101 std::unique_ptr<QuicControlFrameManager> manager_;
102 QuicFrame frame_;
103 size_t number_of_frames_;
104 int ping_frame_id_;
105 };
106
TEST_F(QuicControlFrameManagerTest,OnControlFrameAcked)107 TEST_F(QuicControlFrameManagerTest, OnControlFrameAcked) {
108 Initialize();
109 InSequence s;
110 EXPECT_CALL(*session_, WriteControlFrame(_, _))
111 .Times(3)
112 .WillRepeatedly(Invoke(&ClearControlFrameWithTransmissionType));
113 EXPECT_CALL(*session_, WriteControlFrame(_, _)).WillOnce(Return(false));
114 // Send control frames 1, 2, 3.
115 manager_->OnCanWrite();
116 EXPECT_TRUE(manager_->IsControlFrameOutstanding(QuicFrame(&rst_stream_)));
117 EXPECT_TRUE(manager_->IsControlFrameOutstanding(QuicFrame(&goaway_)));
118 EXPECT_TRUE(manager_->IsControlFrameOutstanding(QuicFrame(&window_update_)));
119 EXPECT_TRUE(manager_->IsControlFrameOutstanding(QuicFrame(&blocked_)));
120 EXPECT_TRUE(manager_->IsControlFrameOutstanding(QuicFrame(&stop_sending_)));
121
122 EXPECT_FALSE(manager_->IsControlFrameOutstanding(
123 QuicFrame(QuicPingFrame(ping_frame_id_))));
124 EXPECT_TRUE(manager_->OnControlFrameAcked(QuicFrame(&window_update_)));
125 EXPECT_FALSE(manager_->IsControlFrameOutstanding(QuicFrame(&window_update_)));
126 EXPECT_EQ(number_of_frames_,
127 QuicControlFrameManagerPeer::QueueSize(manager_.get()));
128
129 EXPECT_TRUE(manager_->OnControlFrameAcked(QuicFrame(&goaway_)));
130 EXPECT_FALSE(manager_->IsControlFrameOutstanding(QuicFrame(&goaway_)));
131 EXPECT_EQ(number_of_frames_,
132 QuicControlFrameManagerPeer::QueueSize(manager_.get()));
133 EXPECT_TRUE(manager_->OnControlFrameAcked(QuicFrame(&rst_stream_)));
134 EXPECT_FALSE(manager_->IsControlFrameOutstanding(QuicFrame(&rst_stream_)));
135 // Only after the first frame in the queue is acked do the frames get
136 // removed ... now see that the length has been reduced by 3.
137 EXPECT_EQ(number_of_frames_ - 3u,
138 QuicControlFrameManagerPeer::QueueSize(manager_.get()));
139 // Duplicate ack.
140 EXPECT_FALSE(manager_->OnControlFrameAcked(QuicFrame(&goaway_)));
141
142 EXPECT_FALSE(manager_->HasPendingRetransmission());
143 EXPECT_TRUE(manager_->WillingToWrite());
144
145 // Send control frames 4, 5.
146 EXPECT_CALL(*session_, WriteControlFrame(_, _))
147 .WillRepeatedly(Invoke(&ClearControlFrameWithTransmissionType));
148 manager_->OnCanWrite();
149 manager_->WritePing();
150 EXPECT_FALSE(manager_->WillingToWrite());
151 }
152
TEST_F(QuicControlFrameManagerTest,OnControlFrameLost)153 TEST_F(QuicControlFrameManagerTest, OnControlFrameLost) {
154 Initialize();
155 InSequence s;
156 EXPECT_CALL(*session_, WriteControlFrame(_, _))
157 .Times(3)
158 .WillRepeatedly(Invoke(&ClearControlFrameWithTransmissionType));
159 EXPECT_CALL(*session_, WriteControlFrame(_, _)).WillOnce(Return(false));
160 // Send control frames 1, 2, 3.
161 manager_->OnCanWrite();
162
163 // Lost control frames 1, 2, 3.
164 manager_->OnControlFrameLost(QuicFrame(&rst_stream_));
165 manager_->OnControlFrameLost(QuicFrame(&goaway_));
166 manager_->OnControlFrameLost(QuicFrame(&window_update_));
167 EXPECT_TRUE(manager_->HasPendingRetransmission());
168
169 // Ack control frame 2.
170 manager_->OnControlFrameAcked(QuicFrame(&goaway_));
171
172 // Retransmit control frames 1, 3.
173 EXPECT_CALL(*session_, WriteControlFrame(_, _))
174 .Times(2)
175 .WillRepeatedly(Invoke(&ClearControlFrameWithTransmissionType));
176 manager_->OnCanWrite();
177 EXPECT_FALSE(manager_->HasPendingRetransmission());
178 EXPECT_TRUE(manager_->WillingToWrite());
179
180 // Send control frames 4, 5, and 6.
181 EXPECT_CALL(*session_, WriteControlFrame(_, _))
182 .Times(number_of_frames_ - 2u)
183 .WillRepeatedly(Invoke(&ClearControlFrameWithTransmissionType));
184 manager_->OnCanWrite();
185 manager_->WritePing();
186 EXPECT_FALSE(manager_->WillingToWrite());
187 }
188
TEST_F(QuicControlFrameManagerTest,RetransmitControlFrame)189 TEST_F(QuicControlFrameManagerTest, RetransmitControlFrame) {
190 Initialize();
191 InSequence s;
192 // Send control frames 1, 2, 3, 4.
193 EXPECT_CALL(*session_, WriteControlFrame(_, _))
194 .Times(number_of_frames_)
195 .WillRepeatedly(Invoke(&ClearControlFrameWithTransmissionType));
196 manager_->OnCanWrite();
197
198 // Ack control frame 2.
199 manager_->OnControlFrameAcked(QuicFrame(&goaway_));
200 // Do not retransmit an acked frame
201 EXPECT_CALL(*session_, WriteControlFrame(_, _)).Times(0);
202 EXPECT_TRUE(manager_->RetransmitControlFrame(QuicFrame(&goaway_),
203 PTO_RETRANSMISSION));
204
205 // Retransmit control frame 3.
206 EXPECT_CALL(*session_, WriteControlFrame(_, _))
207 .WillOnce(Invoke(&ClearControlFrameWithTransmissionType));
208 EXPECT_TRUE(manager_->RetransmitControlFrame(QuicFrame(&window_update_),
209 PTO_RETRANSMISSION));
210
211 // Retransmit control frame 4, and connection is write blocked.
212 EXPECT_CALL(*session_, WriteControlFrame(_, _)).WillOnce(Return(false));
213 EXPECT_FALSE(manager_->RetransmitControlFrame(QuicFrame(&window_update_),
214 PTO_RETRANSMISSION));
215 }
216
TEST_F(QuicControlFrameManagerTest,DonotSendPingWithBufferedFrames)217 TEST_F(QuicControlFrameManagerTest, DonotSendPingWithBufferedFrames) {
218 Initialize();
219 InSequence s;
220 EXPECT_CALL(*session_, WriteControlFrame(_, _))
221 .WillOnce(Invoke(&ClearControlFrameWithTransmissionType));
222 EXPECT_CALL(*session_, WriteControlFrame(_, _)).WillOnce(Return(false));
223 // Send control frame 1.
224 manager_->OnCanWrite();
225 EXPECT_FALSE(manager_->HasPendingRetransmission());
226 EXPECT_TRUE(manager_->WillingToWrite());
227
228 // Send PING when there is buffered frames.
229 manager_->WritePing();
230 // Verify only the buffered frames are sent.
231 EXPECT_CALL(*session_, WriteControlFrame(_, _))
232 .Times(number_of_frames_ - 1)
233 .WillRepeatedly(Invoke(&ClearControlFrameWithTransmissionType));
234 manager_->OnCanWrite();
235 EXPECT_FALSE(manager_->HasPendingRetransmission());
236 EXPECT_FALSE(manager_->WillingToWrite());
237 }
238
TEST_F(QuicControlFrameManagerTest,SendAndAckAckFrequencyFrame)239 TEST_F(QuicControlFrameManagerTest, SendAndAckAckFrequencyFrame) {
240 Initialize();
241 InSequence s;
242 // Send Non-AckFrequency frame 1-5.
243 EXPECT_CALL(*session_, WriteControlFrame(_, _))
244 .Times(5)
245 .WillRepeatedly(Invoke(&ClearControlFrameWithTransmissionType));
246 EXPECT_CALL(*session_, WriteControlFrame(_, _)).WillOnce(Return(false));
247 manager_->OnCanWrite();
248
249 // Send AckFrequencyFrame as frame 6.
250 QuicAckFrequencyFrame frame_to_send;
251 frame_to_send.packet_tolerance = 10;
252 frame_to_send.max_ack_delay = QuicTime::Delta::FromMilliseconds(24);
253 manager_->WriteOrBufferAckFrequency(frame_to_send);
254 EXPECT_CALL(*session_, WriteControlFrame(_, _))
255 .WillOnce(Invoke(&ClearControlFrameWithTransmissionType));
256 manager_->OnCanWrite();
257
258 // Ack AckFrequencyFrame.
259 QuicAckFrequencyFrame expected_ack_frequency = {
260 6, 6, 10, QuicTime::Delta::FromMilliseconds(24)};
261 EXPECT_TRUE(
262 manager_->OnControlFrameAcked(QuicFrame(&expected_ack_frequency)));
263 }
264
TEST_F(QuicControlFrameManagerTest,DonotRetransmitOldWindowUpdates)265 TEST_F(QuicControlFrameManagerTest, DonotRetransmitOldWindowUpdates) {
266 Initialize();
267 // Send two more window updates of the same stream.
268 manager_->WriteOrBufferWindowUpdate(kTestStreamId, 200);
269 QuicWindowUpdateFrame window_update2(number_of_frames_ + 1, kTestStreamId,
270 200);
271
272 manager_->WriteOrBufferWindowUpdate(kTestStreamId, 300);
273 QuicWindowUpdateFrame window_update3(number_of_frames_ + 2, kTestStreamId,
274 300);
275 InSequence s;
276 // Flush all buffered control frames.
277 EXPECT_CALL(*session_, WriteControlFrame(_, _))
278 .WillRepeatedly(Invoke(&ClearControlFrameWithTransmissionType));
279 manager_->OnCanWrite();
280
281 // Mark all 3 window updates as lost.
282 manager_->OnControlFrameLost(QuicFrame(&window_update_));
283 manager_->OnControlFrameLost(QuicFrame(&window_update2));
284 manager_->OnControlFrameLost(QuicFrame(&window_update3));
285 EXPECT_TRUE(manager_->HasPendingRetransmission());
286 EXPECT_TRUE(manager_->WillingToWrite());
287
288 // Verify only the latest window update gets retransmitted.
289 EXPECT_CALL(*session_, WriteControlFrame(_, _))
290 .WillOnce(Invoke(this, &QuicControlFrameManagerTest::SaveControlFrame));
291 manager_->OnCanWrite();
292 EXPECT_EQ(number_of_frames_ + 2u,
293 frame_.window_update_frame->control_frame_id);
294 EXPECT_FALSE(manager_->HasPendingRetransmission());
295 EXPECT_FALSE(manager_->WillingToWrite());
296 DeleteFrame(&frame_);
297 }
298
TEST_F(QuicControlFrameManagerTest,RetransmitWindowUpdateOfDifferentStreams)299 TEST_F(QuicControlFrameManagerTest, RetransmitWindowUpdateOfDifferentStreams) {
300 Initialize();
301 // Send two more window updates of different streams.
302 manager_->WriteOrBufferWindowUpdate(kTestStreamId + 2, 200);
303 QuicWindowUpdateFrame window_update2(5, kTestStreamId + 2, 200);
304
305 manager_->WriteOrBufferWindowUpdate(kTestStreamId + 4, 300);
306 QuicWindowUpdateFrame window_update3(6, kTestStreamId + 4, 300);
307 InSequence s;
308 // Flush all buffered control frames.
309 EXPECT_CALL(*session_, WriteControlFrame(_, _))
310 .WillRepeatedly(Invoke(&ClearControlFrameWithTransmissionType));
311 manager_->OnCanWrite();
312
313 // Mark all 3 window updates as lost.
314 manager_->OnControlFrameLost(QuicFrame(&window_update_));
315 manager_->OnControlFrameLost(QuicFrame(&window_update2));
316 manager_->OnControlFrameLost(QuicFrame(&window_update3));
317 EXPECT_TRUE(manager_->HasPendingRetransmission());
318 EXPECT_TRUE(manager_->WillingToWrite());
319
320 // Verify all 3 window updates get retransmitted.
321 EXPECT_CALL(*session_, WriteControlFrame(_, _))
322 .Times(3)
323 .WillRepeatedly(Invoke(&ClearControlFrameWithTransmissionType));
324 manager_->OnCanWrite();
325 EXPECT_FALSE(manager_->HasPendingRetransmission());
326 EXPECT_FALSE(manager_->WillingToWrite());
327 }
328
TEST_F(QuicControlFrameManagerTest,TooManyBufferedControlFrames)329 TEST_F(QuicControlFrameManagerTest, TooManyBufferedControlFrames) {
330 Initialize();
331 EXPECT_CALL(*session_, WriteControlFrame(_, _))
332 .Times(5)
333 .WillRepeatedly(Invoke(&ClearControlFrameWithTransmissionType));
334 // Flush buffered frames.
335 manager_->OnCanWrite();
336 // Write 995 control frames.
337 EXPECT_CALL(*session_, WriteControlFrame(_, _)).WillOnce(Return(false));
338 for (size_t i = 0; i < 995; ++i) {
339 manager_->WriteOrBufferRstStream(kTestStreamId, QUIC_STREAM_CANCELLED, 0);
340 }
341 // Verify write one more control frame causes connection close.
342 EXPECT_CALL(
343 *connection_,
344 CloseConnection(QUIC_TOO_MANY_BUFFERED_CONTROL_FRAMES, _,
345 ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET));
346 manager_->WriteOrBufferRstStream(kTestStreamId, QUIC_STREAM_CANCELLED, 0);
347 }
348
349 } // namespace
350 } // namespace test
351 } // namespace quic
352